Bases de datos y SQL

Una base de datos es un lugar donde se guardan datos ordenados para encontrarlos rápido, aunque sean miles. La lista de tu grupo es una base de datos chiquita: un renglón por alumno, con su nombre y su grupo. La tienda de la esquina tiene una con sus productos, su precio y cuántos quedan. El banco tiene una con cada cuenta y cada depósito. Y este sitio también: guarda alumnos, partidas y calificaciones en un archivo que se llama SQLite. Cada vez que juegas en la sala, se escribe un renglón nuevo ahí.

Los datos viven en tablas. Una tabla tiene filas y columnas, como una hoja de cálculo. Cada fila es una cosa (un alumno) y se llama registro. Cada columna es un dato de esa cosa (su nombre) y se llama campo. Así se ve la tabla alumno de este sitio:

Cuatro filas: cuatro alumnos. Tres columnas: tres datos de cada uno. La fila 3 se lee así: «el alumno número 3 se llama Caro y está en 1B».

Cada columna guarda un tipo de dato, y solo ese. Se decide al crear la tabla:

Fíjate: el teléfono es texto, aunque tenga puros dígitos. No lo vas a sumar ni a restar, y puede empezar con 0. Regla fácil: si no vas a hacer cuentas con él, es texto.

La columna id es la llave primaria: un número que identifica a cada fila. Tiene tres promesas: es única (no hay dos filas con el mismo id), no se repite aunque borres una fila (el 3 no se vuelve a usar) y no cambia. Si Caro se cambia a 1A, cambia su grupo; su id sigue siendo 3. Por eso todo lo demás del sitio (sus partidas, sus calificaciones) apunta a su id y no a su nombre: puede haber dos Caros en la escuela, pero no dos id 3.

Antes de llenar una tabla hay que pensarla. La pregunta es siempre la misma: «¿qué necesito saber de cada cosa?». Para la tienda de la escuela: de cada producto quiero su nombre, su precio y cuántos quedan. Eso son tres columnas, más el id. Lo que no vas a usar no lo guardes; lo que vas a usar, no lo olvides, porque agregar una columna después de tener 500 filas es un dolor.

Hay tres reglas que separan una tabla buena de una que da problemas:

1. Un dato por celda. Una celda con «Ana, Beto» no sirve: no puedes buscar a Beto ni contar cuántos hay. Si una cosa tiene varios datos iguales (un equipo tiene varios alumnos), eso son varias filas, no una celda larga.
2. No repitas información. Si en cada alumno escribes «1A, maestro Israel, salón 12», ese dato se repite 30 veces y el día que cambie el salón tienes que corregir 30 filas (y se te va a escapar una). El alumno lleva solo su grupo: 1A. Lo demás del grupo va una sola vez, en una tabla grupo.
3. Nombres de columna limpios: en minúsculas, sin espacios, sin acentos ni ñ, y si tienen dos palabras se unen con guion bajo: fecha_nacimiento, no «Fecha de Nacimiento». Las computadoras se pelean con los espacios y los acentos; tú no quieres pelear con ellas.

Compara. Esta tabla está mal pensada:

Y esta es la misma información, bien pensada (el salón y el maestro viven en la tabla grupo):

Cuando ya sabes las columnas y sus tipos, la tabla se crea con una orden de SQL. SQL es el lenguaje con el que se habla con la base de datos, y esta es su primera palabra:

CREATE TABLE producto (
  id INTEGER PRIMARY KEY,
  nombre TEXT,
  precio REAL,
  cantidad INTEGER
);

Se lee: «crea la tabla producto con estas columnas». PRIMARY KEY marca al id como llave primaria, y SQLite le va poniendo 1, 2, 3… solito. Cada columna lleva su tipo. Las órdenes de SQL terminan con punto y coma.

La orden más usada de SQL es SELECT: «dame datos». Se dice qué columnas quieres y de qué tabla. Para toda esta lección usamos la tabla partida:

SELECT juego, puntos FROM partida;

Se lee «selecciona juego y puntos de partida». La base contesta con una tabla nueva que solo tiene esas dos columnas, con las 5 filas:

Si quieres todas las columnas, en vez de escribirlas una por una pones un asterisco: SELECT * FROM partida;. El asterisco significa «todo».

Para ordenar el resultado se agrega ORDER BY y la columna. De menor a mayor es lo normal (puedes escribir ASC, que significa ascendente); de mayor a menor se pone DESC:

SELECT juego, puntos FROM partida ORDER BY puntos DESC;

Ahora las filas salen 90, 80, 70, 65, 55. Si solo quieres las primeras, LIMIT recorta: LIMIT 3 deja las tres primeras del resultado ya ordenado. Así se saca «las 3 mejores partidas»:

SELECT juego, puntos FROM partida ORDER BY puntos DESC LIMIT 3;

