ABM Archivos Algorítmica Programación

Algorítmica y Programación I

Archivos : procesamiento
Archivos en Ada

Procesos
Apareo de archivos (mezclarlos respetando el orden).

Consiste en intercalar información de dos o más archivos, donde cada uno debe estar
ordenado previamente en el mismo orden y bajo la misma clave.

ABM de archivos (Altas, Bajas y Modificaciones de información en un archivo).

Los tipos de archivos que estamos estudiando son una fuente de información, y como tal,
necesitamos mantenerla actualizada. La actualización implica agregar, borrar o modificar la
información que se encuentra en un archivo.

Ordenamiento de un archivo, Búsqueda.

Para ordenar un archivo lo “bajamos” a memoria, a un vector de registros, lo ordenamos
como se ordena un vector de registros, y luego lo “subimos” a disco. Las búsquedas se
pueden realizar sobre el dispositivo, o más rápidamente en la memoria.


Apareo de Archivos
Veremos este modelo de procesamiento al estudiar en la próxima clase
los cortes de control.

Archivo
Maestro Archivo de
Detalles

Impresión 1


Archivo1 Archivo2 Archivon
…………

Archivo=Archivo1 U Archivo2 U ……
Archivon


Clave Descripcion SM SA PU Clave PA
ABM
345 zapatos 80 90 122 345 135
357 toallas 600 800 32 371 9
368 manteles 150 160 63 375 11
371 harina 2300 5000 8 380 5
375 jabon 2500 2800 9 389 14
380 esponja 1200 1300 3 393 17
384 lavandina 3000 4500 5 402 36
Mercaderia
389 tijeras 50 80 12 407 467
393 semillas 120 300 13 427 24
398 regador 120 200 10 433 27
402 fertilizante 200 356 32
407 cubierta 100 134 456
413 almohada 200 345 15 Precios_nuevos
SM: stock mínimo
SA : stock actual 427 delantal 250 456 21
PU : Precio unitario
PA: precio actual 433 pañales 2000 5000 23

Clave Descripcion SM SA PU Resultado de
ABM modificaciones a
345 zapatos 80 90 135 Mercadería con
357 toallas 600 800 32 Precios_nuevos
368 manteles 150 160 63
371 harina 2300 5000 9
375 jabon 2500 2800 11
380 esponja 1200 1300 5
384 lavandina 3000 4500 5
Mercaderia
389 tijeras 50 80 14
393 semillas 120 300 17
398 regador 120 200 10
407 cubierta 100 134 467
413 almohada 200 345 15
SM: stock mínimo
433 pañales 2000 5000 27

Clave Descripcion SM SA PU Clave
ABM
345 zapatos 80 90 122 357
357 toallas 600 800 32 384
368 manteles 150 160 63 389
371 harina 2300 5000 8 398
375 jabon 2500 2800 9 413
380 esponja 1200 1300 3
384 lavandina 3000 4500 5
Mercaderia
389 tijeras 50 80 12
393 semillas 120 300 13
398 regador 120 200 10
407 cubierta 100 134 456
413 almohada 200 345 15 Bajas
SM: stock mínimo
PA: precio actual 433 pañales 2000 5000 23

ABM modificaciones a
345 zapatos 80 90 122 Mercadería con
368 manteles 150 160 63 bajas de claves
371 harina 2300 5000 8
375 jabon 2500 2800 9
380 esponja 1200 1300 3
393 semillas 120 300 13
Mercaderia
407 cubierta 100 134 456
427 delantal 250 456 21
433 pañales 2000 5000 23

SM: stock mínimo
SA : stock actual


Clave Descripcion SM SA PU Clav Descripci SM SA P
ABM e on U
345 zapatos 80 90 122
368 manteles 150 160 63 348 zapatilla 80 900 11
3
371 harina 2300 5000 8
370 rejilla 150 800 12
375 jabon 2500 2800 9
382 semola 100 245 7
380 esponja 1200 1300 3
456 maiz 200 450 4
393 semillas 120 300 13
467 arroz 560 899 5
Mer 480 fideos 400 800 3
407 cubierta 100 134 456
cad
eria 427 delantal 250 456 21
433 pañales 2000 5000 23

