Bases de Données Et SQL

ÉCOLE SUPÉRIEURE DE GESTION
ET D’ADMINISTRATION DES ENTREPRISES

Agrément définitif par Arrêté n°4677/MES/CAB du 05 Juillet 2017
Accréditée par le Conseil Africain et Malgache pour l’Enseignement Supérieur (CAMES)
BP : 2339 – Brazzaville – CONGO
E-mail : esgae@esgae.org Site web : www.esgae.org
Département Licence
BASES DE DONNÉES ET SQL
Parcours
Licence 1 – Programmation
Enseignants
Equipe pédagogique
BASES DE DONNEES ET SQL
Table des matières

Chapitre 1 : Introduction aux base de données .......................................................................3
Section 1 : qu’est-ce qu’une base de données et un serveur de base de données ...............3
Section 2 : Lire un modèle relationnel .................................................................................3
Section 3 : Composition d’une table ...................................................................................3
Section 4 : Clé primaire et unicité .......................................................................................4
Section 5 : Notion d’intégrité référentielle ..........................................................................4
Section 6 : Principaux SGBD ................................................................................................4
Section 7 : Exercice .............................................................................................................5
Chapitre 2 : Présentation du langage SQL ...............................................................................8
Section 1 : Langage SQL ......................................................................................................8
Section 2 : Types d’instructions SQL, DDL, DML, DCL...........................................................8
Section 3 : Les éléments de la syntaxe SQL .........................................................................9
Section 4 : Traduction de l’algèbre relationnel ....................................................................9
CHAPITRE 3 : MANIPULATION DE DONNEES .........................................................................13
Section 1 : INSERTION (INSERT).........................................................................................13
Section 2 : Modification (UPDATE) ....................................................................................13
Section 3 : Suppression (DELETE/TRUNCATE) ....................................................................14
Section 4 : Clause RETURNING/OUTPUT ...........................................................................16
Section 5 : Exercice ...........................................................................................................16
Chapitre 4 : Extraction des données d’une table ...................................................................17
Section 1 : Qu’est-ce qu’une requête d’extraction ............................................................17
Section 2 : Lire les valeurs à retourner ..............................................................................17
Section 3 : La clause WHERE pour filtrer les données ........................................................18
Section 4 : L’absence de valeur (marqueur NULL) .............................................................19
Section 5 : Retourner les lignes sans doublon (DISTINCT) ..................................................19
Section 6 : Operateur de restriction ..................................................................................20
CHAPITRE 5 : INTERROGATION DES DONNEES DE PLUSIEURS TABLES ...................................22
Section 1 : Principe de jointure .........................................................................................22
Section 2 : Jointure interne et jointure externe .................................................................22
Section 3 : La jointure Naturelle ........................................................................................29
Section 4 : Operateurs ensemblistes (UNION, INTERSECT,…..) ..........................................30
P a g e 1 | 46

CHAPITRE 6 : ORDONNANCEMENT ET STATISTIQUES ............................................................36
Section 1 : Trouver les valeurs agrégées (MIN, MAX, AVG, SUM,….)..................................36
Section 2 : Calculer les agrégats relatifs avec GROUP BY ...................................................36
Section 3 : Filtrer les valeurs agrégées avec HAVING .........................................................37
CHAPITRE 7 : PRESENTATION ET TRI DE DONNEES ................................................................39
Section 1 : Présenter les données des colonnes avec des alias ..........................................39
Section 2 : effectuer les choix avec l’opérateur CASE ........................................................39
Section 3 : Trier les données avec ORDER BY ....................................................................40
CHAPITRE 8 : UTILISATION DES SOUS REQUETES ..................................................................43
Section 1 : Qu’est-ce qu’une sous-requête ? .....................................................................43
Section 2 : Les différents typologies de résultats...............................................................43
Section 3 : Sous-requêtes liste et opérateur IN, ANY/SOME et All .....................................44
Section 4 : sous requêtes corrélées ...................................................................................45
P a g e 2 | 46
CHAPITRE 1 : INTRODUCTION AUX BASE DE DONNEES

Section 1 : qu’est-ce qu’une base de données et un serveur de base de données
Une base de données informatique est un ensemble de données qui ont été stockées sur un
support informatique, et organisées et structurées de manière à pouvoir facilement consulter
et modifier leur contenu.
Un serveur de base de données sert à stocker, à extraire et à gérer les données dans une base
de données. Il permet également de gérer la mise à jour des données. Il donne un accès
simultané à cette base à plusieurs utilisateurs.
Section 2 : Lire un modèle relationnel

Le modèle relationnel est une manière de modéliser les relations existantes entre plusieurs
informations, et de les ordonner entre elles. Cette modélisation qui repose sur des principes
mathématiques mis en avant par E.F. Codd est souvent retranscrite physiquement dans une
base de données.
Dans ce modèle, les données sont représentées par des tables, sans préjuger de la façon dont
les informations sont stockées dans la machine. Les tables constituent donc la structure
logique du modèle relationnel. Au niveau physique, le système est libre d'utiliser n'importe
quelle technique de stockage (fichiers séquentiels, indexage, adressage dispersé, séries de
pointeurs, compression…) dès lors qu'il est possible de relier ces structures à des tables au
niveau logique.
Section 3 : Composition d’une table

Dans une base nous avons donc des tables, et dans ces tables, on a des colonnes. Dans ces
tables, vous introduisez vos données. Chaque donnée introduite le sera sous forme de ligne
dans une table, définissant la valeur de chaque colonne pour cette donnée.
Numéro Nom Prénom E-mail

1 Moukana Christ moukanachris@yahoo.fr
2 Batchi Debora Batchi_debo@yahoo.fr
3 Goma Juste jgoma@gmail.com
4 Kaba Claude K_claude@gamil.com
Lorsque nous allons créer notre table, il nous faudra choisir le type de données le plus adapté
à chaque champ ou colonne et aux données qu'il va contenir. A défaut cela risque de nous
poser des problèmes de performances, voire d'enregistrement de données (on ne pourra pas,
par exemple, stocker une chaîne de caractères dans un champ qui attend des nombres) On ne
pourra pas non plus utiliser une fonction de date sur un champ qui n'est pas de type DATE ou
DATETIME.
 INT : nombre entier

 DECIMAL : nombre décimal. On doit indiquer sa taille à l'aide de deux arguments : le
nombre total de chiffres, et le nombre après la virgule. Ex : DECIMAL (5,2)
P a g e 3 | 46
 CHAR : texte de moins de 255 caractères. Sa taille, passée en argument, sera fixe,
quelle que soit la valeur du texte. Ainsi un CHAR (100) prendra toujours 100 octets. A
utiliser donc quand on a du contenu de taille fixe.
 VARCHAR : texte de moins de 255 caractères. A la différence de CHAR, la taille passée
