Introducción a Bases de Datos Relacionales

¿Qué son las bases de datos relacionales? (10 minutos)

Explicación:
Una base de datos relacional organiza datos en tablas que se relacionan entre sí mediante claves. Es gestionada por un sistema como MySQL, que permite almacenar, consultar, y actualizar datos de forma eficiente.

Conceptos clave:

• Tabla: Estructura con filas (registros) y columnas (campos).
  • Ejemplo: Tabla estudiantes con columnas id, nombre, email.
• Clave primaria (Primary Key): Columna que identifica de forma única cada registro.
  • Ejemplo: id en estudiantes, único y no nulo.
  • Reglas: Debe ser único, no nulo, y generalmente es un número autoincremental (INT AUTO_INCREMENT).
• Clave foránea (Foreign Key): Columna que vincula una tabla con otra, referenciando la clave primaria de la tabla relacionada.
  • Ejemplo: id_usuario en una tabla posts que referencia id en usuarios.
  • Reglas: Asegura integridad referencial (solo valores válidos de la tabla referenciada).
• Relaciones: Conexiones entre tablas basadas en claves foráneas. Tipos:
  • Uno a muchos (1:N): Un registro en una tabla se relaciona con varios en otra.
    • Ejemplo: Un usuario escribe muchos posts.
  • Uno a uno (1:1): Un registro en una tabla se relaciona con exactamente un registro en otra.
    • Ejemplo: Un usuario tiene un perfil.
  • Muchos a muchos (N:N): Múltiples registros en una tabla se relacionan con múltiples registros en otra, usando una tabla intermedia.
    • Ejemplo: Estudiantes inscritos en varios cursos, y cursos con varios estudiantes.

Por qué es importante:

• Las bases de datos relacionales permiten organizar datos complejos (por ejemplo, en un blog o tienda) de forma estructurada, eficiente, y escalable.
• En Laravel, las migraciones y modelos Eloquent reflejan estas relaciones (por ejemplo, hasMany, belongsTo).

Punto clave: Las tablas, claves, y relaciones son la base para modelar datos en aplicaciones web.

Actividad rápida (2 minutos):
Piensa en una aplicación web (por ejemplo, una red social). Escribe en papel una tabla y su clave primaria. Ejemplo:

• Tabla: usuarios, Clave primaria: id.

---

Componentes de una base de datos relacional (15 minutos)

Explicación:
Exploremos cómo funcionan las tablas, claves, y relaciones en detalle.

Tablas:

• Cada tabla representa una entidad (por ejemplo, usuarios, productos).
• Columnas definen los atributos (por ejemplo, nombre, precio).
• Filas son registros individuales.
• Ejemplo:

  Tabla: usuarios
  +----+---------+-----------------+
  | id | nombre  | email           |
  +----+---------+-----------------+
  | 1  | Ana     | ana@correo.com  |
  | 2  | Juan    | juan@correo.com |
  +----+---------+-----------------+

Claves primarias:

• Identifican registros de forma única.
• Ejemplo: En usuarios, id es la clave primaria.
• En MySQL:

  id INT AUTO_INCREMENT PRIMARY KEY

Claves foráneas:

• Conectan tablas.
• Ejemplo: Tabla posts con id_usuario que referencia id en usuarios.

  id_usuario INT,
  FOREIGN KEY (id_usuario) REFERENCES usuarios(id)

• Restricciones:
  • ON DELETE CASCADE: Elimina registros dependientes si se borra el registro principal.
  • ON DELETE RESTRICT: Impide borrar si hay registros dependientes.

Relaciones:

• Uno a muchos (1:N):
  • Ejemplo: Un usuario (usuarios) tiene muchos posts (posts).
  • Estructura: posts tiene una clave foránea id_usuario.
• Uno a uno (1:1):
  • Ejemplo: Un usuario tiene un perfil (perfiles).
  • Estructura: perfiles tiene una clave foránea id_usuario con restricción de unicidad.
• Muchos a muchos (N:N):
  • Ejemplo: Estudiantes (estudiantes) y cursos (cursos).
  • Estructura: Tabla intermedia estudiantes_cursos con claves foráneas id_estudiante y id_curso.

Cómo se implementa en MySQL:

