SQL Handout · ⁨Material de SQL⁩

Una base de datos guarda los datos en tablas. Una consulta lee los datos con SELECT. SELECT * devuelve todas las columnas; FROM nombra la tabla.

CREATE TABLE student (id INTEGER, name TEXT, score INTEGER);
INSERT INTO student VALUES (1, 'Mei', 88), (2, 'Sam', 71);
SELECT * FROM student;

• Cada fila es un registro. Las palabras clave de SQL se escriben en MAYÚSCULAS por convención.
• Una sentencia termina con punto y coma ;.

Enumere las columnas que desea, separadas por comas. Use AS para renombrar una columna en el resultado (un alias).

CREATE TABLE student (id INTEGER, name TEXT, score INTEGER);
INSERT INTO student VALUES (1, 'Mei', 88), (2, 'Sam', 71);
SELECT name, score AS mark FROM student;

Una columna seleccionada también puede ser un cálculo; empuje con AS para nombrar la nueva columna:

CREATE TABLE student (id INTEGER, name TEXT, score INTEGER);
INSERT INTO student VALUES (1, 'Mei', 88), (2, 'Sam', 71);
SELECT name, score + 5 AS bonus FROM student;

• SELECT DISTINCT col elimina valores duplicados del resultado.

WHERE conserva solo las filas que coinciden con una condición. Compare con =, <> (distinto de), <, >, <=, >=. Coloque texto entre comillas simples.

CREATE TABLE student (id INTEGER, name TEXT, score INTEGER);
INSERT INTO student VALUES (1, 'Mei', 88), (2, 'Sam', 71), (3, 'Ana', 95);
SELECT name, score FROM student WHERE score >= 80;

• SQL ejecuta las partes en este orden: FROM → WHERE → SELECT.

Errores comunes

• Coloque valores de texto entre comillas simples: WHERE name = 'Ann'; los nombres de columna no llevan comillas.
• SELECT * devuelve todas las columnas; nombre solo las columnas que necesita.
• WHERE filtra filas; viene después de FROM.

Combine condiciones con AND, OR, NOT. AND requiere que todos los lados sean verdaderos; OR requiere que al menos un lado sea verdadero; NOT invierte uno. Utilice paréntesis para establecer la precedencia 优先级.

CREATE TABLE student (id INTEGER, name TEXT, form TEXT, score INTEGER);
INSERT INTO student VALUES (1,'Mei','11A',88),(2,'Sam','11B',71),(3,'Ana','11A',95);
SELECT name FROM student WHERE form = '11A' AND score >= 90;

LIKE coincide con un patrón de texto 模式: % representa cualquier texto y _ un solo carácter — estos son comodines 通配符.

CREATE TABLE student (id INTEGER, name TEXT, form TEXT, score INTEGER);
INSERT INTO student VALUES (1,'Mei','11A',88),(2,'Sam','11B',71),(3,'Ana','11A',95);
SELECT name FROM student WHERE name LIKE 'M%';        -- starts with M

IN coincide con un conjunto 集合 de valores; BETWEEN coincide con un rango 范围 (ambos extremos incluidos).

CREATE TABLE student (id INTEGER, name TEXT, form TEXT, score INTEGER);
INSERT INTO student VALUES (1,'Mei','11A',88),(2,'Sam','11B',71),(3,'Ana','11A',95);
SELECT name, score FROM student
WHERE form IN ('11A', '11C') AND score BETWEEN 80 AND 100;

NULL marca un valor ausente 缺失值 — no se almacenó nada en esa celda. NULL no es 0 ni una cadena vacía. Una comparación con = o <> nunca coincidirá con él; pruébelo con IS NULL o IS NOT NULL.

CREATE TABLE student (id INTEGER, name TEXT, score INTEGER);
INSERT INTO student VALUES (1, 'Mei', 88), (2, 'Sam', NULL), (3, 'Ana', 95);
SELECT name FROM student WHERE score IS NULL;

CREATE TABLE student (id INTEGER, name TEXT, score INTEGER);
INSERT INTO student VALUES (1, 'Mei', 88), (2, 'Sam', NULL), (3, 'Ana', 95);
SELECT name, score FROM student WHERE score IS NOT NULL;

