Apprendre SQL : introduction et exemples

La syntaxe du langage de programmation SQL se base sur l’algèbre relationnelle et se distingue ainsi de multiples manières des autres langages de programmation. Pour apprendre SQL, disposer de connaissances de cette syntaxe et d’exemples clairs est d’un grand secours.

Les principes de la syntaxe SQL

De manière générale, la syntaxe désigne « l’écriture » d’un langage de programmation. La syntaxe détermine la forme que prennent les constructions de base du code et la manière dont il est possible de relier celles-ci entre elles. Pour lire et écrire du code dans un langage donné, il est absolument essentiel d’en comprendre la syntaxe.

Dans le cadre du langage SQL, les principales constructions syntaxiques sont représentées par les instructions SQL et, le cas échéant, les clauses qu’elles renferment. Bien que ce ne soit pas tout à fait correct d’un point de vue technique, ces constructions sont généralement qualifiées de « commandes SQL ». Nous tenons également à vous présenter les autres constructions syntaxiques qui existent :

Terme Équivalent anglais Explication Exemple
Instruction Statement Ordonne au système de gestion de base de données relationnelle (DBMS) d’exécuter une action ; se termine par un point-virgule. « CREATE TABLE People; »
Clause Clause Modifie une instruction ; peut uniquement apparaître dans une instruction. « WHERE, HAVING »
Expression Expression Retourne une valeur lors de l’évaluation. « 6 * 7 »
Identificateur Identifier Nom d’un objet de la base de données, d’une variable ou d’une procédure ; peut être qualifié ou non. « dbname.tablename / tablename »
Prédicat Predicate Expression évaluée à « TRUE, FALSE » ou « UNKNOWN ». « Age < 42 »
Requête Query Instructions spéciales ; retourne un jeu d’enregistrement des ensembles de données. « SELECT Name FROM People WHERE Age < 42; »
Fonction Function Traite une ou plusieurs valeurs ; génère normalement une nouvelle valeur. « UPPER(‘text’) – Retourne ‘TEXT’»
Commentaire Comment Permet de commenter le code SQL ; est ignoré par le RDBMS. « – Commentaire jusqu’à la fin de la ligne / /Commentaire sur plusieurs lignes le cas échéant/ »
Note

Les commandes SQL, comme SELECT et CREATE TABLE, sont la plupart du temps indiquées en majuscules. Dans la pratique, SQL ne distingue pourtant pas les majuscules des minuscules. Il s’agit uniquement d’une convention largement répandue.

Comment exécuter le code SQL ?

Dans les fichiers texte, le code SQL se présente sous la forme d’un code source. Seul un environnement d’exécution approprié peut alors donner vie à ce code. Le code source est donc lu par un interprète SQL avant d’être transposé en actions du système de gestion de base de données relationnelle (RDBMS). Il existe deux approches prédominantes :

  1. Exécuter le code SQL dans le cadre d’une session interactive

Avec cette approche, le code SQL est saisi ou copié directement dans une fenêtre de texte. Le code SQL est ensuite exécuté et le résultat correspondant s’affiche. Ce code peut être modifié, puis exécuté à nouveau. La manipulation du code et l’affichage des résultats se succédant rapidement, cette approche est tout particulièrement adaptée aux situations d’apprentissage et de création de requêtes complexes.

  1. Exécuter le code SQL sous forme de script

Dans le cadre de cette approche, l’ensemble du fichier source contenant le code SQL est exécuté ligne par ligne. Selon le cas, l’utilisateur ne reçoit un retour qu’une fois l’exécution terminée. Il convient d’utiliser cette approche pour automatiser des processus et enregistrer des sauvegardes de bases de données MySQL avec un dump MySQL.

Interface Description Exemples
Interface de ligne de commande (CLI) Dans cette interface basée sur le texte, le code SQL est saisi et exécuté, puis le résultat apparaît de manière textuelle. mysql, psql, mysqlsh
Interface utilisateur graphique (GUI) Le code SQL est saisi dans une fenêtre de texte et/ou généré en fonction de l’interaction de l’utilisateur ; une fois le code SQL exécuté, le résultat se présente sous forme de tables. phpMyAdmin, MySQL Workbench, HeidiSQL
Interface de programmation (API) Elle permet de communiquer directement avec un système de gestion de base de données relationnelle (RDBMS) ; avant d’être exécuté, le code SQL est intégré en tant que chaîne au code du langage de programmation correspondant, puis les résultats sont mis à disposition sous forme de structures de données qu’il est possible d’utiliser par la suite. PHP Data Objects (PDO), Connector/J (Java), Connector/Python, C API

