Cette page nécessite un navigateur récent (avec support SharedArrayBuffer). Veuillez mettre à jour Chrome, Edge, Firefox ou Safari vers la dernière version.
Une base de données conserve les données dans des tables. Une requête lit les données avec SELECT. Le SELECT * retourne toutes les colonnes ; le FROM nomme la table.
CREATE TABLE student (id INTEGER, name TEXT, score INTEGER);
INSERT INTO student VALUES (1, 'Mei', 88), (2, 'Sam', 71);
SELECT * FROM student;
Une table stocke des enregistrements : chaque ligne est un enregistrement, chaque colonne est un champ
Chaque ligne correspond à un enregistrement. Les mots-clés SQL s'écrivent par habitude en MAJUSCULES.
Une instruction se termine par un point-virgule ;.
1.2
Choisir des colonnes
Listez les colonnes souhaitées, séparées par des virgules. Utilisez AS pour renommer une colonne dans le résultat (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;
Une colonne sélectionnée peut aussi être un calcul — associez-la à AS pour nommer la nouvelle colonne :
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 élimine les valeurs dupliquées du résultat.
1.3
Filtrage avec WHERE
WHERE conserve uniquement les lignes qui correspondent à une condition. Comparez avec =, <> (différent de), <, >, <=, >=. Placez du texte entre guillemets 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;
Lisez les parties dans cet ordre logique : FROM → WHERE → SELECT. (La base de données peut exécuter les opérations différemment, mais le résultat est identique.)
Erreurs courantes
Mettez les valeurs textuelles entre guillemets simples : WHERE name = 'Ann' ; les noms de colonnes n'ont pas de guillemets.
SELECT * retourne toutes les colonnes — nommez uniquement les colonnes dont vous avez besoin.
Combinez les conditions avec AND, OR, NOT. AND nécessite que tous les côtés soient vrais ; OR nécessite qu'au moins un côté soit vrai ; NOT inverse un côté. Utilisez des parenthèses pour définir la priorité 优先级.
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 nécessite tous vrais ; OR nécessite au moins un ; NOT inverse un seul
2.2
LIKE, IN et BETWEEN
LIKE correspond à un motif de texte 模式 : % représente n'importe quel texte et _ représente un seul caractère — ce sont des caractères génériques 通配符.
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
Motif
Correspond à
'M%'
commence par M
'%a'
finit par a
'%an%'
contient "an"
'M_i'
M, puis exactement un caractère, puis i
IN correspond à un ensemble 集合 de valeurs ; BETWEEN correspond à une plage 范围 (extrémités incluses).
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 marque une valeur manquante 缺失值 — rien n'a été stocké dans cette cellule. NULL n'est pas 0 et n'est pas une chaîne vide. Une comparaison avec = ou <> ne correspond jamais ; testez avec IS NULL ou 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 ne retourne aucune ligne — pas même la ligne de Sam.
Un NULL en arithmétique donne un NULL : score + 5 reste NULL pour Sam.
Erreurs courantes
Testez une valeur vide avec IS NULL, jamais = NULL.
Dans LIKE, % correspond à n'importe quel texte et _ correspond à un seul caractère : 'A%' signifie « commence par A ».
IN (1, 2, 3) est plus court que beaucoup de ORs ; BETWEEN a AND b inclut les deux extrémités.
ORDER BY trie 排序 les lignes du résultat. Ajoutez DESC pour un tri décroissant 降序 (de haut en bas) ; le tri croissant 升序 (de bas en haut) est par défaut.
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;
Tri par plusieurs colonnes
Répertoriez plusieurs colonnes. En cas d'égalité 平局 dans la première colonne, la suivante fait office de critère de rupture.
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 garde seulement les premières n lignes — associez-le à ORDER BY pour une liste des N premiers 前 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 peut aussi trier selon un alias ou un calcul : ORDER BY avg_score DESC.
Le texte se trie alphabétiquement : ORDER BY name exécute A → Z.
Erreurs courantes
ORDER BY trie par défaut par ordre croissant ; ajoutez DESC pour un ordre décroissant.
ORDER BY intervient vers la fin, après WHERE et GROUP BY.
LIMIT limite le nombre de lignes retournées, mais seulement après le tri.
ORDER BY trie ; LIMIT garde les n premières après tri
Une fonction agrégée convertit plusieurs lignes en une valeur de résumé. Enveloppez une moyenne dans ROUND(x, 2) pour l'arrondir.
Fonction
Donne
COUNT(*)
combien de lignes
SUM(col)
le total
AVG(col)
la moyenne arithmétique
MIN(col) / MAX(col)
la valeur la plus petite / la plus 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 et HAVING
GROUP BY génère une ligne de résumé par groupe. HAVING filtre ces groupes — c'est comme WHERE, mais il s'exécute après le groupement.
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 rassemble les lignes dans un seul bucket par valeur ; chaque bucket devient une ligne de résumé
Écrivez les clauses SQL dans leur ordre syntaxique requis. Le tableau ci-dessous est un modèle logique pour raisonner sur une requête ; le moteur peut optimiser son ordre d'exécution physique :
Étape
Clause
1
FROM (et tout JOIN)
2
WHERE — filtre les lignes
3
GROUP BY — forme les groupes
4
HAVING — filtre les groupes
5
SELECT — calcule les colonnes de sortie
6
ORDER BY, puis LIMIT
Erreurs courantes
Pour des résultats groupés prévisibles, regroupez chaque colonne sélectionnée non agrégée (ou utilisez une dépendance fonctionnelle connue supportée par la base de données). SQLite permet une colonne nue hors de GROUP BY, mais elle peut provenir d'une ligne arbitraire du groupe ; une requête réussie ne garantit pas la valeur que vous aviez prévue.
Filtrez les lignes avec WHERE (avant le groupement) et filtrez les groupes avec HAVING (après).
COUNT(*) compte les lignes ; COUNT(col) ignore les NULLs dans cette colonne.
Une clé primaire nomme uniquement chaque ligne dans une table. Une clé étrangère dans une table pointe vers la clé primaire d'une autre — cela établit une relation entre elles.
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 joint combine des lignes de deux tables. INNER JOIN ... ON ... conserve les lignes où les clés correspondent. Un alias court (s, c) garde la requête lisible.
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;
INNER JOIN associe chaque clé étrangère à une clé primaire et combine les lignes correspondantes
5.3
Joining avec groupement
Jointez d'abord, puis GROUP BY pour résumer à travers les lignes jointes.
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;
Regroupez par la clé c.id ainsi que par le nom : deux classes partageant accidentellement le même nom seraient sinon fusionnées en une seule ligne.
5.4
LEFT JOIN
Un INNER JOIN conserve uniquement les lignes correspondantes. Un LEFT JOIN conserve toutes les lignes de la table de gauche (première) ; lorsqu'il n'y a pas de correspondance, les colonnes de la table de droite retournent comme 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 n'a pas de classe, mais la ligne apparaît quand même — avec class valant NULL.
Pour trouver uniquement les lignes sans correspondance, ajoutez WHERE c.id IS NULL.
Erreurs courantes
Un join sans condition ON apparie chaque ligne avec chaque ligne (un joint cartésien).
Associez la clé étrangère à la clé primaire : ON orders.customer_id = customers.id.
Un INNER JOIN rejette les lignes qui n'ont pas de correspondance de l'autre côté ; utilisez un LEFT JOIN pour les garder.
INSERT INTO ... VALUES ... ajoute de nouvelles lignes 行. Nommez les colonnes, puis donnez les valeurs dans le même ordre. (Chaque bloc ci-dessous se termine par un SELECT pour que vous puissiez voir le résultat.)
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 (...), (...); ajoute plusieurs lignes en une seule instruction.
INSERT ajoute une nouvelle ligne à une table
6.2
UPDATE
UPDATE ... SET ... WHERE ... modifie des lignes existantes. Toujours ajouter WHERE, sinon toutes les lignes changent.
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 ... supprime des lignes. Sans WHERE, il vide entièrement la table 表.
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;
Erreurs courantes
UPDATE et DELETEsansWHERE modifient toutes les lignes — ajoutez toujours le WHERE.
Dans INSERT, les valeurs doivent correspondre à la liste des colonnes par ordre et type.
Testez d'abord un DELETE risqué comme un SELECT avec le même WHERE.
CREATE TABLE définit le schéma d'une table : les noms des colonnes et leurs types de données. Les principaux types SQLite sont INTEGER, TEXT et REAL (un nombre à virgule flottante : rapide, mais pas toujours exact, donc 0.1 + 0.2 = 0.3 est faux).
CREATE TABLE student (id INTEGER, name TEXT, score REAL);
INSERT INTO student VALUES (1, 'Mei', 88.5);
SELECT * FROM student;
CREATE TABLE nomme les colonnes et leurs types
7.2
Clés & contraintes
Une contrainte est une règle sur une colonne : PRIMARY KEY (une ID unique), NOT NULL (doit avoir une valeur), UNIQUE, et DEFAULT (une valeur par défaut).
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;
Déclarez une clé étrangère avec REFERENCES. Dans SQLite, activez l'application pour chaque connexion avec PRAGMA foreign_keys = ON; avant de commencer une transaction. Une simple déclaration ne garantit pas l'application.
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 forme longue est FOREIGN KEY (class_id) REFERENCES class(id) sur sa propre ligne.
7.3
ALTER TABLE
ALTER TABLE ... ADD COLUMN ... modifie le schéma d'une table existante. Un DEFAULT remplit la nouvelle colonne dans les anciennes lignes.
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; renomme toute la table.
DROP TABLE student; supprime complètement la table — structure et données.
Erreurs courantes
Déclarez un type approprié pour chaque colonne. SQLite permet des noms de type omis et utilise normalement un typage flexible ; une déclaration de type seule ne valide pas toutes les valeurs stockées.
Conceptionnez une clé primaire pour qu'elle soit unique et non-NULL. Dans les tables SQLite ordinaires, certaines déclarations de clé primaire autorisent encore NULL ; utilisez NOT NULL explicitement pour une clé texte. INTEGER PRIMARY KEY a un comportement spécial d'ID de ligne : insérer NULL alloue une ID entière.
Avec l'application des clés étrangères activée, une valeur de clé étrangère non-NULL doit correspondre à une clé référencée. NULL est autorisé sauf si la colonne possède également NOT NULL.
Les tables se connectent via des relations. La relation un-à-plusieurs est la plus courante : une classe a plusieurs étudiants. La relation plusieurs-à-plusieurs nécessite une table de jointure intermédiaire. Un diagramme entité-relations (diagramme ER) représente chaque entité par une boîte et chaque relation par une ligne.
Relation
Exemple
un-vers-un
une personne et son passeport
un-vers-beaucoup
une classe et ses étudiants
beaucoup-vers-beaucoup
étudiants et clubs
Le côté "beaucoup" porte la clé étrangère ; un lien beaucoup-vers-beaucoup nécessite une table de jonction
La table de jointure contient une ligne par lien, et chacune de ses colonnes est une clé étrangère. Sa clé primaire est le paire(student_id, club_id), une clé composite, afin qu'un même étudiant ne puisse pas s'inscrire deux fois au même club. Les deux colonnes sont NOT NULL, ce qui lie chaque adhésion à un étudiant et à un club. Ici, Mei est dans deux clubs, et Échecs compte deux membres :
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
Normalisation
La normalisation organise les tables pour éviter la redondance (les mêmes données répétées) et les erreurs de mise à jour qu'elle provoque. Les trois premières formes normales :
1NF : chaque cellule contient une valeur atomique — aucune liste à l'intérieur d'une cellule.
2NF : aucune colonne ne dépend uniquement d'une partie d'une clé composite.
3NF : aucune colonne ne dépend d'une autre colonne non-clé.
Non normalisé (mauvais)
Normalisé (mieux)
student(name, club1, club2)
student(name) + membership(student, club)
Erreurs courantes
Séparez les groupes répétés dans leur propre table (normalisation) au lieu de nombreuses colonnes similaires.
Chaque table doit décrire UN SEUL type de chose.
Liez les tables avec une clé étrangère pointant vers la clé primaire d'une autre table.