• WHERE score = NULL no devuelve ninguna fila — ni siquiera la fila de Sam.
• Un NULL en una operación aritmética da como resultado NULL: score + 5 permanece NULL para Sam.

Errores comunes

• Para verificar si hay un valor nulo, utilice IS NULL, nunca = NULL.
• En LIKE, % coincide con cualquier texto y _ con un solo carácter: 'A%' significa "comienza con A".
• IN (1, 2, 3) es más corto que múltiples OR; BETWEEN a AND b incluye ambos extremos.

ORDER BY ordena 排序 las filas del resultado. Añade DESC para ordenar de forma descendente 降序 (de mayor a menor); el valor predeterminado es ascendente 升序 (de menor a mayor).

CREATE TABLE student (id INTEGER, name TEXT, score INTEGER);
INSERT INTO student VALUES (1,'Mei',88),(2,'Sam',71),(3,'Ana',95);
SELECT name, score FROM student ORDER BY score DESC;

Ordenar por más de una columna

Enumera varias columnas. Un empate 平局 en la primera columna se resuelve mediante la siguiente.

CREATE TABLE student (id INTEGER, name TEXT, score INTEGER);
INSERT INTO student VALUES (1,'Mei',88),(2,'Sam',88),(3,'Ana',95);
SELECT name, score FROM student ORDER BY score DESC, name ASC;

LIMIT (top-N)

LIMIT n conserva únicamente las primeras n filas — combínalo con ORDER BY para obtener una lista de los N primeros 前 N名.

CREATE TABLE student (id INTEGER, name TEXT, score INTEGER);
INSERT INTO student VALUES (1,'Mei',88),(2,'Sam',71),(3,'Ana',95);
SELECT name, score FROM student ORDER BY score DESC LIMIT 2;

• ORDER BY también puede ordenar según un alias o un cálculo: ORDER BY avg_score DESC.
• El texto se ordena alfabéticamente: ORDER BY name ordena de la A a la Z.

Errores comunes

• ORDER BY ordena de forma ascendente por defecto; añade DESC para ordenar de forma descendente.
• ORDER BY aparece cerca del final, después de WHERE y GROUP BY.
• LIMIT limita cuántas filas se devuelven, pero solo después del ordenamiento.

Una función de agregación 聚合函数 convierte varias filas en un único valor resumen 汇总. Envuelve una media con ROUND(x, 2) para redondearla.

CREATE TABLE student (id INTEGER, name TEXT, form TEXT, score INTEGER);
INSERT INTO student VALUES (1,'Mei','11A',88),(2,'Sam','11B',71),(3,'Ana','11A',95);
SELECT COUNT(*), ROUND(AVG(score), 2), MAX(score) FROM student;

GROUP BY crea una única fila resumen por grupo 组. HAVING filtra esos grupos — es como WHERE, pero se ejecuta después del agrupamiento.

CREATE TABLE student (id INTEGER, name TEXT, form TEXT, score INTEGER);
INSERT INTO student VALUES (1,'Mei','11A',88),(2,'Sam','11B',71),(3,'Ana','11A',95);
SELECT form, COUNT(*) AS n, ROUND(AVG(score), 2) AS avg_score
FROM student
GROUP BY form
HAVING COUNT(*) > 1;

Cualquiera que sea el orden en que los escribas, SQL siempre ejecuta las cláusulas de una consulta en el mismo orden fijo:

Errores comunes

• No puedes seleccionar una columna simple junto a una agregada a menos que esté en GROUP BY.
• Filtra las filas con WHERE (antes del agrupamiento) y los grupos con HAVING (después).
• COUNT(*) cuenta filas; COUNT(col) omite los valores NULL en esa columna.

Una clave primaria (primary key) nombra de forma única cada fila en una tabla. Una clave foránea (foreign key) en una tabla apunta a la clave primaria de otra; esto establece una relación entre ellas.

