SQLite Cheat Sheet : les commandes à connaître

SQLite est une base de données qui tient dans un seul fichier. Pas de serveur à démarrer, pas d’utilisateurs à configurer, pas de port à ouvrir. Tu crées un fichier .db, et c’est ta base de données.

C’est le moteur le plus déployé au monde. Tous les smartphones Android et iOS l’utilisent en interne. Les navigateurs stockent l’historique et les cookies dedans. VS Code s’en sert pour ses extensions. SQLite est partout, justement parce qu’il ne demande rien d’autre que lui-même.

Pour les projets perso, les scripts de traitement de données, les prototypes ou les petites apps web, c’est imbattable. Pas besoin de Docker, pas besoin d’un service PostgreSQL qui tourne en arrière-plan. Une seule commande suffit pour commencer :

sqlite3 ma-base.db

Ce cheat sheet regroupe les commandes que j’utilise le plus souvent, des dot commands de l’interpréteur jusqu’aux fonctions JSON.

Ouvrir et gérer une base #

Ouvrir ou créer une base (le fichier est créé s’il n’existe pas) :

sqlite3 ma-base.db

Ouvrir en lecture seule :

sqlite3 -readonly ma-base.db

Sortir de l’interpréteur :

.quit

Commandes méta (dot commands) #

Ces commandes commencent par un point et s’exécutent dans l’interpréteur sqlite3.

Lister les tables :

.tables

Voir le schéma d’une table :

.schema nom_table

Voir le schéma de toutes les tables :

.schema

Afficher les noms de colonnes dans les résultats :

.headers on

Voir les bases attachées :

.databases

Modes d’affichage #

Le mode .mode box est le plus lisible en console (SQLite >= 3.37) :

.mode box

Résultat avec .mode box :

┌────┬───────┬───────────────────┐
│ id │ nom   │ email             │
├────┼───────┼───────────────────┤
│ 1  │ Alice │ alice@example.com │
│ 2  │ Bob   │ bob@example.com   │
└────┴───────┴───────────────────┘

Les autres modes disponibles :

Avec beaucoup de colonnes, .mode box provoque des chevauchements. .mode line affiche une valeur par ligne, sans risque de débordement :

.mode line

Résultat avec .mode line :

   id = 1
  nom = Alice
email = alice@example.com

   id = 2
  nom = Bob
email = bob@example.com

Limiter la largeur des colonnes (les valeurs trop longues sont tronquées) :

.width 4 15 25

Scroll horizontal dans le terminal sans chevauchement :

sqlite3 ma-base.db ".mode box" ".headers on" "SELECT * FROM nom_table;" | less -S

Créer et modifier des tables #

Créer une table :

CREATE TABLE utilisateurs (
  id INTEGER PRIMARY KEY AUTOINCREMENT,
  nom TEXT NOT NULL,
  email TEXT UNIQUE,
  created_at TEXT DEFAULT (datetime('now'))
);

Ajouter une colonne :

ALTER TABLE utilisateurs ADD COLUMN actif INTEGER DEFAULT 1;

Renommer une table :

ALTER TABLE utilisateurs RENAME TO users;

Supprimer une table :

DROP TABLE IF EXISTS users;

Insérer des données #

Insérer une ligne :

INSERT INTO utilisateurs (nom, email) VALUES ('Alice', 'alice@example.com');

Insérer plusieurs lignes en une requête :

INSERT INTO utilisateurs (nom, email) VALUES
  ('Bob', 'bob@example.com'),
  ('Carol', 'carol@example.com');

Ignorer les doublons sur une contrainte UNIQUE :

INSERT OR IGNORE INTO utilisateurs (nom, email) VALUES ('Alice', 'alice@example.com');

Upsert (insérer ou mettre à jour si conflit) :

INSERT INTO utilisateurs (email, nom) VALUES ('alice@example.com', 'Alice B.')
ON CONFLICT(email) DO UPDATE SET nom = excluded.nom;

Lire des données #

Sélectionner toutes les lignes :

SELECT * FROM utilisateurs;

Filtrer par condition :

SELECT nom, email FROM utilisateurs WHERE actif = 1;

Paginer les résultats :

SELECT * FROM utilisateurs ORDER BY nom ASC LIMIT 10 OFFSET 20;

Compter les lignes :

SELECT COUNT(*) FROM utilisateurs;

Dédupliquer :

SELECT DISTINCT nom FROM utilisateurs;

Mettre à jour et supprimer #

Mettre à jour une ligne :

UPDATE utilisateurs SET actif = 0 WHERE email = 'bob@example.com';

Supprimer une ligne :

