Docs SQLite exécutables : Liste des commandes SQL

Q: Quelles sont les commandes SQL de base ?

Cinq commandes couvrent l'essentiel du travail quotidien : CREATE TABLE pour définir une table, INSERT pour ajouter des lignes, SELECT pour les lire, UPDATE pour les modifier et DELETE pour les supprimer. Viennent ensuite ALTER TABLE, DROP TABLE, JOIN, GROUP BY et les commandes de transaction BEGIN, COMMIT et ROLLBACK.

Q: Les commandes SQL sont-elles sensibles à la casse ?

Non. SELECT, select et Select fonctionnent tous. Écrire les mots-clés en majuscules est une convention qui les distingue des noms de tables et de colonnes. Le texte entre guillemets, lui, est comparé à l'identique : 'Ada' et 'ada' sont deux chaînes différentes dans SQLite, sauf si vous demandez une comparaison insensible à la casse.

Commandes SQL : liste des requêtes SQL courantes avec exemples

Les commandes SQL de tous les jours, classées selon ce qu'elles font (DDL, DML, DQL et TCL), chacune avec un exemple à exécuter dans SQLite.

Cette page contient des éditeurs exécutables - modifiez, exécutez et voyez la sortie instantanément.

Par Kevin Spektor, Co-founder & CTO

Publié le Sep 23, 2026

Les commandes SQL en un coup d'œil

Les commandes SQL se répartissent en quelques groupes selon ce qu'elles font. Le tableau liste celles que vous utiliserez le plus, et chaque section ci-dessous en exécute une.

Commande	Groupe	Ce qu'elle fait
`CREATE TABLE`	DDL	Définit une nouvelle table et ses colonnes
`ALTER TABLE`	DDL	Ajoute ou renomme une colonne, ou renomme une table
`DROP TABLE`	DDL	Supprime une table et toutes ses lignes
`INSERT`	DML	Ajoute de nouvelles lignes
`UPDATE`	DML	Modifie des valeurs dans des lignes existantes
`DELETE`	DML	Supprime des lignes
`SELECT`	DQL	Lit des lignes, filtrées avec `WHERE` et triées avec `ORDER BY`
`BEGIN`, `COMMIT`, `ROLLBACK`	TCL	Regroupe des modifications pour qu'elles réussissent ou échouent ensemble

DDL signifie langage de définition de données (data definition language), DML langage de manipulation de données, DQL langage de requête de données et TCL langage de contrôle des transactions. Les noms comptent moins que la distinction : le DDL change la forme de la base de données, le DML change ce qu'elle contient.

CREATE TABLE : définir une table

CREATE TABLE nomme la table et liste ses colonnes avec leurs types et leurs règles. Toutes les autres commandes de cette page ont besoin d'une table sur laquelle travailler.

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

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

La page sur CREATE TABLE présente les règles comme NOT NULL, UNIQUE et DEFAULT.

INSERT : ajouter des lignes

INSERT INTO ajoute une ligne ou plusieurs. Listez les colonnes, puis les valeurs dans le même ordre.

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 colonne id s'est remplie toute seule : une INTEGER PRIMARY KEY reçoit le numéro suivant quand vous l'omettez. Plus de détails dans INSERT.

SELECT : lire des lignes

SELECT est la commande que vous écrirez le plus souvent. Choisissez les colonnes, filtrez les lignes avec WHERE et triez-les avec 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;

Seules les lignes qui passent le test du WHERE sont renvoyées, la meilleure note en premier. Voir les bases de SELECT et WHERE pour les détails.

UPDATE : modifier des lignes

UPDATE attribue de nouvelles valeurs à des lignes qui existent déjà. La clause WHERE décide quelles lignes ; sans elle, toutes les lignes changent.

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 vous n'êtes pas sûr des lignes que sélectionne une clause WHERE, exécutez-la d'abord dans un SELECT. La page UPDATE montre d'autres cas.

DELETE : supprimer des lignes

DELETE FROM supprime les lignes qui correspondent à sa clause WHERE. Comme UPDATE, elle touche toutes les lignes si la clause est absente.

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 ligne de Chen a disparu et les autres sont intactes. Voir DELETE.