en argument sera sa taille maximum et il n'occupera que le nombre d'octets
correspondant à la longueur du contenu. Souvent on trouve des champs de type
VARCHAR (255) car on sait que le texte sera inférieur ou égal à 255 caractères mais on
ne connaît pas sa longueur. Toutefois si vous savez qu'il ne fera que 100 caractères
maximum, VARCHAR (100) suffit. La taille indiquée en argument correspond à l'espace
réservé en base de données, il convient donc de le définir le plus précisément possible
dans un souci de performances.
 TEXT : texte de 216 octets maximum
 LONGTEXT : texte de 232 octets maximum
 DATE : date au format AAAA-MM-JJ
 DATETIME : date et heure au format AAAA-MM-JJ HH:MM:SS
 BOOLEAN : booléen. Sera en réalité transformé par MySQL en TINYINT qui prendra
comme valeur 0 ou 1.
Section 4 : Clé primaire et unicité

Une table dans une base de donnée ne contiendra qu’une seule clé primaire. Une clé
primaire est la donnée qui permet d'identifier de manière unique un enregistrement dans une
table. Elle peut être est formée d'un ou plusieurs champs(colonne) d'une base de données qui
identifient de manière unique un enregistrement dans une table.
Section 5 : Notion d’intégrité référentielle

En informatique, et plus particulièrement dans les bases de données relationnelles, l´intégrité
référentielle est une situation dans laquelle pour chaque information d'une table A qui fait
référence à une information d'une table B, l'information référencée existe dans la table B.
L'intégrité référentielle (RI) est un concept de base de données relationnelle, qui stipule que
les relations de table doivent toujours être cohérentes. En d'autres termes, tout champ de clé
étrangère doit correspondre à la clé primaire référencée par la clé étrangère. Ainsi, toute
modification du champ de clé primaire doit être appliquée à toutes les clés étrangères, ou pas
du tout. La même restriction s'applique également aux clés étrangères en ce sens que toutes
les mises à jour (mais pas nécessairement les suppressions) doivent être propagées à la clé
parent principale.
Section 6 : Principaux SGBD

Un Système de Gestion de Base de Données (SGBD) est un logiciel (ou un ensemble de
logiciels) permettant de manipuler les données d’une base de données. Manipuler, c’est-à-
dire sélectionner et afficher des informations tirées de cette base, modifier des données, en
ajouter ou en supprimer (ce groupe de quatre opérations étant souvent appelé “CRUD”, pour
Create, Read, Update, Delete). MySQL est un système de gestion de bases de données.
P a g e 4 | 46
Il en existe plusieurs parmi lesquels :

 MySQL
 Oracle
 PostgreSQL
 Access
 HFSQL
 SQL SERVER
 Etc
Section 7 : Exercice
Pour traduire un schéma du modèle entités-associations vers le modèle relationnel, on peut
appliquer les règles suivantes :
1. Chaque type entité donne naissance à une relation. Chaque attribut de ce type
entité devient un attribut de la relation. L'identifiant est conservé en tant que clé de la
relation.
2. Chaque type association dont aucune patte n'a pour cardinalité maximale 1 donne
naissance à une relation. Chaque attribut de ce type association devient un attribut de
la relation. L'identifiant, s'il est précisé, est conservé en tant que clé de la relation,
sinon cette clé est formée par la concaténation des identifiants des types entité qui
interviennent dans le type association.
3. Un type association dont au moins une patte a une cardinalité maximale à 1 (ce type
association devrait être binaire et n'a généralement pas d'attribut) ne devient pas une
relation. Il décrit en effet une dépendance fonctionnelle (cf. section 3.2). La relation
correspondant au type entité dont la patte vers le type association a une cardinalité
maximale valant 1, se voit simplement ajouter comme attribut (et donc comme clé
étrangère) l'identifiant de l'autre type entité.
 Cas particulier d'un type association du type 1 vers 1
P a g e 5 | 46
Toutes les cardinalités maximales du type association Etre sont de 1. L'application des règles
de passage du modèle entités-associations au modèle relationnel énoncées ci-dessus nous
donnerait :
 Citoyen(Num-Citoyen, Nom, Prénom, Adresse) ;

 Candidat(Num-Citoyen, Parti).
 Cas particulier d'un type entité sans attribut autre que sa clé
Lorsqu'un type entité ne possède pas d'attribut en dehors de sa clé, il ne faut pas
nécessairement en faire une relation.
Par exemple, le type entité Date de la figure ne doit pas se traduire par une relation. Le
schéma relationnel adéquat correspondant au modèle entités-associations de la figure est
donc :
 Exemplaire(Num-Exemplaire, date-achat) ;
 Personne(Num-Personne, nom, prénom, adresse) ;
 Emprunter(Num-Exemplaire, Num-Personne, Date, date-retour).
P a g e 6 | 46
 Exemple complet
Comme exemple d'application, voici les relations déduites du schéma entités-associations de

la figure :
 Patient (Num-Patient, Nom-Patient, Num-Mutuelle) ;

 Mutuelle (Num-Mutuelle, Nom-Mutuelle) ;
 Médecin (Num-Médecin, Nom-Médecin, Prénom-Médecin) ;
 Affection (Num-Affection, Nom-Affection) ;
 Hospitaliser (Num-Patient, Num-Affection, Num-Médecin, Date-Entrée, Chambre, Durée-
Hospitalisation).
P a g e 7 | 46
CHAPITRE 2 : PRESENTATION DU LANGAGE SQL

Section 1 : Langage SQL
SQL est un langage informatique normalisé servant à exploiter des bases de données
relationnelles. La partie langage de manipulation des données de SQL permet de rechercher,
d'ajouter, de modifier ou de supprimer des données dans les bases de données relationnelles.
Le langage SQL (Structured Query Language) peut être considéré comme le langage d'accès
normalisé aux bases de données. Il est aujourd'hui supporté par la plupart des produits
commerciaux que ce soit par les systèmes de gestion de bases de données micro tel
que Access ou par les produits plus professionnels tels qu’Oracle. Il a fait l'objet de plusieurs
normes ANSI/ISO dont la plus répandue aujourd'hui est la norme SQL2 qui a été définie en
1992.
Le succès du langage SQL est dû essentiellement à sa simplicité et au fait qu'il s'appuie sur le
schéma conceptuel pour énoncer des requêtes en laissant le SGBD responsable de la stratégie
d'exécution. Le langage SQL propose un langage de requêtes ensembliste et assertionnel.
Néanmoins, le langage SQL ne possède pas la puissance d'un langage de programmation :
entrées/sorties, instructions conditionnelles, boucles et affectations. Pour certains
traitements il est donc nécessaire de coupler le langage SQL avec un langage de
programmation plus complet.
De manière synthétique, on peut dire que SQL est un langage relationnel, il manipule donc
des tables (i.e. des relations, c'est-à-dire des ensembles) par l'intermédiaire de requêtes qui
produisent également des tables.
Section 2 : Types d’instructions SQL, DDL, DML, DCL

Les instructions SQL sont regroupées en catégories en fonction de leur utilité et des entités
manipulées. Nous pouvons distinguer cinq catégories, qui permettent :
 La définition des éléments d'une base de données (tables, colonnes, clés, index,
contraintes…),
 La manipulation des données (insertion, suppression, modification, extraction…),
 La gestion des droits d'accès aux données (acquisition et révocation des droits),
