MySQL - Capitulo 1

Una guía através del camino de las bases de datos con MySQL uno de los sistemas de gestión de bases de datos más conocidos y utilizados en el mundo de la programación.

Síguenos con el tutorial

En QuéPasalinux MySQL - Introducción a MySQL con Docker un vídeo práctico sobre MySQL y Docker

Volver a Página Principal

Ver Codigo en GitLab

📚 Curso de Capacitación de MySQL

🤝 Módulo 1: Introducción a MySQL con Docker

¡Bienvenidos al Módulo 1! En esta sección, profundizaremos en el proceso de inicialización de MySQL con Docker, crear y modificar tablas, e insertar y consultar datos básicos.

Objetivo: Que los participantes entiendan qué es una base de datos, para qué sirve, y logren interactuar con MySQL utilizando el CLI (Command Line Interface) dentro de un contenedor Docker.

Público: Personas sin experiencia previa en bases de datos.

1. ¿Qué es una Base de Datos?

Una base de datos es un conjunto organizado de datos que se almacena y se recupera de manera eficiente.
Tipos de Bases de Datos:
- SQL (Relacionales): Las más comunes. Organizan los datos en tablas con filas y columnas (como hojas de cálculo, pero más potentes). MySQL es un ejemplo.
- NoSQL (No Relacionales): Otros tipos para datos más flexibles (solo mencionar que existen).
¿Qué es MySQL?
- Es un Sistema Gestor de Bases de Datos Relacionales (SGBDR).
- Es de código abierto, muy popular y se usa para sitios web, aplicaciones móviles, sistemas empresariales.

2. Preparando el Entorno con Docker

¿Por qué Docker? (La ventaja para los principiantes)
- Simplifica la instalación: No hay que instalar MySQL directamente en su máquina (que a veces da errores).
- Aislamiento: MySQL corre en su propio “paquete” (contenedor) sin afectar el resto del sistema.
- Portabilidad: Funciona igual en cualquier máquina con Docker.
- “Caja mágica”: Piénsenlo como una caja pre-configurada que ya tiene MySQL listo para usar.

Revisión del docker-compose.yml

YAML

services:
  mysql:
    image: mysql:latest
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: admin
      MYSQL_DATABASE: db
      MYSQL_USER: admin
      MYSQL_PASSWORD: admin
    ports:
      - "3306:3306"  # Exponer el puerto 3306 para conexiones externas
    networks:
      - general  # Red compartida

  phpmyadmin:
    image: phpmyadmin/phpmyadmin:latest
    restart: always
    ports:
      - "8080:80"  # phpMyAdmin accesible en el puerto 8080 del host
    environment:
      PMA_HOST: mysql  # Conectar al servicio MySQL
      PMA_USER: root
      PMA_PASSWORD: admin
    depends_on:
      - mysql  # Levantar phpMyAdmin después de MySQL
    networks:
      - general  # Red compartida

networks:
  general:
    driver: bridge  # Red compartida entre los servicios

Puntos importantes a enfatizar:
- image: mysql:8.0: Estamos usando la imagen oficial de MySQL.
- MYSQL_ROOT_PASSWORD: ¡La contraseña de root! Recuérdenla.
- MYSQL_DATABASE: Se creará una base de datos inicial para nosotros.
- volumes: Importante para que sus datos no se pierdan.

3. Levantando MySQL con Docker Compose

Abrir la Terminal/Línea de Comandos:
Navegar a la carpeta del docker-compose.yml:
```
Bash
```
```
cd /ruta/a/tu/proyecto
```
Iniciar los servicios:
```
Bash
```
```
docker-compose up -d
```
- up: Inicia los servicios definidos en el docker-compose.yml.
- -d: Ejecuta los contenedores en segundo plano (detached mode) para que puedan seguir usando la terminal.
Verificar que el contenedor esté corriendo:
```
Bash
```
```
docker ps
```
- Deberían ver un contenedor con el nombre de su servicio (ej. mi_proyecto_db_1) y mysql:8.0 en la columna IMAGE.
Revisar los logs (si hay problemas):
```
Bash
```
```
docker-compose logs db
```
- db es el nombre de su servicio en el docker-compose.yml. Aquí verán si MySQL inició correctamente o si hay algún error.

4. Conectándose al CLI de MySQL

¿Qué es el CLI (Command Line Interface)?
- Es una forma de interactuar con MySQL escribiendo comandos de texto directamente en la terminal, sin interfaz gráfica.
- Es muy potente y fundamental para los administradores de bases de datos.

Paso a paso para conectar

Identificar el nombre del contenedor MySQL:

Bash

docker ps

