Guida SQLite interattiva: Elenco comandi SQL

Q: Quali sono i comandi SQL di base?

Cinque coprono quasi tutto il lavoro quotidiano: CREATE TABLE per definire una tabella, INSERT per aggiungere righe, SELECT per leggerle, UPDATE per modificarle e DELETE per eliminarle. Subito dopo vengono ALTER TABLE, DROP TABLE, JOIN, GROUP BY e i comandi di transazione BEGIN, COMMIT e ROLLBACK.

Q: I comandi SQL distinguono tra maiuscole e minuscole?

No. SELECT, select e Select funzionano tutti. Scrivere le parole chiave in maiuscolo è una convenzione che le fa risaltare rispetto ai nomi di tabelle e colonne. Il testo tra apici, però, viene confrontato esattamente, quindi 'Ada' e 'ada' sono stringhe diverse in SQLite, a meno che tu non chieda un confronto che ignori le maiuscole.

I comandi SQL in sintesi

I comandi SQL si dividono in alcuni gruppi in base a cosa fanno. La tabella elenca quelli che userai di più, e ogni sezione qui sotto ne esegue uno.

Comando	Gruppo	Cosa fa
`CREATE TABLE`	DDL	Definisce una nuova tabella e le sue colonne
`ALTER TABLE`	DDL	Aggiunge o rinomina una colonna, oppure rinomina una tabella
`DROP TABLE`	DDL	Elimina una tabella e tutte le sue righe
`INSERT`	DML	Aggiunge nuove righe
`UPDATE`	DML	Modifica i valori nelle righe esistenti
`DELETE`	DML	Rimuove righe
`SELECT`	DQL	Legge righe, filtrate con `WHERE` e ordinate con `ORDER BY`
`BEGIN`, `COMMIT`, `ROLLBACK`	TCL	Raggruppa le modifiche perché riescano o falliscano tutte insieme

DDL sta per data definition language, DML per data manipulation language, DQL per data query language e TCL per transaction control language. I nomi contano meno della divisione: il DDL cambia la forma del database, il DML cambia ciò che contiene.

CREATE TABLE: definire una tabella

CREATE TABLE dà un nome alla tabella ed elenca le sue colonne con i loro tipi e le loro regole. Ogni altro comando di questa pagina ha bisogno di una tabella su cui lavorare.

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

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

La pagina su CREATE TABLE tratta regole come NOT NULL, UNIQUE e DEFAULT.

INSERT: aggiungere righe

INSERT INTO aggiunge una o più righe. Elenca le colonne, poi i valori nello stesso ordine.

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 colonna id si è riempita da sola: un INTEGER PRIMARY KEY riceve il numero successivo quando lo ometti. Trovi di più in INSERT.

SELECT: leggere righe

SELECT è il comando che scriverai più spesso. Scegli le colonne, filtra le righe con WHERE e ordinale 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;

Tornano solo le righe che superano il test del WHERE, a partire dal voto più alto. Per i dettagli vedi le basi di SELECT e WHERE.

UPDATE: modificare righe

UPDATE imposta nuovi valori su righe che esistono già. La clausola WHERE decide quali righe; se la ometti, cambiano tutte.

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;

Quando non sei sicuro di cosa selezioni una clausola WHERE, eseguila prima come SELECT. La pagina su UPDATE mostra altri schemi.

DELETE: rimuovere righe

DELETE FROM rimuove le righe che soddisfano la sua clausola WHERE. Come UPDATE, se la clausola manca agisce su tutte le righe.

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 riga di Chen è sparita e le altre sono intatte. Vedi DELETE.

ALTER TABLE e DROP TABLE: modificare o rimuovere una tabella

ALTER TABLE modifica una tabella esistente senza perderne le righe. DROP TABLE rimuove completamente la tabella.

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 nuova colonna parte da NULL nelle righe esistenti finché non la riempi. ALTER e DROP TABLE elenca cosa permette SQLite.

JOIN: combinare tabelle

Un JOIN legge righe da due tabelle contemporaneamente, abbinate su una colonna che hanno in comune.

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 non ha iscrizioni, quindi un INNER JOIN lo lascia fuori. Un LEFT JOIN lo terrebbe, con il corso vuoto.

GROUP BY: riassumere righe

GROUP BY riduce a una sola riga le righe che condividono un valore, e una funzione di aggregazione come COUNT o AVG riassume ogni gruppo.

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;

Funzioni di aggregazione e GROUP BY e HAVING vanno più a fondo.

BEGIN, COMMIT e ROLLBACK: raggruppare modifiche

Una transazione fa valere più modifiche come una sola. COMMIT le tiene tutte; ROLLBACK le annulla tutte.

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;

Il trasferimento è stato confermato e la seconda modifica è stata annullata, quindi Ada finisce con 70 e Boris con 80. Transazioni spiega quando usarle.

Dove SQLite è diverso

I comandi di questa pagina sono SQL standard, e quello che impari qui vale anche per MySQL e PostgreSQL. Gli esempi eseguibili, però, sono scritti per SQLite, e sui database più grandi cambiano tre dettagli:

Elencare le tabelle. Gli esempi leggono sqlite_master, la tabella di schema di SQLite. MySQL usa SHOW TABLES e PostgreSQL usa la vista information_schema.tables (o \dt in psql).
Id automatici. Una colonna dichiarata INTEGER PRIMARY KEY numera da sola le nuove righe in SQLite, ed è per questo che gli esempi con INSERT omettono id. MySQL richiede AUTO_INCREMENT sulla colonna, e PostgreSQL una colonna identity (GENERATED BY DEFAULT AS IDENTITY) o SERIAL.
Permessi e modifiche allo schema. SQLite non ha GRANT né REVOKE, perché un database SQLite è un unico file senza account utente, e il suo ALTER TABLE non può cambiare il tipo di una colonna.

Domande frequenti

Quali sono i comandi SQL di base?

Cinque coprono quasi tutto il lavoro quotidiano: CREATE TABLE per definire una tabella, INSERT per aggiungere righe, SELECT per leggerle, UPDATE per modificarle e DELETE per eliminarle. Subito dopo vengono ALTER TABLE, DROP TABLE, JOIN, GROUP BY e i comandi di transazione BEGIN, COMMIT e ROLLBACK.

Che differenza c'è tra DDL e DML?

Il DDL (data definition language, linguaggio di definizione dei dati) cambia la struttura del database: CREATE, ALTER e DROP. Il DML (data manipulation language, linguaggio di manipolazione dei dati) cambia le righe dentro le tabelle: INSERT, UPDATE e DELETE. SELECT si limita a leggere, quindi spesso viene elencato a parte come DQL.

I comandi SQL distinguono tra maiuscole e minuscole?

No. SELECT, select e Select funzionano tutti. Scrivere le parole chiave in maiuscolo è una convenzione che le fa risaltare rispetto ai nomi di tabelle e colonne. Il testo tra apici, però, viene confrontato esattamente, quindi 'Ada' e 'ada' sono stringhe diverse in SQLite, a meno che tu non chieda un confronto che ignori le maiuscole.

Questi comandi funzionano allo stesso modo in MySQL e PostgreSQL?

Le istruzioni sono SQL standard e hanno lo stesso significato in tutti e tre, quindi quello che impari qui ti serve anche altrove. Gli esempi eseguibili, però, sono scritti per SQLite: per elencare le tabelle qui si legge sqlite_master, gli id automatici richiedono AUTO_INCREMENT in MySQL o una colonna identity in PostgreSQL, e SQLite non ha GRANT né REVOKE.

Concetti correlati