Introduction à SQL à l’aide d’exemples

SQL vous permet de créer ou d’interroger des bases de données. Ce langage se retrouve dans le répertoire de base des développeurs Web, des analystes de données et des chercheurs. SQL est toutefois différent des autres langages de programmation. Découvrez avec nous la structure et le fonctionnement de ce langage.

Domaine Internet pas cher

Bien plus qu'un simple domaine !

Personnalisez votre présence en ligne avec un nom de domaine pertinent.

Email
Certificat SSL
Assistance 24/7

Qu’est-ce que le format SQL ?

SQL est l’acronyme de Structured Query Langage, soit « langage de requête structuré ». Créé au milieu des années 1970, SQL est aujourd’hui devenu le langage de programmation standard pour les applications de base de données. En effet, SQL dépasse de loin les requêtes qui lui ont donné son nom : ce langage constitue en réalité l’interface prédominante d’interaction avec les données relationnelles ou encore les systèmes de gestion de base de données relationnelle.

Pour comprendre l’origine du langage SQL, vous devez d’abord savoir qu’il repose sur l’« algèbre relationnelle ». Cette théorie mathématique permet de structurer les données et de calculer les résultats d’une requête. Nombre des spécificités de SQL en tant que langage de programmation proviennent d’ailleurs de cette base mathématique.

SQL en tant qu’interface de contrôle des systèmes de gestion de base de données relationnelle

SQL est utilisé comme une interface lorsqu’il s’agit de communiquer avec un système de gestion de bases de données relationnelle. Le code SQL peut être directement saisi et exécuté par l’homme à partir d’une interface textuelle, mais également intégré à des accès API. Certaines interfaces graphiques sont également capables de traduire les interactions de l’utilisateur en un code SQL. Quel que soit le cas, le code SQL est finalement exécuté par un système de gestion de base de données relationnelle. Celui-ci est constitué de différents éléments :

  1. Un moteur de stockage ou de base de données, pour gérer les données sur le plan technique.
  2. Une ou plusieurs interfaces de programmation API pour assurer le contrôle par programmation du système de gestion de base de données relationnelle et garantir l’accès aux données.
  3. Des interfaces utilisateur (GUI/CLI), pour permettre à l’homme de contrôler le système de gestion de base de données relationnelle et d’accéder aux données.
  4. Une ou plusieurs bases de données à proprement parler, pour organiser les données sur le plan logique.

Un système de gestion de base de données relationnelle comprend plusieurs couches de mémoire organisées de façon hiérarchique, du serveur de la base de données à la valeur enregistrée dans un champ. Les commandes proposées par SQL permettent d’agir sur toutes ces couches. Voici un aperçu de la hiérarchie des différents objets d’un système de gestion de base de données relationnelle :

Objet de système de gestion de base de données relationnelle Contenu
Serveur Bases de données
Base de données Tables
Table Ensembles de données
Ensemble de données Champs
Champ Valeur d’un type donné

SQL est un langage dédié et déclaratif

SQL est différent de la plupart des autres langages de programmation existants. Tout d’abord, il a été créé avant l’avènement d’Internet, mais il s’agit également d’un « langage dédié » (domain-specific language ou DSL en anglais). Il s’oppose en cela au « langage à usage général » (general-purpose language, ou GPL), qui peut être utilisé dans un grand nombre de situations différentes. Le langage à usage général est notamment représenté par C, C++, C#, Java, JavaScript, Python et PHP.

Sur tous les langages utilisés aujourd’hui sur le Web, un seul autre langage dédié existe : CSS. Étonnamment, SQL et CSS sont tous deux des langages de programmation « déclaratifs ». Le programmeur décrit donc le résultat qu’il souhaite obtenir et le système chargé d’exécuter le code veille à la réalisation de cet objectif. Cette méthode s’oppose à celle de la programmation « impérative », plus répandue, qui nécessite de définir explicitement les différentes étapes dans le code pour obtenir les résultats souhaités.

De nombreuses normes ISO/IEC encadrent la portée du langage SQL. Par dérogation à celles-ci, il existe des dialectes pour les différentes implémentations SQL des plus gros fournisseurs. Ainsi, MySQL/MariaDB, PostgreSQL, Oracle SQL et Microsoft SQL Server disposent chacun de commandes ou de variantes de commandes qui leur sont propres.

À quoi sert le langage SQL ?

