BASESDEDATOS

Bases de datos
Profesor: Jhon Jairo Londoño

Estudiante: Jorge Lozano Arenas
Contenido Temático
1. Conceptos generales de las bases de datos, antecedentes, definiciones de sistema

2. Almacenamiento de la información en repositorios tradicionales
a. Ficheros de acceso secuencial |- CRUD-| = Capture- Read - Update – Delete
Ventajas y desventajas
3. Almacenamiento de la información en repositorios tradicionales
a. Ficheros de acceso directo |-CRUD-| = Capture- Read - Update – Delete
Ventajas y Desventajas
4. Bases de datos relacionales, diseño por el método de las dependencias funcionales
exclusivas [DFE]
a. Normalización a través de los modelos =
● Pseudomatematica
● Relacional
● DDLC (lenguaje, definición de datos)
● Entidad relación
b. Lenguaje para manejo de datos DML
i. Instrucciones básicas =
● Insert
● Select
● Delete
● Update
no exclusivas [DFNE]
a. Normalización a través de los modelos =
● Pseudomatematica
● Relacional
● DDLC (lenguaje, definición de datos)
● Entidad relación

mixtas [DFE-DFNE] / Normalización
╔═════════════ CORTE 1 ══════════════╗
[1]
Conceptos generales de las bases de datos
Cuando se piensa en bases de datos se debe vincular por obligaciones

Definidos en dos conceptos que son:
● Diseño en bases de datos
● Motor en bases de datos
El primer concepto en el más importante, pues hace relación a todos aquellos preceptos de
tipo: Metodológicos; técnicas que se encuentran en los libros tratados y que deberá ser
utilizados de manera lógica y coherente, para construir con estricta funcionalidad, el
escenario donde deberá aparecer la información y sus datos, definiendo relaciones
inteligentes entre los diferentes espacios, contenido dentro de un escenario que hace
referencia a un “Sistema”.
El segundo concepto es el menos importante “menos importante” y hace referencia al
software a través del cual se automatiza es diseño; este software se denomina motor de
bases de datos y se le conoce con los nombres de= MySQL, SQL server, Oracle, para bases
de datos relacionales, Mongo BD y otras para las bases de datos documentales también
llamados BD orientados a objetos o BD No SQL= Not only SQL.
Conclusiones:
1. Referente a las bases de datos se entiende el manejo en los dos tipos de
conceptos sean diseño y motor respectivamente.
2. Respecto a cada concepto, la parte del diseño es la parte lógica propuesta para el
desarrollo en cambio el motor es encargado de la creación y la automatización a
partir del trabajo en bases documentales
1.1
Una diferencia significativa entre bases de datos relacionales y bases de datos documentales
es la siguiente:
Base de dato-Documental
Los “registros” de datos son string o cadenas de

información compuestas por fragmentos de datos
significativos, separados por una coma, un guion, punto y
coma, etc.
La información la distribuye en tablas, asignando a cada columna un nombre, con lo cual se

rompe el paradigma de los string o cadenas;
Cuando se advierte que determinada información es susceptible de “Codificación” se creará
una nueva tabla con el código y la descripción, y en la tabla donde inicialmente aparecía la
descripción, aparecerá ahora un código.
Antecedentes
Antes de que apareciera el concepto e ingeniería de las bases de datos relacionales y esto en
concordancia con la tecnología del momento, la información y sus datos eran guardados en
“cintas magnéticas”, “Discos flexibles”, “Discos duros”, en Archivos secuenciales.
Parecidos a los registros de las Bases de datos documentales, pero no utilizaban el concepto
de “Arreglos”; se arman cadenas o string de datos y se grababa una cadena después de la
otra.
La creación de los aplicativos de software exigía de mucha programación a razón de que
los componentes en base a las operaciones de “borrado” y “modificación” de datos.
No tienen una instrucción propia del lenguaje que los faciliten a diferencia de los motores
de las bases de datos relacionales que tienen sus propias instrucciones para borrar y
modificar.
Independiente del tipo de estructura que se esté utilizando para el almacenamiento de la

información, es decir, archivos secuenciales o bases de datos, es impositivo entender en
primera instancia que es el sistema.
El sistema es el escenario dentro del cual se localiza el “negocio” que motiva la creación de
los controles que deberán incorporarse en la entrada, proceso, salida; En consecuencia, no
podrá existir un repositorio o estructura para el almacenamiento de la información, si de
manera previa no se ha identificado y contextualizado el negocio del sistema.
Ejemplo:
Escenario= Dpto. financiero de la universidad central
Negocios=
1. Compras material didáctico
2. Pagas a proveedores
3. Matrículas estudiantes
4. Construcción edificios
Si se hace hincapié en el negocio matriculas estudiantes, se tendría el siguiente sistema
E P S
Documentos de matriculación Liquidación matricula Recibo de pago-

matricula
Sustanti Ver Sustanti
Todo sustantivo, cómo verbos generan una información en particular, que deberá ser
guardada en una estructura o repositorio denominado “archivo y bases de datos” y así
mismo se elaboran los programas de computador que harán diferentes operaciones con la
información.
Ejemplos de compresión
● Se tiene la siguiente arquitectura que hace relación a una base
documental convirtiéndola a una tabla de datos relacional
100 Pedro 2 1
200 Carlos 1 2
300 María 3 3
400 Paula 2 2
● Construya el sistema con el negocio compras material didáctico
E P S
Solicitud de compra Liquidación Factura

Conclusiones:
1. Las diferencias entre bases de datos documentales y relacionales están representadas
por el uso de signos de puntuación para organización en una tabla para el caso de la
documental y en la relacional es la agrupación de elementos o información en
tablas.
2. Respecto a los antecedentes se entendió la forma de almacenamiento a partir de
archivos secuenciales.
a. Para el sistema se hace hincapié en el negocio usando el formato de
sustantivo-verbo-sustantivo, para la entrada, proceso y salida
respectivamente, a fin de que la información sea guardada en estructuras
o repositorios > Bases de datos.
[2]
Ficheros de manejo secuencial
Un antecedente fundamental a partir del cual se crearon las bases de datos, corresponde a
los “ficheros”.
Un “fichero” es un repositorio o archivo, dispuesto para guardar información y permitir su
acceso, a través de ciertas instrucciones, que fueron construidas por casi todos los lenguajes
de programación, con la propiedad particular de grabar en líneas de datos y de leer líneas de
datos.
Las “líneas de datos”> (registros de datos), son “cadenas o String´s” de información, que
contienen porciones o fragmentos de textos, números o alfanuméricos separados
(Concatenados), a través de un carácter convencional tipo: “guion, “coma”, “punto y
coma”, etc.
Para crear y manejar un “fichero” (Repositorio o archivo secuencial) en java (NetBeans), se
deberá estructurar un programa con la siguiente secuencia de recursos:
Import java…;
Import java…;
Public class fichero 1
{
Public static void main (String [] args)
{
Archivo= new file(c:\-----\empleado);
Grabar ();
Leerunido ();
Leerseparado ();→ Instrucción “Split”
}
Public static void grabar ()
Evita sobrescribir en líneas
{
ya guardadas siempre
//abrir archivo para escritura
después de la última línea.
Fw= New filewrite (archivo, true);
// crear “canal” de comunicación entre teclado y archivos
Br= New Bufferedwrited(fw);
//Ingresar datos desde el teclado mediante una “variable” tipo scanner
Ced=;
Nom=;
Tel=;
//concatenar los datos
Datos= ced + “-” + nom + “- ” + tel; Ejemplo:
// Grabar la cadena
Bw. write(datos); 100 - pedro-
4020
}
Public static void Leerunido ()

{
// Abrir archivo para leer
Fr=new File Reader(archivos);
// Crear canal de comunicación entre el archivo y medio externo:
Br= new BufferedReader (fr);
// Leer del archivo
Datos=br.ReadLine();
// Mostar lo leído
Ejemplo:
System.out.println(“datos”);
// Cerrar el buffer 100 - pedro-
Br.clase(); 4020
}
Public static void Leerseparado ()
{
Fr= new FileReader (Archivo);
Br= new BufferedReader (fr);
Datos= br.ReadLine();
String [ ] parte= datos. Split (“_”);

Vector dinámico
System.out.println(“parte[0]”);
System.out.println(“parte[1]”); Parte
System.out.println(“parte[2]”); 100 Pedro 4020
0 1 2
Br.clase();
}
Conclusiones:
1. La forma de guardar predestina en la programación es el uso de los ficheros
2. Para crear un fichero se es necesario un programa con una serie de recursos
predispuestos
[3]
Archivos secuenciales
(Ficheros de acceso secuencial)
Una de las características físicas de las Bases de datos, es lo de guardar la información de
manera distribuida, utilizando varios archivos denominados “tablas” los cuales y gracias a
las instrucciones brindadas por el “lenguaje” del motor permite la interacción coherente,
funcional e inmediata entre los datos.
Los “archivos secuenciales” mantienen toda la información dentro de un mismo archivo,

pues las instrucciones que se utilizan para su manejo, no tienen la capacidad que tienen las
instrucciones contenidas en los lenguajes para los motores de bases de datos.
Las operaciones de “Modificación” y de “Borrado”, en especial, son operaciones

engorrosas cuando se actúa sobre archivos secuenciales, en razón a que se deberá crear
unas rutinas o métodos de programación que efectúan lo siguiente:
“Borrado de registros”
-ingresar desde teclado cedula a borrar
- abrir archivo, “splitear” la cedula del string leído
- Preguntas si cedula del teclado es igual a cedula “spliteado”:
● Si es no: se debe grabar en un nuevo archivo secuencial al

registro leído
● Si es si: No se graba este registro en el archivo nuevo, pero si
todos los demás
✔ Cerrar el archivo original
✔ Borrar o eliminar (remove) el archivo original
✔ Renombrar el nuevo archivo original(rename)
“Modificación de registros”
Aplica lo mismo utilizado para borrado, teniendo en cuenta que cuando lo encuentra:
● Ingreso desde el teclado los datos modificados y estos se graban

en el nuevo archivo.
Conclusiones:
1. En los archivos secuenciales tenemos la cualidad del uso en formato de borrado,
es decir que mantienen todo dentro de un mismo archivo y en caso dado se hace
una búsqueda hasta remover el archivo necesitado
2. Para borrar datos se hace necesaria la utilización de rutinas programadas
haciendo uso lógicamente de métodos
Ejemplo
de archivo
secuenciales
[4]
Antecedentes de las bases de datos
“Archivos de acceso secuencial”
(Ficheros)
Contienen registros compuestos por “concatenación de datos”, cada registro se arma como
una cadena de datos, separados por un carácter especial, ejemplo raya al piso o coma
2000, Carlos, Médico

1000, Pedro, abogado
4000, María, técnico
3000, Carol, ingeniero
Modificación de registros:
Para los ficheros de acceso secuencial, la modificación de registros, utiliza básicamente la
misma mecánica utilizada para borrar los registros:
1) Ingresar desde el teclado el número de cedula, que obedece al registro que se
quiere modificar
2) Leer el registro del archivo haciendo “Split”, para extraer la cedula, sobre la cual se
harpa la búsqueda
3) Preguntar si la cedula ingresada desde el teclado, coincide con la cedula del registro:
● Si es no:
- Se grabará el registro en un nuevo archivo o fichero
- Se vuelve al paso 2
● Si es si:
- Este registro no se graba en el nuevo archivo
- Se ingresan datos para nombre y profesión
- Se concatenan los datos de cedula, nombre y profesión
- Se graba el registro en el nuevo archivo
- Se graban todos los demás registros del archivo original en
el archivo nuevo.
4)
- Se cierra el archivo original
- Se cierra el archivo nuevo.
5)
- Borrar el archivo original
- Renombrar el archivo nuevo con el nombre del archivo original
Import java. util. Scanner;
Scanner registro= new Scanner (System.in);
Cedula=registro.nextInt();
Nombre=registro.nextInt();
Profesión=registro.nextInt();
Datos= “cedula” + “nombre” + “profesión”;
Bw.write(datos);
Conclusiones:
1) Para la modificación de registros es utilizada la misma mecánica implementada
en borrado de registros cerrando y reescribiendo en un nuevo archivo, pero
manteniendo el mismo nombre anteriormente creado.
2) Se analiza si lo ingresado por teclado coincide con el registro, si esto es así es
posible hacer la modificación , borrado o renombrado en el fichero
[5]
“Cruce entre ficheros de acceso secuencial”
Es posible que en el “plano real” se presente la necesidad de acceder a la información en