i. Langage de définition de données
Le langage de définition de données (LDD, ou Data Définition Language, soit DDL en anglais)
est un langage orienté au niveau de la structure de la base de données. Le LDD permet de
créer, modifier, supprimer des objets. Il permet également de définir le domaine des données
(nombre, chaîne de caractères, date, booléen…) et d'ajouter des contraintes de valeur sur les
données. Il permet enfin d'autoriser ou d'interdire l'accès aux données et d'activer ou de
désactiver l'audit pour un utilisateur donné.
Les instructions du LDD sont : CREATE, ALTER, DROP, AUDIT, NOAUDIT, ANALYZE, RENAME,
TRUNCATE.
P a g e 8 | 46
ii. Langage de manipulation de données
Le langage de manipulation de données (LMD, ou Data Manipulation Language, soit DML en

anglais) est l'ensemble des commandes concernant la manipulation des données dans une
base de données. Le LMD permet l'ajout, la suppression et la modification de lignes, la
visualisation du contenu des tables et leur verrouillage.
Les instructions du LMD sont : INSERT, UPDATE, DELETE, SELECT, EXPLAIN, PLAN, LOCK TABLE.
Ces éléments doivent être validés par une transaction pour qu'ils soient pris en compte.
iii. Langage de protections d'accès
Le langage de protections d'accès (ou Data Control Language, soit DCL en anglais) s'occupe de
gérer les droits d'accès aux tables.
Les instructions du DCL sont : GRANT, REVOKE.
Section 3 : Les éléments de la syntaxe SQL

Cette section sera implémentée dans les cas pratiques
Section 4 : Traduction de l’algèbre relationnel

On appelle algèbre relationnelle un ensemble d'opérations simples sur des tables
relationnelles, à partir desquelles des opérations plus complexes sont définies par
composition. Ils définissent donc un petit langage de manipulation de données.
L'élément fondamental du modèle de base de données relationnelle est la table relationnelle.
Une table relationnelle est une représentation en extension d'une relation définie sur un
certain domaine.
Cette méthode consiste essentiellement à créer ou à recréer de nouvelles relations à partir de
relations existantes. Il existe 2 types d'opérateurs algébriques :
 Opérateurs de base ou primitifs.
 Opérateurs non essentiels ou dérivés.
Ensemble d’opérateurs s’appliquant sur l’ensemble des lignes (ou tuples) d’une (ou plusieurs)
table(s). Le résultat d’une opération (ou d’une requête) est une nouvelle table qui est
exploitable à son tour par une nouvelle opération
a. UNION
P a g e 9 | 46
L'union de deux relations sur le même schéma est la relation sur ce schéma contenant
exactement l'union des enregistrements de ces deux relations.
b. INTERSECTION
L'intersection de deux relations sur le même schéma est la relation sur ce schéma contenant
exactement les enregistrements qui apparaissent dans les deux relations.
P a g e 10 | 46
c. PRODUIT CARTESIEN
Avec le produit cartésien de deux relations, on recopie chaque tuple de la première relation
pour chacun des tuples de la deuxième
d. SELECTION
La sélection (ou restriction) consiste à ne retenir que les enregistrements vérifiant une
condition donnée. Dans l'exemple plus bas, on ne garde que les touristes dont la ville est Paris.
 Données : Une relation R et une formule F formée d'une combinaison de
comparaisons et de connecteurs logiques.
 Résultat :
 Equivalent SQL : WHERE
e. PROJECTION :
La projection permet de ne garder que certains attributs. Dans l'exemple ci-dessous, on ne

garde que les attributs NomT et Ville de la relation Touristes.
P a g e 11 | 46
f. JOINTURE
P a g e 12 | 46
CHAPITRE 3 : MANIPULATION DE DONNEES

Section 1 : INSERTION (INSERT)
L’insertion de données dans une table s’effectue à l’aide de la commande INSERT INTO. Cette
commande permet au choix d’inclure une seule ligne à la base existante ou plusieurs lignes
d’un
coup.
la syntaxe qui suit est très similaire, excepté qu’il faut indiquer le nom des colonnes avant «
VALUES ». La syntaxe est la suivante :
Il est possible d’ajouter plusieurs lignes à un tableau avec une seule requête. Pour ce faire, il
convient d’utiliser la syntaxe suivante :
Section 2 : Modification (UPDATE)

La commande UPDATE permet d’effectuer des modifications sur des lignes existantes. Très
souvent cette commande est utilisée avec WHERE pour spécifier sur quelles lignes doivent
porter la ou les modifications.
Sa syntaxe est la suivante :
Cette syntaxe permet d’attribuer une nouvelle valeur à la colonne nom_colonne_1 pour les
lignes qui respectent la condition stipulée avec WHERE. Il est aussi possible d’attribuer la
même valeur à la colonne nom_colonne_1 pour toutes les lignes d’une table si la condition
WHERE n’était pas utilisée.
P a g e 13 | 46
A noter, pour spécifier en une seule fois plusieurs modification, il faut séparer les attributions
de valeur par des virgules. Ainsi la syntaxe deviendrait la suivante :
EXEMPLE :
Imaginons une table « client » qui présente les coordonnées de clients.
Pour modifier l’adresse du client Pierre, il est possible d’utiliser la requête suivante :
RESULTAT :
Section 3 : Suppression (DELETE/TRUNCATE)

La commande DELETE en SQL permet de supprimer des lignes dans une table. En utilisant cette
commande associé à WHERE il est possible de sélectionner les lignes concernées qui seront
supprimées.
NB : Avant d’essayer de supprimer des lignes, il est recommandé d’effectuer une sauvegarde
de la base de données, ou tout du moins de la table concernée par la suppression. Ainsi, s’il y
a une mauvaise manipulation il est toujours possible de restaurer les données.
P a g e 14 | 46
La syntaxe est la suivante :
NB : s’il n’y a pas de condition WHERE alors toutes les lignes seront supprimées et la table
sera alors vide.
EXEMPLE :
Imaginons une table « utilisateur » qui contient des informations sur les utilisateurs d’une
application.
Si l’on souhaite supprimer les utilisateurs qui se sont inscrit avant le « 10/04/2012″, il va falloir
effectuer la requête suivante :
La requête permettra alors de supprimer les utilisateurs « Daniel » et « Constantin ». La table

contiendra alors les données suivantes :
En SQL, la commande TRUNCATE permet de supprimer toutes les données d’une table sans
supprimer la table en elle-même. En d’autres mots, cela permet de purger la table. Cette
instruction diffère de la commande DROP qui a pour but de supprimer les données ainsi que
la table qui les contient.
NB : l’instruction TRUNCATE est semblable à l’instruction DELETE sans utilisation de WHERE.
Parmi les petite différences TRUNCATE est toutefois plus rapide et utilise moins de ressource.
Ces gains en performance se justifie notamment parce que la requête n’indiquera pas le
nombre d’enregistrement supprimés et qu’il n’y aura pas d’enregistrement des modifications
dans le journal.
P a g e 15 | 46
Voici sa syntaxe :
EXEMPLE :
Pour montrer un exemple concret de l’utilisation de cette commande, nous pouvons imaginez
un système informatique contenant la liste des fournitures d’une entreprise. Ces données
seraient tout simplement stockées dans une table « fourniture ».
Il est possible de supprimer toutes les données de cette table en utilisant la requête suivante :
Une fois la requête exécutée, la table ne contiendra plus aucun enregistrement. En d’autres
mots, toutes les lignes du tableau présenté ci-dessus auront été supprimées.
Section 4 : Clause RETURNING/OUTPUT

