Apuntes mysql

“SET PASSWORD has no significance for user 'root'@'localhost'”

Fundamentos de SQL - Una guía con ejemplos usando Sakila

1. Introducción

SQL (Structured Query Language) es el lenguaje que usamos para comunicarnos con bases de datos relacionales. No es un lenguaje de programación en sentido estricto, pero sí nos permite decirle a la base de datos qué datos queremos ver, modificar o eliminar, y cómo queremos organizarlos.

Nota: Las muestras de código de este tema están planteadas para consultas sobre sakila, una base de datos de ejemplo ofrecida por la propia mysql, que simula un videoclub ficticio con películas, actores, clientes y alquileres, perfecta para experimentar en un entorno realista.

2. Cómo se lee una sentencia SQL

Una consulta SQL se construye como una frase bien ordenada: primero decimos qué queremos (como SELECT o INSERT), luego de dónde y, si hace falta, bajo qué condiciones.

Por ejemplo:

SELECT title, rental_rate FROM film WHERE rental_rate < 1.00;
Se puede leer como: “Muestra el título y el precio de alquiler de las películas cuya tarifa sea menor a 1 dólar”.

Las sentencias suelen terminar en punto y coma (;), especialmente si estás ejecutando varias en bloque.

3. Errores comunes al empezar

  • Olvidar WHERE en un DELETE o UPDATE puede llevarte a borrar toda la tabla.
  • Usar comillas dobles (" ") para textos, cuando deben ir entre comillas simples ('Texto').
  • Elegir nombres problemáticos, como select o order, para columnas o tablas.
  • Confundir el orden de ejecución: aunque escribas SELECT ... WHERE ... ORDER BY, internamente se ejecuta primero el FROM, luego el WHERE, etc.

Son detalles que vale la pena dominar temprano.

4. SELECT - Consultar datos

SELECT es el comando más usado de SQL: con él pedimos a la base datos que nos muestre información. Por ejemplo:

SELECT first_name, last_name FROM customer WHERE active = 1;

Esto recupera los nombres de clientes activos.

Podemos ordenarlo:

SELECT title FROM film ORDER BY rental_rate DESC LIMIT 5;

Esta sentencia lista las 5 películas más caras de alquilar.

Y también hacer cálculos:

SELECT AVG(rental_rate) FROM film;

Aquí obtenemos el precio medio de alquiler entre todas las películas.
El resultado de esta consulta será un conjunto bidimensional de filas y columnas, efectivamente una copia de la tabla, pero solo con las columnas que hayamos solicitado.

Si queremos recuperar absolutamente todas las columnas de datos de una tabla, podemos usar el asterisco (*) como abreviatura en lugar de enumerar todos los nombres de columnas individualmente.

Para limitar el retorno de datos (imagina una columna con miles de datos) SQL usa restricciones (constraints). Asi, para afinar la consulta, tenemos que usar la cláusula WHERE en la consulta. Esta cláusula se aplica a cada fila de datos verificando valores específicos de columnas para determinar si deben incluirse en los resultados o no.

Aqui tienes un ejemplo en pseudoSQL:

`SELECT column, another_column, …
FROM mytable **
WHERE _condition_
AND/OR _another_condition_
AND/OR …;`

Estos son algunos de los operadores que puedes usar.

| Operador             | Descripción                    | Ejemplo
|----------------------|--------------------------------|---------------------|
| `=`                  | Igual a                        | `precio = 100`      |
| `!=` o `<>`          | Distinto de                    | `stock != 0`        |
| `<`                  | Menor que                      | `edad < 18`         |
| `<=`                 | Menor o igual que              | `cantidad <= 10`    |
| `>`                  | Mayor que                      | `salario > 2000`    |
| `>=`                 | Mayor o igual que              | `puntuacion >= 8.5` |
| `BETWEEN x AND y`    | Entre dos valores (inclusive)  | `precio BETWEEN 50  |
|                                                       |  AND  100`          |
| `NOT BETWEEN`        | Fuera del rango de valores     | `edad NOT BETWEEN 18|  |                                                       |  AND 65`            |
| `IN (x,y,z)`         | En la lista de valores         | `id IN (1, 5, 9)`   |
|                      | especificados
| `NOT IN (x,y,z)`     | No está en la lista de valores | `categoria NOT IN   |
                       |especificados                   |  ('A','B')`         |