SQL permet de contrôler tous les aspects d’un système de gestion de base de données relationnelle. De manière générale, SQL se définit comme un langage de programmation, mais sa fonctionnalité s’étend au moins à cinq sous-langages avec leurs propres noms. Chacun de ces cinq sous-langages dispose de commandes SQL portant sur le sous-domaine qu’il représente. Intéressons-nous de plus près à quelques exemples.

Sous-langage SQL Commandes Exemples
Data Definition Language (DDL) Commandes de définition du schéma de la base de données : création, modification et suppression de tables de la base de données ; définition des clés primaires, des clés étrangères et des contraintes CREATE TABLE, DROP TABLE
Data Manipulation Language (DML) Commandes de manipulation des données : modification, insertion et suppression d’ensembles de données INSERT, UPDATE
Data Query Language (DQL) Commandes d’interrogation et de préparation des données SELECT
Data Control Language (DCL) Commandes de gestion des autorisations GRANT, REVOKE
Transaction Control Language (TCL) Commandes de contrôle des transactions COMMIT, ROLLBACK

Découvrir la syntaxe SQL à l’aide d’exemples

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. Avant de nous intéresser de plus près à la syntaxe SQL, commençons par observer la façon dont le code SQL est exécuté.

Conseil

Apprenez facilement à utiliser MySQL grâce à notre tutoriel MySQL.

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éteur SQL avant d’être transposé en actions du système de gestion de base de données relationnelle. 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. Étant donné que la manipulation du code et l’affichage des résultats se succèdent 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 ; 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

Constructions syntaxiques avec le langage SQL

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. Généralement, ces constructions sont toutes qualifiées d’« instructions SQL », même si cela n’est pas tout à fait correct d’un point de vue technique. 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 d’effectuer une action et se termine par un point-virgule CREATE TABLE People;
Clause Clause Modifie une instruction et ne peut apparaître qu’à l’intérieur de celle-ci WHERE, HAVING
Expression Expression Renvoie une valeur lors de l’évaluation 6 * 7
Identificateur Identifier Représente le nom d’un objet de la base de données, d’une variable ou d’une procédure et peut être qualifié ou non dbname.tablename / tablename
Prédicat Predicate Renvoie, en tant qu’expression, une valeur TRUE, FALSE ou UNKNOWN Age < 42
Requête Query Renvoie, en tant qu’instruction spéciale, l’ensemble de données trouvé comme résultat SELECT Name FROM People WHERE Age < 42;
Fonction Function Traite une ou plusieurs valeurs, généralement pour en créer une nouvelle UPPER(’text’) -- Gibt ’TEXT’ zurück
Commentaire Comment Permet de commenter le code SQL, mais n’est pas pris en compte par le système de gestion de base de données relationnelle -- Commentaire jusqu’à la fin de la ligne / /* Commentaire sur plusieurs lignes, le cas échéant */
Note

Les commandes SQL telles que SELECT et CREATE TABLE s’écrivent généralement en majuscules. Dans la pratique, SQL ne fait toutefois aucune distinction entre les majuscules et les minuscules. Il ne s’agit donc là que d’une convention très répandue.

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éteur 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 celle-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ées 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 );
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);

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 donc 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 devons à présent créer la table de commandes :

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

Nous insérons donc 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 que contient 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 allons utiliser 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;

Quels sont les avantages et les inconvénients de SQL ?

Avantages du système SQL

Les principaux avantages de SQL sont avant tout sa grande notoriété et la diffusion à grande échelle de sa technologie. Pour ce qui est des solutions relatives aux bases de données, ce langage est même devenu une référence dans le secteur. Vous ne devriez donc avoir aucun mal à trouver des programmateurs ayant de l’expérience avec SQL. En attribuant correctement les autorisations correspondantes, vous pouvez en outre donner à des analystes l’accès à votre système sans que cela risque de causer des erreurs.

Comme le langage s’inspire de l’algèbre relationnelle, il repose sur une base mathématique solide. Vous pouvez donc conserver vos données de façon optimale, mais vous devez pour cela bien comprendre la technologie et les compétences qui entourent la modélisation. Si vous parvenez à concevoir correctement votre schéma, vous pourrez ensuite tirer de nouveaux résultats de vos données à l’aide de requêtes pertinentes.

Inconvénient du système SQL : un langage d’une grande complexité