Parfois, il est intéressant d'obtenir des données de lignes modifiées pendant qu'elles sont
manipulées.
Les commandes INSERT, UPDATE et DELETE ont toutes une clause RETURNING optionnelle
qui le permet. L'utilisation de la clause RETURNING évite l'exécution d'une requête
supplémentaire pour coller les données, et est particulièrement intéressante quand il serait
difficile d'identifier autrement les lignes modifiées.
Le contenu autorisé d'une clause RETURNING est identique à celui de la liste de sortie d'une
commande SELECT. Elle peut contenir les noms des colonnes de la table cible ou des
expressions utilisant ces colonnes. Un raccourci habituel est RETURNING *, qui sélectionne
toutes les colonnes de la table cible, dans l'ordre de définition.
P a g e 16 | 46
CHAPITRE 4 : EXTRACTION DES DONNEES D’UNE TABLE

Section 1 : Qu’est-ce qu’une requête d’extraction
Une requête d'extraction vous permet de récupérer les détails des cas ou des données de
structure sous-jacents, en envoyant une requête au modèle d'exploration de données.
L'extraction est utile si vous souhaitez consulter les cas utilisés pour l'apprentissage du
modèle, par opposition à ceux utilisés pour tester le modèle, ou si vous souhaitez consulter
des détails supplémentaires à partir des données de cas.
Section 2 : Lire les valeurs à retourner

L’utilisation la plus courante de SQL consiste à lire des données issues de la base de données.
Cela s’effectue grâce à la commande SELECT, qui retourne des enregistrements dans un
tableau de résultat. Cette commande peut sélectionner une ou plusieurs colonnes d’une table.
L’utilisation basique de cette commande s’effectue de la manière suivante :
Cette requête va sélectionner (SELECT) le champ « nom_du_champ » provenant (FROM) du

tableau appelé « nom_du_tableau ».
Exemple :
Imaginons une base de données appelée « client » qui contient des informations sur les clients
d’une entreprise.
Si l’on veut avoir la liste de toutes les villes des clients, il suffit d’effectuer la requête suivante
:
P a g e 17 | 46
Le résultat serait :
Section 3 : La clause WHERE pour filtrer les données

La commande WHERE dans une requête SQL permet d’extraire les lignes d’une base de
données qui respectent une condition. Cela permet d’obtenir uniquement les informations
désirées.
La commande WHERE s’utilise en complément à une requête utilisant SELECT. La façon la plus
simple de l’utiliser est la suivante :
EXEMPLE :
Imaginons une base de données appelée « client » qui contient le nom des clients, le nombre
de commandes qu’ils ont effectués et leur ville :
Pour obtenir seulement la liste des clients qui habitent à Paris, il faut effectuer la requête
suivante :
P a g e 18 | 46
Le résultat serait :
NB :
 Dans notre cas tout est en minuscule donc il n’y a pas eu de problème. Cependant, si
une
table est sensible à la casse, il faut faire attention aux majuscules et minuscules
 Il existe plusieurs opérateurs de comparaisons. La liste ci-jointe présente quelques-uns
des
opérateurs les plus couramment utilisés.
Section 4 : L’absence de valeur (marqueur NULL)

Les marqueurs NULL sont utilisés pour indiquer que les champs ou la colonne ne contient
aucune donnés. Dans l’implémentation des bases de données on utilise le NULL
Section 5 : Retourner les lignes sans doublon (DISTINCT)

L’utilisation de la commande SELECT en SQL permet de lire toutes les données d’une ou
plusieurs colonnes. Cette commande peut potentiellement afficher des lignes en doubles.
Pour éviter des redondances dans les résultats il faut simplement ajouter DISTINCT après le
mot SELECT.
L’utilisation basique de cette commande s’effectue de la manière suivante :
P a g e 19 | 46
Cette requête sélectionne le champ « ma_colonne » de la table « nom_du_tableau » en

évitant de retourner des doublons.
Prenons le cas concret d’une table « client » qui contient des noms et prénoms :
En utilisant seulement SELECT tous les noms sont retournés, or la table contient plusieurs fois
le même prénom (cf. Pierre). Pour sélectionner uniquement les prénoms uniques il faut utiliser
la requête suivante :
Section 6 : Operateur de restriction

1. BETWEEN : L’opérateur BETWEEN est utilisé dans une requête SQL pour sélectionner
un intervalle de données dans une requête utilisant WHERE. L’intervalle peut être
constitué de chaînes de caractères, de nombres ou de dates. L’exemple le plus concret
consiste par exemple à récupérer uniquement les enregistrements entre 2 dates
définies. Sa syntaxe est la suivante :
2. IN : L’opérateur logique IN dans SQL s’utilise avec la commande WHERE pour vérifier
si une colonne est égale à une des valeurs comprise dans set de valeurs déterminés.
C’est une méthode simple pour vérifier si une colonne est égale à une valeur OU une
autre valeur OU une autre valeur et ainsi de suite, sans avoir à utiliser de multiple fois
l’opérateur OR. Sa syntaxe est la suivante :
P a g e 20 | 46
3. LIKE : L’opérateur LIKE est utilisé dans la clause WHERE des requêtes SQL. Ce mot-clé
permet d’effectuer une recherche sur un modèle particulier. Il est par exemple
possible de rechercher les enregistrements dont la valeur d’une colonne commence
par telle ou telle lettre. Les modèles de recherches sont multiple. Sa syntaxe est la
suivante :
Dans cet exemple le « modèle » n’a pas été défini, mais il ressemble très généralement à l’un
des exemples suivants :
 LIKE ‘%a’ : le caractère « % » est un caractère joker qui remplace tous les autres
caractères. Ainsi, ce modèle permet de rechercher toutes les chaines de caractère qui
se termine par un « a ».
 LIKE ‘a%’ : ce modèle permet de rechercher toutes les lignes de « colonne » qui
commence
par un « a ».
 LIKE ‘%a%’ : ce modèle est utilisé pour rechercher tous les enregistrements qui utilisent
le caractère « a ».
 LIKE ‘pa%on’ : ce modèle permet de rechercher les chaines qui commence par « pa »
et qui se terminent par « on », comme « pantalon » ou « pardon ».
 LIKE ‘a_c’ : peu utilisé, le caractère « _ » (underscore) peut être remplacé par n’importe
