Proyecto final: base de datos para app de tareas

Introducción al proyecto y planificación (20 minutos)

Explicación:
El proyecto consiste en diseñar y crear una base de datos relacional para una aplicación de tareas con las siguientes características:

• Tablas:
  • usuarios: Almacena información de los usuarios (por ejemplo, nombre, email).
  • tareas: Almacena tareas, cada una asociada a un usuario.
• Relación: Uno a muchos (1:N) entre usuarios y tareas (un usuario puede tener muchas tareas).
• Consultas: Listar tareas por usuario, usando JOINs y filtros.

Requisitos:

• Tabla usuarios:
  • Campos: id (clave primaria), nombre, email (único).
• Tabla tareas:
  • Campos: id (clave primaria), titulo, descripcion, estado (por ejemplo, pendiente/completada), id_usuario (clave foránea).
• Relación:
  • tareas.id_usuario referencia usuarios.id (1:N).
• Consultas: Al menos 3 consultas SQL para:
  • Listar todas las tareas con el nombre del usuario.
  • Listar tareas de un usuario específico.
  • Listar tareas por estado (por ejemplo, completadas).
• Herramientas: Usar phpMyAdmin, MySQL Workbench, o CLI para crear y probar la base de datos.

Planificación (2 horas):

1. Diseñar el esquema (20 min).
2. Crear la base de datos y tablas (30 min).
3. Insertar datos de prueba (20 min).
4. Escribir y probar consultas (30 min).
5. Documentar y entregar (20 min).

Por qué es importante:

• Integra todos los conceptos del Módulo 5: tablas, claves, relaciones, JOINs, y herramientas.
• Prepara para Laravel, donde diseñarás bases de datos similares con migraciones y consultarás datos con Eloquent.

Diagrama del esquema:

usuarios
+----+---------+-----------------+
| id | nombre  | email           |
+----+---------+-----------------+
| PK | VARCHAR | VARCHAR UNIQUE  |

tareas
+----+---------+-------------+--------+-------------+
| id | titulo  | descripcion | estado | id_usuario  |
+----+---------+-------------+--------+-------------+
| PK | VARCHAR | TEXT        | ENUM   | FK->usuarios|

Punto clave: Este proyecto consolida las habilidades del módulo en una base de datos funcional, similar a un sistema real.

Actividad rápida (3 minutos):
Dibuja en papel el diagrama de las tablas usuarios y tareas, indicando la clave foránea. Solución sugerida:

• usuarios: id (PK), nombre, email.
• tareas: id (PK), titulo, descripcion, estado, id_usuario (FK → usuarios.id).

---

Diseño y creación de la base de datos (30 minutos)

Explicación:
Diseñamos el esquema y creamos la base de datos y tablas usando una herramienta (recomendado: phpMyAdmin).

Paso 1: Diseñar el esquema:

• Tabla usuarios:
  • id: Clave primaria, autoincremental.
  • nombre: Nombre del usuario (máximo 100 caracteres).
  • email: Correo único (máximo 100 caracteres).
• Tabla tareas:
  • id: Clave primaria, autoincremental.
  • titulo: Título de la tarea (máximo 200 caracteres).
  • descripcion: Detalles de la tarea (texto largo).
  • estado: Estado de la tarea (“pendiente” o “completada”).
  • id_usuario: Clave foránea que referencia usuarios.id.
• Relación: Uno a muchos (usuarios.id → tareas.id_usuario).

Paso 2: Crear la base de datos y tablas:

• Usando phpMyAdmin:
  1. Accede a http://localhost/phpmyadmin.
  2. Crea una base de datos:
     • Nombre: app_tareas.
     • Codificación: utf8_general_ci.
  3. En la pestaña “SQL”, ejecuta:

     CREATE TABLE usuarios (
         id INT AUTO_INCREMENT PRIMARY KEY,
         nombre VARCHAR(100) NOT NULL,
         email VARCHAR(100) NOT NULL UNIQUE
     );
     
     CREATE TABLE tareas (
         id INT AUTO_INCREMENT PRIMARY KEY,
         titulo VARCHAR(200) NOT NULL,
         descripcion TEXT,
         estado ENUM('pendiente', 'completada') NOT NULL DEFAULT 'pendiente',
         id_usuario INT,
         FOREIGN KEY (id_usuario) REFERENCES usuarios(id) ON DELETE CASCADE
     );

     • ON DELETE CASCADE: Si se elimina un usuario, sus tareas también se eliminan.
  4. Verifica: Selecciona app_tareas, revisa las tablas en “Structure”.
• Alternativa (CLI):
  1. Conecta: mysql -u root -p.
  2. Ejecuta:

     CREATE DATABASE app_tareas;
     USE app_tareas;

     Luego el SQL anterior.
  3. Verifica: SHOW TABLES; DESCRIBE usuarios; DESCRIBE tareas;.
• Alternativa (MySQL Workbench):
  1. Conecta a localhost.
  2. Crea la base de datos: CREATE DATABASE app_tareas;.
  3. Usa el editor visual para crear las tablas (o ejecuta el SQL).