5. INSERT, UPDATE y DELETE - Modificar datos

INSERT

Permite agregar nuevas filas a una tabla. Por ejemplo:

INSERT INTO actor (first_name, last_name) VALUES ('Ana', 'Rodríguez');

UPDATE

Modifica valores existentes. ¡Nunca sin WHERE!

UPDATE film SET rental_duration = 7 WHERE title = 'ACADEMY DINOSAUR';

DELETE

Elimina registros. Úsalo con precaución:

DELETE FROM actor WHERE first_name = 'Ana' AND last_name = 'Rodríguez';

6. JOIN - Relacionar tablas

Un JOIN sirve para combinar datos de varias tablas que están relacionadas. En Sakila, por ejemplo, la tabla film no tiene directamente actores, sino que se conecta con actor mediante una tabla intermedia: film_actor.

Si queremos saber qué actores aparecen en una película concreta, podríamos hacer:

SELECT f.title, a.first_name, a.last_name
FROM film f
JOIN film_actor fa ON f.film_id = fa.film_id
JOIN actor a ON fa.actor_id = a.actor_id
WHERE f.title = 'ACADEMY DINOSAUR';

Este JOIN múltiple nos lleva desde la tabla film → film_actor → actor, enlazando por las claves correspondientes. El resultado: todos los actores de esa película.

También puedes usar LEFT JOIN para ver todos los elementos de una tabla aunque no tengan correspondencia en la otra (útil para detectar huérfanos o valores faltantes).

7. Un vistazo a funciones agregadas y agrupaciones

SQL también permite resumir información con funciones como:

  • COUNT(*): cuenta registros
  • SUM(column): suma valores numéricos
  • AVG(column): calcula el promedio
  • MIN, MAX: mínimo y máximo

Por ejemplo, para saber cuántas películas hay por categoría:

SELECT c.name, COUNT(*) AS total
FROM film_category fc
JOIN category c ON fc.category_id = c.category_id
GROUP BY c.name
ORDER BY total DESC;

Aquí agrupamos las películas por categoría y contamos cuántas hay de cada tipo, de mayor a menor.

8. GROUP BY y HAVING - Agrupar y filtrar grupos

Cuando agrupamos datos con GROUP BY, a veces queremos filtrar esos grupos según alguna condición, y para eso usamos HAVING.

Por ejemplo, si queremos saber qué categorías tienen más de 50 películas:

SELECT c.name, COUNT(*) AS total
FROM film_category fc
JOIN category c ON fc.category_id = c.category_id
GROUP BY c.name
HAVING total > 50
ORDER BY total DESC;

HAVING funciona como un WHERE, pero se aplica después de agrupar.

9. Subconsultas - Consultas dentro de consultas

Las subconsultas permiten usar el resultado de una consulta como filtro o valor en otra.

Por ejemplo, para listar los actores que participaron en la película más cara de alquilar:

SELECT a.first_name, a.last_name
FROM actor a
JOIN film_actor fa ON a.actor_id = fa.actor_id
JOIN film f ON fa.film_id = f.film_id
WHERE f.rental_rate = (
  SELECT MAX(rental_rate) FROM film
);

Aquí la subconsulta SELECT MAX(rental_rate) FROM film devuelve el valor máximo de tarifa, y luego lo usamos para filtrar la película.

10. Claves primarias y foráneas - Relacionando tablas

Las bases de datos relacionales usan claves para mantener la integridad de los datos.

  • Clave primaria (Primary Key): identifica de forma única cada fila en una tabla. Por ejemplo, film.film_id es clave primaria.
  • Clave foránea (Foreign Key): es un campo que apunta a la clave primaria de otra tabla, estableciendo una relación. Por ejemplo, film_actor.film_id es clave foránea que referencia a film.film_id.

Esto permite que, por ejemplo, un actor pueda estar asociado a muchas películas, y una película a muchos actores, a través de la tabla intermedia film_actor.

TOP