un segundo archivo, a partir del primero; este ejercicio no procede de manera inmediata,
pues no resulta posible abandonar un primer archivo, acceder al segundo, o querer volver al
primero sin olvidar el registro de información en donde el apuntador de lectura se
encontraba inicialmente.
Cuando se abandona el primer fichero, el apuntador de la lectura volvería al primer registro
en el instante de retomarse nuevamente el archivo, con lo cual se indica que sería imposible
avanzar en la lectura lógica de nuevos registros:
Código ciudad, Nombre ciudad
Fichero 1
D
Fichero 2 isc
Disco
duro
Cedula, Nombre, Código
ciudad
Si se quisiera obtener un “informe” de todos los registros de ficheros, reemplazando el
código de la ciudad, por el nombre de la ciudad, obligaría a leer el primer registro de
ficheros 1, y con el código de la ciudad (Splitear) ir a fichero 2, comparar con el código
ciudad (Splitear) de fichero 2 extraer el nombre de ciudad, lo cual resultaría, sin embargo,
al volver a fichero 1, el apuntador volvería al primer registro impidiendo avanzar a un
nuevo registro.
Lo anterior se debe solucionar de la siguiente manera:
1) Crear fichero 1, fichero 2, guardar información en cada uno de ellos
2) Subir a una lista de nodos de memoria dinámica el fichero 2: se sube a la Ram
Dato1= Código ciudad
100,
pedro,
médico
200,
Carlos,
Abogado
300,
María,
Ingeniero
400,
Paola,
Medico
100 Pedro 2
200 Carlos 1
300 María 3
400 Paula 2
1 Abogado
2 Médico
3 Ingeniería
1 Abogado
2 Medico
3 Ingeniera
100 Pedro 2 1
200 Carlos 1 2
300 María 3 3
400 Paula 2 2
1 Futbol
2 Tenis
3 Natación
1000,
Pedro, 2
4000,
María, 3
2000,
Carlos, 1
3000,
Carol, 2
7000,
Julián, 3
1,
Medellín
2, Cúcuta
3,
Manizale
s
Dato2= Código ciudad

3) Leer ficheros, splitear código ciudad, buscarlo en “lista” extraer nombre ciudad,
imprimir la información.
Leer siguiente registro.
Disco duro RAM
1000, Pedro, 2
4000, María, 3
1 Med 2 3
2000, Carlos, 1
3000, Carol, 2
7000, Julián, 3
O
K
Conclusiones:
1) El cruce de ficheros de tipo secuencial hace sentido con el hecho de acceder a
valores contenidos, pero solo con un determinado orden.
2) Para hacer más versátil el hecho de reemplazar, cambiar, etc. un registro guardado
la forma más sencilla de hacerla es creando dos ficheros, hacer listas dinámicas
“las que se necesiten” y esta ser implementada en la RAM del computador.
5.1
Bases de datos
public static void armalista()

{
FileReader fr = new FileReader(archivo);
BufferedReader br = new BufferedReader(fr);
int i; String datos;

nodo cab=new nodo();
nodo q=new nodo();
nodo p=new nodo();
for(i=0;i<3;i++) // suponiendo que sean 3 registros

{
p= new nodo ():
datos = br. readLine(); // leer del archivo

splitear lo leido cod y ciud;
p.cod= codigo spliteado;
p.ciud= ciudad spliteada;
if(i==0){
cab=p
; q=p;
}
else{
q.enlace=p;
q=p;
}
}
}
}
class nodo{
String cod;
String ciud;
nodo enlace;
}
[6]
“Ficheros con acceso directo”
Se entiende entonces que un “fichero” es un archivo “txt”, compuesto por registros de

información, en donde cada registro está representado, por una “Cadena”, o “String” de
datos, separados por un carácter especial, por lo general el carácter coma (,) , y cada dato
como tal que es una porción de la “cadena” tiene relación con una información específico
Los ficheros pueden ser accedidos de manera secuencial con lo cual puede “tardar” el
acceso a un determinado “registro” mientras recorre los anteriores.
También los ficheros pueden ser accedidos de manera “Directa”, con lo cual se permite
acceder a un registro determinado, sin necesidad de hacer recorrido los registros anteriores,
mejorando la velocidad de acceso.
Para implementar el acceso directo, se recomienda determinar una “longitud fija” para
todos los registros, facilitando la posición inicial exacta de cada uno de ellos.
Comprensión:
Cedula nombre teléfono
100, pedro,42170, 200, juana,73265, 300, carlos,84321,
16 caracteres 16 caracteres 16 caracteres
0 32
Registros de igual tamaño
16
Guion = fin de registro

FileRandomAccess alias= new FileRandomAccess( “c:\_\_. txt”);
Int pos =16; //localiza el apuntador de la lectura en la posición 16 del string de registros
While
{
Alias.seek(pos);
Registro=alias.readLine();
Splitear [0], [1],[2];
Muestra 0.1.2;
Pide un Nuevo pos;
}
Ya no se define en modo
File alias…
Si no en modo
FileRandomAccess
alias…
REFLEXION:
Actuando sobre el .txt
En un fichero de acceso directo
no se deberá cerrar como en los mismo
secuenciales, para acceder a un
registro anterior al que se encuentra
en memoria
Conclusiones:
1) Por lo general para evitar tener problemas en los ficheros de acceso directo se
agregan más espacios para ingresar datos, es decir, se dejan en blanco
2) La velocidad del acceso en los ficheros directos es mucho mayor al secuencial
por no tener la necesidad de hacer recorridos en registros anteriores
Ejemplo de ficheros directos
Ejercicio de comprensión:
Se tiene dos ficheros con extensión “.txt” cada uno con las mismas características en
cuanto a la cantidad de columnas (variables o atributos) y cantidad de registros; así
mismo los datos contenidos son los mismos.
En la primera columna (primer atributo) de cada registro y en cada uno de los
archivos se encuentra la cedula; son 300 registros y los números de las cedulas van
del número 10 hasta el 300 con incrementos de 10 en 10.
Si se quiere acceder al registro de cedula numero “200”, indique como hacerlo

accediendo al primer fichero de manera secuencial, y al segundo de manera directa.
Explique textualmente y vincule si es el caso alguna instrucción propia del lenguaje
java.
Solución:
1.
Para acceder a un archivo de manera secuencial se tiene en cuenta el hecho de que
esta manera es poco eficiente en la búsqueda de registros por tener que recorrer
todo el archivo, o en este caso una tabla.
Ahora tenemos que efectuar una rutina de tal manera que se pueda ubicar el registro
entre los ya guardados en el archivo .txt, por lo cual se ingresa la cedula que se
quiere buscar; sea para modificación o borrado. Independiente de cual sea el caso se
opta por splitear la cedula y preguntar como ciclo si coinciden con los registros, es
decir que mientras se está recorriendo por medio del spliteado y no hay coincidencia
de los registros con el buscado “200” se colocarán en un nuevo archivo secuencial,
todo esto a fin de que apenas se halle, cierre el archivo original y se guarden los
otros registros y por ultimo se borre (remove) o renombre (rename).
2.
Para el acceso de manera directa al segundo fichero se determina el uso de una
longitud fija para obtener una cantidad de registros de igual tamaño y acceder un
registro determinado sin la necesidad de hacer recorrido en los registros anteriores.
En especifico para este ejemplo se tienen 300 registros pero son dados de 10 en 10
por lo cual se deduce una cantidad total de registros serán separados en registros
iguales, pero como se sabe no todos los registros son iguales, entonces se deja con
un rango mayor al nivel de caracteres y de esta manera identificar la posición inicial
más fácil, es decir que para el registro 200 se tendrá que identificar una cantidad de
20 registros por estar delimitados en incrementos de 10 en 10.
[7]
Explicación de talleres propuestos para identificación de ficheros
secuenciales y directos
1. Para este primer ejercicio de practica se hace énfasis en el ingreso de datos a partir
de una dirección propuesta en el ordenador donde se esté trabajando, en este caso
se utiliza el manejo de ficheros de forma secuencial con los siguientes métodos =
GRABAR – LEER (UNIDO Y SEPARADO) – ELIMINAR Y MODIFICAR.
Todo esto para organizar el fichero por registros conteniendo información de un
empleado: CEDULA, NOMBRE Y TELEFONO.
Información esencial:
Filewriter = Encargado de la escritura para un archivo nuevo.

