Saltar a contenido

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