CREATE TABLE class (id INTEGER, name TEXT);
CREATE TABLE student (id INTEGER, name TEXT, class_id INTEGER);
INSERT INTO class VALUES (1, 'Maths'), (2, 'Art');
INSERT INTO student VALUES (1, 'Mei', 1), (2, 'Sam', 2);
SELECT * FROM student;

Un join combina filas de dos tablas. INNER JOIN ... ON ... conserva solo las filas donde las claves coinciden. Un alias corto (s, c) mantiene la consulta legible.

CREATE TABLE class (id INTEGER, name TEXT);
CREATE TABLE student (id INTEGER, name TEXT, class_id INTEGER);
INSERT INTO class VALUES (1, 'Maths'), (2, 'Art');
INSERT INTO student VALUES (1, 'Mei', 1), (2, 'Sam', 2);
SELECT s.name, c.name AS class
FROM student s INNER JOIN class c ON s.class_id = c.id;

Primero realiza el join y luego usa GROUP BY para resumir los datos a lo largo de las filas unidas.

CREATE TABLE class (id INTEGER, name TEXT);
CREATE TABLE student (id INTEGER, name TEXT, class_id INTEGER);
INSERT INTO class VALUES (1, 'Maths'), (2, 'Art');
INSERT INTO student VALUES (1, 'Mei', 1), (2, 'Sam', 2), (3, 'Ana', 1);
SELECT c.name AS class, COUNT(*) AS n
FROM student s INNER JOIN class c ON s.class_id = c.id
GROUP BY c.name;

Un INNER JOIN conserva únicamente las filas que tienen coincidencia. Un LEFT JOIN conserva todas las filas de la tabla izquierda (la primera); cuando no hay coincidencia, las columnas de la tabla derecha se devuelven como NULL.

CREATE TABLE class (id INTEGER, name TEXT);
CREATE TABLE student (id INTEGER, name TEXT, class_id INTEGER);
INSERT INTO class VALUES (1, 'Maths'), (2, 'Art');
INSERT INTO student VALUES (1, 'Mei', 1), (2, 'Sam', NULL);
SELECT s.name, c.name AS class
FROM student s LEFT JOIN class c ON s.class_id = c.id;

• Sam no tiene clase, pero la fila sigue apareciendo — con class como NULL.
• Para encontrar únicamente las filas sin coincidencia, añade WHERE c.id IS NULL.

Errores comunes

• Un join sin condición ON empareja cada fila con todas las filas (un cruce de tablas o cross join).
• Empareja la clave foránea con la clave primaria: ON orders.customer_id = customers.id.
• Un INNER JOIN elimina las filas que no tienen coincidencia en el otro lado; utiliza un LEFT JOIN para conservalas.

INSERT INTO ... VALUES ... agrega nuevas filas. Nombra las columnas y luego proporciona los valores en el mismo orden. (Cada bloque de abajo termina con un SELECT para que puedas ver el resultado).

CREATE TABLE student (id INTEGER, name TEXT, score INTEGER);
INSERT INTO student (id, name, score) VALUES (1, 'Mei', 88);
INSERT INTO student VALUES (2, 'Sam', 71);
SELECT * FROM student;

• INSERT INTO t VALUES (...), (...); agrega varias filas en una sola instrucción.

UPDATE ... SET ... WHERE ... modifica filas existentes. Siempre agrega WHERE, o se cambiarán todas las filas.

CREATE TABLE student (id INTEGER, name TEXT, score INTEGER);
INSERT INTO student VALUES (1, 'Mei', 88), (2, 'Sam', 71);
UPDATE student SET score = 75 WHERE name = 'Sam';
SELECT * FROM student;

DELETE FROM ... WHERE ... elimina filas. Sin WHERE, vacía toda la tabla.

CREATE TABLE student (id INTEGER, name TEXT, score INTEGER);
INSERT INTO student VALUES (1, 'Mei', 88), (2, 'Sam', 71);
DELETE FROM student WHERE score < 80;
SELECT * FROM student;

Errores comunes

• UPDATE y DELETE sin un WHERE modifican cada fila — siempre agrega el WHERE.
• En INSERT, los valores deben coincidir con la lista de columnas en orden y tipo.
• Prueba primero un DELETE riesgoso como un SELECT con el mismo WHERE.