Busquen el nombre en la columna NAMES (ej. mi_proyecto_db_1). 2. Ejecutar el cliente MySQL dentro del contenedor:

Bash

docker exec -it <nombre_del_contenedor> mysql -u root -p

- `docker exec`: Ejecuta un comando dentro de un contenedor en ejecución.
- `-it`: Permite la interacción y una terminal limpia.
- `<nombre_del_contenedor>`: Sustituyan por el nombre real de su contenedor.
- `mysql -u root -p`: El comando para iniciar el cliente MySQL como usuario `root` y solicitar la contraseña.

Introducir la contraseña: Usen la contraseña que definieron en MYSQL_ROOT_PASSWORD en su docker-compose.yml.
¡Bienvenido al prompt de MySQL! Si ven mysql>, están dentro.

Primeros Comandos Sencillos:
- Ver las bases de datos existentes:
```
SQL
```
```
SHOW DATABASES;
```
  - Explicar: Observarán mi_primera_bd (la que se creó con Docker Compose), mysql, information_schema, performance_schema, sys (estas son bases de datos internas de MySQL, ¡no tocarlas aún!).
- Seleccionar una base de datos para trabajar:
```
SQL
```
```
USE mi_primera_bd;
```
  - Explicar: Esto les dice a MySQL que todos los comandos posteriores se aplicarán a mi_primera_bd. El prompt cambiará a Database changed.
- Ver las tablas dentro de la base de datos actual (ahora no habrá ninguna):
```
SQL
```
```
SHOW TABLES;
```
  - Explicar: Esto mostrará Empty set porque aún no hemos creado ninguna tabla.
- Salir del CLI de MySQL:
```
SQL
```
```
EXIT;
```
  o simplemente presionar Ctrl+D.

5. Primeras Interacciones: Creando una Tabla Sencilla

Concepto de Tabla: Una tabla es donde organizamos la información de un tipo específico (ej. “clientes”, “productos”, “doctores”).
- Columnas: Las categorías de información (ej. nombre, edad, ciudad).
- Filas: Los registros individuales (ej. “Juan”, “30”, “Madrid”).
Tipos de Datos (Muy básico y esencial):
- INT: Para números enteros (ej. edad, cantidad).
- VARCHAR(tamaño): Para texto corto/mediano (ej. nombre, ciudad, con un límite de caracteres).
- DATE: Para fechas (ej. fecha de nacimiento).
- PRIMARY KEY: Una columna especial que identifica de forma única cada fila (ej. id_cliente). Es como un número de identificación único.
- AUTO_INCREMENT: Para que la PRIMARY KEY numérica se genere automáticamente.

Creando la primera tabla (ejemplo: alumnos):

Conéctense de nuevo al CLI y usen la base de datos mi_primera_bd:

Bash

docker exec -it <nombre_del_contenedor> mysql -u root -p
USE mi_primera_bd;

Comando CREATE TABLE:

SQL

CREATE TABLE alumnos (
    id INT AUTO_INCREMENT PRIMARY KEY,
    nombre VARCHAR(100) NOT NULL,
    apellido VARCHAR(100) NOT NULL,
    edad INT,
    fecha_nacimiento DATE,
    correo_electronico VARCHAR(255) UNIQUE,
    telefono VARCHAR(20),
    fecha_inscripcion DATETIME DEFAULT CURRENT_TIMESTAMP,
    activo BOOLEAN DEFAULT TRUE,
    promedio_calificaciones DECIMAL(4,2),
    comentarios TEXT
);

Explicar cada parte: CREATE TABLE, nombre de la tabla, paréntesis con las columnas, nombre de la columna, tipo de dato, restricciones (PRIMARY KEY, AUTO_INCREMENT).
¡Importante el punto y coma al final ;!

Verificar que la tabla se creó:
```
SQL
```
```
SHOW TABLES;
```
Deberían ver alumnos.
Ver la estructura de la tabla:
```
SQL
```
```
DESCRIBE alumnos;
```
Esto mostrará las columnas, sus tipos de datos, si pueden ser nulas, etc.

6. Insertando Datos

Comando INSERT INTO: Para añadir nuevas filas (registros) a la tabla.

Sintaxis básica:

SQL

INSERT INTO <nombre_tabla> (columna1, columna2, ...) VALUES (valor1, valor2, ...);

Ejemplos prácticos:

SQL

INSERT INTO alumnos (nombre, apellido, edad) VALUES ('Juan', 'Pérez', 20);
INSERT INTO alumnos (nombre, apellido, edad) VALUES ('María', 'García', 22);
INSERT INTO alumnos (nombre, apellido, edad) VALUES ('Carlos', 'López', 19);

