¿Qué

es una Base de Datos?

Una base de datos es un conjunto de información organizada

que cumple con un objetivo común.

Sin embargo, hablando desde el punto de vista tecnológico,

estas bases de datos deben estar almacenadas de manera
persistente en un medio electrónico/digital.
Características que debe cumplir una BD:

• Versatilidad en la representación de la información.

• Desempeño.
• Mínima Redundancia.
• Capacidad de Acceso. (Compartida y concurrente).
• Simplicidad.
• Integridad.
• Seguridad y Privacidad.
SGBD
Sistema Gestor de Bases de Datos. (DBMS)

Es la herramienta de software que permite administrar una base de datos.

• Crear
• Modificar
• Poblar
• Actualizar
• Seleccionar
• Borrar
• Administrar privilegios

Dentro de los SGBD Relacionales más conocidos están: Dentro de los SGBD No Relacionales más conocidos:
• MySQL • MongoDB
• Sql Server • FireBase
• Oracle • CouchDB
• DB2 • Neo4j
• Informix • Cassandra

Para el presente curso utilizaremos el SGBDR Llamado Postgresql.

Fases del diseño de las bases de datos

• Diseño Conceptual
• Diseño Lógico
• Diseño Físico
 Diseño Conceptual
Modelo Entidad Relación - MER
Atributo1 Atributo1
Atributo2 Atributo2
Atributo3 Atributo3

ENTIDAD RELACIÓN ENTIDAD

Conceptos
Entidad: Representa un objeto/elemento del
ENTIDAD Universo de discurso (Del problema a resolver).
Nombre_atributo
Entidad Débil: Representa un objeto/elemento del
ENTIDAD Universo de discurso (Del problema a resolver)
pero que necesita de una relación con otra entidad
Nombre_atributo
para su identificación.

Relación: Representa el tipo de relación entre

Relación entidades.

Relación con dependencia de identificación:

Relación Representa el tipo de relación que identifica la
dependencia entre entidades.
Representan las características de
ROL: Es la representación de la unión entre las los atributos.
relaciones y las entidades. (Conector).
 Tipos de Atributos Atributo
Compuesto
Atributo simple Atributo Identificador Atributo Identificador Atributo Atributo
y monovaluado Principal Alternativo multivaluado Opcional

Único Único per no Varios Valores Dato no es Varios Valores

Mas utilizado para una
es principal obligatorio
“Nulo o vacío” definición
Restricciones
Tipo de Correspondencia de cardinalidades

Número máximo de ejemplares de una entidad asociados a una combinación de

ejemplares de las otras entidades en la interrelación, que puede ser 1 o N.

1:N

Persona Posee Vehículo

Restricciones
Cardinalidades Máximas y Mínimas
Son el número máximo y mínimo de ejemplares de una entidad que puede
relacionarse con un único ejemplar de la otra entidad que participa en la
interrelación. Se representan como (0,1), (1,1), (0,N), (1,N) y se situan en la línea
que conecta la entidad con el rombo que representa el tipo de interrelación.

1:N
(0,1) (0,N)
Persona Posee Vehículo
Conceptos
Ejemplo de Relación.
Nombre Edad Estatura Placa Modelo Color
1:N

Persona Posee Vehículo

Relación Recursiva
Nombre Edad Estatura

Persona compañer @
 Ejemplo:
Se requiere un sistema de información que permita gestionar la información de los
Arriendos/Alquileres de las viviendas.

Este sistema debe contener la información del propietario de la(s) vivienda(s) y la información
que se debe contemplar para dicho propietario es: identificación, nombre completo, teléfonos de
contacto y opcionalmente el correo electrónico. La(s) vivienda(s) deben tener la información de:
código de la vivienda, dirección, la cual está compuesta por: calle y número, la vivienda debe
tener además una descripción y la cantidad de habitantes. Cada vivienda se encuentra ubicada
en una ciudad y dicha ciudad pertenece a un departamento/estado. Se debe tener la información
de los arriendos/alquileres los cuales tendrán la información de: fecha de inicio, fecha de fin,
valor mensual. Y también se requiere conocer la información del (los) inquilino(s), la información
de este debe ser: identificación, nombre completo y teléfonos.
 nombres apellidos
código código nombre
Identifi.
nombre dirección
1:N N:1
(1:1) (1:N) (0:N) (1:1)
PROPIETARIO Posee VIVIENDA Ubicada CIUDAD

(1:1) (1:N)

telefonos email cant_habitantes descripción

N:1 Pertenece

nombres apellidos (1:1)

1:N Participa
Identifi. DEPARTAMENTO
nombre
N:M (0:N)

(1:N) (1:N)
INQUILINO Realizado ARRIENDO
código nombre

telefonos código f_inicio f_fin valor_mensual

 Diseño Lógico
Modelo Relacional - MR

R(atributo1, atributo2, atributo3, …, atributoN)

Traducción del MER al MR:
ENTIDADES, ATRIBUTOS SIMPLES Y MONOVALUADOS RELACIONES Y ATRIBUTOS
Nombre Edad Estatura PERSONA(Nombre, Edad, Estatura)

dominio(Nombre) : carácter de tamaño n

Persona dominio(Edad): entero de 0 hasta 150
dominio(Estatura): decimal de 0 hasta 2.90

ENTIDADES, ATRIBUTOS OPCIONALES RELACIONES Y ATRIBUTOS

Nombre Edad Email

PERSONA(Nombre, Edad, Email*)

Persona
ENTIDADES, ATRIBUTOS COMPUESTOS RELACIONES Y ATRIBUTOS

Apellidos
PERSONA(Nombre_Nombres, Nombre_Apellidos, Edad)
Nombre Edad
dominio(Nombre_Nombres) : carácter de tamaño n
dominio(Nombre_Apellidos) : carácter de tamaño n
Persona dominio(Edad): entero de 0 hasta 150

ENTIDADES, ATRIBUTOS MULTIVALUADOS RELACIONES Y ATRIBUTOS

Nombre Edad Teléfonos

PERSONA(Nombre, Edad)

TELEFONOS(Telefono)
Persona
ENTIDADES, ATRIBUTOS MULTIVALUADOS
CLAVES PRIMARIAS Y CLAVES FORANEAS RELACIONES Y ATRIBUTOS

Nombre Edad Teléfonos

PERSONA(Nombre, Edad)

Persona TELEFONOS(Nombre, Telefono)

O
PERSONA

TELEFONOS(Nombre, Telefono)
RELACIONES
CARDINALIDAD 1:N 1:N
Una Persona
posee muchos
PERSONA Posee VEHÍCULO vehículos
PERSONA(Nombre, edad, dirección)

VEHÍCULO(Nombre, modelo, color)

1:N