quel caractère, mais un seul caractère uniquement (alors que le symbole pourcentage
« % » peut être remplacé par un nombre incalculable de caractères . Ainsi, ce modèle
permet de retourner les lignes « aac », « abc » ou même « azc ».
P a g e 21 | 46
CHAPITRE 5 : INTERROGATION DES DONNEES DE PLUSIEURS TABLES

Section 1 : Principe de jointure
Les jointures en SQL permettent d’associer plusieurs tables dans une même requête. Cela
permet d’exploiter la puissance des bases de données relationnelles pour obtenir des résultats
qui combinent les données de plusieurs tables de manière efficace.
En général, les jointures consistent à associer des lignes de 2 tables en associant l’égalité des
valeurs d’une colonne d’une première table par rapport à la valeur d’une colonne d’une
seconde table. Imaginons qu’une base de 2 données possède une table « utilisateur » et une
autre table « adresse » qui contient les adresses de ces utilisateurs. Avec une jointure, il est
possible d’obtenir les données de l’utilisateur et de son adresse en une seule requête.
On peut aussi imaginer qu’un site web possède une table pour les articles (titre, contenu, date
de publication …) et une autre pour les rédacteurs (nom, date d’inscription, date de naissance
…). Avec une jointure il est possible d’effectuer une seule recherche pour afficher un article et
le nom du rédacteur. Cela évite d’avoir à afficher le nom du rédacteur dans la table « article
».
Il y a d’autres cas de jointures, incluant des jointures sur la même table ou des jointure
d’inégalité. Ces cas étant assez particulier et pas si simple à comprendre, ils ne seront pas
élaborés sur cette page.
Section 2 : Jointure interne et jointure externe

Pour sélectionner des enregistrements provenant de plusieurs fichiers de données, il est
nécessaire d'utiliser des jointures dans la requête SQL.
Deux types de jointures peuvent être utilisés dans des requêtes en code SQL :
 Les jointures internes.
 Les jointures externes.
1. Jointure Interne
Une jointure interne permet de sélectionner les enregistrements ayant des correspondances
entre deux tables jointes.
Par exemple, pour lister les clients ayant déjà passé des commandes, il est nécessaire de lier
les tables "Client" et "Commande" grâce à une jointure interne. La requête sélectionnera
uniquement les clients liés à au moins un numéro de commande. Les clients n'ayant jamais
passé de commande ne seront pas listés. Pour ce faire on utilise le INNER JOIN dont la syntaxe
est la suivante :
P a g e 22 | 46
La syntaxe ci-dessus stipule qu’il faut sélectionner les enregistrements des tables table1 et
table2 lorsque les données de la colonne « id » de table1 est égal aux données de la colonne
fk_id de table2.
EXEMPLE :
Imaginons une application qui possède une table utilisateur ainsi qu’une table commande qui
contient toutes les commandes effectuées par les utilisateurs.
Table Commande
Pour afficher toutes les commandes associées aux utilisateurs, il est possible d’utiliser la
requête
suivante :
Résultat :
P a g e 23 | 46
Le résultat de la requête montre parfaitement la jointure entre les 2 tables. Les utilisateurs 3
et 4 ne sont pas affichés puisqu’il n’y a pas de commandes associés à ces utilisateurs.
NB : il est important de noter que si un utilisateur a été supprimé, alors on ne verra pas ses
commandes dans la liste puisque INNER JOIN retourne uniquement les résultats ou la
condition est vrai dans les 2 tables.
2. Jointure Externe
Une jointure externe permet de sélectionner à la fois :

 Les enregistrements ayant des correspondances entre les deux fichiers joints.
 Les enregistrements n'ayant pas de correspondance dans le premier, le second ou dans
tous les fichiers joints.
Par exemple, pour connaître le montant total dépensé par chaque client :
En utilisant une jointure interne, seuls les clients ayant déjà passé une commande (dont le
montant dépensé sera différent de 0) seront sélectionnés.
En utilisant une jointure externe, tous les clients seront sélectionnés, même ceux n'ayant
jamais passé de commande.
Voici les différents types de jointures externes :
FULL OUTER JOIN Permet de sélectionner :
1. Les enregistrements satisfaisant à la jointure.
2. Les enregistrements du premier fichier cité qui ne satisfont pas la jointure. Le nom du
premier fichier cité est placé à gauche de la jointure OUTER JOIN.
3. Les enregistrements du second fichier cité qui ne satisfont pas la jointure. Le nom du
second fichier cité est placé à droite de la jointure OUTER JOIN.
LEFT OUTER JOIN Jointure la plus courante. Permet de sélectionner :
 Les enregistrements satisfaisant à la jointure.
 Les enregistrements du premier fichier cité qui ne satisfont pas la jointure. Le nom du
premier fichier cité est placé à gauche de la jointure OUTER JOIN.
RIGHT OUTER JOIN Permet de sélectionner :
 Les enregistrements satisfaisant à la jointure.
 Les enregistrements du second fichier cité qui ne satisfont pas la jointure. Le nom du
second fichier cité est placé à droite de la jointure OUTER JOIN.
1. FULL OUTER JOIN
Dans le langage SQL, la commande FULL JOIN (ou FULL OUTER JOIN) permet de faire une
jointure entre 2 tables. L’utilisation de cette commande permet de combiner les résultats des
2 tables, les associer entre eux grâce à une condition et remplir avec des valeurs NULL si la
condition n’est pas respectée.
P a g e 24 | 46
EXEMPLE :
Prenons l’exemple d’une base de données qui contient une table utilisateur ainsi qu’une table
commande qui contient toutes les ventes.
Il est possible d’utiliser FULL JOIN pour lister tous les utilisateurs ayant effectué ou non une
vente, et de lister toutes les ventes qui sont associées ou non à un utilisateur. La requête SQL
est la suivante :
P a g e 25 | 46
Ce résultat affiche bien l’utilisateur numéro 4 qui n’a effectué aucun achat. Le résultat
retourne également la facture A00107 qui est associée à un utilisateur qui n’existe pas (ou qui
n’existe plus). Dans les cas où il n’y a pas de correspondance avec l’autre table, les valeurs des
colonnes valent NULL.
2. LEFT OUTER JOIN
Dans le langage SQL, la commande LEFT JOIN (aussi appelée LEFT OUTER JOIN) est un type de
jointure entre 2 tables. Cela permet de lister tous les résultats de la table de gauche (left =
gauche) même s’il n’y a pas de correspondance dans la deuxième table.
Cette requête est particulièrement intéressante pour récupérer les informations de table1
tout en récupérant les données associées, même s’il n’y a pas de correspondance avec table2.
A savoir, s’il n’y a pas de correspondance les colonnes de table2 vaudront toutes NULL.
EXEMPLE :
Imaginons une application contenant des utilisateurs et des commandes pour chacun de ces
utilisateurs. La base de données de cette application contient une table pour les utilisateurs
et sauvegarde leurs achats dans une seconde table. Les 2 tables sont reliées grâce à la colonne
P a g e 26 | 46
utilisateur_id de la table des commandes. Cela permet d’associer une commande à un

utilisateur.
Table commande
Pour lister tous les utilisateurs avec leurs commandes et afficher également les utilisateurs qui
n’ont pas effectuées d’achats, il est possible d’utiliser la requête suivante :
Les dernières lignes montrent des utilisateurs qui n’ont effectuée aucune commande. La ligne
retourne la valeur NULL pour les colonnes concernant les achats qu’ils n’ont pas effectués.
3. RIGHT OUTER JOIN :
En SQL, la commande RIGHT JOIN (ou RIGHT OUTER JOIN) est un type de jointure entre 2
tables qui permet de retourner tous les enregistrements de la table de droite (right = droite)
même s’il n’y a pas de correspondance avec la table de gauche. S’il y a un enregistrement de
la table de droite qui ne trouve pas de correspondance dans la table de gauche, alors les
colonnes de la table de gauche auront NULL pour valeur.
P a g e 27 | 46
Cette syntaxe stipule qu’il faut lister toutes les lignes du tableau table2 (tableau de droite) et
afficher les données associées du tableau table1 s’il y a une correspondance entre ID de table1
et FK_ID de table2. S’il n’y a pas de correspondance, l’enregistrement de table2 sera affiché
et les colonnes de table1 vaudront toutes NULL
EXEMPLE :
Prenons l’exemple d’une base de données qui contient des utilisateurs et un historique
d’achat de ces utilisateurs. Cette 2 tables sont reliées entre grâce à la colonne utilisateur_id
de la table des commandes. Cela permet de savoir à quel utilisateur est associé un achat.
Table commande
P a g e 28 | 46
Pour afficher toutes les commandes avec le nom de l’utilisateur correspondant il est
normalement d’habitude d’utiliser INNER JOIN en SQL. Malheureusement, si l’utilisateur a été
supprimé de la table, alors ça ne retourne pas l’achat. L’utilisation de RIGHT JOIN permet de
retourner tous les achats et d’afficher le nom de l’utilisateur s’il existe. Pour cela il convient
d’utiliser cette requête :
Ce résultat montre que la facture A00107 est liée à l’utilisateur numéro 5. Or, cet utilisateur
n’existe pas ou n’existe plus. Grâce à RIGHT JOIN, l’achat est tout de même affiché mais les
informations liées à l’utilisateur sont remplacées par NULL.
Section 3 : La jointure Naturelle

Dans le langage SQL, la commande NATURAL JOIN permet de faire une jointure naturelle entre
2 tables. Cette jointure s’effectue à la condition qu’il y ai des colonnes du même nom et de
même type dans les 2 tables. Le résultat d’une jointure naturelle est la création d’un tableau
avec autant de lignes qu’il y a de paires correspondant à l’association des colonnes de même
nom.
La jointure naturelle de 2 tables peut s’effectuer facilement, comme le montre la requête SQL
suivante :
P a g e 29 | 46
EXEMPLE :
Une utilisation classique d’une telle jointure pourrait être l’utilisation dans une application qui
utilise une table utilisateur et une table pays. Si la table utilisateur contient une colonne pour
l’identifiant du pays, il sera possible d’effectuer une jointure naturelle.
Pour avoir la liste de tous les utilisateurs avec le pays correspondant, il est possible d’effectuer
une requête SQL similaire à celle-ci :
Cette requête retournera le résultat suivant :
Section 4 : Operateurs ensemblistes (UNION, INTERSECT,…..)

I. UNION
La commande UNION de SQL permet de mettre bout-à-bout les résultats de plusieurs

requêtes utilisant elles-mêmes la commande SELECT. C’est donc une commande qui permet
de concaténer les résultats de 2 requêtes ou plus. Pour l’utiliser il est nécessaire que chacune
P a g e 30 | 46
des requêtes à concaténer retournes le même nombre de colonnes, avec les mêmes types de
données et dans le même ordre.
L’union de 2 ensembles A et B est un concept qui consiste à obtenir tous les éléments qui
correspondent à la fois à l’ensemble A ou à l’ensemble B. Cela se résume très simplement par
un petit schéma où la zone en bleu correspond à la zone que l’on souhaite obtenir (dans notre
cas : tous les éléments)
EXEMPLE :
Imaginons une entreprise qui possède plusieurs magasins et dans chacun de ces magasins il y
a une table qui liste les clients.
La table du magasin n°1 s’appelle « magasin1_client » et contient les données suivantes :
P a g e 31 | 46
La table du magasin n°2 s’appelle « magasin2_client » et contient les données suivantes :
Sachant que certains clients sont présents dans les 2 tables, pour éviter de retourner plusieurs
fois les mêmes enregistrements, il convient d’utiliser la requête UNION. La requête SQL est
alors la suivante :
Le résultat de cette requête montre bien que les enregistrements des 2 requêtes sont mis
bout-à-bout mais sans inclure plusieurs fois les mêmes lignes.
P a g e 32 | 46
II. INTERSECT
La commande SQL INTERSECT permet d’obtenir l’intersection des résultats de 2 requêtes.

Cette commande permet donc de récupérer les enregistrements communs à 2 requêtes. Cela
peut s’avérer utile lorsqu’il faut trouver s’il y a des données similaires sur 2 tables distinctes.
L’intersection de 2 ensembles A et B correspond aux éléments qui sont présent dans A et dans
B, et seulement ceux-là. Cela peut être représenté par un schéma explicatif simple ou
l’intersection de A et B correspond à la zone en bleu.
EXEMPLE :
Prenons l’exemple de 2 magasins qui appartiennent au même groupe. Chaque magasin
possède sa table de clients.
La table du magasin n°1 est « magasin1_client » :
P a g e 33 | 46
La table du magasin n°2 est « magasin2_client » :
Pour obtenir la liste des clients qui sont présents de façon identiques dans ces 2 tables, il est
possible d’utiliser la commande INTERSECT de la façon suivante :
Le résultat présente 2 enregistrements, il s’agit des clients qui sont à la fois dans la table «
magasin1_client » et dans la table « magasin2_client ». Sur certains systèmes une telle
requête
permet de déceler des erreurs et d’enregistrer seulement à un seul endroit la même
information.
Section 5 : Introduction aux vues : principe et intérêt
Les vues sont des requêtes stockées qui sont nommées et présentées aux utilisateurs comme
des tables virtuelles. Elles sont accessibles en lecture et peuvent parfois l’être en écriture
(INSERT, DELETE, UPDATE) sous certaines conditions dont voici une liste non exhaustive :
 Ne pas utiliser de fonction d’agrégat (sum(), min(), max()...) dans la définition de la vue.
P a g e 34 | 46
 Ne pas utiliser de clauses DISTINCT, GROUP BY, HAVING, UNION et UNION

ALL, LIMIT dans la définition de la vue.
 Ne pas accéder à des vues sous-jacentes non modifiables dans la définition de la vue.
 Avoir une relation 1-1 entre les lignes retournées par la vue et les tables accédées dans
la définition de la vue.
Vous l’aurez compris, lorsque vous accédez à une vue, MySQL exécute le code associé et
stocké dans sa table interne information_schema.views. Les vues n’ont donc pas de meilleures
performances qu’une exécution directe du code correspondant. Par contre, les vues
permettent de ne pas forcément connaître le traitement SQL à effectuer pour obtenir un
résultat. Les utilisateurs pourront par exemple accéder à une vue sans pour autant avoir le
besoin de savoir dans quelles tables et comment sont récupérées les informations obtenues.
Ainsi, la modification de ce traitement peut passer inaperçue auprès des utilisateurs.
P a g e 35 | 46
CHAPITRE 6 : ORDONNANCEMENT ET STATISTIQUES

Section 1 : Trouver les valeurs agrégées (MIN, MAX, AVG, SUM,….)
Il existe plusieurs fonctions qui peuvent être utilisées pour manipuler plusieurs
enregistrements, il s’agit des fonctions d’agrégations statistiques, les principales sont les
suivantes :
 AVG() : pour calculer la moyenne d’un set de valeur. Permet de connaître le prix du
panier moyen pour de chaque client
 COUNT() : pour compter le nombre de lignes concernées. Permet de savoir combien
d’achats a été effectué par chaque client
 MAX() : pour récupérer la plus haute valeur. Pratique pour savoir l’achat le plus cher
 MIN() : pour récupérer la plus petite valeur. Utile par exemple pour connaître la date
du premier achat d’un client
 SUM() : pour calculer la somme de plusieurs lignes. Permet par exemple de connaître
le total de tous les achats d’un client
Ces petites fonctions se révèlent rapidement indispensable pour travailler sur des données.
Section 2 : Calculer les agrégats relatifs avec GROUP BY

La commande GROUP BY est utilisée en SQL pour grouper plusieurs résultats et utiliser une
fonction de totaux sur un groupe de résultat. Sur une table qui contient toutes les ventes d’un
magasin, il est par exemple possible de regrouper les ventes par clients identiques et d’obtenir
le coût total des achats pour chaque client.
De façon générale, la commande GROUP BY s’utilise de la façon suivante :
EXEMPLE :
Prenons en considération une table « achat » qui résume les ventes d’une boutique :
P a g e 36 | 46
Ce tableau contient une colonne qui sert d’identifiant pour chaque ligne, une autre qui
contient le nom du client, le coût de la vente et la date d’achat. Pour obtenir le coût total de
chaque client en regroupant les commandes des mêmes clients, il faut utiliser la requête
suivante :
La fonction SUM() permet d’additionner la valeur de chaque tarif pour un même client. Le
résultat sera donc le suivant :
La manière simple de comprendre le GROUP BY c’est tout simplement d’assimiler qu’il va

éviter de présenter plusieurs fois les mêmes lignes. C’est une méthode pour éviter les
doublons.
Section 3 : Filtrer les valeurs agrégées avec HAVING

La condition HAVING en SQL est presque similaire à WHERE à la seule différence que HAVING
permet de filtrer en utilisant des fonctions telles que SUM(), COUNT(), AVG(), MIN() ou MAX().
L’utilisation de HAVING s’utilise de la manière suivante :
Cela permet donc de SÉLECTIONNER les colonnes DE la table « nom_table » en GROUPANT les
lignes qui ont des valeurs identiques sur la colonne « colonne1″ et que la condition de HAVING
soit respectée.
P a g e 37 | 46
EXEMPLE :
Pour utiliser un exemple concret, imaginons une table « achat » qui contient les achats de
différents clients avec le coût du panier pour chaque achat.
Si dans cette table on souhaite récupérer la liste des clients qui ont commandé plus de 40€,
toute commandes confondu alors il est possible d’utiliser la requête suivante :
La cliente « Marie » a cumulée 38€ d’achat (un achat de 18€ et un autre de 20€) ce qui est
inférieur à la limite de 40€ imposée par HAVING. En conséquent cette ligne n’est pas affichée
dans le résultat.
P a g e 38 | 46
CHAPITRE 7 : PRESENTATION ET TRI DE DONNEES

Section 1 : Présenter les données des colonnes avec des alias
Dans le langage SQL il est possible d’utiliser des alias pour renommer temporairement une
colonne ou une table dans une requête. Cette astuce est particulièrement utile pour faciliter
la lecture des requêtes.
 Alias sur une colonne
Permet de renommer le nom d’une colonne dans les résultats d’une requête SQL. C’est
pratique pour avoir un nom facilement identifiable dans une application qui doit ensuite
exploiter les résultats d’une recherche.
 Alias sur une table
Permet d’attribuer un autre nom à une table dans une requête SQL. Cela peut aider à avoir
des noms plus court, plus simple et plus facilement compréhensible. Ceci est particulièrement
vrai lorsqu’il y a des jointures
Section 2 : effectuer les choix avec l’opérateur CASE

Dans le langage SQL, la commande « CASE … WHEN … » permet d’utiliser des conditions de
type « si / sinon » (cf. if / else) similaire à un langage de programmation pour retourner un
résultat disponible entre plusieurs possibilités. Le CASE peut être utilisé dans n’importe quelle
instruction ou clause, telle que SELECT, UPDATE, DELETE, WHERE, ORDER BY ou HAVING
L’utilisation du CASE est possible de 2 manières différentes :
 Comparer une colonne à un set de résultat possible
 Élaborer une série de conditions booléennes pour déterminer un résultat
P a g e 39 | 46
Voici la syntaxe nécessaire pour comparer une colonne à un set d’enregistrement :
Section 3 : Trier les données avec ORDER BY

La commande ORDER BY permet de trier les lignes dans un résultat d’une requête SQL. Il est
possible de trier les données sur une ou plusieurs colonnes, par ordre ascendant ou
descendant.
Une requête où l’on souhaite filtrer l’ordre des résultats utilise la commande ORDER BY de la
sorte :
Par défaut les résultats sont classés par ordre ascendant, toutefois il est possible d’inverser
l’ordre en utilisant le suffixe DESC après le nom de la colonne. Par ailleurs, il est possible de
trier sur plusieurs colonnes en les séparant par une virgule. Une requête plus élaboré
ressemblerais alors cela :
NB : il n’est pas obligé d’utiliser le suffixe « ASC » sachant que les résultats sont toujours classé
par ordre ascendant par défaut. Toutefois, c’est plus pratique pour mieux s’y retrouver,
surtout si on a oublié l’ordre par défaut.
EXEMPLE :
Pour l’ensemble de nos exemples, nous allons prendre un base « utilisateur » de test, qui
contient les données suivantes :
P a g e 40 | 46
Pour récupérer la liste de ces utilisateurs par ordre alphabétique du nom de famille, il est
possible d’utiliser la requête suivante :
Résultat :
En utilisant deux méthodes de tri, il est possible de retourner les utilisateurs par ordre
alphabétique ET pour ceux qui ont le même nom de famille, les trier par ordre décroissant
d’inscription. La requête serait alors la suivante :
P a g e 41 | 46
P a g e 42 | 46
CHAPITRE 8 : UTILISATION DES SOUS REQUETES

Section 1 : Qu’est-ce qu’une sous-requête ?
Dans le langage SQL une sous-requête (aussi appelé « requête imbriquée » ou « requête en
cascade ») consiste à exécuter une requête à l’intérieur d’une autre requête. Une requête
imbriquée est souvent utilisée au sein d’une clause WHERE ou de HAVING pour remplacer une
ou plusieurs constantes.
Section 2 : Les différents typologies de résultats
Il y a plusieurs façons d’utiliser les sous-requêtes. De cette façon il y a plusieurs syntaxes
envisageables pour utiliser des requêtes dans des requêtes.
L’exemple ci-dessous est une exemple typique d’une sous-requête qui retourne un seul
résultat à la requête principale.
Cet exemple montre une requête interne (celle sur « table2″) qui renvoi une seule valeur. La
requête externe quant à elle, va chercher les résultats de « table » et filtre les résultats à partir
de la valeur retournée par la requête interne.
NB : il est possible d’utiliser n’importe quel opérateur d’égalité tel que =, >, <, >=, <= ou <>.
Une requête imbriquée peut également retournée une colonne entière. Dès lors, la requête
externe peut utiliser la commande IN pour filtrer les lignes qui possèdent une des valeurs
retournées par la requête interne. L’exemple ci-dessous met en évidence un tel cas de figure
:
P a g e 43 | 46
Section 3 : Sous-requêtes liste et opérateur IN, ANY/SOME et All

1. ANY/SOME
Dans le langage SQL, la commande ANY (ou SOME) permet de comparer une valeur avec le
résultat d’une sous-requête. Il est ainsi possible de vérifier si une valeur est « égale », «
différente », « supérieur », « supérieur ou égale », « inférieur » ou « inférieur ou égale » pour
au moins une des valeurs de la sous-requête.
Cette commande s’utilise dans une clause conditionnelle juste après un opérateur
conditionnel et juste avant une sous-requête. L’exemple ci-dessous démontre une utilisation
basique de ANY dans une requête SQL :
Cette requête peut se traduire de la façon suivante : sélectionner toutes les colonnes de
table1, où la condition est supérieure à n’importe quel résultat de la sous-requête. A savoir :
les opérateur conditionnels peuvent être les suivants : =, <, >, <>, !=,<=, >=, !> ou !<
EXEMPLE :
En se basant sur l’exemple relativement simple présenté ci-dessus, il est possible d’effectuer
une requête concrète qui utilise la commande ANY :
2. ALL
Dans le langage SQL, la commande ALL permet de comparer une valeur dans l’ensemble de
valeurs d’une sous-requête. En d’autres mots, cette commande permet de s’assurer qu’une
condition est « égale », « différente », « supérieure », « inférieure », « supérieure ou égale »
ou « inférieure ou égale » pour tous les résultats retournés par une sous-requête.
Cette commande s’utilise dans une clause conditionnelle entre l’opérateur de condition et la
sous requête. L’exemple ci-dessous montre un exemple basique :
P a g e 44 | 46
Imaginons une requête similaire à la syntaxe de base présentée précédemment :
Section 4 : sous requêtes corrélées

Une sous-requête corrélée est une sous-requête qui utilise des valeurs de la requête externe dans sa
clause WHERE. La sous-requête est évaluée une fois pour chaque ligne traitée par la requête externe.
Utilisez des sous-requêtes corrélées pour filtrer ou pour modifier les données lorsque vous interrogez
des tables virtuelles dans un service de données SQL.
Par exemple, la requête “Rechercher tous les magasins dont les ventes de produits laitiers
représentent plus de 10 % des ventes totales” peut être écrite dans SQL comme suit :
Cette requête est une sous-requête corrélée, car la requête interne utilise l'ID de magasin de
la colonne externe de la table Stores dans la requête parent pour calculer les totaux de
produits laitiers de magasins spécifiques.
Dans la plupart des cas, vous pouvez également écrire des requêtes corrélées comme
jointures. Par exemple, vous pouvez réécrire l'exemple en utilisant une jointure entre la table
Stores et une sous-requête sur Items.
P a g e 45 | 46
Dans cette version, la sous-requête crée une table de résultats dans le cadre de la clause FROM
externe qui est jointe à la table Stores pour que le test Dairy sales puisse être exécuté.
P a g e 46 | 46

Bases de Données Et SQL

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Bases de Données Et SQL

Transféré par

Droits d'auteur :

Formats disponibles

ÉCOLE SUPÉRIEURE DE GESTION

ET D’ADMINISTRATION DES ENTREPRISES

BASES DE DONNÉES ET SQL

Table des matières

Section 6 : Exercice ...........................................................................................................35

CHAPITRE 1 : INTRODUCTION AUX BASE DE DONNEES

Section 2 : Lire un modèle relationnel

Section 3 : Composition d’une table

Numéro Nom Prénom E-mail

 INT : nombre entier

Section 4 : Clé primaire et unicité

Section 5 : Notion d’intégrité référentielle

Section 6 : Principaux SGBD

Il en existe plusieurs parmi lesquels :

 Cas particulier d'un type association du type 1 vers 1

 Citoyen(Num-Citoyen, Nom, Prénom, Adresse) ;

Comme exemple d'application, voici les relations déduites du schéma entités-associations de

 Patient (Num-Patient, Nom-Patient, Num-Mutuelle) ;

CHAPITRE 2 : PRESENTATION DU LANGAGE SQL

Section 2 : Types d’instructions SQL, DDL, DML, DCL

i. Langage de définition de données

ii. Langage de manipulation de données

Le langage de manipulation de données (LMD, ou Data Manipulation Language, soit DML en

iii. Langage de protections d'accès

Les instructions du DCL sont : GRANT, REVOKE.

Section 3 : Les éléments de la syntaxe SQL

Section 4 : Traduction de l’algèbre relationnel

La projection permet de ne garder que certains attributs. Dans l'exemple ci-dessous, on ne

CHAPITRE 3 : MANIPULATION DE DONNEES

Section 2 : Modification (UPDATE)

Section 3 : Suppression (DELETE/TRUNCATE)

La syntaxe est la suivante :

La requête permettra alors de supprimer les utilisateurs « Daniel » et « Constantin ». La table

Section 4 : Clause RETURNING/OUTPUT

CHAPITRE 4 : EXTRACTION DES DONNEES D’UNE TABLE

Section 2 : Lire les valeurs à retourner

Cette requête va sélectionner (SELECT) le champ « nom_du_champ » provenant (FROM) du

Section 3 : La clause WHERE pour filtrer les données

Section 4 : L’absence de valeur (marqueur NULL)

Section 5 : Retourner les lignes sans doublon (DISTINCT)

Cette requête sélectionne le champ « ma_colonne » de la table « nom_du_tableau » en

Section 6 : Operateur de restriction

définies. Sa syntaxe est la suivante :

CHAPITRE 5 : INTERROGATION DES DONNEES DE PLUSIEURS TABLES

Section 2 : Jointure interne et jointure externe

Une jointure externe permet de sélectionner à la fois :

1. FULL OUTER JOIN

Sa syntaxe est la suivante :

Sa syntaxe est la suivante :

utilisateur_id de la table des commandes. Cela permet d’associer une commande à un

Sa syntaxe est la suivante :

Section 3 : La jointure Naturelle

Cette requête retournera le résultat suivant :

Section 4 : Operateurs ensemblistes (UNION, INTERSECT,…..)

La commande UNION de SQL permet de mettre bout-à-bout les résultats de plusieurs

Sa syntaxe est la suivante :

La table du magasin n°2 s’appelle « magasin2_client » et contient les données suivantes :

La commande SQL INTERSECT permet d’obtenir l’intersection des résultats de 2 requêtes.

La table du magasin n°2 est « magasin2_client » :

 Ne pas utiliser de clauses DISTINCT, GROUP BY, HAVING, UNION et UNION

CHAPITRE 6 : ORDONNANCEMENT ET STATISTIQUES

Section 2 : Calculer les agrégats relatifs avec GROUP BY

La manière simple de comprendre le GROUP BY c’est tout simplement d’assimiler qu’il va