CREATE TABLE define el esquema de una tabla 表结构: los nombres de las columnas y sus tipos de datos 数据类型. Los principales tipos de SQLite son INTEGER, TEXT y REAL (un número decimal).

CREATE TABLE student (id INTEGER, name TEXT, score REAL);
INSERT INTO student VALUES (1, 'Mei', 88.5);
SELECT * FROM student;

Una restricción 约束 es una regla sobre una columna: PRIMARY KEY (un ID único), NOT NULL (debe tener un valor), UNIQUE y DEFAULT (un valor por defecto).

CREATE TABLE student (
    id INTEGER PRIMARY KEY,
    name TEXT NOT NULL,
    score INTEGER DEFAULT 0
);
INSERT INTO student (id, name) VALUES (1, 'Mei');
SELECT * FROM student;

Declarar una clave foránea con REFERENCES — registra que la columna apunta a la clave primaria de otra tabla:

CREATE TABLE class (id INTEGER PRIMARY KEY, name TEXT);
CREATE TABLE student (
    id INTEGER PRIMARY KEY,
    name TEXT NOT NULL,
    class_id INTEGER REFERENCES class(id)
);
INSERT INTO class VALUES (1, 'Maths');
INSERT INTO student VALUES (1, 'Mei', 1);
SELECT s.name, c.name AS class
FROM student s INNER JOIN class c ON s.class_id = c.id;

• La forma larga es FOREIGN KEY (class_id) REFERENCES class(id) en una línea separada.

ALTER TABLE ... ADD COLUMN ... cambia el esquema de una tabla que ya existe. Un DEFAULT rellena la nueva columna en las filas antiguas.

CREATE TABLE student (id INTEGER, name TEXT);
INSERT INTO student VALUES (1, 'Mei');
ALTER TABLE student ADD COLUMN score INTEGER DEFAULT 0;
SELECT * FROM student;

• ALTER TABLE student RENAME TO pupil; renombra toda la tabla.
• DROP TABLE student; elimina la tabla completamente — estructura y datos.

Errores comunes

• Cada columna necesita un tipo de datos (p. ej., INTEGER, TEXT).
• Una PRIMARY KEY debe ser única y no puede ser NULL.
• El valor de una clave foránea debe existir en la tabla a la que apunta.

Las tablas se conectan a través de relaciones. La relación uno a muchos es la más común: una clase tiene muchos estudiantes. Una relación muchos a muchos requiere una tabla intermedia en el medio. Un diagrama entidad-relación (diagrama ER) representa cada entidad como un recuadro y cada relación como una línea.

La tabla intermedia contiene una fila por cada enlace. Aquí Mei está en dos clubes, y Ajedrez tiene dos miembros:

CREATE TABLE student (id INTEGER PRIMARY KEY, name TEXT);
CREATE TABLE club (id INTEGER PRIMARY KEY, name TEXT);
CREATE TABLE membership (student_id INTEGER, club_id INTEGER);
INSERT INTO student VALUES (1, 'Mei'), (2, 'Sam');
INSERT INTO club VALUES (1, 'Chess'), (2, 'Art');
INSERT INTO membership VALUES (1, 1), (1, 2), (2, 1);
SELECT s.name, c.name AS club
FROM membership m
INNER JOIN student s ON m.student_id = s.id
INNER JOIN club c ON m.club_id = c.id;

La normalización organiza las tablas para evitar la redundancia (los mismos datos repetidos) y los errores de actualización que esta provoca. Las tres primeras formas normales:

• 1FN: cada celda contiene un solo valor atómico — no hay listas dentro de una celda.
• 2FN: ninguna columna depende solo de una parte de una clave compuesta.
• 3FN: ninguna columna depende de otra columna que no sea clave.

Errores comunes

• Dividir los grupos repetitivos en su propia tabla (normalización) en lugar de tener muchas columnas similares.
• Cada tabla debe describir UN solo tipo de cosa.
• Vincular las tablas mediante una clave foránea que apunte a la clave primaria de otra tabla.