(0,1) (0,N) Máximo

PERSONA Posee VEHÍCULO

(0,N)
(0,N) Persona puede tener mínimo 0 y máximo muchos vehículos

Mínimo
(0,1) Un vehículo puede pertenecer mínimo a 0 y máximo a 1 persona
RELACIONESCARDINALIDAD N:M

N:M

ALUMNO Matricula MATERIA

ALUMNO(identificacion, nombre, edad)

MATRICULA(identificacion, codigo)

MATERIA(codigo, nombre, salon, horario)

 nombres apellidos calle número
código código nombre
Identifi.
nombre dirección
1:N N:1
(1:1) (1:N) (0:N) (1:1)
PROPIETARIO Posee VIVIENDA Ubicada CIUDAD

(1:1) (1:N)

telefonos email cant_habitantes descripción

N:1 Pertenece

nombres apellidos (1:1)

1:N Participa
Identifi. DEPARTAMENTO
nombre
N:M (0:N)

(1:N) (1:N)
INQUILINO Realizado ARRIENDO
código nombre

telefonos código f_inicio f_fin valor_mensual

 Modelo Relacional
PROPIETARIO(identificacion, nom_nombres, nom_apellidos, email*)

TELEFONOS(identificación, telefono)

VIVIENDA(código, dir_calle, dir_numero, cant_habitantes, descripción, identificación, codigo_ciudad)

CIUDADES(codigo_ciudad, nombre, departamento)

DEPARTAMENTO(codigo_departamento, nombre)

ARRIENDO(codigo, f_inicio, f_fin, valor_mensual, codigo_vivienda)

ARRIENDO_INQUILINO(codigo, identificacion)

INQUILINO(identificacion, nom_nombres, nom_apellidos)

TELEFONOS_INQUILINOS(identificación, telefono)
Representación Tabular

R {
(atributo1, atributo2, atributo3, …, atributoN),
(atributo1, atributo2, atributo3, …, atributoN),
(atributo1, atributo2, atributo3, …, atributoN),
…
(atributo1, atributo2, atributo3, …, atributoN)
}
Restricciones:
• Restricción Nulo: No permite que el valor del atributo sea nulo.
• Restricción de Identidad: No permite tener dos valores repetidos en las
claves primarias.
• Restricción de Integridad de Entidad: No permite tener valores nulos en la
clave primaria.
• Restricción de Integridad Referencial: No permite tener valores en la clave
foránea que no existan en la clave primaria. Sin embargo, si permite tener
valores nulos en la clave foránea.
• Restricción de Clave Alterna: No permite valores repetidos en la clave
alterna.
• Restricción de Dominio: Los datos deben ser del dominio específico.
Ejemplo: dominio de los números enteros comprendidos entre 0 y 18.
Operaciones Transaccionales
• INSERCIÓN
• ELIMINACIÓN
• ACTUALIZACIÓN

Transacciones Compuestas
• BEGIN
• COMMIT
• ROLLBACK
 Violaciones de Restricciones
OPERACIÓN IDENTIDAD ENTIDAD REFERENCIAL UNICA DOMINIO NULO
INSERTAR SI SI SI SI SI SI
Sin Alternativas Sin Alternativas Alternativa Alternativa Sin Alternativas Alternativa
NULO NULO VALOR X
DEFECTO
ELIMINAR NO NO SI (Si es de la NO NO NO
tabla padre que
contiene
información en Nulificar: Al borrar información padre colocar
las tablas hijo) NULL a la referencia (clave foránea).
Alternativa Cascada: Al borrar información padre borrar
NULIFICAR, registros hijos.
CASCADA, Restringir: Restringir pero informar.
RESTRINGIR
ACTUALIZAR SI SI SI (Padre a Hijo) SI SI SI
Sin Alternativas Sin Alternativas Alternativas Alternativa Sin Alternativas Sin Alternativas
iguales a NULO
Eliminar.
Lenguaje SQL
Structured Query Language por sus siglas en inglés.

Lenguaje de consulta estructurado, es el lenguaje estándar para la administración

de la información en los SGBDR.

Los 3 principales Grupos de SQL

• DDL: Lenguaje de Definición de Datos (Data Definition Language).
• DML: Lenguaje de Manipulación de Datos (Data Manipulation Language).
• DCL: Lenguaje de Control de Acceso a Datos (Data Control Language).
DDL – Data Definition Language
DDL – CREAR
CREAR
Usuarios
MODIFICAR
Bases de Datos
BORRAR
Tablas
CREATE USER nombre PASSWORD ‘contraseña’
CREATE ROLE nombre LOGIN PASSWORD ‘contraseña’
CREATE DATABASE nombre OWNER = usuario TABLESPACE = el_tablespace
CREATE TABLE nombre_tabla (
columna1 tipo_dato,
columna2 tipo_dato (tamaño),
columna3 tipo_dato NOT NULL,
columna4 tipo_dato DEFAULT valor_x_defecto,
columna5 SERIAL,
CONSTRAINT nombre_constraint1 CHECK (columnaN > valor and columaN < valor),
CONSTRAINT nombre_constraint2 PRIMARY KEY (columnaN, …, columnaM),
CONSTRAINT nombre_constraint3 UNIQUE (columnaN, …, columnaM),
CONSTRAINT nombre_constraint4 FOREIGN KEY (columnaN, … columnaM)
REFERENCES otra_tabla(columnaN, … columnaM) ON DELETE acción ON
UPDATE accion
)
 DDL – MODIFICAR
Usuarios
Bases de Datos
Tablas
ALTER USER nombre PASSWORD ‘contraseña’

ALTER ROLE nombre PASSWORD ‘contraseña’

ALTER DATABASE nombre RENAME TO nuevo_nombre

ALTER DATABASE nombre OWNER TO nuevo_usuario

ALTER DATABASE nombre SET TABLESPACE nuevo_tablespace

OWNER = Asignar usuario no es obligatorio

DDL – MODIFICAR TABLAS.
ALTER TABLE nombre ADD COLUMN campoN tipo_dato (tamaño)

ALTER TABLE nombre DROP COLUMN campoN

ALTER TABLE nombre ALTER COLUMN campoN SET NOT NULL à Primero quitar valores Nulos.

ALTER TABLE nombre ALTER COLUMN campoN DROP NOT NULL

ALTER TABLE nombre ADD CONSTRAINT nombre_constraint FOREIGN KEY (campoN, … campoM) REFERENCES
otra_tabla (campoN, …, campoM) ON DELETE acción ON UPDATE acción

ALTER TABLE nombre DROP CONSTRAINT nombre_constraint

ALTER TABLE nombre ALTER COLUMN campoN SET DEFAULT valor_x_defecto