DELETE FROM utilisateurs WHERE id = 3;

Vider une table sans la supprimer :

DELETE FROM utilisateurs;

Index #

Créer un index :

CREATE INDEX idx_email ON utilisateurs(email);

Index unique :

CREATE UNIQUE INDEX idx_email_unique ON utilisateurs(email);

Voir les index d’une table :

PRAGMA index_list(utilisateurs);

Jointures #

INNER JOIN (seulement les lignes qui ont une correspondance) :

SELECT u.nom, c.titre
FROM utilisateurs u
JOIN commandes c ON c.user_id = u.id
WHERE u.actif = 1;

LEFT JOIN avec agrégation (toutes les lignes de gauche, même sans correspondance) :

SELECT u.nom, COUNT(c.id) AS nb_commandes
FROM utilisateurs u
LEFT JOIN commandes c ON c.user_id = u.id
GROUP BY u.id;

Fonctions utiles #

Dates #

Date et heure actuelles :

SELECT datetime('now');

Date relative :

SELECT date('now', '-7 days');

Extraire l’année et le mois :

SELECT strftime('%Y-%m', created_at) AS mois FROM utilisateurs;

Texte #

Mettre en majuscules et mesurer la longueur :

SELECT upper(nom), length(nom) FROM utilisateurs;

Recherche par préfixe :

SELECT * FROM utilisateurs WHERE nom LIKE 'A%';

Recherche par sous-chaîne :

SELECT * FROM utilisateurs WHERE nom LIKE '%ice%';

JSON (SQLite >= 3.38) #

Extraire une valeur JSON :

SELECT json_extract(meta, '$.ville') FROM utilisateurs;

Modifier une valeur JSON :

UPDATE utilisateurs SET meta = json_set(meta, '$.score', 42) WHERE id = 1;

Transactions #

BEGIN;
INSERT INTO utilisateurs (nom) VALUES ('Dave');
UPDATE stats SET total = total + 1;
COMMIT;

Annuler une transaction en cours :

ROLLBACK;

Import / Export #

Importer un fichier CSV. À exécuter dans l’interpréteur sqlite3 :

.mode csv
.import donnees.csv nom_table

Exporter une table en CSV :

sqlite3 -separator ',' ma-base.db "SELECT * FROM utilisateurs;" > export.csv

Exporter toute la base en SQL :

sqlite3 ma-base.db .dump > backup.sql

Restaurer depuis un dump SQL :

sqlite3 nouvelle-base.db < backup.sql

PRAGMA courants #

Activer les clés étrangères (désactivées par défaut) :

PRAGMA foreign_keys = ON;

Vérifier l’intégrité de la base :

PRAGMA integrity_check;

Statistiques de pagination :

PRAGMA page_count;

PRAGMA page_size;

Mode WAL pour de meilleures performances en lecture concurrente :

PRAGMA journal_mode = WAL;

Exécuter une requête sans ouvrir l’interpréteur #

Requête simple :

sqlite3 ma-base.db "SELECT * FROM utilisateurs LIMIT 5;"

Avec en-têtes et colonnes alignées :

sqlite3 -column -header ma-base.db "SELECT * FROM utilisateurs;"

Quand ne pas utiliser SQLite #

SQLite couvre la majorité des projets, mais il y a des situations où un vrai serveur s’impose.

Évite SQLite si plusieurs processus écrivent en même temps de façon intensive. Le mode WAL aide à séparer lectures et écritures, mais SQLite sérialise quand même les écritures. Pour une API avec de nombreuses requêtes simultanées, PostgreSQL est plus adapté.

Évite-le aussi si la base est sur un partage réseau (NFS, CIFS, Samba). Les verrous fichier ne fonctionnent pas de façon fiable dans ces environnements et exposent à des corruptions silencieuses.

Enfin, SQLite ne propose pas de système d’utilisateurs ni de permissions par table. Si tu dois cloisonner l’accès aux données entre plusieurs rôles, tu as besoin d’un serveur de base de données.

Pour les projets qui démarrent sur SQLite et évoluent vers plus de concurrence, LibSQL et Turso offrent une compatibilité totale avec un passage vers le distribué sans réécriture du code.

Conclusion #

SQLite est la base de données que j’ouvre en premier quand je ne sais pas encore si le projet mérite une infrastructure. La plupart du temps, elle suffit. Un fichier versionnable, aucune dépendance à installer, une CLI qui fonctionne partout.

Si tu veux aller plus loin, la documentation officielle SQLite est l’une des mieux écrites du monde du logiciel libre.

Sources et références #

• Documentation officielle SQLite
• SQLite CLI reference
• PRAGMA statements