Le langage SQL se caractérise principalement par sa grande complexité. Alors qu’un langage de programmation tel que Python peut fonctionner avec moins de 40 commandes, SQL comporte quant à lui des centaines de commandes et autres clauses. Pire encore, la plupart d’entre elles sont spécifiques à l’implémentation.

Pour créer une base de données SQL, il est nécessaire de formuler plusieurs hypothèses sur les données à enregistrer. Celles-ci sont spécifiées dans le schéma de la base de données. Dans le meilleur des cas, elles permettent de veiller à la qualité des données. Toutefois, si votre schéma n’est pas bien conçu, vous risquez de rencontrer des problèmes persistants. Dans certaines circonstances, il peut d’ailleurs s’avérer particulièrement difficile d’apporter des modifications à un schéma que vous utilisez déjà.

Dans le cas de bases de données SQL avec de nombreux accès ou d’importants volumes de données, l’optimisation des performances constitue également un défi non négligeable. Toute répartition géographique est également considérée comme particulièrement ambitieuse, et il est recommandé d’avoir recours à des spécialistes expérimentés et des stratégies élaborées, telles que le partitionnement et le sharding.

Inconvénient du système SQL : différence d’impédance

La programmation orientée objet (OOP) est une méthodologie très répandue. Tous les langages OOP ont un point commun : leurs données sont « encapsulées » sous forme d’objets. Le plus souvent, un programme OOP est constitué de systèmes d’objets liés entre eux. En plus des données, ces objets possèdent également, sous la forme de leurs méthodes, un certain « comportement » transmis par les hiérarchies de classes.

Mais l’approche relationnelle est complètement différente de tout cela, les données étant réparties sur plusieurs tables. Il est impossible de modéliser le comportement des objets concernés. Ainsi, il convient plutôt de faire appel à des requêtes et à des restrictions en ce qui concerne les valeurs des champs. Les spécificités de l’OOP ne peuvent donc pas s’appliquer en 1:1 aux structures des bases de données relationnelles. Il est alors question de « différence d’impédance », par analogie avec un phénomène électrotechnique.

Pour combler le fossé entre l’OOP et les systèmes de gestion de base de données relationnelle basés sur SQL, il convient d’avoir recours au mapping objet-relationnel (object-relational mapping ou ORM). L’ORM agit comme une couche de traduction qui instancie les objets sur demande et leur fournit des données issues de la base de données ou qui écrit les données de ces objets dans la base de données concernée.

Quelles sont les solutions de substitution au langage SQL ?

Les systèmes de gestion de base de données relationnelle, et avec eux SQL, règnent depuis des décennies sur la technologie relative aux bases de données. Aujourd’hui, il existe toutefois de nombreuses solutions de substitution, chacune d’elles étant plus ou moins proche des systèmes de gestion de base de données relationnelle SQL. Découvrez avec nous trois solutions de substitution bien connues :

PostgreSQL

PostgreSQL est un système de gestion de base de données relationnel-objet particulièrement puissant. En plus d’intégrer SQL en tant que langage de requête, il prend directement en charge les concepts fondamentaux de la programmation orientée objet. Il est donc possible d’exploiter les caractéristiques héritées ainsi que les hiérarchies et le comportement des objets sans aucun mapping objet-relationnel. Les types de données composites et définis par l’utilisateur réduisent tout particulièrement la complexité des schémas et autres requêtes.

SQLite

SQLite met à disposition une base de données SQL intégrée sous une licence open source. La base de données SQL ainsi simplifiée est associée en tant que bibliothèque et s’exécute directement dans votre navigateur, ainsi que sur vos appareils mobiles. SQLite se démarque par la faible complexité de son système, tout l’ensemble de données étant disponible sous la forme d’un unique fichier binaire.

NoSQL

Le terme « NoSQL » désigne une famille de systèmes de gestion de base de données non relationnelle. Au lieu de modéliser essentiellement les données sous forme de champs dans des tables, différentes approches peuvent être utilisées. Généralement, les solutions NoSQL sont moins complexes et offrent des avantages intéressants en ce qui concerne l’évolutivité et l’optimisation des performances. De plus, il est normalement plus facile de modifier le schéma en cours de route ou d’enregistrer les données de façon plus flexible. Toutefois, dans certaines circonstances, les garanties en matière de qualité des données peuvent être plus limitées.

Voici quelques-unes des solutions NoSQL les plus populaires :