ALTER TABLE nombre ALTER COLUMN campoN DROP DEFAULT

ALTER TABLE nombre ALTER COLUMN campoN TYPE nuevo_tipo (tamaño) à Entre el mismo Tipo de dato

ALTER TABLE nombre RENAME COLUMN columnaN TO columnaM

ALTER TABLE nombre RENAME TO nuevo_nombre

DDL – BORRAR
Usuarios
DROP USER nombre

Bases de Datos
DROP DATABASE nombre

Tablas
DROP TABLE nombre
DCL – GRANT and REVOKE
GRANT: Permite realizar una acción sobre un objeto.

GRANT acción ON objeto TO usuario

GRANT CONNECT ON DATABASE clase02 TO usurios;
GRANT SELECT ON nombre_tabla TO usurios;

Pueden haber mas acciones, es una forma de controlar, tener encuenta si hay secuencias
Tambien se deben dar permisos. Para que se peude utilizar. Esto para instertar.

REVOKE: Restringe realizar una acción sobre un objeto.

REVOKE acción ON objeto FROM usuario

REVOKE SELECT ON nombre_table FROM usuarios;
REVOKE CONNECT DATABASE clase02 FROM usuarios;
DML – Manipulación de Datos

INSERT: Ingresar información

UPDATE: Modificar Información

DELETE: Borrar Información

DML – INSERT
INSERT INTO tabla (campo1, campo2, …, campoN) VALUES (valor1, valor2, …., valorN)

INSERT INTO tabla (campo5, campo3, campo1, campo18, …, campoN) VALUES (valor5, valor1, valor18, …,
valorN)

INSERT INTO tabla VALUES (valor1, valor2, …, valorN)

INSERT INTO tabla VALUES (DEFAULT, valorN, valorM, …, valorZ)à llamara el valor por defecto. Tambien
para serial.

INSERT INTO tabla VALUES (valorA1, valorA2, … valorAN),

(valorB1, valorB2, …, valorBN),
(valorC1, valorC2, … valorCN)

INSERT INTO tabla SELECT consulta_aqui

DML – UPDATE
UPDATE tabla SET campo1 = valor1, campo2 = valor2, …, campoN =
valorN WHERE campoM = valorM

Where:
WHERE campoM = valorM (=, >, <, <>)
WHERE campoM BETWEEN valor1 AND valor2
WHERE campoM IN (valor1, valor2, …, valorN)
WHERE campoM IN SELECT consulta
WHERE campoM NOT IN…
DML – DELETE
DELETE FROM tabla WHERE campoN = valorN

Where:
WHERE campoM = campoM (=, >, <, <>)
WHERE campoM BETWEEN valor1 AND valor2
WHERE campoM IN (valor1, valor2, …, valorN)
WHERE campoM IN SELECT consulta
WHERE campoM NOT IN…
 Configuración Postgres
• Configurar variable PATH para postgtress con postgressApp.
• - sudo mkdir -p /etc/paths.d &&
• echo /Applications/Postgres.app/Contents/Versions/latest/bin | sudo tee /etc/paths.d/postgresapp
•
• Archivos de Configuración.
•
• Ruta:
• /Users/mauricio/Library/Application Support/Postgres/var-10/pg_hba.conf
•
• pg_hba.conf —> Configurar prestación de servicios o autenticación del cliente.
•
• Postgresql.conf —> Configurar las ip que puede ingresar a nuestra base de datos. ‘*’ para todas las
maquinas si son varias ipso se separa por ‘,’
Crear Espacio De Trabajo
Dar permisos y usuario a la carpeta
chown -R mauricio basesdedatos
chgrp -R mauricio basesdedatos

CREATE TABLESPACE tbl_basesdedatos LOCATION

'/Users/mauricio/basesdedatos/miprimebase';

Crear base apuntando al espacio de trabajo

CREATE DATABASE clase2 TABLESPACE = tbl_basesdedatos;

psql -U postgres -d clase2;

Secuencias
Secuencias en postgres: insertar datos sin alimentar el campo consecutivo;

CREATE SEQUENCE seq_nombreTabla;

INSERT INTO tabla VALUES (‘campo1’, campo2, NEXTVAL(‘seq_nombreTabla’));

SELECT NEXTVAL(‘seq_nombre_Tabla’); —> Cada vez que se llama la función

nextval se incrementa en 1,
SELECT CURRCAL(‘seq_nombreTabla’); —> Ver Valor actual de la secuencia.
Creación de Tablas Ejemplo Anterior
CREATE TABLE propietarios(
identificacion varchar(12),
nom_nombresvarchar(100) NOT NULL,
nom_apellidos varchar(100) NOT NULL,
email varchar(200),
CONSTRAINT pk_propietario PRIMARY KEY (identificacion));

CREATE TABLE telefonos (

identificacion varchar(12),
telefono varchar(30), Cuando se intente actualizar información
CONSTRAINT pk_telefono PRIMARY KEY (identificacion, telefono), en la tabla padre, no se puede cambiar si
CONSTRAINT fk_telefonos_propietarios FOREIGN KEY (identificacion) hay información en la tabla hijo. En el
REFERENCES propietarios (identificacion) hijo se puede eliminar la información
ON UPDATE RESTRICT ON DELETE RESTRICT); siempre que no sea padre de otra tabla.
CREATE TABLE departamentos(
codigo smallserial,
nombre varchar(100) NOT NULL,
CONSTRAINT pk_departamentos PRIMARY KEY (codigo));

CREATE TABLE ciudades(

codigo smallserial,
nombre varchar(100),
departamento smallint NOT NULL,
CONSTRAINT pk_ciudades PRIMARY KEY (codigo),
CONSTRAINT fk_ciudades_departamentos FOREIGN KEY (departamento)
REFERENCES departamentos (codigo)
ON UPDATE RESTRICT ON DELETE RESTRICT);
CREATE TABLE viviendas(
codigo smallserial,
dir_calle varchar (50) NOT NULL,
dir_numero smallint NOT NULL,
habitantes smallint NOT NULL,
descripcion text NOT NULL,
identificacion varchar(12) NOT NULL,
ciudad smallint NOT NULL,
CONSTRAINT pk_viviendas PRIMARY KEY (codigo),
CONSTRAINT fk_viviendas_propietarios FOREIGN KEY (identificacion)
REFERENCES propietarios (identificacion)
ON UPDATE RESTRICT ON DELETE RESTRICT,
CONSTRAINT fk_viviendas_ciudades FOREIGN KEY (ciudad)
REFERENCES ciudades (codigo)
ON UPDATE RESTRICT ON DELETE RESTRICT);
CREATE TABLE arriendos(
codigo smallserial,
f_inicio date NOT NULL,
f_fin date NOT NULL,
valor integer NOT NULL,
vivienda smallint NOT NULL,
CONSTRAINT pk_arriendos PRIMARY KEY (codigo));