BufferedWriter =Acceso al disco para agilizar, en resumen, es el puente de
comunicación entre teclado y archivos.
Scanner= Ingreso de datos para el empleado
FileReader = Abre el archivo para ser leido
String [] parte = datos. Split ("-"); = Separación en vector dinámico.
String datos= concatenación de datos
Bw. write(datos) =Grabar cadena
Br. close () = cerrar buffer
Fw. close ()= cerrar writer
Métodos:
Grabar:
Leer unido:
Leer separado:
Borrar registro:
// se hace a partir de la cedula
Modificar:
Codigo:
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package fichero1;
import java.io.*;
import java.util.Scanner;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
*
* @author FABIO BAYONA DUARTE
*/
public class Fichero1 {
/**
* @param args the command line arguments
*/
public static int opcion;
public static void main(String[] args) {

Scanner cont1 = new Scanner(System.in);
try {
// TODO code application logic here
File archivo =
new File("C:\\Users\\FABIO BAYONA DUARTE\\Desktop\\"
+ "ORDEN\\Bases de datos\\Ficheromenu"
+ "\\Fichero1\\empleado.txt");
if (!archivo.exists()) {
archivo.createNewFile();
}
do {
System.out.println("╔═══════════════════════╗")
; System.out.println("║ MENU ║");
System.out.println("╠═══════════════════════╣")
; System.out.println("║ 1.- Grabar ║");
System.out.println("║ 2.- Leer unido ║");
System.out.println("║ 3.- Leer separado ║");
System.out.println("║ 4.- Eliminar ║");
System.out.println("║ 5.- Modificar ║");
System.out.println("║ 6.- salir ║");
System.out.println("╚═══════════════════════╝")
; opcion = cont1.nextInt();
switch (opcion) {
case 1:
grabar(archivo);
break;
case 2:
leerunido(archivo);
break;
case 3:
leerseparado(archivo);
break;
case 4:
borrarRegistro(archivo);
if (archivo.delete()) {
System.out.println("el fichero se borro");
}
archivo = null;
File borrador = new File("C:\\Users\\FABIO BAYONA DUARTE\\Desktop\\ola
si\\Fichero1\\empleadoBorrar.txt");
if (borrador.renameTo(new File("C:\\Users\\FABIO BAYONA DUARTE\\Desktop\\ola

si\\Fichero1\\empleado.txt"))) {
System.out.println("se renombro el archivo");
}
break;
case 5:
Modificar(archivo);
break;
case 6:
System.exit(0);
break;
default:
System.out.println("╔══════════════════════════╗");
System.out.println("║Ingrese un valor dentro del rango de 1 a 6║");
System.out.println("╚══════════════════════════╝");
break;
}
} while (opcion != 7);
Scanner s = new Scanner(System.in);

System.out.println("¿desea eliminar? \n1 si\n2 no");
if (s.nextInt() == 1) {
borrarRegistro(archivo);
}
System.out.println("¿desea Modificar? \n1 si\n2 no");
if (s.nextInt() == 1) {
if (archivo.delete()) {
System.out.println("el fichero se
borro");
}
archivo = null;
File borrador = new File("C:\\Users\\FABIO BAYONA DUARTE\\Desktop\\ola
si\\Fichero1\\empleadoBorrar.txt");
if (borrador.renameTo(new File("C:\\Users\\FABIO BAYONA DUARTE\\Desktop\\ola

si\\Fichero1\\empleado.txt"))) {
System.out.println("se renombro el archivo");
}
} else {
System.exit(0);
}
} catch (IOException ex) {
Logger.getLogger(Fichero1.class.getName()).log(Level.SEVERE, null, ex);
}
}
public static void grabar(File archivo) {

try {
FileWriter fw = new FileWriter(archivo, true);
BufferedWriter bf = new BufferedWriter(fw);

System.out.println("Ingrese porfavor la cedula del usuario");
String ced = s.nextLine();
System.out.println("Ingrese porfavor el nombre del usuario");
String nombre = s.nextLine();
System.out.println("Ingrese por favor el teléfono del usuario");
String tel = s.nextLine();
String datos = ced + "-" + nombre + "-" + tel + "-";
bf.write(datos);
bf.close();
fw.close();
} catch (Exception e) {
System.out.println("no se encontro el archivo");
}
}
public static void leerunido(File archivo) {
FileReader fr = null;
try {
fr = new FileReader(archivo);
BufferedReader br = new
BufferedReader(fr); String datos;
try {
datos = br.readLine();
System.out.println(datos);
br.close();
}
} catch (FileNotFoundException ex) {

} finally {
try {
fr.close();
}
}
}
public static void leerseparado(File archivo) {

try {
try {
String[] parte = datos.split("-");
System.out.println(parte[0]);
br.close();
}

} finally {
try {
fr.close();
}
}
}
public static void borrarRegistro(File archivo) {
System.out.println("Ingrese la cedula que desea eliminar");
String ced = s.next();
try {
String datos;
try {
int i = 0;
File empleadoBorrador = new File("C:\\Users"
+ "\\FABIO BAYONA DUARTE\\Desktop"
+ "\\ola si\\Fichero1\\empleadoBorrar.txt");
empleadoBorrador.createNewFile();
FileWriter fw = new FileWriter(empleadoBorrador, true);
BufferedWriter bw = new BufferedWriter(fw);
while (i != parte.length) {
if (!(ced.equals(parte[i]))) {
bw.write(parte[i] + "-" + parte[i + 1] + "-" + parte[i + 2] + "-");
}
i = i + 3;
}
bw.close();
fw.close();
br.close();
fr.close();

}
}
}
public static void Modificar(File archivo) {

System.out.println("Ingrese porfavor la cedula que desea eliminar");
String ced = s.next();
try {
String datos;
try {
int i = 0;
File empleadoBorrador = new File("C:\\Users"
+ "\\FABIO BAYONA DUARTE\\Desktop"
+ "\\ola si\\Fichero1\\empleadoBorrar.txt");
empleadoBorrador.createNewFile();
FileWriter fw = new FileWriter(empleadoBorrador, true);
BufferedWriter bw = new BufferedWriter(fw);
while (i != parte.length) {
if (!(ced.equals(parte[i]))) {
bw.write(parte[i] + "-" + parte[i + 1] + "-" + parte[i + 2] + "-");
} else {
System.out.println("Ingrese porfavor la cedula nueva");
int Cedula = s.nextInt();
System.out.println("Ingrese porfavor el nombre nuevo");
String nombre = s.next();
System.out.println("Ingrese porfavor el telefono nuevo");
int telefono = s.nextInt();
bw.write(Cedula + "-" + nombre + "-" + telefono + "-");
}
i = i + 3;
}
bw.close();
fw.close();
br.close();
fr.close();

}
}
}
}
2. Para el siguiente ejemplo de ejercicios desarrollados se utiliza un fichero común y
corriente tomando datos del usuario como cedula, nombre y teléfono, pero se
agregará otro fichero, pero en forma de lista pues se creará un puente respecto a la
información que en estas dos es almacenada, relacionado a codigo de ciudad y
nombre de ciudad.
El ejercicio actual tiene similitud con el primer ejercicio solo que a diferencia del
anterior se utilizan dos archivos txt para grabar y leer.
Y un menú diferente dando las siguientes características
Se crean dos métodos, uno para grabar en fichero 1 “personal” y otro para el fichero
2 “ciudad”
Se crean 2 métodos de lectura
Finalmente se agrega el método y su enlazamiento con la lista llamado en este caso
armLista
Codigo:
package fichero2;
import java.io.*;
/**
*
*/
public class Fichero2 {
static Scanner entrada = new Scanner(System.in);
public static void main(String[] args) throws IOException {

File archivo = new File("C:\\archivo1.txt");
File archivo1 = new File("C:\\archivo2.txt");
if (!archivo1.exists()) {
try {
archivo1.createNewFile();
}
}
if (!archivo.exists()) {
try {
archivo.createNewFile();
}
}
Fichero2 p = new Fichero2();

int opcion;
boolean comprobar;
Scanner numero = new Scanner(System.in);
do {
do {
opcion = 0;
comprobar = false;
; System.out.println("║ MENÚ ║");
System.out.println("╠═══════════════════════╣")
; System.out.println("║ 1. Grabar en el fichero 1 ║");
System.out.println("║ 2. Leer separado para el fichero 1 ║");
System.out.println("║ 3. Grabar en el fichero 2 ║");
System.out.println("║ 4. Leer separado para el fichero 2 ║");
System.out.println("║ 5. Salir ║");
; System.out.println("Seleccione una opción de 1 a 5 ");
opcion = numero.nextInt();
if (opcion <= 0 || opcion >= 6) {
System.out.println("╔═════╗");
System.out.println("║ Error ║");
System.out.println("╚═════╝");
} else {
comprobar = true;
}
} while (comprobar == false);
switch (opcion) {
case 1:
Fichero2.grabar(archivo);
break;
case 2:
Fichero2.leerseparado(archivo);
break;
case 3:
Fichero2.grabar1(archivo1);
break;
case 4:
Fichero2.leerseparado1(archivo1);
break;
case 5:
p.armLista(archivo1);
break;
}
}
public static void grabar(File archivo) {

try {
try (FileWriter fw = new FileWriter(archivo, true);
BufferedWriter bf = new BufferedWriter(fw)) {

; System.out.println("║ Digite cedula del usuario ║");
String ced = s.nextLine();
System.out.println("║ Digite nombre del usuario ║");
String nombre = s.nextLine();
System.out.println("║ Digite telefono del usuario ║");
String tel = s.nextLine();
System.out.println("╚═══════════════════════╝");
String datos = ced + "-" + nombre + "-" + tel + "-";
bf.write(datos);
}
} catch (IOException e) {
System.out.println("no se encuentra el archivo");
}
}
public static void grabar1(File archivo1) {
try {
try (FileWriter fw = new FileWriter(archivo1, true);
BufferedWriter bf = new BufferedWriter(fw)) {

System.out.println("╔═══════════════════════╗");
System.out.println("║ Digite el codigo de la ciudad ║");
String cod = s.nextLine();
System.out.println("║ Digite el nombre de la ciudad ║");
String nombreC = s.nextLine();
; String datos = cod + "-" + nombreC + "-";
bf.write(datos);
}
} catch (IOException e) {
System.out.println("no se encuentra el archivo");
}
}
public static void leerseparado(File archivo) {

try {
try {
br.close();
}

} finally {
try {
fr.close();
}
}
}
public static void leerseparado1(File archivo1) {

try {
fr = new FileReader(archivo1);
String datos;
try {
br.close();
}
} finally {
try {
fr.close();
}
}
}
// LISTA PARA INGRESO DE DATOS
class Nodo {
String cod;
String Ciud;
Nodo enlace;
}
private Nodo raiz;
public Fichero2() {
raiz = null;
}
public void armLista(File archivo2) throws IOException {
try {
FileReader fr = new FileReader(archivo2);
try (BufferedReader br = new BufferedReader(fr)) {
int i;
String datos;
String[] parte = datos.split("/");
String[] parte1 = parte[0].split("-");
Nodo p=new Nodo();

p.cod=parte1[0];
p.Ciud=parte1[1];
p.enlace=new Nodo();
p.enlace.cod=parte2[0];
p.enlace.Ciud=parte2[1];
p.enlace.enlace=new Nodo();
p.enlace.enlace.cod=parte3[0];
p.enlace.enlace.Ciud=parte3[1];
raiz=p;
}
}
}
}
Interfaz menú
3. El siguiente ejercicio se hace con base al último tema visto del corte 1 denominado
ficheros de acceso directo el cual se trabaja con archivos prediseñados de txt y su
función se resume en la búsqueda y posible modificación de datos de forma más
eficiente, para este caso se implementa la lectura e impresión de los datos.
Utilizando ahora la extensión FileRandomAccess.
Interfaz menú
Métodos:
Codigo:
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package FicheroAccesoDirecto;
import java.io.*;
import java.io.RandomAccessFile;
/**
*
*/
public class FicheroAccesoDirecto {
/**
* @param args the command line arguments
* @throws java.io.IOException
* @throws java.io.FileNotFoundException
* @throws java.lang.InterruptedException
*/
public static void main(String[] args)
throws IOException,
FileNotFoundException,
InterruptedException {
File archivo1 = new File("C:\\Users\\FABIO BAYONA DUARTE"
+ "\\Desktop\\datos\\FicheroAccesoDirecto.txt");
if (!archivo1.exists()) {
try {
archivo1.createNewFile();
Logger.getLogger(FicheroAccesoDirecto.class.getName()).log(Level.SEVERE, null, ex);
}
}
FicheroAccesoDirecto p = new FicheroAccesoDirecto();
int opcion;
boolean comprobar;
Scanner numero = new Scanner(System.in);
do {
do {
opcion = 0;
comprobar = false;
; System.out.println("║ MENU ║");
System.out.println("║ 1. Leer fichero ║");
System.out.println("║ 2. Imprimir el fichero ║");
System.out.println("║ 3. Salir ║");
; System.out.println("Ingrese una opción de 1 a 3");
opcion = numero.nextInt();
if (opcion <= 0 || opcion > 3) {
System.out.println("╔═══════════════════════╗");
System.out.println("║ Usted ingresó un dato invalido ║");
System.out.println("╚═══════════════════════╝ ");
} else {
comprobar = true;
}
} while (comprobar == false);
switch (opcion) {
case 1:
FicheroAccesoDirecto.leer(archivo1);
break;
case 2:
p.imprimir(archivo1);
break;
case 3:
System.exit(0);
break;
}
}
public static void leer(File archivo1) {

try {
fr = new FileReader(archivo1);
String datos;
try {
String[] parte0 = datos.split("/");
System.out.println(parte0[0]);
br.close();
}

} finally {
try {
fr.close();
}
}
}
public void imprimir(File archivo1) throws FileNotFoundException,

IOException, InterruptedException {
RandomAccessFile fr = new RandomAccessFile(archivo1, "r");
int Pos = 16;
int F = 31;
String registro;
while (true) {
fr.seek(Pos);
registro = fr.readLine();
String[] parte0 = registro.split("/");
}
}
}
╔═════════════ CORTE 2 ══════════════╗
[1]
Bases de datos
Al igual que el diseño de software, el diseño de las bases de datos nace de las necesidades
que reclame el “sistema” para ser automatizado:
Sistema
Software Bases de datos
Tanto “software” como “bases de datos” deberán alinear con el “sistema” y de manera
impositiva software y bases de datos deben ser concordantes.
De lo anterior, los “sistemas” son un absoluto claro y rico procedimientos de lógica que se
encuentran inmersos en los sectores productivos (primario, secundario y terciario) y que
deben ser concebidos inicialmente independientes de software y bases de datos.
La “lógica absoluta” de los sistemas, definen claramente “procedimientos” de la entrada,
proceso y salida.
E P S
Entrada proceso salida

Procedimientos
En consecuencias cuando se habla de automatizar el sistema, hay 3 escenarios que
se pueden automatizar: Entrada, Proceso y Salida.
No obstante, y con base en las necesidades, podrán automatizarse:
- Solo la entrada
- Solo la salida
- Solo el proceso
- Solo entrada y proceso
- Solo entrada y salida
- Solo proceso y salida
- Etc.
Debe quedar claro, que la automatización de los sistemas, implica entonces software
y bases de datos y que estos se deberán fundamentar en lo que es el Diseño.
Un “preliminar” importante de la automatización es el que hace relación a la
“contextualización” del sistema, la cual deberá servir para el diseño de software y para el
diseño de las bases de datos.
El “contexto” es un ejercicio de abstracción (extraer, extender, concluir); que aplica sobre
una “narrativa” de necesidades que solicita el cliente dentro de un “documento”, alrededor
de un sistema que se quiere automatizar, sin cambiar su lógica; se cambia la forma de
trabajar, pero no la lógica del sistema.
Software Bases de datos
El “contexto” de un sistema concordante con la “abstracción “debe utilizar lo siguiente
metodología.
1) Leer la narrativa del cliente
2) Separar,” Lógica de negocio del sistema” de inteligencia de negocios del
sistema: Lógica: Vincula “actores”, vincula procedimiento
Inteligencia: Vincula los informes o reportes que desea el cliente de la
automatización del sistema.
3) Construir el “contexto” con base en los “actores de la lógica” y con base en los
procedimientos, utilizando las siguientes de las 2 preguntas
● Que se va a controlar
● Para quien se va a controlar
-------------------------------------------------------------------------------------------------------------
- ACTOR INICIAL ACTOR FINAL
Actor 1
PARA Actor 2
QUIEN SE
VA A QUE SE VA
ACONTROL A
CONTROLAR
4) Tomar los datos de los informes o reportes y asignarlos dentro del “actor” que
corresponda
Conclusiones:
1) En resumen, el desarrollo de las bases de datos como del software no se hará
trabajo enfáticamente a la entrada, proceso y salida, si no que será puntual en
la automatización de uno o dos de los escenarios propuestos
2) Para hacer un uso debido de la abstracción se debe tener en cuenta los
requerimientos del cliente, lógica del sistema y los dos contextos principales de
para quien y que se va a controlar.
[2]
Arquitectura y diseño
Aunque en la actualidad las bases datos “ha vuelto a tener

relevancia y son estas las que se disponen para las denominadas
bases de datos “ ” (“BDD”),
también llamadas bases datos orientadas a objetos (BDOO) o bases datos not only SQL
(BD. NOSQL), son las bases datos relacionales (BDR) las más frecuentes y recurrentes
por su disposición y funcionalidad para soportar con facilidad las transacciones de tipo
CRUD (create, read, update, delete) que sucede con los datos entre los datos.
Está claro que para diseñar software o diseñar bases de datos es importante abstraer el
“ ” del sistema a partir de la “ en donde mezcla “ ”e
“ ”, además de expresar que es lo que requiere (requerimientos funcionales) del
sistema dentro de un escenario de automatización.
El “contexto” del sistema define lo largo y angosto de lo que se quiera automatizar del
sistema y deberá ser representado de la siguiente manera:
1) Esquema de lo “Que se va a controlar” y “Para quien se va a controlar”
2) Modelo conceptual en términos de un diagrama “Entidad – Relación”, sustentado en
los principios de “Peter Chenn”
Para hacer más comprensible lo anterior, supóngase que se quiere construir el “contexto” de
un sistema, con base en la siguiente “abstracción” producto de la narrativa de un cliente:
Controlar las “facturas” de los “clientes” de un almacén y obtener los informes que
sean requeridos en donde se involucran datos como cédula, nombre, números de
facturas, dirección de cliente, valor total de la factura, profesión del cliente, código
de consumo de facturas, teléfono del cliente.
Reflexión:
De manera explícita la abstracción ya determina “Que se va a controlar” y “para
quien se va a controlar”, con lo cual es facilitara la construcción del Esquema.
Así mismo la “abstracción” hace mención de unos “datos”, los cuales deberán ser
asignados de manera acertada al esquema haciendo uso de la
Ley de la “Autodeterminación”: Al esquema del contexto, el cual estará
representado por “actores” le serán asignados de manera “absoluta” los “atributos”
que representan datos, los cuales deberán ser propios y primitivos de cada actor.
Esquema:
1
1
m
Client 1
es m
Factur
Para quien se va a as
controlar R Que se va a
controlar
Nofac
Relac PK
ión Fechfac
Valtfac
Codcoms
FKD
Después de hacerse sucedido la “autodeterminación”, se elegirá la llave primaria (PK

Primary Key) o atributo encargado de identificar a cada uno de los actores; así mismo se
identificará dentro de cada actor aquellos atributos que se pueden ser expresados como
“códigos”, los cuales de denominarán “llaves foráneas por defecto” (FKD Foreing Key
Default)
Entre el “actor antecesor” y el “actor sucesor” se establecerá una “relación R” la cual será
siempre de uno (1) a muchos (m)
Para el ejemplo en cuestión se leería:
- Hay muchos (m) clientes
- Cada uno (1) de los muchos (m) clientes, tienen muchos(m)
facturas
Esta relación R se denomina “Relación natural”
Finalmente se deberá identificar el tipo de “Relación inversa” que existe ente el “actor y el
sucesor”
Y el “actor antecesor” y que puede ser de 2 formas:
1) DFE: Dependencia Funcional Exclusiva
Define una relación inversa entre los actores sucesor y antecesor de 1 uno a 1 uno.
2) DFNE: Dependencia Funcional Exclusiva
Define una relación inversa entro los actores sucesor y antecesor de 1 uno a m
muchos.
Reflexión:
El tipo de dependencia funcional marca la pauta para construir el diseño de B.D,
para resolver el diseño.
Conclusiones:
1) En la arquitectura y diseño se tiene que tener muy en cuenta la utilización de la