SM: stock mínimo
SA : stock actual Altas


ABM 345 zapatos 80 90 122 modificaciones a
348 zapatilla 80 900 113 Mercadería con
altas de claves y
368 manteles 150 160 63
datos
370 rejilla 150 800 12
371 harina 2300 5000 8
375 jabon 2500 2800 9
380 esponja 1200 1300 3
382 semola 100 245 7
Mercaderia
393 semillas 120 300 13
407 cubierta 100 134 456
427 delantal 250 456 21
433 pañales 2000 5000 23

SM: stock mínimo
456 maiz 200 450 4
SA : stock actual 467 arroz 560 899 5
PA: precio actual 480 fideos 400 800 3

Nosotros restringiremos nuestro estudio a los archivos secuenciales, de los que a
continuación veremos la sintaxis y requisitos formales para su aplicación:

Los elementos necesarios para manejar archivos secuenciales se encuentran en el
paquete "Sequential_IO".
with Ada.Sequential_IO;
Declaración
Para poder usar archivos secuenciales se deben definir previamente el tipo de sus
componentes
type TPersona is
record
Nombre : string(1..20);
DNI : string(1..10);
Edad : natural;
end record;
Una vez definido el tipo, se definen instancias de los paquetes de manejo de
archivos, según el tipo de acceso que se vaya a utilizar.
package ArchTPersona_Sec is new Ada.Sequential_IO(TPersona); - - Acceso
secuencial
use ArchTPersona_Sec; Algorítmica y Programación I

Ahora se pueden declarar variables de tipo archivo secuencial:
MiArchivo : ArchTPersona_Sec.tipo_archivo;

Creación de archivo secuencial
Create ( File => <nombre de variable >, Mode => Out_File, -- por defecto
Name => "<nombre de archivo externo>" );
<nombre de variable > -- el nombre de la variable archivo
<external file name> - - el nombre del archivo externo (físico).

Ejemplo :
Create ( File => MiArchivo,
Mode => Out_File,
Name => "c: MiArchivo.dat" );