CREATE TABLE inquilinos(

identificacion varchar(12),
nom_nombres varchar (100) NOT NULL,
nom_apellidos varchar (100) NOT NULL,
CONSTRAINT pk_inquilinos PRIMARY KEY (identificacion));

CREATE TABLE telefonos_inquilinos (

identificacion varchar(12),
telefono varchar(30),
CONSTRAINT pk_telefonos_inquilinos PRIMARY KEY (identificacion, telefono),
CONSTRAINT fk_telefonos_inquilinos FOREIGN KEY (identificacion)
REFERENCES inquilinos (identificacion)
ON UPDATE RESTRICT ON DELETE RESTRICT);
CREATE TABLE arriendos_inquilinos(
codigo smallint,
identificacion varchar(12),
CONSTRAINT pk_arriendos_inquilinos PRIMARY KEY (codigo),
CONSTRAINT fk_arriendos_inquilinos_arriendos FOREIGN KEY (codigo)
REFERENCES arriendos (codigo)
ON UPDATE RESTRICT ON DELETE RESTRICT,
CONSTRAINT fk_arriendos_inquilinos_inquilinos FOREIGN KEY (identificacion)
REFERENCES inquilinos (identificacion)
ON UPDATE RESTRICT ON DELETE RESTRICT);
Crear Back up
• Modo Copy en DATA
• Pg_dump --host localhost –Port 5432 –Username postgres –verbose
backup_20180209.backup algeb

• Modo Insert en DATA

• Pg_dump --host localhost –Port 5432 –Username postgres –verbose --
inserts --column-inserts backup_20180209.backup algebra

• Para insertar primero se debe crear el usuarios del backup:

• Conectar como postgres: Crear usuario y base de datos.
• Cambiar al usuario y base “\c base_de_datos usuario”
• \i /ruta_del_backup/backup_20180209.backup
ÁLGEBRA RELACIONAL
PROYECCIÓN
Permite filtrar las columnas / atributos que se quieren
mostrar de una relación.

SELECT campo1, campo2, …, campoN

FROM tabla
Evitar el uso del * siempre es mejor escribir todos los
campos.
RENOMBRAMIENTO - ALIAS
Permite renombrar la relación o los atributos de una relación.
R(a1, a2, …, aN) -> S(a1, a2, …, aN)

R(a1, a2, …, aN) -> R(b1, b2, …, bN)

R(a1, a2, …, aN) -> S(b1, b2, …, bN)

SELECT *
FROM TABLA1 AS NUEVO_NOMBRE

SELECT campo1 AS nombre, campo2 AS apellidos

FROM TABLA1 AS integrantes
SELECCIÓN
Se conoce también como FILTRO. Y nos permite seleccionar
solamente unos registros de una relación que cumplen con
uno o varios criterios.

SELECT campo1, campo2, …, campoN

FROM tabla
WHERE campo1 {cumple la condición}
UNIÓN
Dos relaciones son compatibles en unión si sus dominios coinciden en número y en
orden. Y es la disyunción de los conjuntos. Es decir, el elemento está en uno o en el
otro conjunto.
R1(a1, a2, …, an)
R2(b1, b2, …, bn)
dominio R1(ai) = dominio R2(bi)

SELECT campo1, campo2, …, campoN , ‘distigir_de_que_tabla_viene’ AS nombre

FROM tabla1
UNION [ ALL ] à ALL En el caso de que existan registros repetidos
SELECT otro1, otro2, …, otroN, ‘distigir_de_que_tabla_viene’ AS nombre
FROM tabla2
INTERSECCIÓN
Dos relaciones son compatibles en intersección si sus dominios coinciden en número
y en orden. Y es la conjunción de los conjuntos. Es decir, el elemento tiene que estar
en ambos conjuntos.

R1(a1, a2, …, an)

R2(b1, b2, …, bn)

dominio R1(ai) = dominio R2(bi)

SELECT campo1, campo2, …, campoN

FROM tabla1
cà Solo trae los que coinciden en las dos relaciones
SELECT otro1, otro2, …, otroN
FROM tabla2
INTERSECCIÓN - EQUIVALENCIA
SELECT campo1, campo2, …, campoN
FROM tabla1
WHERE (campo1, campo2, …, campoN)
IN (SELECT otro1, otro2, …, otroN
FROM tabla2)
Ejemplo: à Hace lo mismo que el INTERSECT

SELECT numero, fecha, valor, identificacion

FROM ventas_contado
WHERE (numero, fecha, valor, identificacion)
IN (numero, fecha, valor, identificacion
FROM ventas_credito)
DIFERENCIA
Dos relaciones son compatibles en diferencia si sus dominios coinciden en número y
en orden. Y es la diferencia de los conjuntos. Es decir, el elemento tiene que estar en
el primer conjunto, pero no en el segundo.

R1(a1, a2, …, an)

R2(b1, b2, …, bn)

dominio R1(ai) = dominio R2(bi)

SELECT campo1, campo2, …, campoN
FROM tabla1
EXCEPT
SELECT otro1, otro2, …, otroN
FROM tabla2
DIFERENCIA - EQUIVALENCIA
SELECT campo1, campo2, …, campoN
FROM tabla1
WHERE (campo1, campo2, …, campoN)
NOT IN (SELECT otro1, otro2, …, otroN
FROM tabla2)
Ejemplo: à Hace lo mismo que el EXCEPT

SELECT numero, fecha, valor, identificacion

FROM ventas_contado
WHERE (numero, fecha, valor, identificacion)
NOT IN (numero, fecha, valor, identificacion
FROM ventas_credito)
PRODUCTO CARTESIANO

El producto cartesiano no exige la compatibilidad de dominios ni en

número ni en orden.

R1(a1, a2, a3, a4, …, aN)

R2(b1, b2, …, bX)

Q(a1, a2, a3, a4, …, aN, b1, b2, …, bX)

 JOIN COMBINACIÓN RELACIONAL.

CROSS JOIN
Es el resultado del producto cartesiano de las relaciones que
intervienen en la combinación.

SELECT a.campo1, a.campo2, …, a.campoN, b.campo1, b.campo2, …, b.campoN

FROM tabla1 as a CROSS JOIN tabla2 as b
NATURAL JOIN

Combina dos relaciones de manera natural entre la clave primaria de

una y la clave foránea de la otra.

SELECT a.campo1, a.campo2, …, a.campoN, b.campo1, b.campo2, …, b.campoN

FROM tabla1 as a NATURAL INNER JOIN tabla2 as b
INNER JOIN

Combina dos relaciones cuando se necesita especificar el (los)