ALTER TABLE et DROP TABLE : modifier ou supprimer une table

ALTER TABLE modifie une table existante sans perdre ses lignes. DROP TABLE supprime complètement la table.

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';

Une nouvelle colonne vaut NULL dans les lignes existantes jusqu'à ce que vous la remplissiez. ALTER et DROP TABLE liste ce que SQLite autorise.

JOIN : combiner des tables

Un JOIN lit les lignes de deux tables à la fois, mises en correspondance sur une colonne qu'elles partagent.

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 n'a aucune inscription, donc un INNER JOIN l'écarte. Un LEFT JOIN le garderait, avec un cours vide.

GROUP BY : résumer des lignes

GROUP BY réunit en une seule ligne les lignes qui partagent une valeur, et une fonction d'agrégation comme COUNT ou AVG résume chaque groupe.

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;

Les fonctions d'agrégation et GROUP BY et HAVING vont plus loin.

BEGIN, COMMIT et ROLLBACK : regrouper des modifications

Une transaction fait compter plusieurs modifications comme une seule. COMMIT les conserve toutes ; ROLLBACK les annule toutes.

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;

Le virement a été validé et la seconde modification a été annulée : Ada finit donc avec 70 et Boris avec 80. Les transactions explique quand les utiliser.

Ce qui change avec SQLite

Les commandes de cette page sont du SQL standard, et ce que vous apprenez ici reste valable dans MySQL et PostgreSQL. Les exemples exécutables sont écrits pour SQLite, cependant, et trois détails changent sur les bases de données plus grandes :

Lister les tables. Les exemples lisent sqlite_master, la table de schéma propre à SQLite. MySQL utilise SHOW TABLES, et PostgreSQL la vue information_schema.tables (ou \dt dans psql).
Identifiants automatiques. Dans SQLite, une colonne déclarée INTEGER PRIMARY KEY numérote seule les nouvelles lignes ; c'est pourquoi les exemples d'INSERT omettent id. MySQL demande AUTO_INCREMENT sur la colonne, et PostgreSQL une colonne d'identité (GENERATED BY DEFAULT AS IDENTITY) ou SERIAL.
Droits et changements de schéma. SQLite n'a ni GRANT ni REVOKE, car une base SQLite est un simple fichier sans comptes utilisateurs, et son ALTER TABLE ne peut pas changer le type d'une colonne.

Questions fréquentes

Quelles sont les commandes SQL de base ?

Cinq commandes couvrent l'essentiel du travail quotidien : CREATE TABLE pour définir une table, INSERT pour ajouter des lignes, SELECT pour les lire, UPDATE pour les modifier et DELETE pour les supprimer. Viennent ensuite ALTER TABLE, DROP TABLE, JOIN, GROUP BY et les commandes de transaction BEGIN, COMMIT et ROLLBACK.

Quelle est la différence entre DDL et DML ?

Le DDL (langage de définition de données) modifie la structure de la base : CREATE, ALTER et DROP. Le DML (langage de manipulation de données) modifie les lignes à l'intérieur des tables : INSERT, UPDATE et DELETE. SELECT ne fait que lire, c'est pourquoi on le classe souvent à part, sous le nom de DQL.

Les commandes SQL sont-elles sensibles à la casse ?

Non. SELECT, select et Select fonctionnent tous. Écrire les mots-clés en majuscules est une convention qui les distingue des noms de tables et de colonnes. Le texte entre guillemets, lui, est comparé à l'identique : 'Ada' et 'ada' sont deux chaînes différentes dans SQLite, sauf si vous demandez une comparaison insensible à la casse.

Ces commandes fonctionnent-elles de la même façon dans MySQL et PostgreSQL ?

Ces instructions sont du SQL standard et ont le même sens dans les trois, donc ce que vous apprenez ici reste valable. Les exemples exécutables sont écrits pour SQLite, cependant : pour lister les tables on lit ici sqlite_master, les identifiants automatiques demandent AUTO_INCREMENT dans MySQL ou une colonne d'identité dans PostgreSQL, et SQLite n'a ni GRANT ni REVOKE.

Concepts liés