Créer un exemple de gestion de produits avec SQL

Pour apprendre un langage de programmation, le plus simple est d’écrire et d’exécuter du code soi-même. Nous allons donc créer une mini-base de données et l’utiliser pour exécuter des requêtes. Pour ce faire, nous avons choisi d’utiliser l’interprète SQL en ligne du site Web sql.js. Accédez au site à l’aide du lien et remplacez le code SQL déjà présent par le code proposé dans nos exemples. Exécutez ensuite le code petit à petit pour obtenir les résultats correspondants.

Création d’une base de données SQL : procédure de base

Pour cet exemple, nous allons mettre en place une gestion de produits commerciale pouvant être utilisée par un magasin physique ou une boutique en ligne. Voici les exigences approximatives que nous définissons à cet effet :

  • Il existe différents produits et nous avons un certain nombre de chacun d’eux en stock.
  • Notre clientèle est composée de plusieurs clients.
  • Ceux-ci passent des commandes pouvant contenir plusieurs produits.
  • À chaque fois, nous enregistrons la date de la commande et le nom de la personne l’ayant passée, ainsi que les produits commandés et leur nombre.

Nous commençons par transposer ces exigences en descriptions abstraites, puis en code SQL. Pour ce faire, nous suivons les étapes ci-dessous :

  1. Créer un modèle
  2. Définir son schéma
  3. Insérer les ensembles de données
  4. Définir les requêtes

Créer le modèle des entités et des associations

Pour cette première étape, il convient d’utiliser une feuille de papier ou des outils de modélisation spécifiques. Nous rassemblons des informations sur le système à modéliser et nous utilisons celles-ci pour en abstraire les entités et les associations. Cette étape prend souvent la forme d’un diagramme entité-association.

Quelles sont les différentes entités et quels sont leurs liens ? Les entités sont des catégories d’objets. Dans cet exemple de gestion de produits, les entités sont donc « Produit », « Client » et « Commande ». Il est nécessaire de créer une table pour chaque entité. Étant donné les spécificités du modèle relationnel, il convient également d’ajouter d’autres tables pour modéliser les associations. Il faut de l’expérience pour identifier ces tables et les mettre en œuvre correctement.

L’une des principales questions concerne la manière dont les entités sont reliées entre elles. Pour le savoir, il convient d’étudier les deux directions d’une association et de distinguer le singulier du pluriel. Prenons l’exemple d’une association « propriétaire-voiture » :

  1. « Un propriétaire peut posséder plusieurs voitures. »
  2. « Une voiture ne peut appartenir qu’à un seul propriétaire. »

Trois modèles d’association sont donc possibles entre ces deux entités :

Association Entités De gauche à droite De droite à gauche
Association 1:1 Voiture:Numéro d’immatriculation « Une voiture n’a qu’un numéro d’immatriculation. » « Un numéro d’immatriculation ne correspond qu’à une voiture. »
Association 1:n Propriétaire:Voiture « Un propriétaire peut posséder plusieurs voitures. » « Une voiture ne peut appartenir qu’à un seul propriétaire. »
Association m:n Voiture:Route « Une voiture peut rouler sur plusieurs routes. » « Plusieurs voitures peuvent rouler sur une même route. »

Implémenter les produits

Nous commençons par implémenter la table des produits. Pour ce faire, nous définissons un schéma, insérons des ensembles de données et exécutons quelques requêtes simples à titre de test. Voici le détail de ces différentes étapes.

Définir un schéma

CREATE TABLE est la commande SQL centrale permettant de définir les tables d’une base de données. Elle permet de créer une table avec un nom et de définir les caractéristiques de ses différentes colonnes. Dans le même temps, vous pouvez l’utiliser pour spécifier les différents types de données et, si nécessaire, les restrictions concernant les valeurs à enregistrer :

DROP TABLE IF EXISTS Products;
CREATE TABLE Products ( product_id int, product_name text, stocked int, price int );
sql
Note

Nous utilisons l’instruction DROP TABLE IF EXISTS avant de définir la table. Cela permet de supprimer toute table éventuellement préexistante et d’exécuter plusieurs fois le même code SQL sans que cela ne génère un message d’erreur.

Insérer les ensembles de données

Pour le test, nous allons créer quelques ensembles de données. Pour ce faire, nous avons besoin de la commande SQL INSERT INTO ainsi que de la fonction VALUES afin de remplir les champs :

INSERT INTO Products VALUES (10, 'ABC Product', 74, 1050);
INSERT INTO Products VALUES (20, 'KLM Product', 23, 750);
INSERT INTO Products VALUES (30, 'XYZ Product', 104, 350);
sql