ley de autodeterminación, pues bien sabemos que se necesita extraer la
información correspondiente a nivel de datos para automatizar el procedimiento
que se requiera mejorar o en su defecto cambiar.
Enfáticamente la autodeterminación asigna a cada actor una serie de atributos en
sí mismo.
2) Principalmente para definir hasta que unto llega el contexto del sistema se debe
utilizar primeramente esquemas para entender el principio de control y
posteriormente efectuar el modelo de entidad relación para tener mayor
entendimiento en cuanto al sistema.
[3]
Diseño bases de datos
Modelo conceptual
Es “Peter Chenn” el inspirador del “Modelo conceptual”, el cual se fundamenta en el
denominado modelo entidad relación (MER).
Históricamente ha sido este modelo a partir del cual se empieza a construir el diseño de las
bases de datos, en concordancia con la lógica del sistema, sin contar con algún antecedente
tecnológico o metodológico, que asegura la construcción de lo que se está haciendo.
Si se aporta como antecedente, el “contexto” de la lógica del sistema y así mismo se
identifican los atributos de los actores del contexto los cuales se asignan por la ley de la
“autodeterminación”, identificando así mismo el tipo de “dependencia funcional” entre los
actores, se asegura la construcción del modelo conceptual, facilitando la construcción
posterior del modelo relacional MR, y del modelo DDL (Lenguaje para definición de datos)
el cual aplica sobre el “motor”
De lo anterior, los antecedentes para construir el “modelo conceptual” son:
- Contexto del sistema
- Identificación y asignación de atributos
- Identificar el tipo de Dependencia funcional entre los actores
del “contexto”.
Después de lo anterior, se construirán los “conjuntos” con sus respectivas “llaves” en modo
solución, resolviendo el tipo de “Dependencia funcional” que haya sido identificado.
Los conjuntos obtenidos serán representados como “entidades” para construir el “modelo
conceptual” asociando atributos y definiendo relaciones.
Retomando el “contexto” del ejercicio de la clase anterior, se obtiene:
DFE
m 1 1
Clientes 1
● Ced -PK m
● Nom Factur
● Dir ● Nofac -PK
● Tel ● Fechfac
● Profes- FKD ● Valtfac
● Codcoms - FKD
Código de la 46
profesión Código de
consumo
DFE: (Dependencia funcional exclusiva)
Existe cuando habiendo una relación R de uno (1) muchos (m) entre el actor antecesor y el
actor sucesor del “contexto”, existe una dependencia funcional de uno (1)a uno (1) entre el
actor sucesor y el actor antecesor
Resolver una DFE en modo conjunto y resolver las FKD
C
Clientes
e
d Se refleja
(ley de
,
reflexión)
N Soluciona la
o DFE
m
,
D
i
r
,
T
e
l
,
P
r
o
f
.
p
F
K
D
Prof, Nomprof : Resuelve la FKD
Profesiones
PKE (emergente)
n
Facturas
o
f
Consumos
a
c
,
f
e
c
h
f
a
c
,
v
a
l
t
f
a
c
,
c
o
d
c
o
n
s
o
,
d
c
c
e
d o
p n
s
k
,
n
F o
K m
D c
o
F
n
s
K
P
P
K
E
Autodeterminación ● Ced PK
● Nom
● Dir
● Tel
● Profes FKD
Modelo conceptual (MER Peter Chenn)

Regla de oro: se construye de izquierda a derecha iniciando en modo Entidad (Rectángulo)
con el conjunto que resolvió el último actor del contexto.
m
E
1 ntidad
E consu
ntida
d
Ent
E idad
m 1 ntid m 1 profesio
ad
Otras reglas:
1) A la derecha de las entidades de la izquierda, aparecerán las entidades que tienen
la PK de los FK de las entidades de la izquierda
2) Sigue relaciones de derecha a izquierda en sentido uno (1) a muchos (m)
m 1
3) En lo sucesivo el modelo se leerá de derecha a izquierda e irá el motor de izquierda

a derecha
NOTA: Como el modelo conceptual obtenido es asegurado y objetivo, la construcción del
modelo relacional (MR) será una simple representación en modo tablas, biunívoca
Conclusiones:
1) Para el desarrollo de modelos se enfatiza en las relaciones de 1 a muchos a nivel de
atributos en las relaciones dadas para las entidades, es por esto que se le llama a la
primera relación o modelo DFE o dependencia funcional exclusiva, pues muestra
cómo a partir de una relación se llega a tomar datos que solucionen o automaticen el
modelo.
2) Las reglas para dar solución al modelo se deben cumplir, ya que con estas se da un
correcto manejo de la información tratada y esta a su vez logra por medio del
diagrama explicar las entidades y sus relaciones en base a las Primary key y Foreing
key por defecto.
[4]
Bases de datos
Modelo conceptual por dependencia funcional exclusiva-DFE/
Contexto simple (2 actores)
El modelo conceptual entonces, se fundamenta en el modelo entidad relación de “Peter
Chenn”, y se puede construir de manera “segura y objetiva”, si se cumple con los siguientes
preliminares o antecedentes:
1) Construir el contexto del sistema (abstracción sobre la narrativa del cliente, en

cuanto a lógica y atributo), identificando los “actores” del sistema:
Que se va a controlar
Para quien se va a controlar
2) Identificar el tipo de dependencia funcional (DF) que sucede entre los actores
3) Identificar y asignar los atributos que corresponden a cada actor del contexto, por la
“ley de la autodeterminación”
4) Identificar la PK dentro de cada actor y la FKD que sean necesarias
Después de lo anterior se podrá construir el “modelo conceptual” resolviendo el tipo
de “dependencia funcional” previamente, obteniendo como resultado una solución
en como “conjuntos”. El modelo conceptual cumplirá con las reglas ya
preestablecidas.
TALLER DE APLICACIÓN
● Construir el modelo conceptual a partir del siguiente contexto:

Modelo
tiposerv
Marca
FKD
idmecanico
So Son
n códi 49
códi gos
Contexto:
Controlar las ordenes de servicios a través de los cuales suceden los mantenimientos de los
vehículos, dentro de un taller de mecánica
● Construir el modelo conceptual a partir del siguiente contexto:
m 1 Relación
1 D inversa
Estudia
ntes 1
FE
Cedest m Matric
R ulas
PK
nrorecib
nomest
PK
telest
fechard
valorreci
Relación
natural b banco
Contexto:
Controlar para el departamento de contabilidad de una determinada universidad, las
matriculas registradas por los estudiantes, durante su pertenencia académica. (el
contexto no tiene en cuenta materias)
: SOLUCIÓN PUNTO 1.
SOLUCIÓN PUNTO 2.
Conclusiones:
1) La ejecución de los ejercicios puestos en práctica es importante al nivel de
entendimiento de los PK, FKD y FKP pues de esta manera se logra identificar
las entidades respecto a sus atributos en base a los actores encontrados en el
modelo.
2) El manejo que se le da al modelo debe ser proporcional al creado por Peter Chenn,
efectuando de manera segura y objetiva enfatizando la abstracción del cliente para
su entendimiento lógico en base a entidades y atributos.
[5]
Bases de datos
La
normalización
A propósito del “modelo conceptual”, la “normalización” es un ejercicio inherente al
diseño de las bases de datos, que consiste en garantizar las siguientes características sobre
el diseño de:
1) Distribuir funcionalmente la información, de tal manera que no exista duplicidad de
la misma dentro, ni fuera de los espacios compartidos.
2) Dentro de los espacios compartidos (tablas) establecer una conectividad lógica a
través de un atributo denominado llave principal (Primary key) y otro denominado
llave foránea (Foreing key) por defecto y por proceso.
3) Al no existir duplicidad de la información, se dice no existir “Redundancia” de la
misma con lo cual no existe perdida de espacio en disco
4) La existencia de las FKD (Foreing key por defecto) evitan así mismo la perdida de
espacio en disco, pues la descripción del código solo aparecerá una vez, aunque el
código si muchas veces.
Cuando se obtiene el “método conceptual”, “Asegurado y objetivo”, se está también
obteniendo un “normalización” del diseño de las bases de datos, la cual maneja las
siguientes 5 fases.
1FN= Primera Forma Normal
2FN= Segunda Forma Normal
3FN= Tercera Forma Normal
4FN=Cuarta Forma Normal
5FN= Quinta Forma Normal
Primera Forma Normal