• Crear tablas con claves:

  CREATE TABLE usuarios (
      id INT AUTO_INCREMENT PRIMARY KEY,
      nombre VARCHAR(100) NOT NULL
  );
  
  CREATE TABLE posts (
      id INT AUTO_INCREMENT PRIMARY KEY,
      titulo VARCHAR(200) NOT NULL,
      id_usuario INT,
      FOREIGN KEY (id_usuario) REFERENCES usuarios(id) ON DELETE CASCADE
  );

Punto clave: Las claves primarias y foráneas definen cómo las tablas se relacionan, asegurando integridad y eficiencia.

Actividad rápida (3 minutos):
Dibuja en papel dos tablas relacionadas (por ejemplo, clientes y pedidos). Indica la clave primaria y foránea. Solución sugerida:

• clientes: id (clave primaria).
• pedidos: id, id_cliente (clave foránea que referencia clientes(id)).

---

Ejemplo práctico: Diagrama de una base de datos para un blog (15 minutos)

Explicación:
Diseñemos una base de datos para un blog con usuarios, posts, y categorías.

Requisitos del blog:

• Usuarios: Cada usuario tiene un nombre y email, y puede escribir posts.
• Posts: Cada post tiene un título, contenido, y está escrito por un usuario.
• Categorías: Cada categoría tiene un nombre, y los posts pueden pertenecer a una categoría.

Diagrama relacional:

• Tablas y relaciones:
  • usuarios: Almacena usuarios.
  • posts: Almacena posts, relacionados con un usuario (1:N) y una categoría (1:N).
  • categorias: Almacena categorías.
• Esquema:

  usuarios
  +----+---------+-----------------+
  | id | nombre  | email           |
  +----+---------+-----------------+
  | PK | VARCHAR | VARCHAR         |
  
  categorias
  +----+---------+
  | id | nombre  |
  +----+---------+
  | PK | VARCHAR |
  
  posts
  +----+---------+----------+--------------+-------------+
  | id | titulo  | contenido| id_usuario   | id_categoria |
  +----+---------+----------+--------------+-------------+
  | PK | VARCHAR | TEXT     | FK->usuarios | FK->categorias |

Código SQL:

CREATE TABLE usuarios (
    id INT AUTO_INCREMENT PRIMARY KEY,
    nombre VARCHAR(100) NOT NULL,
    email VARCHAR(100) NOT NULL UNIQUE
);

CREATE TABLE categorias (
    id INT AUTO_INCREMENT PRIMARY KEY,
    nombre VARCHAR(50) NOT NULL
);

CREATE TABLE posts (
    id INT AUTO_INCREMENT PRIMARY KEY,
    titulo VARCHAR(200) NOT NULL,
    contenido TEXT NOT NULL,
    id_usuario INT,
    id_categoria INT,
    FOREIGN KEY (id_usuario) REFERENCES usuarios(id) ON DELETE CASCADE,
    FOREIGN KEY (id_categoria) REFERENCES categorias(id) ON DELETE SET NULL
);

Cómo funciona:

• Relaciones:
  • Un usuario puede tener muchos posts (1:N, id_usuario en posts).
  • Una categoría puede tener muchos posts (1:N, id_categoria en posts).
• Restricciones:
  • ON DELETE CASCADE: Si se elimina un usuario, sus posts también se eliminan.
  • ON DELETE SET NULL: Si se elimina una categoría, los posts quedan sin categoría (id_categoria = NULL).

Cómo probarlo:

1. Abre phpMyAdmin.
2. Crea la base de datos blog y ejecuta el SQL anterior.
3. Inserta datos de prueba:

   INSERT INTO usuarios (nombre, email) VALUES ('Ana', 'ana@correo.com');
   INSERT INTO categorias (nombre) VALUES ('Tecnología');
   INSERT INTO posts (titulo, contenido, id_usuario, id_categoria) VALUES ('Mi primer post', 'Contenido...', 1, 1);

4. Verifica las relaciones:
   • Consulta: SELECT * FROM posts WHERE id_usuario=1.
   • Elimina un usuario y confirma que sus posts desaparecen (ON DELETE CASCADE).

Punto clave: Este diagrama muestra cómo las claves foráneas conectan tablas, un concepto clave para modelar datos en Laravel.

Actividad rápida (3 minutos):
Modifica el diagrama (en papel) para añadir una tabla comentarios relacionada con posts y usuarios. Solución sugerida:

• Tabla: comentarios
  • Columnas: id (PK), contenido, id_post (FK → posts(id)), id_usuario (FK → usuarios(id)).

---

Resumen y preparación para la tarea (10 minutos)

Resumen:

