LabEx
Se connecterInscription gratuite

Jointure de Tables SQLite

SQLiteSQLiteBeginner
Pratiquer maintenant

💡 Ce tutoriel est traduit par l'IA à partir de la version anglaise. Pour voir la version originale, vous pouvez cliquer ici

Introduction

Dans ce laboratoire, vous apprendrez à combiner des données provenant de plusieurs tables dans SQLite en utilisant des techniques de jointure de tables (table joining). Nous aborderons INNER JOIN, LEFT JOIN, la jointure de plusieurs tables et le filtrage des résultats de jointure. À la fin de ce laboratoire, vous serez en mesure de récupérer et de combiner des données efficacement à l'aide de SQLite.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL sqlite(("SQLite")) -.-> sqlite/SQLiteGroup(["SQLite"]) sqlite/SQLiteGroup -.-> sqlite/init_db("Create SQLite Database") sqlite/SQLiteGroup -.-> sqlite/make_table("Create New Table") sqlite/SQLiteGroup -.-> sqlite/add_rows("Insert Multiple Rows") sqlite/SQLiteGroup -.-> sqlite/get_all("Select All Rows") sqlite/SQLiteGroup -.-> sqlite/query_where("Filter With WHERE") subgraph Lab Skills sqlite/init_db -.-> lab-552556{{"Jointure de Tables SQLite"}} sqlite/make_table -.-> lab-552556{{"Jointure de Tables SQLite"}} sqlite/add_rows -.-> lab-552556{{"Jointure de Tables SQLite"}} sqlite/get_all -.-> lab-552556{{"Jointure de Tables SQLite"}} sqlite/query_where -.-> lab-552556{{"Jointure de Tables SQLite"}} end

Créer et remplir les tables

Dans cette étape, vous allez créer deux tables, employees (employés) et departments (départements), et les remplir avec des exemples de données. Ces tables seront utilisées dans les étapes suivantes pour illustrer les techniques de jointure de tables (table joining).

Tout d'abord, ouvrez l'interpréteur (shell) SQLite en exécutant la commande suivante dans le terminal :

sqlite3 /home/labex/project/company.db

Cette commande ouvre l'interpréteur SQLite et se connecte à un fichier de base de données nommé company.db. Si le fichier n'existe pas, SQLite le créera.

Maintenant, créez la table employees avec la commande SQL suivante :

CREATE TABLE employees (
    id INTEGER PRIMARY KEY,
    name TEXT,
    department_id INTEGER
);

Cette commande crée une table nommée employees avec trois colonnes : id, name (nom) et department_id. La colonne id est la clé primaire (primary key) et identifiera de manière unique chaque employé.

Ensuite, créez la table departments avec la commande SQL suivante :

CREATE TABLE departments (
    id INTEGER PRIMARY KEY,
    name TEXT
);

Cette commande crée une table nommée departments avec deux colonnes : id et name. La colonne id est la clé primaire et identifiera de manière unique chaque département.

Maintenant, insérez des exemples de données dans la table employees :

INSERT INTO employees (name, department_id) VALUES
('Alice', 1),
('Bob', 2),
('Charlie', 1),
('David', 3),
('Eve', NULL);

Cette commande insère cinq lignes dans la table employees. Chaque ligne représente un employé et son ID de département correspondant.

Enfin, insérez des exemples de données dans la table departments :

INSERT INTO departments (name) VALUES
('Sales'),
('Marketing'),
('Engineering');

Cette commande insère trois lignes dans la table departments. Chaque ligne représente un département et son nom.

Pour vérifier que les tables ont été créées et remplies correctement, vous pouvez exécuter la commande SQL suivante :

SELECT * FROM employees;

Résultat attendu :

1|Alice|1
2|Bob|2
3|Charlie|1
4|David|3
5|Eve|

Et :

SELECT * FROM departments;

Résultat attendu :

1|Sales
2|Marketing
3|Engineering

Effectuer des requêtes INNER JOIN

Dans cette étape, vous apprendrez à utiliser la clause INNER JOIN dans SQLite. Une INNER JOIN renvoie les lignes lorsqu'il existe une correspondance dans les deux tables, basée sur une condition spécifiée.

La syntaxe de base pour INNER JOIN est :

SELECT column1, column2 FROM table1 INNER JOIN table2 ON table1.column_name = table2.column_name;

Dans notre cas, nous voulons récupérer les noms des employés ainsi que les noms de leurs départements. Pour ce faire, exécutez la commande SQL suivante :

SELECT employees.name, departments.name
FROM employees
INNER JOIN departments ON employees.department_id = departments.id;

Cette commande joint les tables employees et departments en fonction de la colonne department_id dans employees correspondant à la colonne id dans departments. Elle sélectionne ensuite le nom de l'employé dans la table employees et le nom du département dans la table departments.

Résultat attendu :

Alice|Sales
Bob|Marketing
Charlie|Sales
David|Engineering

Ce résultat affiche le nom de l'employé et le nom de son département correspondant. Notez qu'Eve n'est pas incluse dans le résultat car son department_id est NULL, et il n'y a pas de département correspondant. INNER JOIN ne renvoie que les lignes correspondantes.

Utiliser LEFT JOIN pour les données optionnelles

