Laboratorio 0001: Almacenamiento con diccionario de datos o Catalogo del sistema

publicado a la‎(s)‎ 10 jul. 2012 19:09 por Hernan Nina Hanco   [ actualizado el 4 jun. 2013 13:50 ]
I) OBJETIVOS
  • Implementar el catalogo del sistema de gestión de bases de datos.

II) MARCO CONCEPTUAL

El catalogo del sistema almacena información del esquema de la base de datos registrada en el sistema de gestión de bases de datos, almacena nombres de tablas, columnas, indices, información de usuarios, claves y demás meta-datos. 

En la presente práctica se implementa un catalogo básico, que solo registra información de las tablas y sus correspondientes atributos. Cada información de tabla se almacena en una entrada de catalogo. El catalogo utiliza una tabla hash para registrar las entradas de catalogo y también las puede localizar en base a las operaciones de la tabla hash.

III) PRÁCTICAS DE LABORATORIO

1) Implementación de una entrada de catalogo
Clase EntradaCatalogo
package org.taqque.almacenamiento;
/**
 * EntradaCatalogo: Almacena toda la informacion referente a una 
 * tabla en el catalogo.
 * 
 * @author hernan
 */
public class EntradaCatalogo implements java.io.Serializable {
    /** Directory of the server. */
    public static String TAQQUE_DIR="d:/prueba";
    /** Tabla para este entrada a catalogo. */
    private Tabla tabla;
    /** El nombre de archvio para la tabla. */
    private String nombreArchivo;
    public EntradaCatalogo(Tabla tabla) {
        this.tabla = tabla;
        crearNombreArchivo();
    } 
    public String getNombreTabla() {
        return tabla.getNombre();
    } 
    public Tabla getTabla() {
        return tabla;
    } 
    public String getNombreArchivo() {
        return nombreArchivo;
    } 
    @Override
    public String toString() {
        return "Tabla: " + getNombreTabla() + ", nombre de Archivo: "
            + nombreArchivo + ", definición: " + tabla+"\n";
    }
    protected void crearNombreArchivo() {
        String nombreTabla = tabla.getNombre();
        nombreArchivo = new String(TAQQUE_DIR
                              + System.getProperty("file.separator")
                              + nombreTabla + "_" + nombreTabla.hashCode());
    } 
}
2) Implementar el catalogo del sistema
Clase Catalogo
package org.taqque.almacenamiento;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.Map;
import java.util.NoSuchElementException;

/**
 * Diccionario de Datos - Meta datos
 * @author hernan
 */
public class Catalogo {
    /** Nombre de archivo del catalogo. */
    private String archivoCatalogo;
    /** Entradas del catalogo, mapean nombres de tabla a entradas. */
    private java.util.Map<String, EntradaCatalogo> entradas;
    /** Numero de tablas actualmente almacenadas en el catalogo. */
    private int numeroDeTablas;
    public Catalogo(String archivoCatalogo) {
        this.archivoCatalogo = archivoCatalogo;
        entradas = new java.util.Hashtable<String, EntradaCatalogo>();
    }
    public void crearNuevaEntrada(EntradaCatalogo entrada)
            throws IllegalArgumentException {
        if (!existeTabla(entrada.getNombreTabla())) {
            entradas.put(entrada.getNombreTabla(), entrada);
            numeroDeTablas++;
        } else {
            throw new IllegalArgumentException("Tabla: "
                    + entrada.getNombreTabla()
                    + " ya existe.");
        }
    }
    protected boolean existeTabla(String nombreTabla) {
        return (entradas.get(nombreTabla) != null);
    }
    @Override
    public String toString() {
        return "Catalogo: " + numeroDeTablas + " tablas.  Entradas: \n"
                + "\t" + entradas.toString();
    }
    // Leer un archivo de catalogo del Disco
    public void leerCatalogo() throws Exception {
        try {
            // Objeto que representa al archivo
            FileInputStream fstream = new FileInputStream(archivoCatalogo);
            // tarea de lectura utilizamos este objeto
            ObjectInputStream istream = new ObjectInputStream(fstream);

            // leer en del número de tablas
            numeroDeTablas = istream.readInt();
            // leer en las entradas del catálogo

            entradas = (Map<String, EntradaCatalogo>) istream.readObject();

            istream.close();
        } catch (Exception ex) {
            System.out.println("Problemas al abrir el archivo: " + ex.getMessage());
        }
    }
    // Metodo para almacenar el catalogo en disco

    public void escribirCatalogo() throws Exception {

        try {
            // Crear un nuevo archivo en disco - Interface acceso de archivo
            FileOutputStream fstream = new FileOutputStream(archivoCatalogo);
            // realizar operaciones de escritura en el archivo
            ObjectOutputStream ostream = new ObjectOutputStream(fstream);

            // write out the number of tables
            ostream.writeInt(numeroDeTablas);
            // write out the entries of the catalog
            ostream.writeObject(entradas);
            // ejecutar el almacenamiento
            ostream.flush();
            ostream.close(); // si no realiza cerrar no almacena 
        } catch (IOException ioe) {
            System.out.println("I/O Exception mientras se almacenaba el archvio del catalogo "
                    + archivoCatalogo + ioe.getMessage());
        }
    }
    