Explicar: Se especifican las columnas y luego los valores en el mismo orden.
¿Qué pasa con id? Como es AUTO_INCREMENT, MySQL lo asigna solo.

7. Consultando Datos

Comando SELECT: ¡El más usado! Para recuperar información de la base de datos.

Sintaxis básica:

SQL

SELECT columna1, columna2 FROM <nombre_tabla>;
SELECT * FROM <nombre_tabla>; -- Para todas las columnas

Ejemplos prácticos:

Ver todos los alumnos:
```
SQL
```
```
SELECT * FROM alumnos;
```

Ver solo nombres y apellidos:

SQL

SELECT nombre, apellido FROM alumnos;

Filtrar datos con WHERE: Para obtener solo las filas que cumplen una condición.
```
SQL
```
```
SELECT * FROM alumnos WHERE edad > 20;
SELECT * FROM alumnos WHERE nombre = 'Juan';
```
- Operadores: =, >, <, >=, <=, LIKE (para búsquedas de texto parcial, ej. LIKE 'M%' para nombres que empiezan con M).

Ordenar resultados con ORDER BY:

SQL

SELECT * FROM alumnos ORDER BY apellido ASC;  -- Ordenar por apellido ascendente
SELECT * FROM alumnos ORDER BY edad DESC;     -- Ordenar por edad descendente

Contar filas con COUNT():

SQL

SELECT COUNT(*) FROM alumnos; -- Cuántos alumnos hay
SELECT COUNT(*) FROM alumnos WHERE edad < 20; -- Cuántos alumnos tienen menos de 20 años

8. Actualizando la Estructura de Tablas (`ALTER TABLE`)

A veces, después de crear una tabla, necesitamos añadir nuevas columnas, eliminar las que ya no usamos, o cambiar el tipo de dato de una columna existente. Para esto, usamos el comando ALTER TABLE.

Comando ALTER TABLE: Para modificar la estructura de una tabla existente.

Sintaxis Básica

Para añadir una columna:

ALTER TABLE <nombre_tabla> ADD COLUMN <nombre_nueva_columna> <tipo_dato> [restricciones];

Para modificar una columna:

ALTER TABLE <nombre_tabla> MODIFY COLUMN <nombre_columna> <nuevo_tipo_dato> [nuevas_restricciones];

Nota: En MySQL, CHANGE COLUMN se usa cuando quieres renombrar una columna y/o cambiar su tipo/definición al mismo tiempo.

Para renombrar una columna (usando CHANGE COLUMN):

ALTER TABLE <nombre_tabla> CHANGE COLUMN <nombre_antiguo> <nombre_nuevo> <tipo_dato> [restricciones];

Para eliminar una columna:

ALTER TABLE <nombre_tabla> DROP COLUMN <nombre_columna>;

Ejemplos Prácticos con la Tabla `alumnos`

Conéctense de nuevo al CLI y usen la base de datos db:

docker exec -it <nombre_del_contenedor> mysql -u root -p
USE db;

Ejemplo 1: Añadir una Nueva Columna (`genero`)

ALTER TABLE alumnos ADD COLUMN genero VARCHAR(10);

Explicación: Agregamos una columna genero de tipo VARCHAR con un tamaño de 10 caracteres. Por defecto, esta columna permitirá valores NULL.

Verificar el cambio:

DESCRIBE alumnos;

Ejemplo 2: Modificar el Tipo de Dato de una Columna (`telefono` a `VARCHAR(30)` y añadir `NOT NULL`)

ALTER TABLE alumnos MODIFY COLUMN telefono VARCHAR(30) NOT NULL;

Explicación: Cambiamos el tamaño máximo de telefono a 30 caracteres y lo hacemos NOT NULL, lo que significa que de ahora en adelante, cada nuevo alumno deberá tener un número de teléfono. Si ya existen filas con NULL en telefono, esta operación fallará a menos que primero actualices esos NULL a un valor válido.

Verificar el cambio:

DESCRIBE alumnos;

Ejemplo 3: Renombrar una Columna (`correo_electronico` a `email`)

ALTER TABLE alumnos CHANGE COLUMN correo_electronico email VARCHAR(255) UNIQUE;

Explicación: Renombramos la columna correo_electronico a email. ¡Importante! Al usar CHANGE COLUMN, deben especificar el tipo de dato completo y sus restricciones para la nueva columna, incluso si no los cambian. En este caso, mantenemos VARCHAR(255) UNIQUE.

Verificar el cambio:

DESCRIBE alumnos;

Ejemplo 4: Eliminar una Columna (`comentarios`)

ALTER TABLE alumnos DROP COLUMN comentarios;

