Documentation SQLite
Référence SQLite concise et illustrée par des exemples. Lisez le concept, voyez le code, puis pratiquez-le dans un parcours Coddy.
Commencer un parcours guidé en SQLitePremiers pas
- C'est quoi SQLiteSQLite, c'est une base de données SQL sans serveur, stockée dans un simple fichier et embarquée directement dans votre application. Voici ce qu'elle est vraiment, en quoi elle diffère d'un serveur de base de données, et quand elle fait des merveilles.
- Liste des commandes SQLLes 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.
- SQLite vs MySQLSQLite et MySQL, deux philosophies opposées : architecture, concurrence, types de données et cas d'usage concrets pour choisir la bonne base.
- SQLite vs PostgresSQLite ou PostgreSQL : architecture, concurrence, types de données et cas d'usage concrets pour choisir la bonne base selon votre projet.
- Quand utiliser SQLiteGuide pratique pour savoir quand SQLite est le bon choix - et quand il vaut mieux passer à PostgreSQL ou MySQL.
- Installer SQLiteComment installer SQLite sur Windows, macOS et Linux : récupérer l'outil en ligne de commande, l'ajouter au PATH et vérifier que tout fonctionne.
- SQLite CLIMaîtrisez le shell sqlite3 depuis le terminal : ouvrir une base, lancer des requêtes, utiliser les dot commands et importer ou exporter des données en CSV.
- Outils GUITour d'horizon des outils graphiques pour ouvrir, explorer et modifier un fichier SQLite : DB Browser for SQLite, SQLiteStudio et les visionneuses en ligne.
- Créer une baseComment créer une base SQLite : le modèle « un fichier = une base », la commande `sqlite3` et pourquoi `CREATE DATABASE` n'existe pas ici.
- Base en mémoireComment fonctionne la base SQLite en mémoire, quand dégainer `:memory:`, et ce qui la distingue d'une base stockée dans un fichier classique.
Tables et types
- CREATE TABLECréer des tables en SQLite : définition des colonnes, contraintes, IF NOT EXISTS, tables temporaires et CREATE TABLE AS SELECT, avec des exemples concrets.
- Types de donnéesComment SQLite stocke réellement les valeurs : les cinq classes de stockage, le principe du typage dynamique, et les pièges classiques quand on vient de Postgres ou MySQL.
- Type AffinityComprendre le système de type affinity de SQLite : les cinq affinités, les règles qui en choisissent une à partir de la déclaration de colonne, et pourquoi une colonne INTEGER peut très bien stocker une chaîne.
- Tables STRICTComment les tables STRICT de SQLite désactivent le stockage à typage flexible, refusent les valeurs incompatibles et apportent enfin la vérification de type qu'on attendait depuis le début.
- Clés primairesTout sur les clés primaires en SQLite : le cas particulier d'INTEGER PRIMARY KEY, les clés composites, AUTOINCREMENT et les pièges classiques.
- ROWIDComprenez ce qu'est vraiment ROWID dans SQLite, dans quels cas INTEGER PRIMARY KEY le remplace, et à quoi servent réellement les tables WITHOUT ROWID.
- NOT NULL & DEFAULTComment fonctionnent vraiment NOT NULL et DEFAULT en SQLite : ce qu'ils imposent, l'astuce CURRENT_TIMESTAMP et les pièges quand on les ajoute à une table existante.
- Contraintes CHECKComment utiliser les contraintes CHECK en SQLite pour valider les valeurs : check sur une colonne, sur plusieurs colonnes, contraintes nommées et pièges courants.
- Contrainte UNIQUETout ce qu'il faut savoir sur la contrainte UNIQUE en SQLite : niveau colonne, niveau table, clés composites, comportement des NULL et résolution des conflits.
- DROP & ALTER TABLESupprimer, renommer et modifier des tables en SQLite : ce que ALTER TABLE sait faire, ce qu'il ne sait pas faire, et l'astuce du rebuild pour le reste.
Insérer et modifier des données
- INSERTMaîtrisez INSERT en SQLite : insertion d'une ligne, insertions multiples, INSERT...SELECT, valeurs par défaut et les modificateurs OR IGNORE et OR REPLACE.
- Requête UPDATE en SQLModifier des lignes existantes en SQLite : syntaxe d'UPDATE, clause WHERE pour éviter les catastrophes, mise à jour multi-colonnes et UPDATE ... FROM pour croiser des tables.
- DELETEComment fonctionne DELETE en SQLite : écrire un WHERE sans risque, vider une table, propager la suppression aux tables liées et récupérer les lignes effacées avec RETURNING.
- UPSERTMaîtrisez l'UPSERT en SQLite : la clause ON CONFLICT, la pseudo-table excluded, DO NOTHING vs DO UPDATE, et pourquoi c'est mieux que INSERT OR REPLACE.
- Clause RETURNINGLa clause RETURNING de SQLite permet de récupérer directement les lignes affectées par un INSERT, UPDATE ou DELETE - sans repasser une requête derrière.
- Importer un CSVComment charger un fichier CSV dans SQLite avec la commande .import : gestion des en-têtes, tables existantes, séparateurs personnalisés et erreurs courantes.
- Exporter les donnéesComment sortir des données de SQLite : export CSV avec en-têtes, JSON, dump SQL complet et sauvegarde d'une table depuis le shell sqlite3.
Interroger les données
- SELECT : les basesComment fonctionne réellement l'instruction SELECT en SQLite : choisir des colonnes, calculer des expressions, renommer avec des alias et adopter le bon réflexe pour toutes vos requêtes.
- Clause WHERETout pour filtrer des lignes en SQLite avec WHERE : opérateurs de comparaison, AND/OR, LIKE, IN, BETWEEN, et le piège classique des NULL.
- Opérateurs & NULLComment les opérateurs SQLite réagissent face à NULL : pourquoi `=` et `<>` ne font pas ce qu'on croit, et quand utiliser IS, IS NOT, COALESCE et IFNULL.
- ORDER BYComment fonctionne ORDER BY en SQLite : tri croissant et décroissant, départage avec plusieurs colonnes, gestion des NULL et tri insensible à la casse.
- LIMIT & OFFSETComment utiliser LIMIT et OFFSET en SQLite pour limiter, sauter des lignes et paginer proprement, sans tomber dans le piège de performance sur les grosses tables.
- DISTINCTTout ce qu'il faut savoir sur SELECT DISTINCT en SQLite : sur une ou plusieurs colonnes, gestion des NULL, COUNT(DISTINCT) et quand préférer GROUP BY.
- Instruction CASE en SQLMaîtrisez CASE en SQLite : forme simple ou avec recherche, utilisation dans SELECT, ORDER BY, WHERE, et quand préférer IIF pour aller plus vite.
Fonctions et agrégats
- Fonctions de chaînesLe guide pratique des fonctions de chaînes en SQLite : concaténation avec ||, SUBSTR, INSTR, REPLACE, TRIM et les bons réflexes pour nettoyer du texte en SQL.
- Fonctions numériquesFaire des calculs en SQLite : ROUND, ABS, CEIL, FLOOR, MOD, POWER, SQRT, RANDOM - et le piège classique de la division entière qui piège tout le monde au moins une fois.
- Dates et heuresComment SQLite stocke et manipule les dates : les cinq fonctions date/heure, les formats, les modificateurs et les bons choix de stockage pour garder vos requêtes rapides.
- Fonctions d'agrégation SQLComment les fonctions d'agrégation de SQLite condensent plusieurs lignes en une seule valeur : COUNT, SUM, AVG, MIN, MAX, GROUP_CONCAT, avec DISTINCT, FILTER et la gestion des NULL.
- GROUP BY & HAVINGComment GROUP BY regroupe les lignes en paquets dans SQLite, et comment HAVING filtre ces paquets après agrégation - avec la différence entre WHERE et HAVING expliquée concrètement.
Relations et jointures
- Clés étrangèresTout ce qu'il faut savoir sur les clés étrangères en SQLite : déclarer REFERENCES, activer l'enforcement avec PRAGMA et choisir le bon comportement ON DELETE.
- INNER JOINComprendre INNER JOIN en SQLite : le bon modèle mental, la clause ON, la jointure de trois tables et le raccourci USING.
- LEFT JOINComprendre le LEFT JOIN en SQLite : conserver les lignes sans correspondance, gérer les NULL, filtrer correctement et joindre plusieurs tables.
- Self JoinLe self join en SQLite expliqué simplement : associer des lignes d'une même table grâce aux alias, avec des exemples concrets sur une hiérarchie employé/manager.
- Sous-requêtesApprenez à imbriquer un SELECT dans un autre en SQLite : sous-requêtes scalaires, IN/EXISTS, tables dérivées, sous-requêtes corrélées, et quand préférer une JOIN.
- CTEComprendre les Common Table Expressions de SQLite : nommer une sous-requête avec WITH, enchaîner plusieurs CTE et écrire des requêtes qui se lisent de haut en bas.
- CTE récursivesComprendre les CTE récursives en SQLite : la structure ancre/récursive, le parcours d'arbres parent-enfant, la génération de séries et comment éviter les boucles infinies.
Index et performance
- IndexComment fonctionnent les index dans SQLite : quand ils accélèrent vos requêtes, quand ils plombent les performances, et comment vérifier que le planificateur les utilise vraiment.
- Index compositesComment fonctionnent les index multi-colonnes en SQLite, pourquoi l'ordre des colonnes change tout, et quand un index composite vous fait gagner du temps plutôt que de l'espace disque.
- Index partielsComprendre les index partiels en SQLite : indexer uniquement les lignes que vous interrogez vraiment, et les cas concrets (soft delete, unicité partielle, sous-ensembles chauds) où ils font vraiment la différence.
- EXPLAIN QUERY PLANApprenez à utiliser EXPLAIN QUERY PLAN dans SQLite pour vérifier l'usage d'un index, comprendre SCAN et SEARCH, et déchiffrer le plan d'exécution d'une jointure.
- ANALYZE & VACUUMComment `ANALYZE` et `VACUUM` gardent une base SQLite rapide et compacte : ce que chacun fait vraiment, quand les lancer et les variantes à connaître.
Fonctionnalités avancées
- TransactionsComprendre les transactions en SQLite : BEGIN, COMMIT, ROLLBACK, le mode autocommit et les variantes DEFERRED, IMMEDIATE et EXCLUSIVE qui décident quand les verrous sont posés.
- SavepointsComprendre les savepoints SQLite : des marqueurs nommés posés à l'intérieur d'une transaction, sur lesquels on peut revenir sans tout annuler.
- VuesTout savoir sur les vues SQLite : sauvegarder une requête comme table virtuelle, utiliser les vues temporaires et contourner leur côté lecture seule.
- TriggersComprendre les triggers SQLite : BEFORE et AFTER, INSTEAD OF sur les vues, les références OLD et NEW, et les cas où c'est vraiment l'outil adapté.
- JSON dans SQLiteComment SQLite stocke et interroge le JSON : extraire des champs, modifier des valeurs, parcourir un tableau avec json_each et indexer un chemin JSON.
- Recherche plein texteComment ajouter la recherche plein texte à SQLite avec FTS5 : tables virtuelles, opérateur MATCH, classement BM25 et synchronisation de l'index avec vos données.
- Window functionsTour d'horizon des window functions en SQLite : OVER, PARTITION BY, fonctions de classement, LAG/LEAD et clauses de frame pour calculer des cumuls.
- Colonnes généréesComprendre les colonnes générées en SQLite : déclaration, choix entre VIRTUAL et STORED, et indexation pour des requêtes rapides.
- ATTACH DATABASEComment ATTACH DATABASE permet d'ouvrir plusieurs fichiers SQLite dans une même connexion, de les requêter via des préfixes de schéma et de les détacher proprement.
Sécurité et intégration applicative
- Requêtes préparéesComprendre les requêtes préparées en SQLite : à quoi elles servent, et le cycle prepare/bind/step/finalize que tous les drivers encapsulent.
- Binding de paramètresComment fonctionne le binding de paramètres en SQLite : placeholders positionnels, paramètres nommés et bonnes pratiques pour passer des valeurs sans risque depuis votre application.
- Injection SQLPourquoi concaténer des chaînes pour construire ses requêtes est une catastrophe, comment fonctionne réellement une injection SQL, et comment les requêtes paramétrées de SQLite la rendent impossible.
- Connexion à SQLiteComment ouvrir une base SQLite depuis votre application : chemins de fichier, chaînes de connexion, drivers selon le langage et les réglages à ne pas négliger dès le départ.
- MigrationsComment faire évoluer un schéma SQLite sans casse : PRAGMA user_version, scripts de migration ordonnés et transactions pour pouvoir revenir en arrière.
- Mode WALComment le mode WAL de SQLite change la donne côté concurrence : lecteurs et écrivains ne se bloquent plus, et à quoi servent vraiment les fichiers -wal et -shm.
Production et exploitation
- Sauvegarde & restaurationComment sauvegarder et restaurer une base SQLite proprement : la commande .backup, VACUUM INTO, l'API de backup en ligne, et pourquoi recopier le fichier est une mauvaise idée.
- Réglages PRAGMALes PRAGMA qui comptent vraiment - journal_mode, synchronous, foreign_keys, busy_timeout, cache_size - et les valeurs à utiliser en production.
- Erreurs courantesLes erreurs SQLite que vous croiserez vraiment en production - database is locked, readonly database, disk image malformed, contraintes - et comment les régler.