Se dice que el diseño de una base de datos relacional se encuentra en “1FN”, cuando existe
- Un “contexto” lógico del sistema que identifica y relaciona
“actores”
- Una asignación de atributos a cada uno de los actores con base
Lectura
en la ley de la “Autodeterminación”
extensa y
profunda, y
un ejercicio
inteligente
de
Segunda Forma Normal
Se dice que el diseño de una base de datos relacional, se encuentra en “2FN”, cuando está
en “1FN” y además cumple con:
- Identificar las PK (Primary Key) de cada actor del contexto
- Identificar las FKD (Foreing Key por Defecto) dentro de
los atributos de cada actor
- Definir el tipo de dependencia funcional (DF) entre los actores
del contexto y que puede ser “exclusiva” (DFE) o “no
exclusiva” (DFNE).
Tercera Forma Normal
Se dice que el diseño de una base de datos relacional se encuentra en “3FN”, cuando
estando en “1FN” Y “2FN”, cumple con las siguientes características.
- Construir el primer conjunto del diseño el cual se encuentra
solucionado en razón a que no existe un actor anterior del
contexto que lo esté condicionando y que previamente se
ha tenido una “autodeterminación” segura.
- Construir los conjuntos que sean necesarios con base en los
actores que se encuentran en “DFE”, en este caso se hace uso de
la “ley de reflexividad” en donde la PK del actor antecesor, se
“Refleja” en el actor sucesor en un modo conjunto, como FKP
(Foreing key por proceso).
- Construir los conjuntos derivados de las FKD (Foreing key por
defecto) , los cuales tendrán una PKE ( primary key emergente)
seguida de los nuevos atributos que describen esta PKE, que por
lo general es un código.
Conclusiones:
1) En la normalización la idea principal es la de manejo de datos con la mayor

efectividad a fin de reducir tiempo de ejecución y versatilidad en disco
referenciando a la duplicidad y codigo repetido pues no verán afectado el
espacio propuesto para la información que sea almacenada.
2) El fin total e la normalización en resumen de cuentas es: evitar redundancia de
datos, reducir errores en la actualización de datos y por ultimo la protección de
datos. En estos casos de modelo relacional se el denominan tabla a la relación y
debe cumplir con tener nombre único, no puede tener filas iguales, todos los
datos de una columna deben ser iguales.
[6]
Bases de datos
Diseño de modelo relacional y diseño de modelo DDL (Lenguaje
para definición de datos)
Después de construido el “contexto del sistema” y de construido el modo selección el

modelo pseudomatematica (conjuntos) y el modelo conceptual (modelo ) debidamente
“asegurado y objetivo” , se podrá construir a través de una representación normal el diseño
por el modelo relacional y el diseño por el modelo, DDL.
Ejercicio de abstracción que separa lógica del negocio o inteligencia del negocio
Interacciones entre los actores y clases o entidades

- Relaciones 1-m naturales
- Relaciones inversas (dependencias
funcionales) DF = DFE 1-m // DFNE m-m
Informes o reportes requeridos donde se encuentran los atributos
Dando continuidad al “modelo conceptual” relacionado con el “contexto del sistema”
clientes facturas se obtiene:
D. Modelo entidad relación
D. modelo relacional (tablas)
Profesiones
Prof
Clientes PK
Recordando: Cedu PK Nomp
1) Se localizan las entidades (MER)Nom rof iniciando
o las tablas (MR) de izquierda a derecha
D
con el conjunto que solucionó el “último actor del contexto”
i
2) Ubicar a la derecha las entidades o tablas que tienen los PK de las FK de
r
la izquierda.
3) Las relaciones se harán de derecha a izquierda, se leerá el diseño de derecha a
izquierda, irá al motor de derecha a izquierda.
Diseño:
create database ventas;

use ventas;
create table profesiones

(
prof int (2),
nomprof varchar (20),
primary key (prof)
);
create table consumos

(
codconsu int (2),
nomconsu varchar (15),
primary key (codconsu)
);
create table clientes

(
cedu int (10),
nom varchar (30),
dir varchar (30),
tel int (12),
prof int (2),
primary key (cedu),
foreign key (prof) references profesiones (prof)
);
create table facturas

(
nofac int (8),
fechfac date,
valfac int (12),
codconsu int (2),
cedu int(10),
primary key(nofac),
foreign key(codconsu) references consumos (codconsu),
foreign key (cedu)references clientes(cedu)
);
Imágenes ejemplo tomadas de Paiza.io
Facturas
Nofac PK
Fechfac
Valfac
Codconsu FKD
Cedu FKP
Consumos
Codconsu PKE
nomconsu
Conclusiones:
1) En esta primera utilización del motor, aplicado en la página paiza.io se pudo
experimentar la forma en la que trabaja una relación pasada a codigo, utilizando
una serie de caracteres muy bien relacionadas con lenguajes de programación
empleados.
2) Es clara la utilización de las relaciones pues se deben cumplir una serie de pasos
que ayuden al desarrollo de este en el motor en forma de codigo, esta serie de
pasos se darán claramente al hacer los dos tipos de diagrama los cuales son modelo
entidad relacional y modelo entidad relación.
Estos dos son los encargados de mostrar el orden para cada “clase” que para todos
los casos es dada en el orden de derecha a izquierda.
[7]
Bases de datos
PLSQL básico (Insert, select, delete, update)
create table Test(id integer, title varchar(100));

insert into Test(id, title) values(1, "Hello");
select * from Test;
-- Your code here!
create database base30;
use base30;
create table empleados
(
cedu int (10),
nom varchar (20),

suel int (10),
ciu int (2),
primary key (cedu)
); ejecutar
insert into empleados (cedu,nom,suel,ciu)

values (100, "pedro", 800000, 2),
(200, "maria", 900000, 1),
(300, "juana", 700000, 2),
(400, “raul", 600000, 2),
A partir de los datos
(500, "ruben", 800000, 1); Ejecución = ingresados se produce
una tabla con 5
registros de personas
distintas
Muestra todos los registros de datos, con
todos los atributos o columnas
select * from empleados;

select cedu,nom from empleados;
Muestra todos los registros de datos,

pero solo con las columnas
requeridas (cedu y nom )
select * from empleados order by ciu; ejecutar/ analizar 1

select * from empleados order by suel; ejecutar/ analizar 2
select * from empleados where ciu = 1; ejecutar/ analizar 3
select * from empleados where ciu = 2; ejecutar/ analizar 4
select * from empleados where suel > 700000; ejecutar/ analizar 5
select * from empleados where suel < 800000; ejecutar/ analizar 6
select * from empleados where suel > 700000 and ciu = 2; ejecutar/ analizar 7
select * from empleados where suel < 900000 and ciu = 1; ejecutar/ analizar 8
Muestra los registros de la

tabla que cumplen con las 2
condiciones
select * from empleados where suel > 700000 or ciu = 2; ejecutar/ analizar 9
Muestra los registros de la tabla

que cumplen con las 2
condiciones, o cualquiera de los
2
select count (*), ciu from empleados group by ciu order by ciu; 10
Se debe indicar que el
Cuenta todos los
conteo lo hago por
registros de la tabla, con
grupos de ciudades 60
bases en el criterio
(ciu) por tanto es
“ciu”
obligado ordenar
ANALIZIS
1
Se genera una tabla en

base a 5 registros de las
5 personas distintas
referente a la cedula,
nombre, sueldo y
ciudad.
--------------------------------------------------------------------------------------------------------------
2
Se produce una nueva
tabla , pero en esta se
produce una serie de
cambios bastante visibles,
pues si se hace énfasis en
la última columna
referente a la ciudad ,
estas son organizadas de
menor a mayor
--------------------------------------------------------------------------------------------------------------
3
Para la siguiente tabla se

hace un cambio referente a
los sueldos que gana cada
uno de los empleados.
--------------------------------------------------------------------------------------------------------------
4
Se hace una tabla en donde solo se

muestre los empleados que viven
en la ciudad número 1.
--------------------------------------------------------------------------------------------------------------
5
Se produce ahora una tabla solo

con los empleados que viven en
la ciudad numero 2.
--------------------------------------------------------------------------------------------------------------
6
Para la siguiente tabla se

produce un cambio respecto a
cuáles empleados tienen un
sueldo mayor a los 700 mil.
--------------------------------------------------------------------------------------------------------------
7
Nuevamente se efectúa una

comparación a fin de verificar
en la tabla que tipos de personas
tienen un salario menor a 800
mil.
--------------------------------------------------------------------------------------------------------------
8
Se hace una comparación respecto al

salario o sueldo y este a su vez debe
corresponder con la ciudad indicada
en el codigo la cual es la numero 2.
9
Es muy similar a la anterior

comparación pero en este se encuentra
el cambio respecto a que debe
efectuarse que se menor a 900 mil y
debe coincidir el empleado con la
ciudad número 1.
10
En este caso en específico se

efectúa la comparación
respecto a que se haga una
tabla de empelados que
tengan un salario mayor a 700
mil o tengan de ciudad la
numero 2.
11
Por ultimo se hace una tabla que

identifique con respecto al orden
por ciudad en cantidad, en este
caso dos viven en las ciudad
número 1 y 3 en la ciudad
número 2.
Conclusiones:
La aplicación colocada en este caso de tables demuestra la
utilización referente al codigo que se prueba en el motor, esto
enfatiza el hecho de entender el funcionamiento de las tablas en las
bases de datos.
70
Se entiende de mejor manera la utilización de tablas y la
organización de datos con la utilización de las instancias where, and, or
y order hasta el momento.
[8]
Bases de datos
PLSQL básico / update,
delete
CEDU NOM SUEL CIU

100 PEDRO 800000 2
200 MARIA 900000 1
300 JUANA 700000 2
400 RAUL 600000 2
500 RUBEN 800000 1
Use base 30;

Select * from empleados;
update empleados set nom = "carol" where cedu=300;
select " ";
update empleados set suel = 1000000 where suel > 700000;
select " ";
update empleados set ciu = 1 where cedu=400;

select " ";
update empleados set suel=950000;
Cuando no hay where, el
select " "; update actúa sobre todos
los registros de la tabla
update empleados set suel=700000 where ciu=1;
select " ";
delete from empleados where cedu=300;
select " ";
delete from empleados where suel > 700000 and ciu =1;
select " ";
delete from empleados;

Cuando no hay
select * from empleados; where, el delete borra
todos los registros de
select " "; la tabla
Volver a hacer los “INSERT”

- “Procedimientos almacenados”
- Un procedimiento almacenado “PA”, es un programa de
computador que se construye a instancias del motor y que
permite “automatizar” la ejecución de largas sentencias del
“SQL” escritas desde la linea de commandos, o finalmente
para solucionar requerimientos que exigen de complejas tareas
que son dificiles de resolver desde la linea de commandos.
- PA para empaquetar sentencias basicas del PLSQL
delimiter //
create procedure pa20()
begin
select * from empleados
where ciu=2;
select " ";
end;
//
delimiter ;
call pa20();
-PA con paso de parámetros
delimiter //
create procedure pa23 (in ciuaux int)
begin
select* from empleados where ciu =ciuaux;
end;
//
delimiter ;
call pa23(2);
call pa23(1);
Imágenes de paiza.io
Para este caso en especifico se tomó el
mismo formato de tabal anterior respecto a
relación, enfáticamente se implementó la
utilización de más métodos en donde se
expresarán los diferentes cambios, pero esta
vez separados por espacios.
Se efectúa el cambio respecto a la
cedula numero 100 el cambio de
nombre por carol.
Los empleados s que tengan
sueldos menores a 700000 serán
aumentados a 1000000.
El empleado que tiene la cedula
número 400 se le produce una
reescritura donde su nueva ciudad es la
numero 1.
Se pone un sueldo total para
todos los empleados de 950000.
A los empleados que viven en la
ciudad número 1 se les dará un salario
de 700000.
Borra empleado con la cedula
numero 300
Borra los empleados que
tengan un sueldo mayor a 70000 y
tengan como ciudad la numero 1
Borra los empelados
Conclusiones:
1) La utilización de instancias nuevas muestran las formas de modificar archivos ,

enfáticamente para este caso se implementa lainserción de datos nuevos , cambios y
borrado de datos ya guardados
2) Se hace enfazis en la utilización en empaquetado de datos, pues estos mejoran
el rendimiento en la utilización de los datos
[9]
B
ases
Empleados
de
dato
s
PLS
QL
pro
gra
mac
ión
bási
ca
CEDU NOM SUEL CIU

100 PEDRO 800000 2
200 MARIA 900000 1
300 JUANA 700000 2
400 RAUL 600000 2
500 RUBEN 800000 1
-Procedimientos de almacenado básico-

Un procedimiento de almacenado PA, es un programa elaborado a instanciar el motor, que
utiliza las sentencias básicas del SQL (Insert, select, update, delete), pero igual involucra
restricciones de control universales como for, while, repeat, loop, etc, además de las
instrucciones para condicionales if-then-else.
Aplicación:
Delimiter //
Create procedure pa10()
begin
select * from empleados();
end
//
Delimiter ;
Call pa10(); Cada vez que se desee hacer un