Para leer el resultado piensa en esto: es una tabla nueva, hecha al momento. La tabla partida sigue exactamente igual, con sus 5 filas y 5 columnas. SELECT solo mira; nunca cambia nada. Por eso puedes probar las consultas que quieras sin miedo.

Casi nunca quieres todas las filas. Quieres «las partidas de recta» o «los alumnos de 1A». Para eso está WHERE: una condición que cada fila tiene que cumplir para salir en el resultado. Seguimos con la tabla partida de la lección anterior.

SELECT juego, puntos FROM partida WHERE puntos >= 70;

La base revisa fila por fila: ¿sus puntos son 70 o más? Si sí, pasa; si no, se queda fuera. Haz tú la misma revisión en una tabla de seguimiento:

Pasan las filas 1, 3 y 4. Los comparadores son los de matemáticas: = igual, <> distinto, < menor, > mayor, <= menor o igual, >= mayor o igual. Ojo con la diferencia entre > 70 (pasan 80 y 90) y >= 70 (pasan 80, 90 y 70).

Cuando comparas con texto, el texto va entre comillas simples: WHERE juego = 'recta'. Sin comillas, la base cree que recta es el nombre de una columna y da error. Los números van sin comillas.

Se pueden juntar condiciones. AND exige las dos; OR se conforma con una; NOT le da la vuelta a una:

WHERE juego = 'recta' AND puntos >= 70     → filas 1 y 4
WHERE juego = 'equis' OR puntos >= 80      → filas 1, 3 y 5
WHERE NOT juego = 'recta'                  → filas 3 y 5

Hay dos ayudas más. LIKE busca texto parecido: el signo % significa «lo que sea», así que nombre LIKE 'A%' da los nombres que empiezan con A. Y BETWEEN es un rango que incluye los dos extremos: puntos BETWEEN 60 AND 80 es lo mismo que puntos >= 60 AND puntos <= 80.

WHERE se combina con lo que ya sabes. El orden de las palabras es fijo: primero filtras, luego ordenas, luego recortas:

SELECT juego, puntos FROM partida
WHERE juego = 'recta'
ORDER BY puntos DESC
LIMIT 2;

Muchas preguntas no piden filas sino un número: ¿cuántas partidas hay? ¿cuántos puntos en total? ¿cuál fue la mejor? Para eso SQL tiene funciones que resumen una columna completa en un solo valor. Seguimos con la tabla partida:

SELECT COUNT(*) FROM partida;              → 5
SELECT SUM(puntos) FROM partida;           → 360
SELECT MAX(puntos) FROM partida WHERE juego = 'recta';   → 80

Fíjate en la última: primero WHERE filtra, luego la función resume. De las partidas de recta (80, 65, 70) el máximo es 80. Así contestas «¿cuántas partidas de equis hay?»: SELECT COUNT(*) FROM partida WHERE juego = 'equis'; da 2.

¿Y si quiero el conteo de cada juego, no de uno? Podrías hacer una consulta por juego, pero GROUP BY lo hace de un jalón: junta las filas que tienen el mismo valor y aplica la función a cada montón:

SELECT juego, COUNT(*) AS partidas
FROM partida
GROUP BY juego;

Sale una fila por juego. AS partidas es un alias: le pone nombre a la columna del resultado, porque «COUNT(*)» es feo de leer y además así puedes usarla para ordenar. Esto es exactamente lo que hace la página de estadísticas del sitio para saber qué juego se juega más:

SELECT juego, COUNT(*) AS partidas
FROM partida
GROUP BY juego
ORDER BY partidas DESC;

Hasta ahora solo hemos mirado los datos. Hay tres órdenes que los cambian. Con estas sí hay que tener cuidado: no hay botón de deshacer.

INSERT mete una fila nueva. Dices la tabla, las columnas y los valores en el mismo orden. El id no se pone: SQLite le da el siguiente número solito.

INSERT INTO partida (alumno, juego, puntos, dia)
VALUES (2, 'equis', 85, '2026-10-08');

Esto es lo que corre el sitio cada vez que terminas un juego. Los textos van entre comillas simples; los números no. Si das 4 columnas tienes que dar 4 valores, y en ese orden.

UPDATE cambia filas que ya existen. Dices la tabla, qué columna poner a qué valor con SET, y a cuáles filas con WHERE:

UPDATE alumno SET grupo = '1A' WHERE id = 3;

Caro (id 3) pasa a 1A. Solo ella, porque el WHERE la señala. Puedes cambiar varias columnas separando con comas: SET grupo = '1A', nombre = 'Carolina'.

DELETE borra filas completas. Tabla y WHERE:

DELETE FROM partida WHERE id = 5;

