Comment afficher les tables dans SQLite

Introduction

SQLite est un moteur de base de données populaire, réputé pour sa simplicité et son efficacité dans la gestion des bases de données relationnelles. C’est un moteur de base de données SQL embarqué, ce qui signifie qu’il est souvent utilisé directement au sein des applications, offrant une solution légère sans nécessiter de processus serveur séparé. Dans ce tutoriel, on va voir comment afficher la liste des tables d’une base de données SQLite, une tâche courante quand tu découvres la structure d’une base existante ou quand tu débogues.

Prérequis

Tu dois avoir SQLite installé et accessible. Tu peux interagir avec les bases de données SQLite de différentes façons, par exemple via la ligne de commande, un script Python ou des outils graphiques comme Beekeeper Studio. Ce guide utilise l’outil en ligne de commande SQLite, disponible partout.

Accéder à la base de données SQLite

Pour commencer, ouvre ton terminal ou ton invite de commandes et accède à ta base de données SQLite avec l’outil en ligne de commande SQLite. La commande générale pour commencer à interagir avec ta base est :

sqlite3 your_database_file.db

Remplace « your_database_file.db » par le chemin vers ton fichier de base de données SQLite.

Lister les tables avec la commande .tables

SQLite propose la commande .tables, une méthode simple pour lister toutes les tables disponibles dans ta base de données active.

Dans ton shell SQLite en ligne de commande, saisis ceci :

.tables

En exécutant cette commande, SQLite renvoie la liste de tous les noms de tables de ta base de données actuelle.

Résultat attendu : (avec la base d’exemple « sakila.db »)

actor                   experiments             payment
address                 film                    rental
category                film_actor              sales_by_film_category
city                    film_category           sales_by_store
country                 film_list               staff
customer                film_text               staff_list
customer_list           inventory               store
events                  language

Comment fonctionne la commande .tables ?

SQLite demande à la base de données de renvoyer les noms de toutes les tables et vues des bases principale et attachées. Pour cela, il exécute en coulisses une commande SELECT sur la table sqlite_master.

Interroger la table sqlite_master

Pour plus de contrôle, tu peux interroger directement la table « sqlite_master », qui stocke les métadonnées de la base, y compris les définitions des tables.

Par exemple :

SELECT name FROM sqlite_master WHERE type='table';

Cette commande SQL sélectionne tous les enregistrements de la colonne name de la table sqlite_master dont le type vaut « table ».

Résultat attendu : (avec la base d’exemple « sakila.db »)

---------------
actor
sqlite_sequence
country
city
address
language
category
customer
film
film_actor
film_category
film_text
inventory
staff
store
payment
rental
experiments
events

Afficher le schéma d’une table avec la commande .schema

Pour examiner la structure ou le « schéma » de ta table (c’est-à-dire ses colonnes et leurs types de données), SQLite fournit la commande .schema :

.schema your_table_name

Résultat attendu : (avec la table « actor » de la base d’exemple « sakila.db »)

CREATE TABLE actor (
  actor_id integer PRIMARY KEY AUTOINCREMENT NOT NULL,
  first_name VARCHAR(45) NOT NULL,
  last_name VARCHAR(45) NOT NULL,
  last_update TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
  , "email_address" VARCHAR(255) NULL);
CREATE INDEX idx_actor_last_name ON actor(last_name)
;
CREATE TRIGGER actor_trigger_ai AFTER INSERT ON actor
 BEGIN
  UPDATE actor SET last_update = DATETIME('NOW')  WHERE rowid = new.rowid;
 END;
CREATE TRIGGER actor_trigger_au AFTER UPDATE ON actor
 BEGIN
  UPDATE actor SET last_update = DATETIME('NOW')  WHERE rowid = new.rowid;
 END;

Remplace « your_table_name » par le nom de ta table.

Cette commande renvoie l’instruction CREATE TABLE utilisée pour créer la table dans ta base de données.

Utiliser une instruction SQL SELECT

Tu peux aussi récupérer le schéma avec une instruction SELECT sur la table sqlite_master :

SELECT sql FROM sqlite_master WHERE name = 'your_table_name';

Cette commande renvoie la même instruction CREATE TABLE que la commande .schema, sans les instructions « INDEX » et « TRIGGER ».

Utiliser la commande PRAGMA pour obtenir des infos sur une table

Une autre approche dans SQLite consiste à utiliser la commande PRAGMA, qui donne accès à différentes caractéristiques de la base SQLite. Une commande PRAGMA utile est « table_info », qui permet d’obtenir des informations sur les colonnes d’une table.

Même si « table_info » ne liste pas toutes les tables, tu peux l’utiliser avec les commandes de listage pour comprendre la structure des tables dès que tu as trouvé leurs noms.

Exemple :

PRAGMA table_info('actor');

Résultat attendu : (avec la table « actor » de la base d’exemple « sakila.db »)

cid  name           type          notnull  dflt_value         pk
---  -------------  ------------  -------  -----------------  --
0    actor_id       INTEGER       1                           1
1    first_name     VARCHAR(45)   1                           0
2    last_name      VARCHAR(45)   1                           0
3    last_update    TIMESTAMP     1        CURRENT_TIMESTAMP  0
4    email_address  VARCHAR(255)  0                           0

Chaque ligne représente une colonne de la table « actor », avec respectivement son « cid », son « name », son « type », son statut « not null », sa « valeur par défaut » et l’information de « clé primaire ».

Conclusion

Lister les tables dans SQLite est une compétence fondamentale pour gérer et inspecter une base de données. Que tu utilises la commande .tables pour une liste rapide, que tu interroges la table sqlite_master pour une approche plus programmatique, ou que tu utilises des instructions PRAGMA pour obtenir des informations détaillées sur la structure des tables, SQLite offre toute une palette d’outils pour comprendre ta base de données et interagir efficacement avec elle.

Comprendre et écrire des commandes SQL pour afficher tes tables SQLite peut être gratifiant, mais aussi long et complexe, surtout avec de très grosses bases de données.

Beekeeper Studio offre une interface conviviale pour les tables de ta base de données, ce qui rend la navigation entre de nombreuses tables bien plus pratique.

En plus, pour récupérer le schéma d’une table, il suffit de cliquer sur son nom et le schéma s’affiche dans un format bien structuré.