select general a “empleados”
bastará con volver hacer = pa10;
Aplicación PA con paso de valor por parámetro
inpu
Delimiter // t
Create procedure pa20( in ciuaux int) parámetr
Begin o
Select * from empleados where ciu = ciuaux;
End;
//
Delimiter ;
Call
pa20(2);
100 pedro 800000 2

300 juana 700000 2 Resultado
400 raul 600000 2
Call pa20(1);
200 maria 900000 1

Resultado
500 rubén 500000 1
Aplicación PA con pasos de valores con parámetros
Delimiter //
Create procedure pa20( in, suelaux, ciuaux, int)
Begin
Select * from empleados where ciu =ciuaux and suel > suelaux;
End
//
Delimiter ;
Call pa30 (600000,2);
100 pedro 800000 2

Resultado
300 juana 700000 2
Codigo:
Create table Test(id integer, title varchar(100));
select * from Test;
-- Your code here!
use base30;
(
cedu int(10),
nom varchar(20),
suel int(10),
ciu int (2),
primary key (cedu)
);
insert into empleados(cedu,nom,suel,ciu)

values(100,"pedro",800000,2),
(200,"maria",900000,1),
(300,"Juana",700000,2),
(400,"Raul",600000,2),
(500,"Ruben",800000,1);
use base30;
delimiter //
create procedure pa10()
begin
Select* from empleados;
end;
//
delimiter ;
call pa10();
delimiter //
create procedure pa20 (in ciuaux int)
begin
select* from empleados where ciu=ciuaux;
end;
//if
delimiter ;
call pa20(2);
call pa20(1);
select " ";
delimiter //
create procedure pa30 (in suelaux int, ciuaux int)
begin
select* from empleados where ciu=ciuaux and suel>suelaux;
end;
//
delimiter ;
call pa30(600000,2);
Pantallazo:
Resultado:
Conclusiones:
1) El manejo de guardado básico respecto a la utilización de datos, se hace más

explicita en la utilización de instancias y restricciones de control, todo esto a fin
de que se reduzca el procesamiento, pero este caso fue la separación de datos
correspondiente a la cuidad y el sueldo por empleado.
2) La utilización de elementos tales como where y and , determina que factores o datos
de la tabla serán cambiados o eliminados, siendo enfático en la selección por dato
que fue almacenado.
[10]
Bases de datos
Programación PA con manejo de cursores
Empleados
CEDU NOM SUEL CIU

100 PEDRO 800000 2
200 MARIA 900000 1
300 JUANA 700000 2
400 RAUL 600000 2
500 RUBEN 800000 1
Si:
Select * from empleados
where ciu = 2;
CEDU NOM SUEL CIU

100 PEDRO 800000 2
200 JUANA 700000 2
400 RAUL 600000 2
Entonces:
delimiter //
create procedure pacu1 (in ciuaux int)
begin
declare ced1,suel1,ciu1 int;
declare nom1 varchar(20);
declare fin int default 0;
declare cursor1 cursor for select * from empleados;
declare continue Handler for not found set fin=1;
open cursor1;
repeat
fetch cursor1 into ced1,nom1,suel1,ciu1;
if ciu1=ciuaux then
select ced1,nom1,suel1,ciu1;
end if;
until fin = 1 Empleados
end repeat;
close cursor1; Cursor1 = es un
end; objeto dinámico tipo
C
/ Select e vector
d
/ u
d N Fetch : leer el
o
e m cursor
C
l e
l
i Cedu/nom/suel/ciu C
i
m u
i
t
e
r
;
call pacu1(2);
Define de
manera Ced1 nom1 suel1 ciu1
automática, en
mismo número
Ced1 nom1 suel1 ciu1
de “columnas
de select”
Se procede a colocar una nueva instancia relacioanda a ciudad 2 y sueldo mayor a 700000
Select * from empleados where ciu =2 and suel > 700000;

delimiter //
create procedure pacu2 (in ciuaux int, suelaux int)
begin
open cursor1;
repeat
if not fin then
if (ciu1=ciuaux) and (suel1> suelaux) then
end if;
end if;
until fin = 1 end repeat;
close cursor1;
end;
//
delimiter ;
call pacu2(2,700000);
CODIGO:

select * from Test;
-- Your code here!
use base30;
(
cedu int(10),
nom varchar(20),
suel int(10),
ciu int (2),
primary key (cedu)
);
insert into empleados(cedu,nom,suel,ciu)

values(100,"pedro",800000,2),
(200,"maria",900000,1),
(300,"Juana",700000,2),
(400,"Raul",600000,2),
(500,"Ruben",800000,1);
use base30;
Select * from empleados where ciu =1;
delimiter //
create procedure pacu1 (in ciuaux int)
begin
open cursor1;
repeat
if ciu1=ciuaux then
end if;
close cursor1;
end;
//
delimiter ;
call pacu1(2);
select " ";
Select * from empleados where ciu =2 and suel > 700000;

delimiter //
create procedure pacu2 (in ciuaux int, suelaux int)
begin
open cursor1;
repeat
if not fin then
if (ciu1=ciuaux) and (suel1> suelaux) then
end if;
end if;
close cursor1;
end;
//
delimiter ;
call pacu2(2,700000);
PANTALLAZO:
CONCLUSIONES:
1) Cuando se quiere tener un procesamiento mucho más rápido y eficiente en la

utilización de bases de datos, se implementan instancias tales como declare, open y
repeat.
Todo esto se da gracias a la utilización de cursores, los cuales se encarga de hacer
consulta de datos por medio de recorridos en forma de columnas para hacer más
rápida la ejecución
2) La forma de procesar datos por medio de cursores es tipo fila a fila , todo este
proceso de cursores se hace por medio de una serie de pasos los cuales son:
a. Declarar cursor
b. Abrir cursor
c. Tomar cada fila
d. Cerrar cursor
e. Designar cursor
[11]
B
INNER JOIN ases
de
datos
PLS
QL
básic
oy
avan
zado
Permite dentro de una sentencia SQL básica un tipo “select”, migrar de una tabla a otra
buscando por ejemplo la descripción de un código:
Aplicaciones
Mayor tiempo de procesamiento
select * from Test;
-- Your code here!
use base30;
create table ciudades
(
ciu int (2),
nomciu varchar(20),
primary key (ciu)
);
insert into ciudades(ciu,nomciu)
values(1,"medellin"),
(2,"cali"),
(3,"Bogotá"),
(4,"Yopal");

(
cedu int(10),
nom varchar(20),
suel int(10),
ciu int (2),
primary key (cedu)
);
insert into clientes(cedu,nom,suel,ciu)

values(100,"pedro",800000,3),
(200,"maria",900000,1),
(300,"carlos",750000,4),
(400,"juana",860000,2),
(500,"carol",900000,3),
(600,"Ruth",820000,1);
use base30;
select clientes.cedu,clientes.nom,clientes.ciu,clientes.suel,
ciudades.nomciu from clientes
inner join ciudades on clientes.ciu=ciudades.ciu;
Resultado para caso simple
Menor tiempo de procesamiento

select * from Test;
-- Your code here!
use base30;
create table ciudades
(
ciu int (2),
nomciu varchar(20),
primary key (ciu)
);
insert into ciudades(ciu,nomciu)
values(1,"medellin"),
(2,"cali"),
(3,"Bogotá"),
(4,"Yopal");

(
cedu int(10),
nom varchar(20),
suel int(10),
ciu int (2),
primary key (cedu)
);
insert into clientes(cedu,nom,suel,ciu)

values(100,"pedro",800000,3),
(200,"maria",900000,1),
(300,"carlos",750000,4),
(400,"juana",860000,2),
(500,"carol",900000,3),
(600,"Ruth",820000,1);
use base30;
delimiter //
create procedure migrar()
begin
declare ced1,suel1,ciu1,ciuaux int;
declare nomciu1 varchar(20);
declare cursor1 cursor for select * from clientes;
open cursor1;
repeat
select nomciu into nomciu1 from ciudades where ciu= ciu1;

select ced1,nom1,suel1,ciu1,nomciu1;
until fin=1 end repeat;

close cursor1;
end;
//
delimiter ;
call migrar();
Resultado para caso con cursor
Conclusiones:
1. El inner join tiene como función principal la migración de datos entre tablas de
datos, estos deben ser de valores idénticos en los dos campos para ser comparados y
unidos.
Para el caso del innner join puede ocasionarse perdida de filas en alguna de las
tablas por tener valores nulos o por tener un valor que no exista en la otra tabla entre
los campos/columnas que se están comparando
2. Cuando se hace utilización del inner join es posible aplicarlo a dos contextos, el de
longitud de código y procesado.
En el caso de longitud solo se hace necesaria la creación de las tablas y la
invocación del método inner join
Para el caso de procesado, referenciando velocidad, se utilizan cursores para hacer
el paso de información y así migrar de forma más rápida.
[PARCIAL #2]
m 1
1 D
Inmue
bles 1
FE
matrin m Refaccio
R nes
PK
noctoref
valin
PK fechcto
tipoin
valocto
tiporefac
FKD
Construya:
Solución modelo seudomatemático

Solución modelo
relacional 3.Solución
modelo DDL 4.Alimentar
las tablas
5.Construir un PA que permita con cursores, representar un inner join
SOLUCIÓN
1. Solución modelo seudomatemático
Inmuebles matrin, valin ,tipoin, iddueño

PK FKD FKD
TipoInmu tipoin, nomin

PKE
Infodueño iddueño, nomdue,teldue.localdue

PKE
Refracciones nuctoref, fechcto, valocto, tiporefac, matrin

PK FKD FKP
Claserefac tiporefac, nomrefac

PK
Clasere
fac
Entida
d refracciones
Tipoin
mu
Entidad
inmuebles
Infodu
eño
2. Solución modelo relacional
Entidad Infodueño
inmuebles Iddueño
matrin, PK PKE
valin nomdue
tipoin teldue
3. Solución modelo DDL
Create database Inmuref;

Use inmuref;
Create table Infodueño

(
Iddueño int (15),
Nomdue varchar (20),
Teldue int (10),
Localdue varchar (20),
Primary key (iddueño)
);
Create table Tipoinmu
(
Tipoin int (20),
Nomin varchar (20),
Primary key (tipoin)
);
Create table inmuebles

(
Matrin varchar (20),
Valin int (15),
Tipoin int (20),
Iddueño int (15),
Primary key (Matrin),
Foreing key (tipoin) references Tipoinmu (tipoin)
Foreing key (iddueño) references Infodueño (iddueño)
);
Create table Claserefac
(
Tiporefac varchar (20),
Nomrefac varchar (20),
Primary key (Tiporefac)
);
Create table refracciones
(
Nuctoref int (20),
Fechcto int (15),
Valocto int (15),
Tiporefac varchar (20),
Primary key (Nuctoref)
Foreing key (Tiporefac) references Claserefac (Tiporefac)
Foreing key (Matrin) references inmuebles (Matrin)
);
4. Alimentar las tablas
insert into refacciones(nuctoref,fechto,valocto,tiporefac)

values(100,2017,850000,2),
(200,2016,900000,3),
(300,2000,755000,1),
(400,2015,451200,4),
insert into inmuebles(Matrin, valim,tipoin,iddueño)

values(100,850000,1,100),
(200,900000,4,200),
(300,755000,3,300),
(400,532100,2,123),
insert into Claserefac( Tiporefac, nomrefac)
values (1, carpinteria)
(2, plomería)
(3, enchapado)
(4, tecnología)
Insert into Tipoinmu (tipoin, nomin)
Values (1,casa)
(2, apartamento)
(3, lote)
(4,chosa)
Insert into Infodueño (iddueño,nomdue,teldue,localdue)
values(100,”Camilo”,123,avenida 124 # 3),
(200,”Andrea”,456,carrera 29ª 56),
(300,”Felipe”,789,calle la esperanza),
(400,”Juan”,147,avenida 26f 16),
(500,”Alfredo”,159,carrera f 23);
5. Construir un PA que permita con cursores, representar un inner join
Inner join:
delimiter //
create procedure pasodatos()
begin
declare matrin1,valim1,tipoin1,iddueño1,tipoinaux int;
declare nom1 int(20);
declare nomin1 varchar(20);
declare cursor1 cursor for select * from inmuebles;
open cursor1;
repeat
fetch cursor1 into matrin1,valim1,tipoin1,iddueño1;
select nomin into nomin1 from Tipoinmu where tipoin= tipoin1;

select matrin1,valim1,tipoin1,iddueño1,nomin1;
until fin=1 end repeat;

close cursor1;
end;
//
delimiter ;
call pasodatos();
╔═════════════ CORTE 3 ══════════════╗
[1]
Bases de datos
-Trigger-
Un trigger es también un procedimiento almacenado PA, que a diferencia de los PA
tradicionales, tiene la propiedad de “autoejecutarse” cuando advierte la activación de una
secuencia SQL sobre las tablas que han sido asociadas a las alertas requeridas, de tipo
delete y update especialmente, pero también de tipo Select e Insert.
La palabra “Trigger” significa “Disparador” o “Alerta” y como PA se utiliza para construir

escenarios de “auditoria” ligados a la “seguridad informática” norma Iso 27001, a través de
los cuales se hace posible crear “tablas de seguimiento” que se encarga de guardar los
registros que han sido borrados o modificados de tablas que hacen parte de las B.D de
determinados negocios; en estas tablas también se guardan datos como fecha y hora en que
se produjo la transacción y el responsable.
Si:
auditoria
Con datos Sin datos

Clientes
Codigo 1:

select * from Test;
-- Your code here!
use base30;

(
cedu int(10),
nom varchar(20),
suel int(10),
primary key (cedu)
);
insert into clientes(cedu,nom,suel)

values(100,"pedro",800000),
(200,"carol",900000),
(300,"luisa",850000),
(400,"ruth",920000),
(500,"carlos",870000),
(600,"juan",950000);
Create table auditoria

(
ceda int(10),
noma
varchar(20), suela
int(10), fecha
date,
usua varchar(20),
primary key (ceda)
);
delimiter //
create trigger tr1 after delete on clientes
for each row
begin
insert into auditoria(ceda, noma,suela,fecha,usua)
values (old.cedu, old.nom, old.suel, now(),"pedro");
end ;
//
delimiter ;
delete from clientes where suel > 900000;

select * from clientes;
select "-------";
select * from auditoria;
use base30;
Codigo 2:

select * from Test;
-- Your code here!
use base30;

(
cedu int(10),
nom varchar(20),
suel int(10),
primary key (cedu)
);
insert into clientes(cedu,nom,suel)

values(100,"pedro",800000),
(200,"carol",900000),
(300,"luisa",850000),
(400,"ruth",920000),
(500,"carlos",870000),
(600,"juan",950000);
Create table auditoria

(
ceda int(10),
noma
varchar(20), suela
int(10), fecha
date,
usua varchar(20),
primary key (ceda)
);
delimiter //
create trigger tr1 after delete on clientes
for each row
begin
insert into auditoria(ceda, noma,suela,fecha,usua)
values (old.cedu, old.nom, old.suel, now(),"pedro");
end ;
//
delimiter ;
delete from clientes where suel > 900000;
select "-------";
delimiter //
create trigger tr2 after update on clientes

for each row
begin
insert into auditoria(ceda,noma,suela,fecha,usua)
values(old.cedu,old.nom,old.suel,now(),"pedro");
end;
update clientes set nom = 'Julian' where cedu = 200;

select " ";
Pantallazo trabajo- paiza.io
Compilación codigo 1
Compilación codigo 2
Conclusiones:
1) En bases de datos, la utilización de la función trigger es de suma importancia para la
modificación de datos a fin de tener noción del momento en el que fue hecha la
actualización respecto a tablas, con relación ha guardado en dos tablas.
La primera encargada del almacenamiento de datos originales, y la segunda del
almacenamiento de datos referente a los cambios producidos.
2) Las principales operaciones efectuadas en el trigger son: Insert, delete y update.
Gracias a estas operaciones se tiene un control claro de la información de la base
de datos, y como principal utilidad del trigger se destaca la prevención de errores
dada una modificación, inserción u eliminación de algún dato en la sincronización
de tablas.
[2]
Bases de datos
-Dependencia funcional no exclusiva DFNE-
Una DFNE es la relación inversa de una (1) a muchos (m) entre 2 componentes del
contexto del sistema.
Una DFNE siempre se resuelve armando una “llave compuesta” con base en la PK del
componente antecesor y la PK del componente sucesor del contexto del sistema.
Con base en la “llave compuesta” se crearán siempre en 2 tablas:
- Tabla con los atributos que dependen de las dos partes de la
llave.
- Tabla con los atributos que depender de la segunda parte de la
llave.
Aplicación:
m 1 DF
Facturas
1
NE
nofac m Articu
R los
PK
fechfa codar
t PK
nomart
valuart
canvar
Cantidad Código
vendida del de bodega del
articulo articulo
Contexto:
Lógi Que se va a controlar: Atributos

