Apprendre SQL : in­tro­duc­tion et exemples

La syntaxe du langage de pro­gram­ma­tion SQL se base sur l’algèbre re­la­tion­nelle et se distingue ainsi de multiples manières des autres langages de pro­gram­ma­tion. Pour apprendre SQL, disposer de con­nais­sances 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 pro­gram­ma­tion. La syntaxe détermine la forme que prennent les cons­truc­tions 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 ab­so­lu­ment essentiel d’en com­prendre la syntaxe.

Dans le cadre du langage SQL, les prin­ci­pales cons­truc­tions syn­taxiques sont re­pré­sen­tées par les ins­truc­tions SQL et, le cas échéant, les clauses qu’elles ren­fer­ment. Bien que ce ne soit pas tout à fait correct d’un point de vue technique, ces cons­truc­tions sont gé­né­ra­le­ment qua­li­fiées de « commandes SQL ». Nous tenons également à vous présenter les autres cons­truc­tions syn­taxiques 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 en­vi­ron­ne­ment d’exécution approprié peut alors donner vie à ce code. Le code source est donc lu par un in­ter­prète SQL avant d’être transposé en actions du système de gestion de base de données re­la­tion­nelle (RDBMS). Il existe deux approches pré­do­mi­nantes :

1. Exécuter le code SQL dans le cadre d’une session in­te­rac­tive

Avec cette approche, le code SQL est saisi ou copié di­rec­te­ment dans une fenêtre de texte. Le code SQL est ensuite exécuté et le résultat cor­res­pon­dant s’affiche. Ce code peut être modifié, puis exécuté à nouveau. La ma­ni­pu­la­tion du code et l’affichage des résultats se succédant ra­pi­de­ment, cette approche est tout par­ti­cu­liè­re­ment adaptée aux si­tua­tions d’ap­pren­tis­sage 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’uti­li­sa­teur ne reçoit un retour qu’une fois l’exécution terminée. Il convient d’utiliser cette approche pour au­to­ma­ti­ser des processus et en­re­gis­trer des sau­ve­gardes 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 pro­gram­ma­tion, 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’in­ter­prè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 cor­res­pon­dants.

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 com­mer­ciale pouvant être utilisée par un magasin physique ou une boutique en ligne. Voici les exigences ap­proxi­ma­tives que nous dé­fi­nis­sons à cet effet :

• Il existe dif­fé­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 en­re­gis­trons 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 com­men­çons par trans­po­ser ces exigences en des­crip­tions abs­traites, 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 as­so­cia­tions

Pour cette première étape, il convient d’utiliser une feuille de papier ou des outils de mo­dé­li­sa­tion spé­ci­fiques. Nous ras­sem­blons des in­for­ma­tions sur le système à modéliser et nous utilisons celles-ci pour en abstraire les entités et les as­so­cia­tions. Cette étape prend souvent la forme d’un diagramme entité-as­so­cia­tion.

Quelles sont les dif­fé­rentes entités et quels sont leurs liens ? Les entités sont des ca­té­go­ries d’objets. Dans cet exemple de gestion de produits, les entités sont donc « Produit », « Client » et « Commande ». Il est né­ces­saire de créer une table pour chaque entité. Étant donné les spé­ci­fi­ci­tés du modèle re­la­tion­nel, il convient également d’ajouter d’autres tables pour modéliser les as­so­cia­tions. Il faut de l’ex­pé­rience pour iden­ti­fier ces tables et les mettre en œuvre cor­rec­te­ment.

L’une des prin­ci­pales questions concerne la manière dont les entités sont reliées entre elles. Pour le savoir, il convient d’étudier les deux di­rec­tions d’une as­so­cia­tion et de dis­tin­guer le singulier du pluriel. Prenons l’exemple d’une as­so­cia­tion « pro­prié­taire-voiture » :

1. « Un pro­prié­taire peut posséder plusieurs voitures. »
2. « Une voiture ne peut ap­par­te­nir qu’à un seul pro­prié­taire. »

Trois modèles d’as­so­cia­tion sont donc possibles entre ces deux entités :

Im­plé­men­ter les produits

Nous com­men­çons par im­plé­men­ter la table des produits. Pour ce faire, nous dé­fi­nis­sons 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 dif­fé­rentes étapes.

Définir un schéma

CREATE TABLE est la commande SQL centrale per­met­tant 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 ca­rac­té­ris­tiques de ses dif­fé­rentes colonnes. Dans le même temps, vous pouvez l’utiliser pour spécifier les dif­fé­rents types de données et, si né­ces­saire, les res­tric­tions con­cer­nant les valeurs à en­re­gis­trer :

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 in­té­gra­lité :

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;

Im­plé­men­ter 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 com­men­ç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é­ri­fi­ca­tions né­ces­saires :

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 iden­ti­fiant en tant que clé primaire. En revanche, la deuxième valeur cor­res­pond à des iden­ti­fiants client qui existent déjà en tant que clés étran­gères. Nous en­re­gis­trons é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é­ri­fi­ca­tions né­ces­saires :

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 as­so­cia­tion m:n, car une commande peut concerner plusieurs produits et le même produit peut se retrouver dans dif­fé­rentes commandes. Nous dé­fi­nis­sons donc une table avec les iden­ti­fiants des commandes et des produits en tant que clés étran­gè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 choi­sis­sons donc les iden­ti­fiants 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é­ri­fi­ca­tions né­ces­saires :

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 com­prendre la structure de notre base de données test. Nous allons main­te­nant passer à des requêtes plus complexes afin de mieux vous démontrer la puissance du langage SQL. Com­men­çons donc par écrire une requête re­grou­pant des données issues de tables dif­fé­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’iden­ti­fiant client en tant que condition JOIN. Attention, nous utilisons des iden­ti­fi­ca­teurs qualifiés afin d’établir une dis­tinc­tion 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 dif­fé­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;