Conceptos¶
Modelo Entidad-Relación (ER)¶
1. Identificar Entidades¶
- Buscar sustantivos importantes del enunciado.
- Ejemplos: Alumno, Curso, Profesor, Venta.
2. Identificar Atributos¶
- Preguntar: ¿qué información se guarda de cada entidad?
- Tipos: simples (nombre), compuestos (dirección), multivaluados (teléfonos).
3. Determinar Claves Primarias¶
- Elegir uno o varios atributos que identifiquen unívocamente cada entidad.
- Evita usar atributos que puedan cambiar frecuentemente.
4. Identificar Relaciones¶
- Relacionar entidades con verbos: inscribe, compra, administra.
5. Cardinalidad y Participación¶
- 1:1, 1:N, N:M (usar tabla intermedia para N:M).
- Total (línea doble) o parcial (línea simple).
6. Entidad Débil¶
- No tiene clave propia.
- Depende de una entidad fuerte.
- Usa clave parcial + clave de la entidad fuerte.
7. Modelo E/R Extendido (EER)¶
- Agrega generalización/especialización (jerarquías).
- Herencia de atributos y relaciones.
- Categorías o clases unión (subtipos de múltiples entidades).
- Notación: triángulo con ISA para representar herencia.
graph LR
A{Leer enunciado} --> B[Identificar entidades];
A --> C[Identificar atributos];
B --> D[Determinar claves primarias]
C --> D;
D --> E{Definir relaciones entre entidades};
E --> F[Establecer cardinalidad y participación];
E --> G[Detectar entidades débiles y compuestas];
E --> H[Aplicar modelo E/R extendido EER];
H --> I[Normalizar: 1FN → 2FN → 3FN];
F --> I;
G --> I;
I --> J[Transformar entidades y relaciones en tablas];
DDL (Data Definition Language)¶
Elemento del E/R | Traducción a SQL (Tabla) |
---|---|
Entidad fuerte | Crear tabla con una clave primaria (PRIMARY KEY ) en uno o más atributos |
Entidad débil | Crear tabla con clave parcial + clave primaria de entidad fuerte como PK compuesta y FK |
Relación 1:1 | Añadir FK en una de las tablas (puede ser UNIQUE) o fusionar si siempre están asociadas |
Relación 1:N | Añadir FK en el lado N (muchos) apuntando a la PK del lado 1 (uno) |
Relación N:M | Crear tabla intermedia con FK a ambas entidades; usar combinación como PK compuesta |
Atributo simple | Columna normal en la tabla |
Atributo multivaluado | Crear nueva tabla: columna para el valor + FK a la entidad principal |
Atributo compuesto | Dividir en columnas simples (ej: dirección → calle, ciudad, código postal) |
Atributo derivado | No se implementa directamente; se calcula cuando se necesita |
Generalización (ISA) | Crear tabla para supertipo y subtipo (opciones: por herencia, por unión, etc.) |
Clave primaria (PK) | Atributo único y no nulo, definido como PRIMARY KEY(nombre_atributo) |
Clave foránea (FK) | Atributo que referencia a la PK de otra tabla: FOREIGN KEY (...) REFERENCES ... |
-- Crear tabla con múltiples constraints
CREATE TABLE Alumno (
id INT NOT NULL,
nombre VARCHAR(50) NOT NULL,
edad INT NOT NULL,
email VARCHAR(100),
CONSTRAINT PK_Alumno PRIMARY KEY (id),
CONSTRAINT CHK_Edad CHECK (edad > 0),
CONSTRAINT UQ_Email UNIQUE (email)
);
CREATE TABLE Curso (
id INT NOT NULL,
nombre VARCHAR(100) NOT NULL,
CONSTRAINT PK_Curso PRIMARY KEY (id)
);
CREATE TABLE Inscripcion (
id_alumno INT NOT NULL,
id_curso INT NOT NULL,
fecha DATE NOT NULL,
CONSTRAINT PK_Inscripcion PRIMARY KEY (id_alumno, id_curso),
CONSTRAINT FK_Inscripcion_Alumno FOREIGN KEY (id_alumno)
REFERENCES Alumno(id) ON DELETE CASCADE ON UPDATE CASCADE,
CONSTRAINT FK_Inscripcion_Curso FOREIGN KEY (id_curso)
REFERENCES Curso(id) ON DELETE CASCADE ON UPDATE CASCADE
);
DML (Data Manipulation Language)¶
-- Insertar datos
INSERT INTO Alumno (id, nombre, edad, email) VALUES (1, 'Ana', 22, 'ana@mail.com');
-- Actualizar datos
UPDATE Alumno SET edad = 23 WHERE id = 1;
-- Eliminar datos
DELETE FROM Alumno WHERE id = 1;
Consultas SQL¶
-- Selección básica
SELECT * FROM Alumno;
-- Filtrado con WHERE
SELECT nombre FROM Alumno WHERE edad > 20;
-- JOIN (INNER JOIN por defecto)
SELECT a.nombre, c.nombre
FROM Alumno a
JOIN Inscripcion i ON a.id = i.id_alumno
JOIN Curso c ON c.id = i.id_curso;
-- LEFT JOIN
SELECT a.nombre, i.id_curso
FROM Alumno a
LEFT JOIN Inscripcion i ON a.id = i.id_alumno;
-- Agrupar y funciones agregadas
SELECT AVG(edad) AS promedio_edad FROM Alumno;
-- Agrupar con condición
SELECT edad, COUNT(*) FROM Alumno GROUP BY edad HAVING COUNT(*) > 1;
-- Subconsulta
SELECT nombre FROM Alumno
WHERE edad > (SELECT AVG(edad) FROM Alumno);
Procedimientos Almacenados¶
Elemento | Descripción |
---|---|
Nombre | Identificador del procedimiento |
Parámetros | IN , OUT , INOUT |
Cuerpo | Instrucciones SQL entre BEGIN ... END |
Variables locales | Declaradas con DECLARE |
Control de flujo | IF , CASE , WHILE , LOOP , REPEAT |
Llamada | CALL nombre_procedure(param1, param2, ...) |
Uso común | Agrupar lógica de negocio, automatización de tareas, evitar repetición |
DELIMITER //
CREATE PROCEDURE insertar_alumno(
IN p_id INT, IN p_nombre VARCHAR(50), IN p_edad INT, IN p_email VARCHAR(100)
)
BEGIN
INSERT INTO Alumno (id, nombre, edad, email)
VALUES (p_id, p_nombre, p_edad, p_email);
END //
DELIMITER ;
-- Llamar procedimiento
CALL insertar_alumno(2, 'Luis', 21, 'luis@mail.com');
DELIMITER //
CREATE PROCEDURE insertar_varios_alumnos(IN cantidad INT)
BEGIN
DECLARE i INT DEFAULT 1;
DECLARE nombre_base VARCHAR(50);
WHILE i <= cantidad DO
SET nombre_base = CONCAT('Alumno_', i);
INSERT INTO Alumno (id, nombre, edad, email)
VALUES (i, nombre_base, 20 + (i % 5), CONCAT(nombre_base, '@mail.com'));
SET i = i + 1;
END WHILE;
END //
DELIMITER ;
CALL insertar_varios_alumnos(10);
Triggers (Disparadores)¶
Elemento | Descripción |
---|---|
Evento | Acción que dispara el trigger: INSERT , UPDATE , DELETE |
Momento | Cuándo se ejecuta: BEFORE o AFTER |
Alcance | Siempre FOR EACH ROW (por cada fila afectada) |
Tabla destino | La tabla sobre la que se activa el trigger |
Referencias | NEW.columna (para nuevos valores), OLD.columna (para valores antiguos) |
Uso común | Validaciones, auditorías, restricciones personalizadas |
Limitaciones | No puede usar COMMIT o ROLLBACK ; no devuelve datos directamente |
-- BEFORE INSERT: normalizar nombre
DELIMITER //
CREATE TRIGGER before_insert_alumno
BEFORE INSERT ON Alumno
FOR EACH ROW
BEGIN
SET NEW.nombre = UPPER(NEW.nombre);
END //
DELIMITER ;
-- AFTER UPDATE: registrar cambios
DELIMITER //
CREATE TRIGGER after_update_alumno
AFTER UPDATE ON Alumno
FOR EACH ROW
BEGIN
INSERT INTO LogCambios (tabla, id_afectado, cambio)
VALUES ('Alumno', NEW.id, CONCAT('Edad actualizada a ', NEW.edad));
END //
DELIMITER ;
Formas Normales (FN)¶
Primera Forma Normal (1FN)¶
- Regla: Todos los atributos deben contener valores atómicos (sin listas o conjuntos).
- Violación común: columnas multivaluadas o repetidas.
Solución: Separar valores multivaluados en otra tabla.
Ejemplo incorrecto:
id | nombre | teléfonos |
---|---|---|
1 | Ana | 123, 456 |
Ejemplo 1FN:
id | nombre | teléfono |
---|---|---|
1 | Ana | 123 |
1 | Ana | 456 |
Segunda Forma Normal (2FN)¶
- Regla: Estar en 1FN y todos los atributos que no son clave deben depender totalmente de la clave primaria (no parcialmente).
- Aplica solo si la PK es compuesta.
Violación común: Atributos que dependen solo de una parte de la PK.
Solución: Dividir la tabla.
Tercera Forma Normal (3FN)¶
- Regla: Estar en 2FN y ningún atributo no clave debe depender de otro atributo no clave (eliminar dependencias transitivas).
Violación común: Un atributo depende de otro que no es clave.
Solución: Crear nuevas tablas para las dependencias.
Formas adicionales (opcional)¶
Forma Normal de Boyce-Codd (BCNF)¶
- Es una versión más estricta de 3FN.
- Toda determinante debe ser clave candidata.
4FN y 5FN¶
- Se centran en dependencias multivaluadas y de unión.
- Poco comunes en práctica habitual, salvo en casos complejos.
Tipos de Anomalías evitadas¶
Tipo | Ejemplo |
---|---|
Inserción | No se puede registrar curso sin alumno |
Actualización | Cambiar el teléfono obliga múltiples cambios |
Eliminación | Borrar última matrícula borra datos del curso |
Resumen rápido¶
Forma Normal | Qué elimina | Requiere |
---|---|---|
1FN | Atributos no atómicos | Celdas con valores indivisibles |
2FN | Dependencias parciales | PK compuesta |
3FN | Dependencias transitivas | Atributos solo dependen de la PK |
BCNF | Determinantes no clave | Reforzar que las claves sean únicas |