ca de
nego
cio
107
Para quien se va a controlar: Facturas
Informes o
Inteligen
Reportes > atributos para asignar el contexto
cia de
negocios
1) Diseño Modelo seudomatematico:
facturas nofac, fechfac, idcli
PK FKD
Clientes idcli, nomcli, telcli

PKE
Fkp Fkp
Fact-art nofac + codart, canvart
PKE
Depende de las dos partes de

la llave
Articulos codart, nomart, valuart, codboart

PK FKD
Bodegas C
o
d
b
o
a
r
t
,
d
i
r
b o
o P
, K
t E
e
l
b
2) Diseño modelo relacional
R
e
f
r
a
c
c
i
o
n
e
s
N
u
c
t
o
r
e
f
P
K
F
e
c
h
c
t
o
V
a
l
o
c
t
o
T
i
p
o
r
e
f
a
c
F
K
D
M
a
t
r
i
n
F
K
P
C
l
a
s
e
r
e
f
a
c
ti
p
o
r
e
f
a
c
P
K
n
o
m
r
e
f
a
c
T
i
p
o
i
n
m
u
T
i
p
o
i
n
P
K
E
n
o
m
i
n
CED NOM SUEL
CEDA NOMA SUELA FECHA SUELA
100 Pedro 800000
200 Carol 900000
300 Luisa 850000
400 Ruth 920000
500 Carlos 870000
600 Juan 950000
Izquierda a derecho se ubican las tablas

3) Diseño modelo DDL
--create table clientes

-create table bodegas
-create table facturas
-create table articulos
-create table fact-art

(
Nofac int (6),
Cordart int (2),
Canvart int (4),
Primary key(nofac,codart),
Foreing key( nofac) references facturas (nofac),
Foreing key(codart) references articulos (codart)
);
Conclusiones:
1) La dependencia funcional no exclusiva tiene solución a partir de llaves compuestas,
con el fin de dar solución desde la normalización de 4FN y 5FN
2) Cuando se hace relación respecto a la dependencia funcional no exclusiva en la
parte del modelo DDL es necesario implementar las llaves foráneas llamando las pk
de cada clase para poder cumplirse la dependencia.
[3]
Bases de datos
- DFNE –
-Diseño modelo entidad relación MER
F
a
c
t
-
a
r
t
N
o
f
a
c
F
K
P
p
k
C
o
d
a
r
t
F
K
P
c
a
n
v
a
r
t
facturas clientes
Nofac PK Idcli PK
Fechfac Nomcli
Idcli FK Telcli
articulos
codart PK
nomart
valvart
cantvart Bodegas
codboard FK
Codboart PK
Dirbo
Telbo
Cuando se obtiene una “llave compuesta”, se dice estar configurando una “Relación
fuerte” y esta deberá representarse a través de un “Rombo” inscrito dentro de un
“Rectángulo” o “cuadro”, esta representación recibe el final el nombre de
“agregación “, pues el rectángulo o cuadro sugiere que el rombo se deberá convertir
en una “entidad” y que como tal deberá “agregarse” al diseño
nofac
c Entidad Entidad
Rel
ació
n
c
Entidad Entidad
Entidad por
agregación
Obsérvese que el icono rombo blanco negro no se vincula

Rentacar:
cuando la entidad antecesora participa en la creación de la
relación fuerte
m Contratos 1 DF
alquiler 1
NE
m Vehícu
nrocto
R los
PK
placa PK
fechcto
idmarca
totcto
FKD color
modelo
idconductor
Atributo que
dependería
nrocto+placa
F
a
c
t
-
a
r
t
N
o
f
a
c
F
K
P
p
k
C
o
d
a
r
t
F
K
P
c
a
n
v
a
r
t
facturas clientes
Nofac PK Idcli PK
Fechfac Nomcli
Idcli FK Telcli
articulos
codart PK
nomart
valvart
cantvart Bodegas
codboard FK
Codboart PK
Dirbo
Telbo
Contratos nrocto fechcto totcto idctista

PK FKD
Contratista idctista nomtista telctista

PKE
Nofac-codart nrocto+placa idconductor

PK
Vehiculos placa idmarca color modelo idconductor

PK FKD FKD
Marca idmarca nommarca

PKE
Conductor Idconductor nomconductor telconductor

PKE
norct
o
Entidad Entidad
Rela
ción
fuert
e
id
c Entidad Entidad
Entidad por
agregación
Conclusiones:
1) Cuando se habla de dependencia funcional no exclusiva, tratamos con el hecho de
que los diseños respecto a entidad relación son diferentes, pues como característica
principal en esta se hace el diagrama con un rombo que contiene la relación fuerte y
no se vincula cuando la entidad antecesora participa en la creación de la relación
fuerte
2) Al tratar la DFNE siempre se debe estar precavido pues se debe tener noción de
la relación que debe haber en la relación fuerte pues en caso dado que se tomen
mal las asociaciones de las clases será de poca utilidad la aplicación DDL
[4]
Diseño bases de datos
-Normalización 4FN-5FN-
La cuarta forma normal (4FN) y la quinta forma normal (5FN), son manifestaciones propias
de la normalización inherentes a la solución de las dependencias funcionales no exclusivas
(DFNE).
Cuando se habla de 4FN, hay que advertir que sucede algo particular con la 3FN, pues esta
última se sucede en el instante en que la PK del “componente antecesor” se refleja en el
“componente sucesor” armando un “llave compuesta” con la PK de este último
componente; cada una de las partes de la “llave compuesta” se convierte a su vez en
“FKP”.
La “4FN” se manifiesta, cuando se construye el “conjunto” con los atributos que dependen
de las dos partes de la llave.
La “5FN” se manifiesta, cuando se construye el “conjunto” con los atributos que dependen
estrictamente de la “segunda” parte de la llave.
Aplicación:
m
1 Estudiante m DF
1 NE
ides Mate
R rias
t PK
idma
nome
t PK
st
nomm
at
credit
N
r
o
c
t
o
+
p
l
a
c
a
N
o
r
c
t
o
F
K
P
p
k
P
a
l
c
a
F
K
P
I
d
c
o
n
d
u
c
t
o
r
contratos
nrocto PK
fechcto
totcto
idctista FKD
c
o
n
t
r
a
t
i
s
t
a
I
d
c
t
i
s
t
a
P
K
N
o
m
c
t
i
s
t
a
t
e
l
c
t
i
s
t
a
v
e
h
i
c
u
l
o
s
p
l
a
c
a
P
K
i
d
m
a
r
c
a
c
o
l
o
r
m
o
d
e
l
o
i
d
c
o
n
d
u
c
t
o
r
F
K
D
C
o
n
d
u
c
t
o
r
I
d
c
o
n
d
u
c
t
o
r
P
K
N
o
m
c
o
n
d
u
c
t
o
r
T
e
l
c
o
n
d
u
c
t
o
r
Estudiante idest nomest telest codprof

PK FKD
codigoprof codprof nomprof

PKE
Idest-idmat idest+idmat codprof

PK
Materias idmat nommat créditos nota codprof

PK FKD
Conclusiones:
1) Cuando se habla de normalización de 4FN y 5FN se debe tener en cuenta
que hacemos relación a dependencias funcionales no exclusivas
2) La 4NF se asegura de que las dependencias multivaluadas independientes estén correctas y
eficientemente representadas en un diseño de base de datos.
3) La 5FN es un nivel de normalización de bases de datos diseñado para reducir redundancia
en las bases de datos relacionales que guardan hechos multi-valores aislando
semánticamente relaciones múltiples relacionadas.
[5]
Dependencias funcionales mixtas
-(DFE-DFNE/DFNE-DFE)-
I
d
e
s
t
+
i
d
m
a
t
i
d
e
s
t
F
K
P
p
k
i
d
m
a
t
F
K
P
c
o
d
p
r
o
f
P
r
o
f
e
s
i
ó
n
C
o
d
p
r
o
f
P
K
n
o
m
p
r
o
f
estudiante
Idest PK
nomest
telest
codprof FKD
materias
idmat PK
nommat
créditos
nota
codprof FKP
P
r
o
f
e
s
i
ó
n
C
o
d
p
r
o
f
P
K
n
o
m
p
r
o
f
clientes Idcli , nomcli, Telcli , Profe

PK FKD
Profesión Profe , codprof

