Esta página necesita un navegador reciente (con soporte para SharedArrayBuffer). Por favor, actualiza Chrome, Edge, Firefox o Safari a la última versión.
1Bases de la consulta
1.1
SELECT y FROM
Una base de datos almacena datos en tablas. Una consulta lee 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;
Una tabla almacena registros: cada fila es un registro, cada columna es un campo
Cada fila es un registro. Las palabras clave SQL se escriben en MAYÚSCULAS por convención.
Una sentencia termina con punto y coma ;.
1.2
Elegir columnas
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.
1.3
Filtrado con WHERE
WHERE conserva solo las filas que coinciden con una condición. Compare con =, <> (diferente 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;
Lea las partes en este orden lógico: FROM → WHERE → SELECT. (La base de datos puede ejecutar el trabajo de forma diferente, pero el resultado es el mismo.)
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.
2Filtrado y lógica
2.1
AND, OR, NOT
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;
AND necesita que todos sean verdaderos; OR necesita al menos uno; NOT invierte uno
2.2
LIKE, IN y BETWEEN
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
Patrón
Coincide con
'M%'
comienza con M
'%a'
termina con a
'%an%'
contiene "an"
'M_i'
M, seguido exactamente de un carácter, luego i
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;
2.3
NULL
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.
3Ordenación y limitación
3.1
ORDER BY y LIMIT
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.
ORDER BY ordena; LIMIT conserva las primeras n tras el ordenamiento
4Funciones agregadas y agrupación
4.1
Funciones de agregación
Una función agregada convierte muchas filas en un único valor resumen. Envuelve un promedio con ROUND(x, 2) para redondearlo.
Función
Da
COUNT(*)
cuántas filas hay
SUM(col)
la suma total
AVG(col)
la media aritmética
MIN(col) / MAX(col)
el valor más pequeño / más grande
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;
4.2
GROUP BY y HAVING
GROUP BY genera una fila de resumen por cada grupo. HAVING filtra esos grupos; es similar a 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;
GROUP BY recopila las filas en un único contenedor por cada valor; cada contenedor se convierte en una fila resumen
Escribe las cláusulas SQL en su orden sintáctico requerido. La tabla siguiente es un modelo lógico para razonar sobre una consulta; el motor puede optimizar su orden de ejecución físico:
Paso
Cláusula
1
FROM (y cualquier JOIN)
2
WHERE — filtrar filas
3
GROUP BY — formar grupos
4
HAVING — filtrar grupos
5
SELECT — calcular las columnas de salida
6
ORDER BY, luego LIMIT
Errores comunes
Para resultados agrupados predecibles, agrupa cada columna seleccionada no agregada (o usa una dependencia funcional conocida respaldada por la base de datos). SQLite permite una columna desnuda fuera de GROUP BY, pero puede provenir de una fila arbitraria del grupo; una consulta exitosa no garantiza el valor que tenías previsto.
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.
5Uniones (Joins)
5.1
Claves y relaciones
Una clave primaria nombra de forma única cada fila en una tabla. Una clave foránea en una tabla apunta a la clave primaria de otra: esto establece una relación entre ellas.
CREATE TABLE class (id INTEGER PRIMARY KEY, name TEXT);
CREATE TABLE student (id INTEGER PRIMARY KEY, name TEXT, class_id INTEGER REFERENCES class(id));
INSERT INTO class VALUES (1, 'Maths'), (2, 'Art');
INSERT INTO student VALUES (1, 'Mei', 1), (2, 'Sam', 2);
SELECT * FROM student;
5.2
INNER JOIN
Un JOIN combina filas de dos tablas. INNER JOIN ... ON ... conserva las filas donde las claves coinciden. Un alias corto (s, c) mantiene la consulta legible.
CREATE TABLE class (id INTEGER PRIMARY KEY, name TEXT);
CREATE TABLE student (id INTEGER PRIMARY KEY, name TEXT, class_id INTEGER REFERENCES class(id));
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;
El INNER JOIN empareja cada clave foránea con una clave primaria y combina las filas coincidentes.
5.3
Join con agrupación
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 PRIMARY KEY, name TEXT);
CREATE TABLE student (id INTEGER PRIMARY KEY, name TEXT, class_id INTEGER REFERENCES class(id));
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.id, c.name;
Agrupar por la clave c.id además del nombre: dos clases que comparten accidentalmente un nombre se fusionarían en una sola fila sin esto.
5.4
LEFT JOIN
Un INNER JOIN conserva solo las filas coincidentes. Un LEFT JOIN conserva todas las filas de la tabla izquierda (primera); donde no hay coincidencia, las columnas de la tabla derecha retornan como NULL.
CREATE TABLE class (id INTEGER PRIMARY KEY, name TEXT);
CREATE TABLE student (id INTEGER PRIMARY KEY, name TEXT, class_id INTEGER REFERENCES class(id));
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.
6Modificación de datos
6.1
INSERT
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.
INSERT agrega una nueva fila a una tabla
6.2
UPDATE
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;
6.3
DELETE
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 DELETEsin 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.
7Definición de tablas
7.1
CREATE TABLE & tipos de datos
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 de punto flotante: rápido, pero no siempre exacto, por lo que 0.1 + 0.2 = 0.3 es falso).
CREATE TABLE student (id INTEGER, name TEXT, score REAL);
INSERT INTO student VALUES (1, 'Mei', 88.5);
SELECT * FROM student;
CREATE TABLE nombra columnas y sus tipos
7.2
Claves y restricciones
Una restricción es una regla aplicada a una columna: PRIMARY KEY (un identificador único), NOT NULL (debe tener un valor), UNIQUE y DEFAULT (un valor predeterminado).
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;
Declara una clave foránea con REFERENCES. En SQLite, habilita la aplicación para cada conexión con PRAGMA foreign_keys = ON; antes de iniciar una transacción. Una declaración sola no garantiza la aplicación.
PRAGMA foreign_keys = ON;
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.
7.3
ALTER TABLE
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
Declara un tipo adecuado para cada columna. SQLite permite omitir nombres de tipo y utiliza tipificación flexible por defecto; una declaración de tipo sola no valida todos los valores almacenados.
Diseña una clave primaria para que sea única y no nula. En tablas ordinarias de SQLite, algunas declaraciones de clave primaria aún permiten NULL; usa NOT NULL explícitamente para una clave de texto. INTEGER PRIMARY KEY tiene comportamiento especial de ID de fila: insertar NULL asigna un ID entero.
Con la aplicación de claves foráneas habilitada, un valor de clave foránea no nulo debe coincidir con una clave referenciada. Se permite NULL a menos que la columna también tenga NOT NULL.
8Diseño de bases de datos
8.1
Relaciones y diagramas ER
Las tablas se conectan mediante relaciones. La relación uno a muchos es la más común: una clase tiene muchos estudiantes. La relación muchos a muchos requiere una tabla intermedia. Un diagrama entidad-relación (diagrama ER) dibuja cada entidad como un cuadro y cada relación como una línea.
Relación
Ejemplo
uno a uno
una persona y su pasaporte
uno a muchos
una clase y sus estudiantes
muchos a muchos
estudiantes y clubes
El lado "muchos" lleva la clave foránea; un enlace muchos a muchos necesita una tabla intermedia
La tabla intermedia contiene una fila por enlace, y cada una de sus columnas es una clave foránea. Su clave primaria es el par(student_id, club_id), una clave compuesta, para que el mismo estudiante no pueda unirse al mismo club dos veces. Ambas columnas son NOT NULL, por lo que cada membresía nombra un estudiante y un club. 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 NOT NULL REFERENCES student(id),
club_id INTEGER NOT NULL REFERENCES club(id),
PRIMARY KEY (student_id, club_id)
);
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;
8.2
Normalización
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 valor atómico —no hay listas dentro de una celda.
2FN: ninguna columna depende solo de parte de una clave compuesta.
3FN: ninguna columna depende de otra columna que no sea clave.
Sin normalizar (malo)
Normalizado (mejor)
student(name, club1, club2)
student(name) + membership(student, club)
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.