Procesamiento de Archivos
Procesamiento de Archivos
Procesamiento de Archivos
Se dice que un archivo es aleatorio o directo cuando cualquier registro es directamente accesible mediante la especi-
ficación de un índice, que da la posición del registro con respecto al origen del fichero. Los archivos aleatorios o
directos tienen una gran rapidez para el acceso comparados con los secuenciales; los registros son fáciles de referen-
ciar —número de orden del registro—, lo que representa una gran facilidad de mantenimiento.
La lectura/escritura de un registro es rápida, ya que se accede directamente al registro y no se necesita recorrer
los anteriores.
Las operaciones con archivos directos son las usuales, ya vistas anteriormente.
Creación
El proceso de creación de un archivo directo o aleatorio consiste en ir introduciendo los sucesivos registros en el
soporte que los va a contener y en la dirección obtenida, resultante del algoritmo de conversión. Si al introducir un
registro se encuentra ocupada la dirección, el nuevo registro deberá ir a la zona de sinónimos o de excedentes.
algoritmo crea_dir
tipo
registro: datos_personales
<tipo_dato1> : nombre_campo1
........... : ............
<tipo_datoN> : nombre_campoN
........... : .............
fin_registro
archivo_d de datos_personales: arch
var
arch : f
datos_personales : persona
inicio
crear(f,<nombre_en_disco>)
abrir(f,l/e,<nombre_en_disco>)
..........................
{ las operaciones pueden variar con arreglo al modo como
pensemos trabajar posteriormente con el archivo
(posicionamiento directo en un determinado registro,
transformación de clave, indexación) }
..........................
cerrar(f)
fin
En los registros de un archivo directo se suele incluir un campo —ocupado— que pueda servir para distinguir un
registro dado de baja o modificado de un alta o de otro que nunca contuvo información.
Dentro del proceso de creación del archivo podríamos considerar una inicialización de dicho campo en cada uno
de los registros del archivo directo.
algoritmo crea_dir
const
max = <valor>
tipo
registro: datos_personales
<tipo_dato1>: cod
336 Fundamentos de programación
<tipo_dato2>: ocupado
........... : .............
<tipo_daton>: nombre_campon
........... : .............
fin_registro
archivo_d de datos_personales: arch
var
arch : f
datos_personales : persona
inicio
crear(f,<nombre_en_disco>)
abrir(f,l/e,<nombre_en_disco>)
desde i ← 1 hasta Max hacer
persona.ocupado ← ' '
escribir(f, i, persona)
fin_desde
cerrar(f)
fin
Altas
La operación de altas en un archivo directo o aleatorio consiste en ir introduciendo los sucesivos registros en una
determinada posición, especificada a través del índice. Mediante el índice nos posicionaremos directamente sobre el
byte del fichero que se encuentra en la posición (indice - 1) * tamaño_de(<tipo_registros_del_ar-
chivo>) y escribiremos allí nuestro registro.
El método de transformación de clave consiste en transformar un número de orden (clave) en direcciones de alma-
cenamiento por medio de un algoritmo de conversión.
Cuando las altas se realizan por el método de transformación de clave, la dirección donde introducir un determi-
nado registro se conseguirá por la aplicación a la clave del algoritmo de conversión (HASH). Si encontráramos que
dicha dirección ya está ocupada, el nuevo registro deberá ir a la zona de sinónimos o de excedentes.
algoritmo altas_dir_trcl
const
findatos = <valor1>
max = <valor2>
tipo
registro: datos_personales
<tipo_dato1>: cod
<tipo_dato2>: ocupado
........... : ............
<tipo_daton>: nombre_campon
........... : .............
fin_registro
archivo_d de datos_personales: arch
var
arch : f
datos_personales : persona, personaaux
lógico : encontradohueco
entero : posi
inicio
abrir(f,l/e,<nombre_en_disco>)
leer(personaaux.cod)
posi ← HASH(personaaux.cod)
Archivos (ficheros) 337
Consulta
El proceso de consulta de un archivo directo o aleatorio es rápido y debe comenzar con la entrada del índice corres-
pondiente al registro que deseamos consultar.
El índice permitirá el posicionamiento directo sobre el byte del fichero que se encuentra en la posición
(indice - 1) * tamaño_de(<var_de_tipo_registros_del_fichero>)
algoritmo consultas_dir
const
max = <valor1>
tipo
registro: datos_personales
{Cuando el código coincide con el índice o posición del
registro en el archivo, no resulta necesario su
almacenamiento }
<tipo_dato1>: ocupado
........... : ............
<tipo_daton>: nombre_campon
........... : .............
fin_registro
archivo_d de datos_personales: arch
var
arch : f
datos_personales : persona
lógico : encontrado
entero : posi
inicio
abrir(f,l/e,<nombre_en_disco>)
leer(posi)
338 Fundamentos de programación
Puede ocurrir que la clave o código por el que deseamos acceder a un determinado registro no coincida con la posi-
ción de dicho registro en el archivo, aunque guarden entre sí una cierta relación, pues al escribir los registros en el
archivo la posición se obtuvo aplicando a la clave un algoritmo de conversión.
En este caso es imprescindible el almacenamiento de la clave en uno de los campos del registro y las operaciones
a realizar para llevar a cabo una consulta serían:
algoritmo consultas_dir_trcl
const
findatos = <valor1>
max = <valor2>
tipo
registro: datos_personales
<tipo_dato1>: cod
<tipo_dato2>: ocupado
........... : ............
<tipo_daton>: nombre_campon
........... : .............
fin_registro
archivo_d de datos_personales: arch
var
arch : f
datos_personales : persona, personaaux
Archivos (ficheros) 339
lógico : encontrado
entero : posi
inicio
abrir(f,l/e,<nombre_en_disco>)
leer(personaaux.cod)
posi ← HASH(personaaux.cod)
leer(f, posi, persona)
si (persona.ocupado <>'*') o (persona.cod <> personaaux.cod) entonces
encontrado ← falso
posi ← Findatos
mientras (posi < Max ) y no encontrado hacer
posi ← posi + 1
leer(f, posi, persona)
si (persona.ocupado = '*' )y
(persona.cod = personaaux.cod) entonces
encontrado ← verdad
fin_si
fin_mientras
si_no
encontrado ← verdad
fin_si
si encontrado entonces
escribir_reg(persona)
si_no
escribir('No está')
fin_si
cerrar(f)
fin
Bajas
En el proceso de bajas se considera el contenido de un campo indicador, por ejemplo, persona.ocupado, que,
cuando existe información válida en el registro está marcado con un *. Para dar de baja al registro, es decir, consi-
derar su información como no válida, eliminaremos dicho *. Este tipo de baja es una baja lógica.
Desarrollaremos a continuación un algoritmo que realice bajas lógicas y acceda a los registros a los que se desea
dar la baja por el método de transformación de clave.
algoritmo bajas_dir_trcl
const
findatos = <valor1>
max = <valor2>
tipo
registro: datos_personales
<tipo_dato1>: cod
<tipo_dato2>: ocupado
........... : ............
<tipo_daton>: nombre_campon
........... : .............
fin_registro
archivo_d de datos_personales: arch
var
arch : f
datos_personales : persona, personaaux
lógico : encontrado
entero : posi
340 Fundamentos de programación
inicio
abrir(f,l/e,<nombre_en_disco>)
leer(personaaux.cod)
posi ← HASH(personaaux.cod)
leer(f, posi, persona)
si (persona.ocupado <>'*') o
(persona.cod <> personaaux.cod) entonces
encontrado ← falso
posi ← findatos
mientras (posi < Max) y no encontrado hacer
posi ← posi + 1
leer(f, posi, persona)
si (persona.ocupado='*') y
(persona.cod = personaaux.cod) entonces
encontrado ← verdad
fin_si
fin_mientras
si_no
encontrado ← verdad
fin_si
si encontrado entonces
persona.ocupado ← ' '
escribir(f, posi, persona)
si_no
escribir('No está')
fin_si
cerrar(f)
fin
Modificaciones
En un archivo aleatorio se localiza el registro que se desea modificar —mediante la especificación del índice o apli-
cando el algoritmo de conversión clave a dirección y, en caso necesario, la búsqueda en la zona de colisiones— se
modifica el contenido y se reescribe.
algoritmo modificaciones_dir_trcl
const
findatos = <valor1>
max = <valor2>
tipo
registro: datos_personales
<tipo_dato1>: cod
<tipo_dato2>: ocupado
........... : ............
<tipo_daton>: nombre_campon
........... : .............
fin_registro
archivo_d de datos_personales: arch
var
arch : f
datos_personales : persona, personaaux
lógico : encontrado
entero : posi
inicio
abrir(f,l/e,<nombre_en_disco>)
leer(personaaux.cod)
Archivos (ficheros) 341
posi ← HASH(personaaux.cod)
leer(f, posi, persona)
if (persona.ocupado <>'*') o
(persona.cod <> personaaux.cod) entonces
encontrado ← falso
posi ← findatos
mientras posi < max y no encontrado hacer
posi ← posi + 1
leer(f, posi, persona)
si (persona.ocupado = '*') y (persona.cod = personaaux.cod)
entonces
encontrado ← verdad
fin_si
fin_mientras
si_no
encontrado ← verdad
fin_si
si encontrado entonces
leer_otros_campos(personaaux)
personaaux.ocupado ← '*'
escribir(f, posi, personaaux)
si_no
escribir('no está')
fin_si
cerrar(f)
fin
9.10.2. Clave-dirección
Con respecto a las transformaciones clave-dirección deberemos realizar aún algunas consideraciones.
En un soporte direccionable —normalmente un disco—, cada posición se localiza por su dirección absoluta —núme-
ro de pista y número de sector en el disco—. Los archivos directos manipulan direcciones relativas en lugar de absolutas,
lo que hará al programa independiente de la posición absoluta del archivo en el soporte. Los algoritmos de conversión
de clave transformarán las claves en direcciones relativas. Suponiendo que existen N posiciones disponibles para el archi-
vo, los algoritmos de conversión de clave producirán una dirección relativa en el rango 1 a N por cada valor de la clave.
Existen varias técnicas para obtener direcciones relativas. En el caso en que dos registros distintos produzcan la
misma dirección, se dice que se produce una colisión o sinónimo.
• Considerar una zona de excedentes y asignar el registro a la primera posición libre en dicha zona. Fue el méto-
do aplicado en los algoritmos anteriores.
• Buscar una nueva dirección libre en la zona de datos del archivo.