PKE
Facturas Nrofac, Fechfac, Valtfac, Sucur
PK FKD
Sucursal Sucur, codsucur
PK
Fac – art Nrofac+ codart, cantvart

PKE
Articulos Codart, nomart, valtunart, cantvart, Sucur, Nrofac+cod
art
PK FKD
FKP
SucursalArt Sucur, codsucur

PK
Fact-art
Nofac
p
FKP
Codart
nofac
Entidad facturas Entidad clientes

codart
Relación fuerte fact-art
117
c
Conclusiones:
Al final de “Dependencias funcionales mixtas” – DFNE /DFE -
[6]
Dependencias funcionales mixtas
-(DFNE-DFE)-
clientes
Idcli PK
Nomcli
Telcli
Profe FK
Profesiones
Profe PKE
Codprof
fa
c
t
u
r
a
s
N
o
f
a
c
P
K
F
e
c
h
f
a
c
V
a
l
t
f
a
c
S
u
c
u
r
F
K
ar
t
i
c
u
l
o
s
c
o
d
a Bodega
s
r
C
t
o
P d
K b
n o
o a
m r
t
a
P
r K
t D
v i
a r
l b
v o
Telbo
a
r
t
c
a
n
t
v
a
r
t
c
o
d
b
o
a
r
d
F
K
Modelo pseudomatemático
Planviajes Idplan, Fechplan, Destiplan, Codaeroli

PK FKD FKD
Destinos Destiplan, nomdesti

PKE
Aerolinea codaeroli, nomaeroli
PKE
Plan – pas Idplan + idpas, sillapas

PKE
Pasajeros idpas, nompas, telpas, activpas
PK FKD
Actividades activpas, nomactiv

PKE
Factuconsu nofac, fechfac, Codconsu, Valfac, Idplan +

PK FKD idpas
F
Consumos Codconsu, nomconsu

PK
Modelo relacional
Modelo DDL

use base30;
create table destinos

(
destiplan varchar(20),
nomdesti varchar(20),
primary key (destiplan)
);
create table aerolineas
(
codaeroli int (10),
nomdesti varchar(20),
primary key (codaeroli)
);
create table actividades
(
activpas varchar(20),
nomactiv varchar (20),
primary key (activpas)
);
create table planviajes
(
idplan int(20),
fechplan int (20),
destiplan varchar(20),
codaeroli int(10),
primary key (idplan),
Foreign key (destiplan) references destinos (destiplan),
Foreign key (codaeroli) references aerolineas (codaeroli)
);
create table pasajeros

(
idpas int (10),
nompas varchar (20),
telpas int (10),
activpas varchar (20),
primary key (idpas),
foreign key (activpas) references actividades (activpas)
);
create table consumos
(
codconsu int(10),
nomconsu varchar(20),
primary key (codconsu)
);
create table plan_pas
(
idplan int(8),
idpas int (10),
sillapas int(4),
primary key (idplan, idpas),
foreign key (idplan) references planviajes (idplan),
foreign key (idpas) references pasajeros (idpas)
);
create table factuconsu
(
nofac varchar(20),
fechfac int(10),
codconsu int(10),
valfac int(20),
idplan int(8),
idpas int(10),
primary key(nofac),
foreign key (codconsu) references consumos (codconsu),
foreign key (idpas) references plan_pas (idpas)
);
Conclusiones:
1) Cuando hablamos de dependencias funcionales mixtas, podemos recalcar el hecho
de que se puede hacer utilización de las normalizaciones completamente, haciendo
énfasis en la 4fn y 5fn que son presentadas en estos últimos ejemplos tratados
2) La utilización de las dependencias funcionales mixtas hace necesario entender
cómo funciona la relación que en ellas se encuentra y como debe implementarse la
información que se compilada en estas, pues un fallo en estas, como lo puede ser en
las llaves puede generar problemas en la normalización.
[7]
Aporte introductorio software
Clientes
extend
● Ced -PK Factu
● Nom ras
● Nofac -PK
● Tel
● Fechfac
● Activ- FKD
● Valtfac
● S
include
u
n
c d
l e
Conclusiones:
1) La aplicación de las bases de datos va ligada a la ingeniería de software, la cual
se ve reunida en ella misma por relaciones o herencias como sucedía en la
programación orientada a objetos
2) Los diagramas aplicados desde las bases de datos tienen relación por diagramas
haciendo utilización de extends e includes
[8]
Bases de datos
-Trabajo final-
1. Construir el contexto de un sistema con 2 componentes (clases externas), cada

componente con 4 atributos y dentro de cada componente un FKD
La dependencia funcional deberá ser no exclusiva (DFNE) y se quiere
a) Diseño pseudomatemático
b) Diseño modelo relacional
c) Diseño modelo DDL
d) Diseño modelo entidad relación
2. Con sus palabras defina

a. Que es 1fn
b. Que es 2fn
c. Que es 3fn
d. Que es 4fn
e. Que es 5fn
Solución:
Primer punto
1. Se hace la creación de una base de datos referenciada a DFNE tomando dos clases
principales, haciendo referencia a una empresa que cuenta con empleados y productos,
estos se relacionan debido a que 1 un empleado tiene dominio de muchos productos, pero
cada producto “unidad” lo posee muchos empleados
Aplicación:
1 Empleado m DF
1 NE
idempl Produc
R tos
e PK
idmat PK
nomemp
nomproduc
le
canvpro
Diseño modelo pseudomatematico
Empleado idemple nomemple telemple codempre
PK FKD
codigoempresa codempre, nomempre

PKE
Idemp-idproduc idemp+idproduct, canvpro

PK
productos idproducto, nomproduct, canvpro, coddistri

PK FKD
Distribución coddistribu, registrodistri
PKE
----------------------------------------------------------------------------------------------
Diseño modelo relacional

Izquierda a derecho se ubican las tablas
Distribución
Coddistribuu PK
registrodistri
Prod
uctos
idproduct PK
nomproduct
canvpro
coddistribu
FKD
Diseño modelo DDL
create table codigoempresa

(
codempre int(10),
nomempre int(10),
primary key (codempre)
);
create table distribucion
(
coddistribu int(15),
registrodistri varchar(20),
primary key (coddistribu)
);
(
idemple int(10),
nomemple varchar(20),
telemple int(15),
codempre int(10),
primary key (idemple),
Foreign key (codempre) references codigoempresa (codempre)
);
create table productos

(
idproduct int(6),
nomproduct varchar(20),
canvpro int(4),
coddistribu int(15),
primary key (idproduct),
Foreign key (coddistribu) references distribucion (coddistribu)
);
create table emp_product
(
idemple int (10),
idproduct int (6),
Canvpro int (4),
Primary key(idemple,idproduct),
Foreign key( idemple) references empleados (idemple),
Foreign key(idproduct) references productos (idproduct)
);
--------------------------------------------------------------------------------------------------------------
Diseño modelo entidad relación
idemple
Entidad Entidad
idproduct
empleado codigoempresa
Relación
fuerte
emple-
produc
canvpro Entidad Entidad distribución

producto
Entidad por
agregación
--------------------------------------------------------------------------------------------------------------
Segundo punto
Según lo aprendido en la materia bases de datos las normalizaciones aplicadas serán
definidas de la siguiente manera:
Normalización- termino- racionalización personal
1FN= Primera forma normal = la primera forma normal es aquella que se destaca por hacer
referencia a los atributos que no pueden ser separados es decir son simples, por otra parte
las tablas en las que se registran los datos si cambia el orden no debe haber variación en
este en sus significados.
Esto quiere decir en resumen de cuentas que por ley de la autodeterminación se generan los
atributos de los actores y se tiene el contexto lógico base del que se quiere tratar.
2FN= Segunda forma normal= Cuando se habla de 2FN hablamos de la primera ley de
conjuntos presentada en la normalización, pues se conoce que la 2FN se presenta cuando
esta tiene contenida en si misma la 1FN, en este contexto aparecen las llaves mostrando
para los actores la PK (primary key) y para los atributos FKD (Foreing key por defecto).
A su vez gracias a este empieza a darse la definición por dependencia funcional sea:
exclusiva o no exclusiva.
3FN= La tercera forma normal se puede resumir en el contexto de que en ella se debe
contener la 2FN, ahora bien, en este caso se debe cumplir el hecho de que la primary key no
debe estar dependiendo con otro atributo, es decir que en el caso de que se cumpla una
dependencia de este tipo, es necesario dividir la tabla con los datos que este contiene
4FN= La cuarta forma normal se puede presentar mientras esté presente la tercera forma
normal y en este caso es posible la eliminación redundante o las relaciones de muchos a
muchos gracias a esta. Es decir que la 4FN tiene como fin el orden de datos y a su vez
evitar que se presente información redundante.
Cuando se hace énfasis en la 4FN sucede algo particular con la 3FN, pues esta última se
sucede en el instante en que la primary key del “componente antecesor” se refleja en el
“componente sucesor” armando un “llave compuesta” con la PK de este último componente
Es decir que cada una de las partes de la “llave compuesta” se convierte a su vez en “FKP”.
5FN= La quinta forma normal es la ultima de las normalizaciones que se encarga de

mostrar como la 4FN la información o datos evitando la redundancia, pero en el caso de la
5FN solo se presenta en la segunda parte de la llave.
Fin de documento
Presentado por: Fabio Andrés Bayona Duarte
Para la asignatura: Bases de datos

BASESDEDATOS

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

BASESDEDATOS

Cargado por

Copyright:

Formatos disponibles

Bases de datos

Profesor: Jhon Jairo Londoño

1. Conceptos generales de las bases de datos, antecedentes, definiciones de sistema

6. Bases de datos relacionales, diseño por el método de las dependencias funcionales

Cuando se piensa en bases de datos se debe vincular por obligaciones

Los “registros” de datos son string o cadenas de

La información la distribuye en tablas, asignando a cada columna un nombre, con lo cual se

Independiente del tipo de estructura que se esté utilizando para el almacenamiento de la

Documentos de matriculación Liquidación matricula Recibo de pago-

Sustanti Ver Sustanti

● Construya el sistema con el negocio compras material didáctico

Solicitud de compra Liquidación Factura

Public static void Leerunido ()

String [ ] parte= datos. Split (“_”);

Los “archivos secuenciales” mantienen toda la información dentro de un mismo archivo,

Las operaciones de “Modificación” y de “Borrado”, en especial, son operaciones

● Si es no: se debe grabar en un nuevo archivo secuencial al

● Ingreso desde el teclado los datos modificados y estos se graban

2000, Carlos, Médico

Es posible que en el “plano real” se presente la necesidad de acceder a la información en

Código ciudad, Nombre ciudad

Dato1= Código ciudad

Dato2= Código ciudad

public static void armalista()

int i; String datos;

for(i=0;i<3;i++) // suponiendo que sean 3 registros

datos = br. readLine(); // leer del archivo

Se entiende entonces que un “fichero” es un archivo “txt”, compuesto por registros de

100, pedro,42170, 200, juana,73265, 300, carlos,84321,

16 caracteres 16 caracteres 16 caracteres

Guion = fin de registro

Si se quiere acceder al registro de cedula numero “200”, indique como hacerlo

Filewriter = Encargado de la escritura para un archivo nuevo.

public static void main(String[] args) {

if (borrador.renameTo(new File("C:\\Users\\FABIO BAYONA DUARTE\\Desktop\\ola

Scanner s = new Scanner(System.in);

if (borrador.renameTo(new File("C:\\Users\\FABIO BAYONA DUARTE\\Desktop\\ola

public static void grabar(File archivo) {

Scanner s = new Scanner(System.in);

public static void leerunido(File archivo) {

} catch (FileNotFoundException ex) {

public static void leerseparado(File archivo) {

} catch (FileNotFoundException ex) {

} catch (FileNotFoundException ex) {

public static void Modificar(File archivo) {

} catch (FileNotFoundException ex) {

Y un menú diferente dando las siguientes características

static Scanner entrada = new Scanner(System.in);

public static void main(String[] args) throws IOException {

Fichero2 p = new Fichero2();

public static void grabar(File archivo) {

Scanner s = new Scanner(System.in);

Scanner s = new Scanner(System.in);

public static void leerseparado(File archivo) {

} catch (FileNotFoundException ex) {

public static void leerseparado1(File archivo1) {

Nodo p=new Nodo();

public static void leer(File archivo1) {

} catch (FileNotFoundException ex) {

public void imprimir(File archivo1) throws FileNotFoundException,

Entrada proceso salida

Aunque en la actualidad las bases datos “ha vuelto a tener

Después de hacerse sucedido la “autodeterminación”, se elegirá la llave primaria (PK