Explicación: Eliminamos completamente la columna comentarios de la tabla alumnos. ¡Cuidado! Esta acción es irreversible y los datos en esa columna se perderán.

Verificar el cambio:

DESCRIBE alumnos;

9. Actualizando y Eliminando Datos

Comando UPDATE: Para modificar datos existentes. ¡MUCHO CUIDADO CON ESTE COMANDO!

Sintaxis básica:

SQL

UPDATE <nombre_tabla> SET columna1 = nuevo_valor1, columna2 = nuevo_valor2 WHERE condicion;

Ejemplos prácticos:
- Cambiar la edad de un alumno específico:
```
SQL
```
```
UPDATE alumnos SET edad = 21 WHERE nombre = 'Juan';
```
  - Explicar: ¡El WHERE es CRUCIAL! Si olvidan el WHERE, actualizarán todas las filas de la tabla.
- Verificar el cambio:
```
SQL
```
```
SELECT * FROM alumnos WHERE nombre = 'Juan';
```
Comando DELETE FROM: Para eliminar filas. ¡MUCHO CUIDADO CON ESTE COMANDO TAMBIÉN!

Sintaxis básica:

SQL

DELETE FROM <nombre_tabla> WHERE condicion;

Ejemplos prácticos:
- Eliminar un alumno específico:
```
SQL
```
```
DELETE FROM alumnos WHERE nombre = 'Carlos';
```
  - Explicar: De nuevo, ¡el WHERE es VITAL! Sin él, se eliminan todas las filas.
- Verificar la eliminación:
```
SQL
```
```
SELECT * FROM alumnos;
```

10. Deteniendo y Limpiando el Entorno Docker

Detener los servicios:
```
Bash
```
```
docker-compose down
```
- Esto detiene y elimina los contenedores, redes y volúmenes por defecto.
Si quieren detener pero no eliminar los datos (solo el contenedor):
```
Bash
```
```
docker-compose stop
```
- Luego, para reiniciarlos: docker-compose start.
Limpiar completamente (elimina datos si no usaron volúmenes persistentes correctamente):
```
Bash
```
```
docker-compose down -v
```
- -v: También elimina los volúmenes nombrados, lo que borrará los datos de la base de datos. Usar con precaución.

Recomendaciones Adicionales para el Módulo:

Paso a paso y repetición: Hagan cada comando juntos, esperando que todos lo ejecuten y vean el resultado.
Preguntas abiertas: Fomenten las preguntas constantemente. Es normal que surjan dudas al principio.
Ejercicios rápidos: Después de cada sección (CREATE, INSERT, SELECT), propongan un mini-ejercicio para que los participantes lo hagan por sí mismos.
- Ej. “Crea una tabla productos con id, nombre y precio.”
- Ej. “Inserta 3 productos.”
- Ej. “Selecciona los productos con precio mayor a 10.”
Errores comunes: Anticipen y expliquen los errores comunes (olvidar el ;, el WHERE, errores de sintaxis). Demuéstrenlos y cómo corregirlos.
Metáforas y analogías: Sigan usando analogías para conceptos abstractos.
Recursos Adicionales:
- Tutoriales online

MySQL - Capitulo 1

Síguenos con el tutorial

📚 Curso de Capacitación de MySQL

🤝 Módulo 1: Introducción a MySQL con Docker

1. ¿Qué es una Base de Datos?

2. Preparando el Entorno con Docker

3. Levantando MySQL con Docker Compose

4. Conectándose al CLI de MySQL

5. Primeras Interacciones: Creando una Tabla Sencilla

6. Insertando Datos

7. Consultando Datos

8. Actualizando la Estructura de Tablas (ALTER TABLE)

Sintaxis Básica

Ejemplos Prácticos con la Tabla alumnos

Ejemplo 1: Añadir una Nueva Columna (genero)

Ejemplo 2: Modificar el Tipo de Dato de una Columna (telefono a VARCHAR(30) y añadir NOT NULL)

Ejemplo 3: Renombrar una Columna (correo_electronico a email)

Ejemplo 4: Eliminar una Columna (comentarios)

9. Actualizando y Eliminando Datos

10. Deteniendo y Limpiando el Entorno Docker

Recomendaciones Adicionales para el Módulo:

8. Actualizando la Estructura de Tablas (`ALTER TABLE`)

Ejemplos Prácticos con la Tabla `alumnos`

Ejemplo 1: Añadir una Nueva Columna (`genero`)

Ejemplo 2: Modificar el Tipo de Dato de una Columna (`telefono` a `VARCHAR(30)` y añadir `NOT NULL`)

Ejemplo 3: Renombrar una Columna (`correo_electronico` a `email`)

Ejemplo 4: Eliminar una Columna (`comentarios`)