Comandos SQL: lista de sentencias SQL básicas con ejemplos

Los comandos SQL de un vistazo

Los comandos SQL se dividen en unos pocos grupos según lo que hacen. La tabla recoge los que más vas a usar, y cada sección de abajo ejecuta uno de ellos.

DDL es el lenguaje de definición de datos, DML el de manipulación de datos, DQL el de consulta de datos y TCL el de control de transacciones. Los nombres importan menos que la división: DDL cambia la forma de la base de datos y DML cambia lo que hay dentro.

CREATE TABLE: definir una tabla

CREATE TABLE da nombre a la tabla y enumera sus columnas con sus tipos y reglas. Todos los demás comandos de esta página necesitan una tabla con la que trabajar.

CREATE TABLE students (
    id INTEGER PRIMARY KEY,
    name TEXT NOT NULL,
    grade INTEGER
);

SELECT name, sql FROM sqlite_master WHERE type = 'table';

La página de CREATE TABLE explica reglas como NOT NULL, UNIQUE y DEFAULT.

INSERT: añadir filas

INSERT INTO añade una fila o varias. Enumera las columnas y luego los valores en el mismo orden.

CREATE TABLE students (id INTEGER PRIMARY KEY, name TEXT NOT NULL, grade INTEGER);

INSERT INTO students (name, grade) VALUES ('Ada', 91);
INSERT INTO students (name, grade) VALUES
    ('Boris', 78),
    ('Rosa', 85);

SELECT * FROM students;

La columna id se rellenó sola: un INTEGER PRIMARY KEY recibe el siguiente número cuando lo omites. Más sobre esto en INSERT.

SELECT: leer filas

SELECT es el comando que más vas a escribir. Elige las columnas, filtra las filas con WHERE y ordénalas con ORDER BY.

CREATE TABLE students (id INTEGER PRIMARY KEY, name TEXT NOT NULL, grade INTEGER);
INSERT INTO students (name, grade) VALUES ('Ada', 91), ('Boris', 78), ('Rosa', 85), ('Chen', 62);

SELECT name, grade
FROM students
WHERE grade >= 80
ORDER BY grade DESC;

Solo vuelven las filas que pasan la prueba del WHERE, con la nota más alta primero. Consulta fundamentos de SELECT y WHERE para los detalles.

UPDATE: cambiar filas

UPDATE pone valores nuevos en filas que ya existen. La cláusula WHERE decide qué filas; si la omites, cambian todas.

CREATE TABLE students (id INTEGER PRIMARY KEY, name TEXT NOT NULL, grade INTEGER);
INSERT INTO students (name, grade) VALUES ('Ada', 91), ('Boris', 78), ('Rosa', 85);

UPDATE students
SET grade = 82
WHERE name = 'Boris';

SELECT * FROM students;

Si no tienes claro qué filas coinciden con un WHERE, ejecútalo antes como un SELECT. La página de UPDATE muestra más patrones.

DELETE: eliminar filas

DELETE FROM elimina las filas que coinciden con su cláusula WHERE. Igual que UPDATE, afecta a todas las filas si falta la cláusula.

CREATE TABLE students (id INTEGER PRIMARY KEY, name TEXT NOT NULL, grade INTEGER);
INSERT INTO students (name, grade) VALUES ('Ada', 91), ('Boris', 78), ('Rosa', 85), ('Chen', 62);

DELETE FROM students
WHERE grade < 70;

SELECT * FROM students;

La fila de Chen ha desaparecido y las demás siguen intactas. Consulta DELETE.

ALTER TABLE y DROP TABLE: cambiar o eliminar una tabla

ALTER TABLE cambia una tabla existente sin perder sus filas. DROP TABLE elimina la tabla por completo.

CREATE TABLE students (id INTEGER PRIMARY KEY, name TEXT NOT NULL);
INSERT INTO students (name) VALUES ('Ada'), ('Boris');

ALTER TABLE students ADD COLUMN email TEXT;
UPDATE students SET email = lower(name) || '@school.test';
SELECT * FROM students;

CREATE TABLE old_notes (id INTEGER PRIMARY KEY, body TEXT);
DROP TABLE old_notes;
SELECT name FROM sqlite_master WHERE type = 'table';

Una columna nueva empieza como NULL en las filas existentes hasta que la rellenas. ALTER y DROP TABLE enumera lo que SQLite permite.

JOIN: combinar tablas

Un JOIN lee filas de dos tablas a la vez, emparejadas por una columna que comparten.

CREATE TABLE students (id INTEGER PRIMARY KEY, name TEXT NOT NULL);
CREATE TABLE enrollments (student_id INTEGER, course TEXT);

INSERT INTO students (name) VALUES ('Ada'), ('Boris'), ('Rosa');
INSERT INTO enrollments VALUES (1, 'Math'), (1, 'Physics'), (3, 'Art');

SELECT students.name, enrollments.course
FROM students
INNER JOIN enrollments ON enrollments.student_id = students.id
ORDER BY students.name;

Boris no tiene inscripciones, así que un INNER JOIN lo deja fuera. Un LEFT JOIN lo mantendría, con el curso vacío.

GROUP BY: resumir filas

GROUP BY junta en una sola fila las filas que comparten un valor, y una función de agregación como COUNT o AVG resume cada grupo.

CREATE TABLE enrollments (student TEXT, course TEXT, score INTEGER);
INSERT INTO enrollments VALUES
    ('Ada', 'Math', 91), ('Boris', 'Math', 78),
    ('Ada', 'Art', 88), ('Rosa', 'Art', 95), ('Chen', 'Art', 70);

SELECT course, COUNT(*) AS students, AVG(score) AS average
FROM enrollments
GROUP BY course
ORDER BY course;

Funciones de agregación y GROUP BY y HAVING van más allá.

BEGIN, COMMIT y ROLLBACK: agrupar cambios

Una transacción hace que varios cambios cuenten como uno solo. COMMIT los conserva todos; ROLLBACK los deshace todos.

CREATE TABLE accounts (name TEXT, balance INTEGER);
INSERT INTO accounts VALUES ('Ada', 100), ('Boris', 50);

BEGIN;
UPDATE accounts SET balance = balance - 30 WHERE name = 'Ada';
UPDATE accounts SET balance = balance + 30 WHERE name = 'Boris';
COMMIT;

BEGIN;
UPDATE accounts SET balance = 0;
ROLLBACK;

SELECT * FROM accounts;

La transferencia se confirmó y el segundo cambio se deshizo, así que Ada termina con 70 y Boris con 80. Transacciones explica cuándo usarlas.

En qué se diferencia SQLite

Los comandos de esta página son SQL estándar, y lo que aprendes aquí te sirve en MySQL y PostgreSQL. Los ejemplos ejecutables están escritos para SQLite, eso sí, y en las bases de datos más grandes cambian tres detalles:

• Listar tablas. Los ejemplos leen sqlite_master, la tabla de esquema propia de SQLite. MySQL usa SHOW TABLES y PostgreSQL usa la vista information_schema.tables (o \dt en psql).
• Ids automáticos. En SQLite, una columna declarada INTEGER PRIMARY KEY numera sola las filas nuevas; por eso los ejemplos de INSERT omiten id. MySQL necesita AUTO_INCREMENT en la columna, y PostgreSQL una columna de identidad (GENERATED BY DEFAULT AS IDENTITY) o SERIAL.
• Permisos y cambios de esquema. SQLite no tiene GRANT ni REVOKE, porque una base de datos SQLite es un único archivo sin cuentas de usuario, y su ALTER TABLE no puede cambiar el tipo de una columna.