Cómo probarlo:

• En phpMyAdmin, ve a la pestaña “Structure” de usuarios y tareas.
• Confirma que id_usuario en tareas tiene una clave foránea a usuarios.id.
• Si hay errores, revisa el SQL o consulta el log de MySQL (C:\xampp\mysql\data\mysql_error.log).

Punto clave: Un esquema bien diseñado asegura que la base de datos sea funcional y escalable.

Actividad rápida (3 minutos):
Escribe en papel una restricción adicional para tareas (por ejemplo, un campo). Solución sugerida:

• Campo: fecha_creacion DATETIME DEFAULT CURRENT_TIMESTAMP.

---

3. Insertar datos de prueba (20 minutos)

Explicación:
Insertamos datos para probar las consultas, asegurando que haya suficientes registros para relaciones 1:N.

Código SQL:

• En phpMyAdmin (pestaña “SQL”) o CLI, ejecuta:

  INSERT INTO usuarios (nombre, email) VALUES 
      ('Ana López', 'ana@correo.com'),
      ('Juan Pérez', 'juan@correo.com'),
      ('María Gómez', 'maria@correo.com');
  
  INSERT INTO tareas (titulo, descripcion, estado, id_usuario) VALUES 
      ('Comprar víveres', 'Lista: leche, pan, huevos', 'pendiente', 1),
      ('Terminar informe', 'Informe para el lunes', 'completada', 1),
      ('Estudiar SQL', 'Repasar JOINs', 'pendiente', 2),
      ('Llamar cliente', 'Confirmar reunión', 'completada', 2),
      ('Hacer ejercicio', NULL, 'pendiente', 3);

Cómo funciona:

• Usuarios: 3 usuarios con nombres y correos únicos.
• Tareas: 5 tareas distribuidas entre los usuarios:
  • Ana (id=1): 2 tareas (pendiente, completada).
  • Juan (id=2): 2 tareas (pendiente, completada).
  • María (id=3): 1 tarea (pendiente).
• estado: Usa ENUM para restringir a “pendiente” o “completada”.
• descripcion: Puede ser NULL (por ejemplo, en “Hacer ejercicio”).

Cómo probarlo:

• En phpMyAdmin:
  • Ve a app_tareas → usuarios → “Browse”: Confirma 3 usuarios.
  • Ve a tareas → “Browse”: Confirma 5 tareas con id_usuario correcto.
• En CLI:

  SELECT * FROM usuarios;
  SELECT * FROM tareas;

Punto clave: Los datos de prueba son esenciales para validar las consultas con relaciones.

Actividad rápida (3 minutos):
Escribe en papel una tarea adicional para insertar. Solución sugerida:

INSERT INTO tareas (titulo, descripcion, estado, id_usuario) 
VALUES ('Revisar correo', 'Chequear bandeja de entrada', 'pendiente', 3);

---

Escribir y probar consultas SQL (30 minutos)

Explicación:
Creamos 3 consultas SQL para listar tareas por usuario, usando JOINs y filtros (Lección 3, Módulo 5).

Consultas requeridas:

1. Listar todas las tareas con el nombre del usuario (INNER JOIN).
2. Listar tareas de un usuario específico (por ejemplo, id_usuario=1).
3. Listar tareas por estado (por ejemplo, “completada”).

Código SQL:

• En phpMyAdmin (pestaña “SQL”) o CLI, ejecuta:

  -- Consulta 1: Todas las tareas con nombre del usuario
  SELECT usuarios.nombre AS usuario, tareas.titulo, tareas.descripcion, tareas.estado
  FROM usuarios
  INNER JOIN tareas ON usuarios.id = tareas.id_usuario;
  
  -- Consulta 2: Tareas de un usuario específico (id_usuario=1)
  SELECT usuarios.nombre AS usuario, tareas.titulo, tareas.descripcion, tareas.estado
  FROM usuarios
  INNER JOIN tareas ON usuarios.id = tareas.id_usuario
  WHERE usuarios.id = 1;
  
  -- Consulta 3: Tareas completadas
  SELECT usuarios.nombre AS usuario, tareas.titulo, tareas.descripcion
  FROM usuarios
  INNER JOIN tareas ON usuarios.id = tareas.id_usuario
  WHERE tareas.estado = 'completada';

Resultados esperados:

• Consulta 1:

  +-------------+-------------------+--------------------+------------+
  | usuario     | titulo            | descripcion        | estado     |
  +-------------+-------------------+--------------------+------------+
  | Ana López   | Comprar víveres   | Lista: leche, pan  | pendiente  |
  | Ana López   | Terminar informe  | Informe para lunes | completada |
  | Juan Pérez  | Estudiar SQL      | Repasar JOINs      | pendiente  |
  | Juan Pérez  | Llamar cliente    | Confirmar reunión  | completada |
  | María Gómez | Hacer ejercicio   | NULL               | pendiente  |
  +-------------+-------------------+--------------------+------------+

