%% nav-debut : généré par gen_navigation.py, ne pas modifier à la main %% > [!nav] > ↩ [[Code et Développement/Développement d'Applications/Bases De Données : initiation/Bases De Données : initiation|Accueil · Bases De Données : initiation]] > > | [[Code et Développement/Développement d'Applications/Bases De Données : initiation/01_Cours_Introduction aux BDDR\|← Cours_Introduction aux BDDR]] | | > |:---|---:| %% nav-fin %% Accueil : [[Introduction aux Bases de Données Relationnelles]] Premier cours : [[Code et Développement/Développement d'Applications/Bases De Données : initiation/01_Cours_Introduction aux BDDR|Cours_Introduction aux BDDR]] # Introduction au Langage SQL Dans cette partie de cours, vous allez découvrir ce qu'est le langage **SQL**, à quoi il sert et donc les différents types de requêtes. Ensuite, nous nous focaliserons sur les requêtes **sélection** et leurs 6 mots clefs principaux à connaitre. Tout cela vous est expliqué dans la vidéo ci-dessous. <div style="position: relative; width: 100%; "> <iframe width="560" height="315" src="https://www.youtube.com/embed/qZRC_BEO2W0?si=L33IqDZUQXm1B0BK" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe></div> >[!danger] Lire la documentation ci-dessous > >tous les éléments de la vidéo sont repris ci-dessous et complétés. > >De plus, l'ordre d'exécution indiqué dans la vidéo n'est pas exactement la bonne, on vous explique pourquoi dans la rubrique [[## Ordre logique d’exécution d’une requête `SELECT`]] # Introduction au langage SQL > [!info] Définition > Le **SQL** (***Structured Query Language***) est un **langage de requête** standardisé utilisé pour **interroger, manipuler et gérer** les données dans une **base de données relationnelle**. > Il permet aussi bien la **création** des structures (tables, vues) que la **gestion** du contenu (ajout, modification, suppression, consultation). --- ## Les types de requêtes SQL > [!info] Catégories principales > Les instructions SQL se classent en quatre grandes familles selon leur fonction : > > | Catégorie | Type de requête | Rôle principal | > | :-- | :-- | :-- | > | **DDL** (*Data Definition Language*) | `CREATE`, `ALTER`, `DROP` | Définir ou modifier la **structure** de la base (tables, vues, index). | > | **DCL / TCL** (*Data Control / Transaction Control*) | `GRANT`, `COMMIT`, `ROLLBACK` | Gérer les **droits d’accès** et la **cohérence** des transactions. | > | **DML** (*Data Manipulation Language*) | `INSERT`, `UPDATE`, `DELETE` | Manipuler les **données contenues** dans les tables. | > | **DQL** (*Data Query Language*) | `SELECT` | **Interroger** les données pour les afficher ou analyser. | --- ## Les 6 mots-clés d’une requête de sélection > [!info] Syntaxe générale > Une requête SQL de sélection suit une structure logique composée de **six mots-clés**. > Tous ne sont pas obligatoires, mais ***leur ordre doit toujours être respecté*** : > > ```sql > SELECT ... > FROM ... > WHERE ... > GROUP BY ... > HAVING ... > ORDER BY ... > ``` > > | Mot-clé | Rôle | > | :-- | :-- | > | `SELECT` | Définit les **champs**/**colonnes** à afficher. Le contenu de chaque champ sera un champ provenant du `FROM` ou une expression*.| > | `FROM` | Indique la ou les **tables** concernées. | > | `WHERE` | Filtre les **enregistrements**/**lignes** provenant du `FROM` selon une condition logique. | > | `GROUP BY` | opération d'agrégat** qui consiste à regrouper les **enregistrements** provenant du `FROM` (pouvant être filtrés par le `WHERE`) selon une ou plusieurs **champs**. | > | `HAVING` | Filtre les **groupes** (après agrégation**). | > | `ORDER BY` | Trie le résultat selon une ou plusieurs colonnes. | > > \* expression : *l'expression peut être un opération sur un **champ** provenant du `FROM`, une opération entre plusieurs **champs** provenant du `FROM` ou encore une opération d'agrégat**.* > > \* agrégation, opération d'agrégat : *c'est le fait de faire une opération sur un ou plusieurs champs d'un ensemble d'enregistrements. Exemple : **min()** pour avoir la plus petite valeur, **sum()** pour faire la somme des valeurs...* > [!tip] Exemple > ```sql > SELECT service, AVG(salaire) AS moySalaire > FROM employes > WHERE service IS NOT NULL > GROUP BY service > HAVING AVG(salaire) > 3000 > ORDER BY service DESC; > ``` > 👉 Cette requête affiche les **services** dont le salaire moyen dépasse 3000 €, triés par ordre alphabétique. > [!info] Les mots-clés obligatoires > Une requête SQL de sélection repose sur **deux mots-clés essentiels** : **`SELECT`** et **`FROM`**. > Sans eux, la requête ne peut pas être exécutée correctement. > > | Mot-clé | Pourquoi il est obligatoire | > | :-- | :-- | > | `SELECT` | C’est le **cœur de la requête** : sans lui, le SGBD ne sait pas quelles données afficher. | > | `FROM` | Sans ce mot-clé, le SGBD ne sait pas **où aller chercher** les informations demandées. | > > Tous les autres mots-clés (`WHERE`, `GROUP BY`, `HAVING`, `ORDER BY`) sont **optionnels**, car ils servent à **affiner**, **regrouper** ou **trier** les résultats. > > 👉 Exemple minimal : > ```sql > SELECT nom, prenom > FROM employes; > ``` > Cette requête affiche les colonnes **nom** et **prenom** de la table **employes**. --- > [!tip] Le point-virgule ( `;` ) dans une requête SQL > Le **point-virgule** marque **la fin d’une instruction SQL**. > Il indique au SGBD que la requête est complète et peut être exécutée. > > C'est important car : > - Il permet de **séparer plusieurs requêtes** exécutées dans un même script (ex. : `CREATE`, `INSERT`, `SELECT`…). > - Certains outils ou SGBD (comme **PostgreSQL** ou **Oracle**) l’exigent systématiquement. > - Dans d’autres (comme **MySQL**), il reste **fortement recommandé** pour assurer la **compatibilité** et éviter les erreurs d’exécution. > > 👉 En pratique : toujours **terminer une requête par `;`**, même si elle est seule. ## Ordre logique d’exécution d’une requête `SELECT` Une requête SQL **ne s’exécute pas** dans l’ordre où elle est **écrite**, mais selon un **ordre logique** défini par le SGBD. Cet ordre détermine **comment les données sont filtrées, regroupées et triées** avant d’être affichées. > [!info] Comprendre l’ordre d’exécution > | Étape | Mot-clé | Rôle | > | :--: | :-- | :-- | > | 1️⃣ | `FROM` | Le SGBD identifie les **tables** ou **vues** utilisées et crée une première combinaison de données (jointures, alias…). | > | 2️⃣ | `WHERE` | Les **lignes non conformes** aux conditions sont **exclues**. | > | 3️⃣ | `GROUP BY` | Les lignes restantes sont **regroupées** selon les colonnes indiquées. | > | 4️⃣ | `HAVING` | Les **groupes** sont filtrés selon des conditions sur les valeurs agrégées. | > | 5️⃣ | `SELECT` | Le SGBD détermine **quelles colonnes** ou expressions afficher. | > | 6️⃣ | `ORDER BY` | Le résultat final est **trié** selon les critères définis. | > > 👉 Même si le `SELECT` est écrit en premier, il n’est **exécuté qu’en cinquième** : le moteur SQL commence toujours par **rassembler et filtrer les données** avant de les afficher. > [!danger] Y a-t-il une erreur dans la vidéo ? > Dans la vidéo, il est indiqué que la clause **`ORDER BY`** est exécutée **avant** le `SELECT`. > Ce n’est **pas totalement faux**, mais il s’agit d’une **simplification pédagogique**. > > Les auteurs ont volontairement présenté cet ordre pour **rendre la logique plus intuitive** (on trie avant d’afficher) afin de ne pas aborder une subtilité importante : le **renommage (`AS`)** des colonnes. ## Résultat d’une requête de sélection Le résultat d’une requête `SELECT` s’affiche sous forme d’un **tableau temporaire** appelé **table éphémère** ou **table virtuelle**. Il contient : - les **colonnes** spécifiées dans le `SELECT`, - les **lignes** répondant aux critères du `WHERE` ou du `HAVING`, Ce tableau n’est **pas stocké** dans la base : il est **calculé à la demande** et disparaît après l’exécution de la requête. > [!important] Une requête dans une requête ! > Le **résultat d’une requête `SELECT`** est une **table temporaire**. Elle possède des **lignes** et des **colonnes**, comme toute autre table de la base. > > Cela signifie qu’une requête peut être **réutilisée comme source** dans une autre requête en tant que **sous-requête** (imbriquée dans le `FROM`, le `WHERE` ou le `SELECT`). > > Exemple : > ```sql > SELECT service, AVG(salaire) AS salaire_moyen > FROM ( > SELECT service, salaire > FROM employes > WHERE actif = TRUE > ) actifs > GROUP BY service; > ``` > Ici, la première requête (`SELECT ... FROM employes`) produit une **table intermédiaire** nommée `actifs`, utilisée ensuite par la requête principale. l %% nav-debut : généré par gen_navigation.py, ne pas modifier à la main %% > [!nav] > ↩ [[Code et Développement/Développement d'Applications/Bases De Données : initiation/Bases De Données : initiation|Accueil · Bases De Données : initiation]] > > | [[Code et Développement/Développement d'Applications/Bases De Données : initiation/01_Cours_Introduction aux BDDR\|← Cours_Introduction aux BDDR]] | | > |:---|---:| %% nav-fin %%