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 :

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.

2. 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.

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 :

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 );

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);

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;

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;

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 );

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');

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

SELECT * FROM Customers;

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 );

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');

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

SELECT * FROM Orders;

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 );

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);

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

SELECT * FROM OrderItems;

É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;

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;