atributo(s) con los que se combinarán.

SELECT a.campo1, a.campo2, …, a.campoN, b.campo1, b.campo2, …, b.campoN

FROM tabla1 as a INNER JOIN tabla2 as b ON a.campo1 = b.campo1
LEFT JOIN
Combina dos relaciones realizando primero un INNER JOIN y luego
añade todas aquellas filas (registros) de la relación nombrada en la
parte izquierda de la sentencia que no satisfacen la combinación con
la relación de la parte derecha.
SELECT a.campo1, a.campo2, …, a.campoN, b.campo1, b.campo2, …, b.campoN
FROM tabla1 as a LEFT JOIN tabla2 as b ON a.campo1 = b.campo1
RIGHT JOIN
Combina dos relaciones realizando primero un INNER JOIN y luego
añade todas aquellas filas (registros) de la relación nombrada en la
parte derecha de la sentencia que no satisfacen la combinación con la
relación de la parte izquierda.
SELECT a.campo1, a.campo2, …, a.campoN, b.campo1, b.campo2, …, b.campoN
FROM tabla1 as a RIGHT JOIN tabla2 as b ON a.campo1 = b.campo1
FULL JOIN
Combina dos relaciones realizando primero un INNER JOIN y luego
realiza un Left Join y por último un Right Join.

SELECT a.campo1, a.campo2, …, a.campoN, b.campo1, b.campo2, …, b.campoN

FROM tabla1 as a FULL JOIN tabla2 as b ON a.campo1 = b.campo1
Funciones Postgres
• Select Now(); --> Traer fecha sistema.
• Select date_part(‘month’, nov()); -->Traer mes fecha sistema.
• Select date_part(‘month’, nov()) as mes_actual ; -->Traer mes fecha
sistema con alias.

• ILIKE à Evitar key sensitive.

• Select upper(nombre) à Muestra Resultado en Mayúscula.
• SELECT *, CASE valor WHEN < 500 THEN ‘Económico’ WHEN valor =
1200 THEN ‘Normal’ WHEN valor > 1200 THEN ‘Costoso’ END AS
Clasificación FROM productos; à Clausulas de clasificación

• Mostrar una vez los campos repetidos:

• SELECT campo1, campo2 FROM nombre_tabla; à Proyecta que
todos los campos seleccionados sean únicos.

• HAVING à Filtro por grupo.

• SELECT producto, sum(cantidad) as suma FROM ventas GROUP BY
producto HAVING SUM(cantidad) < 18;
Paginación
• SELECT * FROM VENTAS ORDER BY consecutivo LIMIT 5 OFFSET 0;
• SELECT * FROM VENTAS ORDER BY consecutivo LIMIT 5 OFFSET 5;
• SELECT * FROM VENTAS ORDER BY consecutivo LIMIT 5 OFFSET 10;
• Toma desde el siguiente Número Ejemplo OFFSET 5 --> Del 6 en
adelante
Sub Consultas
• SELECT producto FROM ventas WHERE producto IN (SELECT codigo
FROM productos WHERE nombre = ‘PAPA’);

• Para traer todos los campos distintos pero asignando que columna no se
quiere repetir:

• SELECT DISTINCT ON (campo1) campo1, campo2 FROM tabla;

Lenguaje Procedural
• Grupos de trabajo
• Funciones: Devuelven un resultado.
• Procedimientos Almacenados: Devuelven uno o mas resultados.
 Funciones:
NOMBRES DE LOS LENGUAJES PROCEDURALES DE DIFERENTES SGBDRPOSTGRESQL - plpgsql, pljava, plperl, plc, plpythonSQL
SERVER - TRANSACTORACLE – plsql
-- CREAMOS LA FUNCIÓN SALUDAR -- CREAR UNA FUNCIÓN QUE SE LLAME DESCUENTO
CREATE FUNCTION saludar() CREATE OR REPLACE FUNCTION descuentofijo(_valor integer)
RETURNS character varying RETURNS real
AS AS
$$ $BODY$
DECLARE nombre character varying; DECLARE nuevo_valor real;
BEGIN BEGIN nuevo_valor = _valor * .9;
RETURN 'Hola Mundo'; RETURN nuevo_valor;
END; END;
$$ $BODY$
LANGUAGE plpgsql; LANGUAGE plpgsql;

-- EJECUTAMOS LA FUNCIÓN SALUDAR -- LLAMADO DE FUNCIÓN

SELECT saludar(); SELECT codigo, nombre, valor, descuentofijo(valor), vencimiento
-- EJECUTAR LA FUNCIÓN DENTRO DE UNA FROM PRODUCTOS;
CONSULTA
SELECT nombre, valor, saludar() FROM COLORES;
  CREAR FUNCION DE ALARMA DE VENCIMIENTO

CREATE OR REPLACE FUNCTION alarma_vencimiento(_fecha date)

RETURNS character varying
AS
$BODY$
DECLARE meses integer; dias integer; total integer; diferencia interval;
BEGIN
meses = date_part('MONTH', age(_fecha, now())); dias = date_part('DAY', age(_fecha, now()));
-- diferencia = age(_fecha, now());
-- RAISE NOTICE 'Los dias son: %', dias;
-- RAISE NOTICE 'La diferencia es: %', diferencia;
total = meses * 30 + dias;
IF total < 60 THEN RETURN 'CUIDADO!!! SE VENCE EN MENOS DE 2 MESES';
ELSE
RETURN 'AUN QUEDA TIEMPO';
END IF;
END;
$BODY$
LANGUAGE plpgsql;

-- SE LLAMA LA FUNCIÓN DE ALERTA

SELECT codigo, nombre, valor, vencimiento, alarma_vencimiento(vencimiento) FROM PRODUCTOS;
CONDICIONALES
-- CONDICIONALES IF a < b AND c > d OR e = f OR g <> h THEN
-- TODA TU LÓGICA SI ES VERDADERO AQUÍ
ELSIF i > j THEN
-- TODA TU LÓGICA SI ES VERDADERA LA CONDICIÓN DEL ELSIF
ELSE
-- TODA TU LÓGICA SI NO SE CUMPLEN TODAS LAS ANTERIORES
END IF;
-- CONCATENAR CADENAS DE CARACTERES ||'HOLA ' || ' MUNDO';
-- CREAR UNA FUNCIÓN QUE NOS PERMITA PAGINAR LOS RESULTADOS
DE UNA CONSULTA
-- RECORDANDO LIMIT Y OFFSET
-- CREACIÓN DE LA FUNCIÓN
SELECT * FROM VENTAS LIMIT 5 OFFSET 5; CREATE OR REPLACE FUNCTION ventas_paginadas(_registros
integer, _pagina integer)
-- FORMULA PARA AVERIGUAR EL OFFSET
RETURNS SETOF ventas
CANTIDAD DE REGISTROS * PAGINA QUE
SE QUIERE VER - CANTIDAD DE REGISTROS AS