Définir les requêtes

Nous écrivons une requête simple pour vérifier l’état de la table des produits. Nous utilisons la commande SELECT FROM et affichons la table dans son intégralité :

SELECT * FROM Products;
sql

Nous écrivons également une requête un peu plus complexe pour calculer la valeur totale des produits stockés :

SELECT product_name AS 'Name', (stocked * price) AS 'Value' FROM Products;
sql

Implémenter les autres tables

Nous devons ensuite créer les autres tables dont nous avons besoin. Nous allons suivre les mêmes étapes que pour la table de produits. Nous commençons donc par créer la table de clients :

DROP TABLE IF EXISTS Customers;
CREATE TABLE Customers ( customer_id int, customer_name text, contact text );
sql

Nous insérons des ensembles de données pour deux exemples de clients :

INSERT INTO Customers VALUES (100, 'EDC Customer', 'ED@example.com');
INSERT INTO Customers VALUES (200, 'WVU Customer', 'WV@example.com');
sql

Nous affichons la table de clients pour effectuer les vérifications nécessaires :

SELECT * FROM Customers;
sql

Pour l’étape suivante, nous créons la table de commandes :

DROP TABLE IF EXISTS Orders;
CREATE TABLE Orders ( order_id int, customer_id int, order_date text );
sql

Nous insérons trois exemples de commandes. Attention : nous avons choisi comme première valeur de l’ensemble de données un identifiant en tant que clé primaire. En revanche, la deuxième valeur correspond à des identifiants client qui existent déjà en tant que clés étrangères. Nous enregistrons également la date de la commande :

INSERT INTO Orders VALUES (1000, 100, '2022-05-03');
INSERT INTO Orders VALUES (1001, 100, '2022-05-04');
INSERT INTO Orders VALUES (1002, 200, '2022-05-08');
sql

Nous affichons les commandes pour effectuer les vérifications nécessaires :

SELECT * FROM Orders;
sql

Pour finir, il nous faut une table pour indiquer les produits contenus dans une commande et leur nombre. Il s’agit d’une association m:n, car une commande peut concerner plusieurs produits et le même produit peut se retrouver dans différentes commandes. Nous définissons donc une table avec les identifiants des commandes et des produits en tant que clés étrangères :

DROP TABLE IF EXISTS OrderItems;
CREATE TABLE OrderItems ( orderitem_id int, order_id int, product_id int, count int );
sql

Nous insérons alors quelques produits commandés. Nous choisissons donc les identifiants des commandes et des produits de manière à obtenir une commande pour deux produits et une autre avec un seul :

INSERT INTO OrderItems VALUES (10001, 1000, 10, 3);
INSERT INTO OrderItems VALUES (10002, 1000, 20, 2);
INSERT INTO OrderItems VALUES (10003, 1002, 30, 12);
sql

Nous affichons les produits commandés pour effectuer les vérifications nécessaires :

SELECT * FROM OrderItems;
sql

Écrire des requêtes complexes

Si vous avez exécuté tous les extraits de code que nous venons de vous présenter, vous devriez être capable de comprendre la structure de notre base de données test. Nous allons maintenant passer à des requêtes plus complexes afin de mieux vous démontrer la puissance du langage SQL. Commençons donc par écrire une requête regroupant des données issues de tables différentes. Nous utilisons une commande SQL JOIN pour relier entre elles les données de la table de clients et celles de la table de commandes. Il convient ici de nommer certaines colonnes et de spécifier la cohérence de l’identifiant client en tant que condition JOIN. Attention, nous utilisons des identificateurs qualifiés afin d’établir une distinction entre les colonnes des deux tables :

SELECT customers.customer_name as 'Customer', customers.customer_id, orders.order_id, orders.order_date AS 'Date' FROM Customers JOIN Orders ON Orders.customer_id = Customers.customer_id ORDER BY Customers.customer_id;
sql

Pour finir, nous utilisons une commande JOIN différente pour calculer le coût total des produits commandés :

SELECT OrderItems.order_id, OrderItems.orderitem_id AS 'Order Item', Products.product_name AS 'Product', Products.price AS 'Unit Price', OrderItems.count AS 'Count', (OrderItems.count * Products.price) AS 'Total' FROM OrderItems JOIN Products ON OrderItems.product_id = Products.product_id;
sql
Conseil

Si vous souhaitez en savoir plus sur SQL, avez besoin d’aide pour résoudre des problèmes spécifiques avec le langage de la base de données ou cherchez simplement à étendre vos connaissances, consultez nos articles Digital Guide :