Apertura de archivo secuencial
Open ( File => <nombre de variable >, Mode => In_File, Name => "<nombre
de archivo externo>" );
<nombre de variable > - el nombre de la variable archivo
<external file name> - el nombre del archivo externo (físico).

Ejemplo :
Open ( File => MiArchivo,
Mode => In_File,
Name => "c: MiArchivo.dat" );
• Mode es el modo de apertura (puede tomar los valores: "In_File",
"Out_File", "Append_File").
• In_File abre el archivo en modo lectura.
• Out_File abre el archivo en modo escritura (si el fichero ya existe,
se vacía).
• Append_File abre un archivo secuencial en modo escritura para
añadir información al final.


Cierre de archivo secuencial
Close ( File => < nombre de variable > );
<nombre de variable> - el nombre de la variable archivo.

Ejemplo :
Close ( File => MiArchivo);

Operaciones de entrada/salida : Read y Write
Read( File => < nombre de variable >, Item => < nombre componente>);
<nombre de variable> - es el nombre de la variable archivo.
< nombre componente> Nombre del componente del archivo que se lee
desde éste.
Write( File => < nombre de variable >, Item => < nombre componente>);
<nombre de variable> - es el nombre de la variable archivo.
< nombre componente> Nombre del componente del archivo que se graba
en éste.


Otras funciones

End_Of_File(Archivo1) es una función que devuelve True si se ha alcanzado el final de
Archivo1 y False en caso contrario.
Is_Open(Archivo1) devuelve True si el archivo "Archivo1" está abierto y "False" en
caso contrario.
Mode(Archivo1) devuelve el modo en que ha sido abierto el archivo.

Name(Archivo1) devuelve el nombre del archivo externo correspondiente a “Archivo1”
(nombre lógico).
Los errores que pudieran producirse al intentar abrir un archivo pueden controlarse
mediante excepciones.


with ada.Text_Io,ada.Sequential_IO, ada.characters.handling, ada.Integer_Text_IO;
use ada.Text_Io, ada.characters.handling, ada.Integer_Text_IO;
procedure crear_Fichero is
subtype Cadena20 is String(1..20);
type T_Persona is
record
Nombre: cadena20 ;
Dni: cadena8;
Edad: Natural;
end record;
package Archi_Persona_Sec is new ada.Sequential_Io(T_Persona);
use Archi_Persona_Sec;
F_Entrada: Archi_persona_sec.File_Type;
Alumno:T_Persona;
sigue:character;
begin
--se abren los ficheros
Create(F_Entrada,Out_File, "F:alumnos.dat");
loop
carga_registro(alumno); - - en este procedimiento se genera el registro alumno
Get_Immediate(Sigue);
sigue:=to_upper(sigue);
Write(F_Entrada, Alumno); - - se graba el registro alumnos en el archivo F_Entrada
exit when sigue/='C';
end loop;
Close(F_Entrada); --se cierran los ficheros
end crear_Fichero;


with ada.Text_Io,ada.Sequential_IO;
with ada.Text_Io , ada.Integer_Text_IO;
use ada.Text_Io, ada.Integer_Text_IO;
procedure leo_Fichero is
type T_Persona is
record
Nombre: cadena20 ;
Dni: cadena8;
Edad: Natural;
end record;
package Archi_Persona_Sec is new ada.Sequential_Io(T_Persona);
use Archi_Persona_Sec;
F_Entrada: Archi_persona_sec.File_Type;
Alumno:T_Persona;
begin
Archi_persona_sec.Open(F_Entrada,In_File, "F:alumnos.dat"); - - se abren los ficheros
loop exit when Archi_Persona_Sec.End_Of_File(F_Entrada); - - esto equivale a mientras no fin archivo
archi_persona_sec.Read(F_Entrada, Alumno);
Put_line("El Nombre y Apellido es ");
Put_line(alumno.nombre);
Put_Line("Su DNI");
put_line(alumno.dni);
Put_line("Su edad ");
Put(Alumno.Edad);
new_line;
end loop;
archi_persona_sec.Close(F_Entrada); - -se cierran los ficheros
end leo_Fichero; Algorítmica y Programación I

-- este programa copia un archivo de texto en otro
with Text_Io;
use Text_Io;
-- El procedimiento Copiar_Fichero copia un fichero de texto
-- llamado "original.txt" en otro llamado "copia.txt"
-- precondiciones: debe existir un fichero externo llamado original.txt
-- no debe existir un fichero externo llamado copia.txt
-- postcondiciones: Existe un fichero externo llamado "copia.txt" cuyo contenido es
-- idéntico al de "original.txt"
procedure Copiar_Fichero_ok is
F_Entrada, F_Salida: File_Type;
Línea : String(1..200);
Lon_Línea : Natural;
begin
--se abren los ficheros
Open(F_Entrada,Mode => In_File,Name => "C:original.txt");
Create(F_Salida,Name => "C:copia.txt");
--se copia F_Entrada en F_Salida
while not End_Of_File(F_Entrada) loop
Get_Line(F_Entrada,Línea,Lon_Línea);
Put_Line(F_Salida,Línea(1..Lon_Línea));
end loop;
--se cierran los ficheros
Close(F_Entrada);
Close(F_Salida);
end Copiar_Fichero_ok; Algorítmica y Programación I

En la próxima clase veremos Cortes de Control ………


ABM Archivos Algorítmica Programación

Recomendados

Recomendados

Más contenido relacionado

Destacado

Destacado (20)

ABM Archivos Algorítmica Programación