• Base de datos relacional: Organiza datos en tablas relacionadas mediante claves.
• Claves:
  • Primarias: Identifican registros únicos.
  • Foráneas: Conectan tablas.
• Relaciones: 1:N, 1:1, N:N.
• Ejemplo: Base de datos para un blog (usuarios, posts, categorias).
• Estos conceptos son fundamentales para diseñar bases de datos en MySQL y trabajar con Laravel.

Preparación para la tarea:
La tarea pide diseñar un esquema para una tienda con productos y categorías.

• Estrategia:
  • Define las entidades: productos (por ejemplo, nombre, precio) y categorías (por ejemplo, nombre).
  • Establece relaciones: Un producto pertenece a una categoría (1:N).
  • Crea un diagrama con tablas, claves primarias, y foráneas.
  • Escribe el SQL para las tablas.
• Lógica básica:
  • Tabla categorias: id, nombre.
  • Tabla productos: id, nombre, precio, id_categoria (FK).

Punto clave: Diseñar un esquema claro es el primer paso para construir bases de datos relacionales eficientes.

---

Tarea práctica: Diseña un esquema para una tienda (productos, categorías)

Instrucciones:

1. Diseña un esquema de base de datos para una tienda que incluya productos y categorías.
2. Requisitos:
   • Productos: Al menos id, nombre, precio, y una relación con categorías.
   • Categorías: Al menos id, nombre.
   • Relación: Un producto pertenece a una categoría (1:N).
   • Usa claves primarias y foráneas.
3. Entregable:
   • Un diagrama (dibujado a mano, en Draw.io, Lucidchart, o MySQL Workbench) que muestre:
     • Tablas con columnas.
     • Claves primarias y foráneas.
     • Relaciones (1:N).
   • Código SQL para crear las tablas.
4. Usa el siguiente ejemplo como guía:
   • Diagrama:

     categorias
     +----+---------+
     | id | nombre  |
     +----+---------+
     | PK | VARCHAR |
     
     productos
     +----+---------+--------+--------------+
     | id | nombre  | precio | id_categoria |
     +----+---------+--------+--------------+
     | PK | VARCHAR | DECIMAL| FK->categorias |

   • SQL:

     CREATE TABLE categorias (
         id INT AUTO_INCREMENT PRIMARY KEY,
         nombre VARCHAR(50) NOT NULL
     );
     
     CREATE TABLE productos (
         id INT AUTO_INCREMENT PRIMARY KEY,
         nombre VARCHAR(100) NOT NULL,
         precio DECIMAL(10,2) NOT NULL,
         id_categoria INT,
         FOREIGN KEY (id_categoria) REFERENCES categorias(id) ON DELETE SET NULL
     );

5. Pasos para completar:
   • Paso 1: Define las columnas de productos y categorías.
     • Ejemplo: productos (id, nombre, precio, id_categoria), categorías (id, nombre).
   • Paso 2: Dibuja el diagrama mostrando claves y relaciones.
     • Usa flechas para indicar que id_categoria en productos referencia id en categorías.
   • Paso 3: Escribe el SQL para crear las tablas.
     • Incluye PRIMARY KEY, FOREIGN KEY, y restricciones como ON DELETE SET NULL.
   • Paso 4: Opcional: Prueba el SQL en phpMyAdmin.
     • Crea la base de datos tienda.
     • Ejecuta el SQL.
     • Inserta datos de prueba:

       INSERT INTO categorias (nombre) VALUES ('Electrónica');
       INSERT INTO productos (nombre, precio, id_categoria) VALUES ('Teléfono', 299.99, 1);

   • Paso 5: Entrega el diagrama (escaneado, foto, o archivo digital) y el SQL (como texto o archivo).

Ejemplo de solución esperada:

• Diagrama:
  • Tabla categorias: id (PK), nombre.
  • Tabla productos: id (PK), nombre, precio, id_categoria (FK).
  • Relación 1:N: Una categoría tiene muchos productos.
• SQL: Como el ejemplo anterior, con columnas claras y restricciones.

Tiempo estimado: 30-45 minutos (puedes hacerlo después de la lección).
Entregable:

• Diagrama (papel o digital).
• Código SQL (texto o archivo).
• Opcional: Captura de phpMyAdmin mostrando las tablas creadas.

Consejo:

• Mantén el diseño simple: solo productos y categorías.
• Usa nombres claros para columnas (por ejemplo, nombre, no nomb).
• Verifica que las claves foráneas referencien correctamente las primarias.