5 * 1 - 5 = 0 $BODY$
DECLARE inicio integer;
5 * 2 - 5 = 5
BEGIN
inicio = _registros * _pagina - _registros;
RETURN QUERY SELECT consecutivo, producto, cantidad FROM
ventas
SETOF à Devolver un conjunto de la tabla. LIMIT _registros OFFSET inicio;
END;
$BODY$
LANGUAGE plpgsql;
-- LLAMADO DE LA FUNCIÓN QUE PERMITE PAGINAR
SELECT * FROM ventas_paginadas(5, 3);

-- TIPOS DE DATOS
-- SON TODOS LOS TIPOS DE DATOS QUE ACEPTA POSTGRESQL
-- %TYPE PERMITE COPIAR EL TIPO DE DATO EXACTO DE UNA COLUMNA (ATRIBUTO) DE UNA TABLA
(RELACIÓN).
DECLARE mi_variable productos.nombre%TYPE;

-- TIPO DE DATO
-- %ROWTYPE PERMITE COPIAR LA ESTRUCTURA DE UNA TABLA PARA ALMACENAR
-- LA INFORMACIÓN DE UN REGISTRO
DECLARE mi_fila productos%ROWTYPE;
mi_fila.valor;
-- CICLOS -- EJECUCIÓN
-- FOR SELECT repetir_for();
CREATE OR REPLACE FUNCTION repetir_for() -- CREAR FUNCION PARA RECORRER UN SELECT
RETURNS void
AS CREATE OR REPLACE FUNCTION obtener_ventas()
$BODY$ RETURNS SETOF ventas
DECLARE iteracion integer; AS
BEGIN $BODY$
FOR iteracion IN 1..10 LOOP DECLARE
RAISE NOTICE 'Voy en la iteración: %', iteracion; fila ventas%ROWTYPE;
END LOOP; BEGIN
END; FOR fila IN SELECT * FROM VENTAS LOOP
$BODY$ -- fila.valor = fila.valor * 3;
LANGUAGE plpgsql; RETURN NEXT fila;
END LOOP;
END;
$BODY$
LANGUAGE plpgsql;

-- llamado a la función
SELECT * FROM obtener_ventas();
-- WHILE
-- SE EJECUTA MIENTRAS QUE LA CONDICIÓN SE CUMPLA
CREATE OR REPLACE FUNCTION mientras()
RETURNS void
AS
$BODY$
DECLARE valor integer;
BEGIN valor = 5;
WHILE valor < 50 LOOP
RAISE NOTICE 'voy en el valor: %', valor;
valor = valor + 10;
END LOOP;
END;
$BODY$
LANGUAGE plpgsql;

-- llamado de la función

SELECT * FROM mientras();

-- PROCEDIMIENTO DE AUDITORIA -- CREACIÓN DE LA FUNCIÓN
-- CREO UNA TABLA DE AUDITORIA CREATE OR REPLACE FUNCTION fn_mostrar_ventas(_nombre
CREATE TABLE auditoria( character varying)
consecutivo smallserial, RETURNS SETOF ventas
nombre varchar(20), AS
accion varchar(50), $BODY$
fecha timestamp DEFAULT now()) BEGIN
-- REGISTRAR LA AUDITORIA
INSERT INTO auditoria (consecutivo, nombre, accion, fecha) VALUES
(DEFAULT, _nombre, 'CONSULTA VENTAS', DEFAULT);

-- DEVUELVO LO SOLICITADO RETURN QUERY

SELECT * FROM ventas;
END;
$BODY$
LANGUAGE plpgsql;

-- LLAMADO DE LA FUNCIÓN

SELECT * FROM auditoria; à que datos tiene debe estar vacio.

SELECT * FROM fn_mostrar_ventas('Alexys Lozada');
TRIGGER
CREATE TABLE productos( --VARIABLES DE LOS TRIGGER
nombre varchar(20), NEW à Contiene la información del nuevo registro que se esté
cantidad smallint, trabajando.
precio smallint,
ultima_modificacion timestamp, OLD à Contiene la información del registro anterior a la operación.
ultimo_usuario_bd text)
TG_OP à Contiene el nombre de la operación que estamos
realizando.
-- CREACIÓN DE TRIGGER (STANDAR)
-- CREATE TR CUANDO:
IGGER nombre
-- CUANDO ACCION[ES] BEFORE à Antes de realizar la acción.
-- AS
-- AQUÍ EL CÓDIGO AFTER à Después de realizar la acción.

Primero se debe crear una Función después el TRIGGER

-- CREAR LA FUNCIÓN QUE SOLICITA POSTGRES
CREATE OR REPLACE FUNCTION valida_productos()
RETURNS TRIGGER
AS
$BODY$
BEGIN
IF NEW.nombre IS NULL OR length(NEW.nombre) = 0 THEN
RAISE EXCEPTION 'El nombre debe contener alguna información';
END IF;
IF NEW.cantidad < 0 THEN
RAISE EXCEPTION 'La cantidad no puede ser negativa';
END IF;
IF NEW.precio < 0 THEN
RAISE EXCEPTION 'El precio no puede ser negativo';
END IF;

NEW.ultima_modificacion = now();
NEW.ultimo_usuario_bd = user;
RETURN NEW;
END;
$BODY$
LANGUAGE plpgsql;
-- CREACIÓN DEL TRIGGER
CREATE TRIGGER valida_productos
BEFORE INSERT OR UPDATE
ON productos
FOR EACH ROW EXECUTE PROCEDURE valida_productos();

Realizar consulta para validar información de la tabla:

SELECT * FROM productos;

Insertar y modificar información en la base de datos:

INSERT INTO productos (nombre, cantidad, precio) VALUES ('PAPA', 10, 1000);
UPDATE productos SET cantidad = 15 WHERE nombre = 'PAPA';
CREAR AUDITORIA

-- CREACIÓN DE UNA AUDITORÍA

