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