• Consulta 2:

  +-----------+------------------+--------------------+------------+
  | usuario   | titulo           | descripcion        | estado     |
  +-----------+------------------+--------------------+------------+
  | Ana López | Comprar víveres  | Lista: leche, pan  | pendiente  |
  | Ana López | Terminar informe | Informe para lunes | completada |
  +-----------+------------------+--------------------+------------+

• Consulta 3:

  +------------+------------------+--------------------+
  | usuario    | titulo           | descripcion        |
  +------------+------------------+--------------------+
  | Ana López  | Terminar informe | Informe para lunes |
  | Juan Pérez | Llamar cliente   | Confirmar reunión  |
  +------------+------------------+--------------------+

Cómo probarlo:

• En phpMyAdmin:
  • Ejecuta cada consulta en la pestaña “SQL”.
  • Verifica los resultados en la salida.
  • Usa “Browse” en tareas para confirmar los datos.
• En CLI:
  • Ejecuta las consultas y revisa la salida en la terminal.
  • Usa SELECT * FROM tareas; para validar.
• En MySQL Workbench:
  • Ejecuta las consultas en la pestaña “Query” y revisa los resultados.

Notas:

• INNER JOIN: Usado porque queremos tareas con usuarios existentes.
• Alias: AS usuario clarifica los resultados.
• WHERE: Filtra por usuario o estado.

Punto clave: Estas consultas demuestran cómo usar JOINs para combinar datos relacionados, una habilidad clave en aplicaciones reales.

Actividad rápida (3 minutos):
Escribe en papel una consulta adicional para listar tareas pendientes. Solución sugerida:

SELECT usuarios.nombre, tareas.titulo
FROM usuarios
INNER JOIN tareas ON usuarios.id = tareas.id_usuario
WHERE tareas.estado = 'pendiente';

---

Documentación y entrega (20 minutos)

Explicación:
Documentamos la base de datos y entregamos el proyecto, asegurando que cumpla con el entregable.

Instrucciones de entrega:

1. Entregable:
   • Base de datos funcional (app_tareas) con:
     • Tablas usuarios y tareas.
     • Datos de prueba (mínimo 3 usuarios, 5 tareas).
     • 3 consultas SQL probadas.
   • Documento con:
     • SQL para crear tablas (CREATE TABLE).
     • SQL para insertar datos (INSERT).
     • Las 3 consultas SQL y sus resultados esperados (descritos o capturas).
     • Herramienta usada (phpMyAdmin, CLI, o MySQL Workbench).
   • Opcional: Capturas de pantalla (tablas en phpMyAdmin, resultados de consultas).
2. Formato sugerido:
   • Archivo de texto o documento (proyecto_tareas.txt o .docx).
   • Estructura:

     Proyecto Final - Módulo 5: Aplicación de Tareas
     Herramienta: phpMyAdmin
     
     1. Creación de tablas:
     [SQL de CREATE TABLE]
     
     2. Datos de prueba:
     [SQL de INSERT]
     
     3. Consultas SQL:
     Consulta 1: [SQL y resultado esperado]
     Consulta 2: [SQL y resultado esperado]
     Consulta 3: [SQL y resultado esperado]

3. Pruebas finales:
   • Verifica que las tablas existan:
     • phpMyAdmin: Revisa app_tareas → “Structure”.
     • CLI: SHOW TABLES;.
   • Confirma los datos:
     • SELECT * FROM usuarios; (3 registros).
     • SELECT * FROM tareas; (5 registros).
   • Ejecuta las consultas y compara los resultados con los esperados.
   • Si hay errores, revisa el SQL o el log de MySQL (C:\xampp\mysql\data\mysql_error.log).

Cómo entregar:

• Comprime el archivo de texto/documento y capturas (si las hay) en proyecto_tareas.zip.
• Alternativa: Describe los resultados y envía el SQL para revisión.

Punto clave: La documentación clara y las pruebas aseguran que el proyecto cumple con los requisitos.

Actividad rápida (3 minutos):
Escribe en papel el nombre de las 3 consultas que entregarás. Solución sugerida:

1. Todas las tareas con usuario.
2. Tareas de un usuario.
3. Tareas completadas.

---

Instrucciones finales para el estudiante

Pasos para completar el proyecto:

1. Crea la base de datos app_tareas en phpMyAdmin, CLI, o MySQL Workbench.
2. Implementa las tablas usuarios y tareas con el SQL proporcionado.
3. Inserta los datos de prueba (3 usuarios, 5 tareas).
4. Escribe y prueba las 3 consultas SQL.
5. Documenta:
   • SQL de creación e inserción.
   • Consultas y resultados.
   • Herramienta usada.
6. Entrega el documento y, opcionalmente, capturas.

Tiempo estimado: 2 horas (puedes dividirlo en sesiones):

• Diseño: 20 min.
• Creación: 30 min.
• Datos: 20 min.
• Consultas: 30 min.
• Documentación: 20 min.

Consejo:

• Usa phpMyAdmin para simplicidad, pero prueba CLI si quieres rapidez.
• Verifica cada paso antes de avanzar (por ejemplo, confirma las tablas antes de insertar).
• Guarda el SQL en un archivo para reutilizarlo.