-- 1. CREAR TABLA DE AUDITORIA
CREATE TABLE auditoria_productos(
accion varchar(20),
fecha timestamp,
nombre varchar(20),
cantidad smallint,
precio smallint
);
-- 2. CREAR LA FUNCIÓN DE AUDITORÍA
CREATE OR REPLACE FUNCTION auditoria_productos()
RETURNS TRIGGER AS
$BODY$
BEGIN
IF TG_OP = 'INSERT' THEN
INSERT INTO auditoria_productos (accion, fecha, nombre, cantidad, precio)
VALUES ('INSERTAR', now() , NEW.nombre, NEW.cantidad, NEW.precio);
RETURN NEW;
ELSIF TG_OP = 'DELETE' THEN
INSERT INTO auditoria_productos (accion, fecha, nombre, cantidad, precio)
VALUES ('BORRAR', now() , OLD.nombre, OLD.cantidad, OLD.precio);
RETURN NULL;
ELSIF TG_OP = 'UPDATE' THEN
INSERT INTO auditoria_productos (accion, fecha, nombre, cantidad, precio)
VALUES ('ANTES ACTUALIZAR', now() , OLD.nombre, OLD.cantidad, OLD.precio);
INSERT INTO auditoria_productos (accion, fecha, nombre, cantidad, precio)
VALUES ('DESPUES ACTULIZAR', now(), NEW.nombre, NEW.cantidad, NEW.precio);
RETURN NEW;
END IF;
END;
$BODY$
LANGUAGE plpgsql;
-- 3. CREAR EL TRIGGER
CREATE TRIGGER auditoria_productos
AFTER INSERT OR UPDATE OR DELETE
ON productos
FOR EACH ROW EXECUTE PROCEDURE auditoria_productos();
-- 4. Prueba del trigger
SELECT * FROM PRODUCTOS;
SELECT * FROM AUDITORIA_PRODUCTOS;
-- 4.1 INSERTAR
INSERT INTO PRODUCTOS (nombre, cantidad, precio) VALUES ('YUCA', 5, 1900);
INSERT INTO PRODUCTOS (nombre, cantidad, precio) VALUES ('CARNE', 40, 3500);
INSERT INTO PRODUCTOS (nombre, cantidad, precio) VALUES ('ARROZ', 22, 2200);
-- 4.2 BORRAR
DELETE FROM productos WHERE nombre = 'PAPA';
-- 4.3 ACTUALIZAR
UPDATE productos SET cantidad = 20 WHERE nombre = 'CARNE';
-- 5 CREAR TRIGGER PARA CONTROLAR LA CANTIDAD DE INVENTARIO

-- 5.1 CREAR UNA TABLA PARA LAS COMPRAS

CREATE TABLE compras(
consecutivo smallserial,
fecha date,
nombre varchar(20),
cantidad smallint,
precio smallint)

-- 5.2 CREAR UNA TABLA PARA LAS VENTAS

CREATE TABLE ventas(
consecutivo
smallserial,
fecha date,
nombre varchar(20),
cantidad smallint,
precio smallint)
-- 5.3 CREAR FUNCION QUE CONTROLE LAS COMPRAS

CREATE OR REPLACE FUNCTION compra_productos()

RETURNS TRIGGER AS
$BODY$
BEGIN
PERFORM nombre FROM productos WHERE nombre = NEW.nombre;
IF FOUND THEN
UPDATE productos
SET cantidad = cantidad + NEW.cantidad, precio = NEW.precio
WHERE nombre = NEW.nombre;
ELSE
INSERT INTO productos (nombre, cantidad, precio)
VALUES (NEW.nombre, NEW.cantidad, NEW.precio);
END IF;
RETURN NEW;
END;
$BODY$
LANGUAGE plpgsql; IF FOUND THEN
Devuelve verdadero si la consulta anterior devuelve algún
registro.
-- 5.4 CREAR LA FUNCION DE VENTAS
CREATE OR REPLACE FUNCTION venta_productos()
RETURNS TRIGGER AS
$BODY$
DECLARE producto productos%ROWTYPE;
BEGIN
SELECT * INTO producto FROM productos WHERE nombre = NEW.nombre;
IF FOUND THEN
IF producto.cantidad >= NEW.cantidad THEN
UPDATE productos
SET cantidad = cantidad - NEW.cantidad
WHERE nombre = NEW.nombre;
ELSE
RAISE EXCEPTION 'No hay suficiente cantidad para la venta: %', producto.cantidad;
END IF;
RETURN NEW;
ELSE
RAISE EXCEPTION 'No existe el producto a vender: %', NEW.nombre;
END IF;
END;
$BODY$
LANGUAGE plpgsql;
-- 5.5 CREAR EL TRIGGER DE COMPRAS
CREATE TRIGGER compra_productos
AFTER INSERT
ON compras
FOR EACH ROW EXECUTE PROCEDURE compra_productos();

-- 5.6 CREAR EL TRIGGER DE VENTAS

CREATE TRIGGER venta_productos
BEFORE INSERT
ON ventas
FOR EACH ROW EXECUTE PROCEDURE venta_productos();
-- 5.7 Prueba de funcionamiento
SELECT * FROM productos;
SELECT * FROM auditoria_productos;
SELECT * FROM compras;
SELECT * FROM ventas;

-- 5.7.1 COMPRANDO UN PRODUCTO EXISTENTE

INSERT INTO compras (fecha, nombre, cantidad, precio)
VALUES (now() , 'YUCA', 2, 2000);

-- 5.7.2 COMPRANDO UN PRODUCTO QUE NO EXISTE

INSERT INTO compras (fecha, nombre, cantidad, precio)

VALUES (now(), 'PAPA', 10, 1500);

-- 5.7.3 VENDIENDO UN PRODUCTO QUE NO EXISTE

INSERT INTO ventas (fecha, nombre, cantidad, precio) VALUES (now() , 'MORA', 5, 200);

-- 5.7.4 VENDIENDO UN PRODUCTO EXISTENTE PERO SIN LA SUFICIENTE CANTIDAD

INSERT INTO ventas (fecha, nombre, cantidad, precio)
VALUES (now(), 'YUCA', 8, 2000);

-- 5.7.5 VENDIENDO UN PRODUCTO EXISTENTE CON SUFICIENTE CANTIDAD

INSERT INTO ventas (fecha, nombre, cantidad, precio)
VALUES (now(), 'ARROZ', 2, 2000);
NORMALIZACIÓN DE RELACIONES
¿PARA QUÉ SIRVE?

La normalización se utiliza para verificar si una relación no tiene

problemas como:

• Redundancia.
• Problemas de:
• Inserción
• Actualización
• Borrado
¿PARA QUÉ SIRVE?

La normalización se utiliza para verificar si una relación no tiene

problemas como:

• Redundancia.
• Problemas de:
• Inserción
• Actualización
• Borrado
Cálculo de las DEPENDENCIAS FUNCIONALES
En una relación:

R(Atributos, Dependencias)

Atributos: {A, B}

B depende funcionalmente de A si para cada valor de A solamente existe un valor de B.

Notación: A -> B

Ejemplo: Identificación -> Nombre

Cálculo de las DEPENDENCIAS REDUNDANTES
En una relación:

R(Atributos, Dependencias)

Atributos: {A, B, C}
Dependencias: {A->B; B->C; A->C}