Ahora lo importante. ¿Qué pasa si escribes DELETE FROM partida; sin WHERE? Que la condición es «todas» y se borran todas las partidas. De todos los alumnos. De todo el año. Lo mismo con UPDATE alumno SET grupo = '1A'; sin WHERE: todos los alumnos de la escuela aparecen en 1A. Por eso la costumbre de los que trabajan con bases de datos es escribir primero el WHERE, o probar la condición con un SELECT antes: SELECT * FROM partida WHERE id = 5; te enseña qué vas a borrar. Si te gusta lo que ves, cambias SELECT * por DELETE.

Y una decisión de diseño de este sitio: nunca borra calificaciones ni partidas. Cuando hay que «limpiar» el periodo, no se usa DELETE: se guarda una fecha de corte y las consultas filtran con WHERE dia >= esa fecha. Una fila borrada no vuelve; una fila marcada se puede volver a mirar. Si algún día un alumno dice «yo sí jugué», el dato sigue ahí.

La tabla partida dice «alumno = 1», no «Ana». ¿Por qué no poner el nombre, que se entiende más? Porque el nombre se repetiría en cada partida (Ana juega 200 veces: 200 Anas), si Ana corrige su nombre habría que cambiarlo 200 veces, y si hay dos Anas no sabrías cuál. El id es único y no cambia; el nombre, no. Así que la partida guarda el id, y el nombre vive una sola vez en la tabla alumno.

Esa columna que apunta al id de otra tabla se llama llave foránea. alumno.id es la llave primaria; partida.alumno es la llave foránea que apunta a ella. Es la flecha del dibujo:

Cuando quieres ver el nombre junto a la partida, le pides a la base que junte las dos tablas por esa flecha. Eso es JOIN: «pega a cada partida la fila del alumno cuyo id coincida».

SELECT alumno.nombre, partida.juego, partida.puntos
FROM partida
JOIN alumno ON alumno.id = partida.alumno;

Se lee: «de partida, junta con alumno donde el id del alumno sea igual al alumno de la partida». Como ahora hay dos tablas, cada columna se escribe con su tabla adelante (alumno.nombre) para que no haya confusión. La base recorre cada partida, busca su alumno y arma una fila con datos de las dos:

Ana aparece dos veces porque tiene dos partidas; su nombre se escribió una sola vez en la tabla alumno y JOIN lo «copió» al momento. Eso es lo bonito: el dato vive en un lugar y se ve donde haga falta. Después del JOIN sigue todo lo demás igual: WHERE, GROUP BY, ORDER BY.

Las consultas que escribiste en la consola las escribe, en la vida real, un programa. En este sitio ese programa es PHP. Son siempre cuatro pasos: abrir la conexión, preparar la consulta, ejecutar con los valores y recorrer el resultado.

$db = new PDO('sqlite:datos/sitio.db');          // 1. abrir

$q = $db->prepare('SELECT nombre, grupo FROM alumno WHERE grupo = ?');   // 2. preparar
$q->execute([$grupo]);                            // 3. ejecutar con el valor
$filas = $q->fetchAll();                          // 4. traer las filas

Lo nuevo es el signo ?. En vez de escribir el grupo dentro del SQL, dejas un hueco, y el valor se pasa aparte en execute, dentro de un arreglo. La base recibe por un lado la orden y por el otro el dato, y nunca los confunde. Eso se llama consulta preparada.

¿Por qué tanto rodeo? Porque el grupo lo escribió alguien en un formulario, y no sabes qué escribió. Imagina que pegas el valor directo:

$sql = "SELECT nombre FROM alumno WHERE nombre = '" . $nombre . "'";   // ¡NO!

Si en el formulario escriben Ana, el SQL queda WHERE nombre = 'Ana'. Bien. Pero si alguien escribe ' OR 1=1, el SQL queda así:

SELECT nombre FROM alumno WHERE nombre = '' OR 1=1

Y como 1=1 siempre es cierto, pasan todas las filas: se lleva la lista completa. Y si escribe '; DELETE FROM alumno; … ya te imaginas. A esto se le llama inyección SQL: meter SQL por donde se esperaba un dato. Es el ataque más viejo y más común de internet, y la consulta preparada lo mata de raíz: con el ?, lo que escriban es un dato y nada más. Si escriben ' OR 1=1, la base busca un alumno que se llame literalmente «' OR 1=1» y no encuentra ninguno.

Lo último es mostrar el resultado. fetchAll devuelve un arreglo con una fila por elemento, y cada fila es un arreglo con las columnas. Con un foreach se pinta una tabla HTML:

<table>
<?php foreach ($filas as $f): ?>
  <tr><td><?= esc($f['nombre']) ?></td><td><?= esc($f['grupo']) ?></td></tr>
<?php endforeach; ?>
</table>

Cada vuelta del foreach es una fila de la base y pinta un <tr>. El esc() es el mismo truco en la otra dirección: lo que viene de la base se muestra como texto, nunca como HTML. Los datos entran por un hueco y salen escapados; así ningún usuario puede meterle código a tu página ni a tu base.