    public void eliminarTabla(String nombreTabla)
        throws NoSuchElementException {
        
        if (! existeTabla(nombreTabla))
            throw new NoSuchElementException("Tabla " + nombreTabla + " no esta "
                                             + "en el catalogo de la BD.");
        entradas.remove(nombreTabla);
        numeroDeTablas--;
    } // deleteTable()

    public static void main(String args[]) {
        try {
            // crear tres nuevas entradas de tabla
            EntradaCatalogo ce1 = new EntradaCatalogo(
                    new Tabla("alumno", new ArrayList<Atributo>()));
            EntradaCatalogo ce2 =
                    new EntradaCatalogo(new Tabla("docente",
                    new ArrayList<Atributo>()));
            EntradaCatalogo ce3 =
                    new EntradaCatalogo(new Tabla("curso",
                    new ArrayList<Atributo>()));

            // crear el catalogo

            Catalogo catalogo = new Catalogo(EntradaCatalogo.TAQQUE_DIR+
                    System.getProperty("file.separator") + "catalogoprueba.dat");
            // añdir informacion a catalogo
            
            catalogo.crearNuevaEntrada(ce1);
            catalogo.crearNuevaEntrada(ce2);
            catalogo.crearNuevaEntrada(ce3);

            // imprimir en patalla el catalogo
            System.out.println(catalogo);
            Thread.sleep(1000);

            // escribir el catalogo en archivo
            System.out.println("Creando catalogo catalog.");
            catalogo.escribirCatalogo();
            Thread.sleep(1000);

            // Leer el catalogo almacenado recientemente
            System.out.println("Leyendo catalogo.");
            catalogo.leerCatalogo();

             // Imprimir nuevamente el catalogo
            System.out.println(catalogo);
            Thread.sleep(1000);
            // Eliminar una Tabla
            System.out.println("Eliminado una tabla.");
            catalogo.eliminarTabla("docente");
             // Imprimir nuevamente el catalogo
            System.err.println(catalogo);
            Thread.sleep(1000);
        } catch (Exception e) {
            System.err.println("Exception " + e.getMessage());
            e.printStackTrace(System.err);
        }
    } // main()
}

3) Implementar una representación básica de una tabla
Clase Tabla
package org.taqque.almacenamiento;
/**
 *
 * @author hernan
 */
public class Tabla extends Relacion implements java.io.Serializable{
      private String nombre;
    
    public Tabla(String nombre) {
        super();
        this.nombre = nombre;
    } 
    public Tabla(String nombre, java.util.List<Atributo> atributos) {
        super(atributos);
        this.nombre = nombre;
    }
    public String getNombre() {
        return nombre;
    }
}

4) Demostración de la utilización del catalogo.
La demostración podemos apreciarla en el método main de la clase Catalogo, puede identificarlo porque tiene el color azul.
El resultado de ejecutar el método main es el siguiente:

run:
Catalogo: 3 tablas.  Entradas: 
{docente=Tabla: docente, nombre de Archivo: d:/prueba\docente_1828437522, definición: {}
, curso=Tabla: curso, nombre de Archivo: d:/prueba\curso_95027356, definición: {}
, alumno=Tabla: alumno, nombre de Archivo: d:/prueba\alumno_-1414605564, definición: {}
}
Creando catalogo catalog.
Leyendo catalogo.
Catalogo: 3 tablas.  Entradas: 
{alumno=Tabla: alumno, nombre de Archivo: d:/prueba\alumno_-1414605564, definición: {}
, docente=Tabla: docente, nombre de Archivo: d:/prueba\docente_1828437522, definición: {}
, curso=Tabla: curso, nombre de Archivo: d:/prueba\curso_95027356, definición: {}
}
Eliminado una tabla.
Catalogo: 2 tablas.  Entradas: 
{alumno=Tabla: alumno, nombre de Archivo: d:/prueba\alumno_-1414605564, definición: {}
, curso=Tabla: curso, nombre de Archivo: d:/prueba\curso_95027356, definición: {}
}
BUILD SUCCESSFUL (total time: 6 seconds)
El resultado indica que se han registrado tres tablas en el catalogo, luego se han escrito en el disco y seguidamente se han leído del disco y se han mostrado en pantalla. Finalmente muestra una entrada eliminada. 
IV) Tarea
  • Modificar el programa anterior, para que muestre información de los atributos de tabla (Campos)
  • Implemente un programa que permita registrar la información de tablas, especificando sus nombres y atributos correspondientes, el programa debe permitir la opción de eliminar entradas y actualizar las mismas sobre cualquier cambio.
V) Refeerencias
  • Se adjunta el código de las clases implementadas hasta la fecha del SGBD.
ċ
Taqque.zip
(30k)
Hernan Nina Hanco,
10 jul. 2012 19:49
Comments