La dependencia A->C es redundante ya que C depende transitivamente de A.

Cálculo de las CLAVES CANDIDATAS
En una relación:

R(Atributos, Dependencias)

Atributos: {A, B, C, D}
Dependencias: {A->B,D; B->C;}

A+ = {A,B,C,D}, B+{B, C}, C+{C}, D+{D}.

Por lo tanto la superclave será A ya que este atributo puede determinar toda la R.
Formas Normales
5FN

4FN
FNBC
3FN
2FN
1FN
Descripción
• Cada atributo es simple.
1FN • Cada atributo es monovaluado.

• Se encuentra en 1FN.
2FN • Cada atributo no principal tiene DF de la clave candidata.

• Se encuentra en 2FN.
3FN • No existe ningún atributo no principal que dependa transitivamente de clave candidata.

• Si y solo si todo determinante es la clave candidata.

FNBC
Ejemplos:
NOMBRE SKILLS
1FN ALVARO FELIPE HTML, CSS,
JAVASCRIPT
ALEXYS LOZADA JAVA, JAVASCRIPT,
DBA

NOMBRE SKILLS
ALVARO FELIPE HTML
ALVARO FELIPE CSS
ALVARO FELIPE JAVASCRIPT
ALEXYS LOZADA JAVA
ALEXYS LOZADA JAVASCRIPT
ALEXYS LOZADA DBA
 Ejemplos:
ESTUDIANTE MATERIA NOTA SALON

2FN PEDRO MATEMÁTICAS 5 204

PABLO MATEMÁTICAS 4 204
JUAN ESPAÑOL 4 111

ESTUDIANTE MATERIA NOTA MATERIA SALON

PEDRO MATEMÁTICAS 5 MATEMÁTICAS 204
PABLO MATEMÁTICAS 4 ESPAÑOL 111
JUAN ESPAÑOL 4
Ejemplos:
Materia Salón Teléfono
3FN MATEMÁTICAS 101 3333333
ESPAÑOL 201 4444444
BIOLOGÍA 104 2121212

Materia Salón Salón Teléfono

MATEMÁTICAS 101 101 3333333
ESPAÑOL 201 201 4444444
BIOLOGÍA 104 104 2121212
 Ejemplos:
IDENTIFICACION NOMBRE MATERIA NOTA
FNBC 123 PEDRO MATEMATICAS 3
123 PEDRO ESPAÑOL 4
233 PABLO MATEMATICAS 4

IDENTIFICACION NOMBRE IDENTIFICACION MATERIA NOTA

123 PEDRO 123 MATEMATICAS 3
233 PABLO 123 ESPAÑOL 4
233 MATEMATICAS 4
Proceso de normalización
Atributos = {A1, A2, …, An}
Dependencias = {D1, D2, … Dn}

Atributos = {A1, …, Ai} Atributos = {Ai, …, An}

Dependencias = {D1, …, Di} Dependencias = {Dj+, … Dn}

Atributos = {A1, …, Ak} Atributos = {Al, …, An}

Dependencias = {Dj+1, …, Ds} Dependencias = {Dl, … Dn}
Ejemplo
Profesor Oficina Teléfono Materia Créditos Libro Autor Año

Pedro 101 2454545 MATEMÁTICAS 5 ALGEBRA BALDOR 1970

Pedro 101 2454545 ESPAÑOL 3 LITERATURA ANÓNIMO 1950

Pablo 105 5414141 MATEMÁTICAS 5 CÁLCULO I BOUNETE 1985

Pablo 105 5414141 MATEMÁTICAS II 4 CÁLCULO I BOUNETE 1985

Pablo 105 5414141 GEOGRAFÍA 2 ALGEBRA BALDOR 1970
Juan 102 3696969 CONTABILIDAD 1 IMPUESTOS ANTORINI 1999

Lucas 103 4585858 CONTABILIDAD 1 IMPUESTOS ANTORINI 1999

Lucas 103 4585858 MATEMÁTICAS 3 5 CÁLCULO 2 BEYONCE 1986

Lucas 103 4585858 ESPAÑOL 3 LENGUAS GAITÁN 1980

Problemas
Inserción:

• No se puede ingresar un Profesor si no se le ha asignado una materia la cual debe tener a su vez un libro y salón.
• No se puede ingresar una Materia si no existe un profesor asignado y un libro y un salón.
• Etc…

Borrado:

• No se puede borrar un solo registro si se quiere eliminar un profesor.

• No se puede borrar un solo registro si se quiere eliminar un libro.
• “ “ “ “ “ “ una materia.
• Si se eliminan los registros de un profesor, se estaría borrando la información de las materias.
• Si se elimina la única materia que dicta un profesor, se pierde la información de dicho profesor.
Encontrando las DF
Un profesor tiene una única oficina y un único teléfono:
• Profesor -> Oficina, Teléfono
Una oficina tiene un único teléfono
• Oficina -> Teléfono
Una materia tiene un número de créditos
• Materia -> Créditos
Un libro tiene un autor y año de edición
• Libro -> Autor, Año
Un profesor puede dictar más de una materia
• Profesor -- / -> Materia
Una materia tiene más de un profesor
• Materia -- / -> Profesor
Un profesor en una materia utiliza un solo libro el
cual tiene un autor y un año de edición
• Profesor, Materia -> Libro, Autor, Año
Encontrando las DF (Resumen)
Dependencias: {
Profesor -> Oficina, Teléfono
Oficina -> Teléfono
Materia -> Créditos
Libro -> Autor, Año
Profesor -- / -> Materia
Materia -- / -> Profesor
Profesor, Materia -> Libro, Autor, Año
}
Encontrando las DF (Resumen)
Dependencias: {
Profesor -> Oficina
Oficina -> Teléfono
Materia -> Créditos
Libro -> Autor, Año
Profesor, Materia -> Libro
}
 Atr = {P,O,T,M,C,L,A,Ñ}
Dep = {P->O; O->T; M->C; L->A,Ñ; P,M->L}

Atr1 = {L,A,Ñ} Atr1’ = {P,O,T,M,C,L}

Dep1 = {L->A,Ñ} Dep1’ = {P->O; O->T; M->C; P,M->L}

Atr2 = {M,C} Atr2’ = {P,O,T,M,L}

Dep2 = {M->C} Dep2’ = {P->O; O->T; P,M->L}

Atr3 = {O,T} Atr3’ = {P,O,M,L}

Dep3 = {O->T} Dep3’ = {P->O; P,M->L}

Atr4 = {P,O} Atr5 = {P,M,L}

Dep4 = {P->O} Dep5 = {P,M->L}
• Desarrollo bases de datos à alfa y omega
• Desarrollo bases de datos à alfa y omega