Dans cette étape, vous apprendrez à utiliser LEFT JOIN dans SQLite. Une LEFT JOIN (ou LEFT OUTER JOIN) renvoie toutes les lignes de la table de gauche, et les lignes correspondantes de la table de droite. S'il n'y a pas de correspondance dans la table de droite, des valeurs NULL sont renvoyées pour les colonnes de la table de droite. Ceci est utile lorsque vous souhaitez récupérer tous les enregistrements d'une table et inclure les données associées d'une autre table si elles existent.

La syntaxe de base pour LEFT JOIN est :

SELECT column1, column2 FROM table1 LEFT JOIN table2 ON table1.column_name = table2.column_name;

Pour récupérer tous les employés et les noms de leurs départements, même si un employé n'a pas de département attribué, exécutez la commande SQL suivante :

SELECT employees.name, departments.name
FROM employees
LEFT JOIN departments ON employees.department_id = departments.id;

Cette commande joint les tables employees et departments en fonction de la colonne department_id dans employees correspondant à la colonne id dans departments. Elle sélectionne le nom de l'employé dans la table employees et le nom du département dans la table departments. Comme il s'agit d'une LEFT JOIN, tous les employés seront listés.

Résultat attendu :

Alice|Sales
Bob|Marketing
Charlie|Sales
David|Engineering
Eve|

Notez qu'Eve est listée, mais le nom du département est vide (NULL) car son department_id est NULL, et il n'y a pas de département correspondant. Ceci démontre comment LEFT JOIN inclut toutes les lignes de la table de gauche (employees) même lorsqu'il n'y a pas de correspondance dans la table de droite (departments).

Joindre plusieurs tables

Dans cette étape, vous apprendrez à joindre plusieurs tables dans SQLite. Joindre plus de deux tables implique de combiner des données provenant de plusieurs tables liées en utilisant plusieurs clauses JOIN.

Tout d'abord, ajoutons une nouvelle table appelée locations pour stocker les emplacements des départements. Exécutez la commande SQL suivante pour créer la table locations :

CREATE TABLE locations (
    id INTEGER PRIMARY KEY,
    department_id INTEGER,
    city TEXT
);

Cette commande crée une table nommée locations avec trois colonnes : id, department_id et city.

Ensuite, insérez des exemples de données dans la table locations :

INSERT INTO locations (department_id, city) VALUES
(1, 'New York'),
(2, 'Los Angeles'),
(3, 'Chicago');

Maintenant, joignons les trois tables pour récupérer les noms des employés, les noms des départements et les emplacements des départements. Exécutez la commande SQL suivante :

SELECT employees.name, departments.name, locations.city
FROM employees
INNER JOIN departments ON employees.department_id = departments.id
INNER JOIN locations ON departments.id = locations.department_id;

Cette requête joint d'abord employees et departments en fonction de employees.department_id = departments.id. Ensuite, elle joint le résultat avec la table locations en fonction de departments.id = locations.department_id. Cela relie les employés à leurs départements, puis à l'emplacement de ces départements.

Résultat attendu :

Alice|Sales|New York
Bob|Marketing|Los Angeles
Charlie|Sales|New York
David|Engineering|Chicago

Cela montre le nom de chaque employé, le nom de son département et la ville où se trouve son département. Eve n'est pas incluse car elle n'a pas de département attribué.

Filtrer les résultats de jointures

Dans cette étape, vous apprendrez à filtrer les résultats des tables jointes en utilisant la clause WHERE dans SQLite. Le filtrage vous permet de récupérer uniquement les lignes qui répondent à des critères spécifiques après l'opération de jointure.

Pour récupérer les noms des employés qui travaillent dans le département des Ventes (Sales), exécutez la commande SQL suivante :

SELECT employees.name
FROM employees
INNER JOIN departments ON employees.department_id = departments.id
WHERE departments.name = 'Sales';

Cette requête joint les tables employees et departments, puis filtre les résultats pour inclure uniquement les employés dont le nom du département est 'Sales'.

Résultat attendu :

Alice
Charlie

Cela montre qu'Alice et Charlie travaillent dans le département des Ventes (Sales).

Maintenant, récupérons les noms des employés qui travaillent dans des départements situés à New York. Exécutez la commande SQL suivante :

SELECT employees.name
FROM employees
INNER JOIN departments ON employees.department_id = departments.id
INNER JOIN locations ON departments.id = locations.department_id
WHERE locations.city = 'New York';

Cette requête joint les trois tables, puis filtre les résultats pour inclure uniquement les employés dont le département est situé à New York.

Résultat attendu :

Alice
Charlie

Encore une fois, Alice et Charlie sont les seuls employés des départements situés à New York.

Résumé

Dans ce labo, vous avez appris à combiner des données provenant de plusieurs tables dans SQLite en utilisant des techniques de jointure de tables. Vous avez étudié INNER JOIN, qui renvoie les lignes lorsqu'il y a une correspondance dans les deux tables, et LEFT JOIN, qui renvoie toutes les lignes de la table de gauche et les lignes correspondantes de la table de droite. Vous avez également appris à joindre plusieurs tables et à filtrer les résultats de jointures en utilisant la clause WHERE. Ces compétences vous permettront de récupérer et de combiner efficacement des données en utilisant SQLite.