Université Moulay Ismaïl 2024-2025

BD-SQL
ENSAM – Meknès AIDT

Notes du cours SQL

Un Système de Gestion de Base de Données (SGBD) est un logiciel qui permet de stocker des
informations dans une base de données. Un tel système permet de lire, écrire, modifier, trier,
transformer ou même imprimer les données qui sont contenus dans la base de données.
Le langage SQL (Structured Query Language) est la norme internationale pour interroger une
base de données relationnelles : comme Oracle, SQL Server, SQLite, DB2, ...
L'intérêt de ce langage est qu'il est très puissant et très bien documenté.
Il permet, via ce qu'on appelle des requêtes, de créer, manipuler, interroger, modifier, supprimer
toutes les données présentes.
Une base de données contient un ou plusieurs tables (relations).

Syntaxe de création d’une base de données : CREATE DATABASE Name_of_database

Note que cette commande n’existe pas dans le standard SQL.

• Table :
Table est la représentation d’une relation. Un tableau est une entité qui est contenu dans une base
de données pour stocker des données ordonnées dans des colonnes. La création d’une table sert à
définir les colonnes et le type de données qui seront contenus dans chacun des colonne (entier,
chaîne de caractères, date, valeur binaire …).

Syntaxe de création d’une table :

CREATE TABLE nom_de_la_table

(
colonne1 type_donnees,
colonne2 type_donnees,
colonne3 type_donnees,
colonne4 type_donnees
)

Dans cette requête, 4 colonnes ont été définies. Le mot-clé “type_donnees” sera à remplacer par
un mot-clé pour définir le type de données (INT, DATE, TEXT …). Pour chaque colonne, il est
également possible de définir des options telles que (liste non-exhaustive) :

• NOT NULL : empêche d’enregistrer une valeur nulle pour une colonne.
• DEFAULT : attribuer une valeur par défaut si aucune donnée n’est indiquée pour cette
colonne lors de l’ajout d’une ligne dans la table.
• PRIMARY KEY : indiquer si cette colonne est considérée comme clé primaire pour un
index.

Exemple :
CREATE TABLE utilisateur • id : identifiant unique qui est utilisé comme
( clé primaire et qui n’est pas nulle
id INT PRIMARY KEY NOT NULL, • nom : nom de l’utilisateur dans une colonne
nom VARCHAR(100), de type VARCHAR avec un maximum de
prenom VARCHAR(100), 100 caractères au maximum
email VARCHAR(255), • prenom : idem mais pour le prénom

1
 date_naissance DATE, • email : adresse email enregistré sous 255
pays VARCHAR(255), caractères au maximum
ville VARCHAR(255), • date_naissance : date de naissance
code_postal VARCHAR(5), enregistré au format AAAA-MM-JJ
nombre_achat INT (exemple : 1973-11-17)
) • pays : nom du pays de l’utilisateur sous 255
caractères au maximum
• ville : idem pour la ville
• code_postal : 5 caractères du code postal
• nombre_achat : nombre d’achat de cet
utilisateur sur le site

• Clé primaire : PRIMARY KEY

• La clé primaire, permet d’identifier chaque enregistrement dans une table de base de
données.
• Chaque enregistrement de cette clé primaire doit être UNIQUE et ne doit pas
contenir de valeur NULL.
• La clé primaire est un index, chacune des tables ne peut contenir qu’une seule clé
primaire, composée d’une ou plusieurs colonnes.
• L’usage le plus fréquent consiste à créer une colonne numérique qui s’incrémente
automatiquement à chaque enregistrement grâce à AUTO_INCREMENT.

Syntaxe :

CREATE TABLE `nom_de_la_table` ( CREATE TABLE `nom_de_la_table` (

id INT PRIMARY KEY NOT NULL `id` INT NOT NULL
AUTO_INCREMENT, AUTO_INCREMENT,
[...] [...],
); PRIMARY KEY (`id`)
);

• Clé étrangère : FOREIGN KEY

• Les clés étrangères ont pour fonction principale la vérification de l'intégrité de votre
base.
• Pour créer une clé étrangère, il faut :
o la ou les colonnes sur lesquelles on crée la clé - on utilise FOREIGN KEY ;
o la ou les colonnes qui vont servir de référence - on utilise REFERENCES.

Syntaxe :

CREATE TABLE `nom_de_la_table` (

colonne1 description_colonne1,
[colonne2 description_colonne2,
colonne3 description_colonne3,
...,]
[ [CONSTRAINT [symbole_contrainte]] FOREIGN KEY (colonne(s)_clé_étrangère)
REFERENCES table_référence (colonne(s)_référence)]
)

2
• Modifier une Table :
• La commande ALTER TABLE permet de modifier une table existante, afin d’ajouter
une colonne, supprimer une colonne ou modifier une colonne existante, par exemple
pour changer le type.
• Syntaxe : ALTER TABLE nom_table instructions
• Instructions peut comprendre des instructions pour ajouter, supprimer ou modifier
une ou plusieurs colonnes.
• Syntaxe :
Ajouter Modifier Supprimer
ALTER TABLE nom_table ALTER TABLE nom_table ALTER TABLE nom_table
ADD nom_colonne MODIFY nom_colonne DROP nom_colonne
type_donnees type_donnees
Renommer une colonne
ALTER TABLE nom_table
CHANGE colonne_ancien_nom colonne_nouveau_nom type_donnees

• Supprimer Table :
• La commande DROP TABLE en SQL permet de supprimer définitivement une table
d’une base de données.
• Syntaxe : DROP Table nom_table
• Requêtage simple :
• La requête la plus simple est celle permettant de récupérer l'ensemble des données
d'une table.
• Toute requête d'interrogation de données commence par le mot-clé SELECT et
termine normalement par un point-virgule (";").
• Syntaxe : SELECT * From nom_table ;
o Le terme SELECT indique donc que nous souhaitons récupérer des données ;
o Le caractère * indique que l'on veut tous les attributs de la table ;
o Le terme FROM permet d'indiquer à partir de quelle table nous devons
récupérer les données.
• Limitation des résultats :
o Il est parfois utile de n'avoir que les premières lignes d'une table.
o Dans ce cas, il est possible d'ajouter en fin de requête le terme LIMIT suivi du
nombre de lignes souhaité.
o Syntaxe : SELECT * From nom_table LIMIT nombre_ligne ;
• Ordre des résultats :
o On est souvent appelé à faire un tri des données (ascendant ou descendant).
o Le terme ORDER BY, à placer en fin de requête aussi, mais avant le LIMIT
si nécessaire, permet de réaliser un tel tri.
o Il faut bien noter que le tri ne se fait qu'à l'affichage et que la table n'est en rien
modifiée. Celui-ci peut se faire sur tout type de données.
o Il est possible d'indiquer de deux façons le ou les attributs à prendre en compte
pour le tri :
▪ par leur nom
▪ par leur position dans la table
o Syntaxe :
SELECT * FROM nom_table ORDER BY
[nom_colonne|position_colonne]

3
 o Pour modifier le type de tri, il est possible d'ajouter le terme DESC pour
indiquer qu'on souhaite un tri décroissant. Par défaut, c'est donc un tri
croissant qui est fait.
o Syntaxe :
SELECT * FROM nom_table ORDER BY [nom_colonne|position_colonne]
DESC;
o Il est possible d'avoir plusieurs critères de tri. Pour cela, il faut séparer les
différents attributs (nom ou position) par une virgule (,).
o Syntaxe :
SELECT * FROM nom_table ORDER BY nom_colonne1, nom_colonne2;

• Restriction :
o Une restriction est une sélection de lignes d'une table, sur la base d'une
condition à respecter, définie à la suite du terme WHERE.
o Cette condition peut être une combinaison de comparaisons à l'aide de AND,
de OR et de NOT.
o On peut utiliser l’ensemble des opérateurs de comparaison : =, <>, >, >=, <,
<=.
o Syntaxe : SELECT * FROM table_name WHERE nom_attribut [operateur]
valeur
o Pour vérifier si les données sont manquantes, on utilise le terme IS NULL
comme condition. Le terme NOT NULL dans le cas contraire.
• Opérateurs spécifiques :
o BETWEEN : permet de définir un intervalle fermé dans lequel l’attribut doit
avoir sa valeur. Exemple : SELECT * FROM nom_table WHERE attribut
BETWEEN valeur_1 AND valeur_2.
o IN : permet de définir une liste de valeurs entre parenthèses et séparées par
des virgules. Exemple : SELECT * FROM nom_table WHERE attribut IN
(valeur_1, valeur_2)
o LIKE: permet de comparer une chaîne de caractère à une pseudo-chaîne,
dans laquelle nous pouvons ajouter deux caractères spécifiques :
▪ % : une suite de caractères, éventuellement nulle
▪ _ : un et un seul caractère
▪ Exemple : SELECT * FROM nom_table WHERE attribute LIKE
‘A%’
• Return les tuples de données dont l’attribut commence par A
▪ SELECT * FROM nom_table WHERE attribute LIKE ‘____’
• Return les tuples de données dont l’attribut contient 4 lettres
• Projection :
o Une projection est une sélection de colonnes d'une table, sur la base d'une liste
d'attributs placés après le SELECT et séparés par une virgule.
▪ Syntaxe : SELECT Attribut_1, Attribut_2… FROM nom_table;
o Doublons : Pour retourner les valeurs uniques on utilise le terme DISTINCT
juste après le SELECT (même si on a utilisé plusieurs attributs).
o Renommage : Il possible de renommer un attribut avec le terme AS placé
après l’attribut à renommer et suivi par son nouveau nom.
▪ Exemple : SELECT attribut AS new_name FROM nom_table
• Calcul Arithmétiques:
o Calcul Simple: SLQ offre la possibilité d’effectuer des calculs arithmétiques.

4
 o Syntaxe : SELECT attribut_1 + attribut_2 FROM nome_table
o On peut effectuer des projections en même temps.
o Renommage : Il est souvent utile de renommer un calcul garce à AS.
o Combinaison de clauses :
▪ On peut utiliser les restrictions que l’on désire dans le WHERE.
▪ On peut aussi tirer le résultat, à l’aide de ORDER BY
▪ Aussi, limiter grâce à LIMIT.
o Calcul complexe :
▪ On peut effectuer des calculs qui sont un peu complexe, grâce à
l’utilisation des parenthèses.
o Arrondi : on peut arrondir le résultat d’un calcul grâce à la fonction ROUND().
▪ Exemple : SELECT ROUND(attribut_1*valeur) FROM nom_table;
• Fonctions sur chaines de caractères :
o Concaténation : obtenue par l’opérateur ||.
o Extraction d'une sous-chaîne : SUBSTR(chaine, debut, longueur)
o Majuscule/Minuscule :
▪ Pour transformer une chaine au Majuscule : UPPER().
▪ Pour transformer une chaine au Minuscule : LOWER().
o Pour savoir la longueur d’une chaine : LENGTH().
o Modification d’une sous chaine : REPLACE(chaîne, sc1, sc2)
▪ Permet de remplacer la sc1 par sc2 dans la chaine.
o Recherche d'une sous-chaîne : INSTR(chaîne, souschaine)
▪ Cherche la position dans la souschaine se trouve dans la chaine. Si la
souschaine n’est pas présente, la fonction return 0.
• Fonctions sur les dates :
o Soit nous avons uniquement la date (jour, mois et année - stockée sous la
forme d'un entier représentant le nombre de jours.
o Soit nous avons un format où la date, l'heure et le fuseau horaire sont stockées
(précisément, le nombre de secondes).
o Génération de dates :
▪ SELECT DATE("now"); retourne la date du jour de l’exécution de la
requête sous format "YYYY-MM-DD".
▪ La fonction DATE() peut prendre d’autres paramètres après le
premier contenant la date, permettant de modifier cette date.
• DATE("now", "-1 day") : permet d’avoir la date de la veille.
▪ Il est possible de cumuler plusieurs modificateurs.
• Pour avoir le dernier jour du mois dernier :
o SELECT DATE("now", "start of month", "-1 day");
▪ La commande DATE() accepte aussi en premier paramètre une date
au bon format, pour par exemple lui appliquer une modification par la
suite.
▪ Informations à partir d'une date :
• La commande STRFTIME() permet d’obtenir des information
à partir d’une date.
• On indique l’information désirée par un caractère précédé d’un
%.
o On récupère l’année : %Y
o On récupère le mois : %M
o On récupère le jour : %D

5
• Traitement conditionnel :
o SQL offre la possibilité de faire un traitement conditionnel avec le terme
CASE.
o Dans SELECT, celui-ci va nous permettre de conditionner la valeur d’une
colonne par les valeurs d’autres colonnes.
o Comparaison à des valeurs : égalité
▪ La première utilisation de cette commande est de comparer un attribut
à un ensemble de valeurs. Puisque la comparaison est l'égalité, ceci
concerne principalement des attributs de type texte ou avec un nombre
de valeurs restreint.
▪ Dans ce cas, l'ordre des comparaisons à l'aide de WHEN n'a aucune
importance.
▪ Syntaxe :
SELECT attribut,
CASE attribut
WHEN "valeur_1" THEN "valeur_pour_remplacer_1"
WHEN "valeur_1" THEN "valeur_pour_remplacer_1"
WHEN "valeur_1" THEN "valeur_pour_remplacer_1"
ELSE attribut
END AS new_name
FROM table;

o Comparaison à des valeurs (infériorité ou supériorité) :

▪ Pour pouvoir comparer un attribut avec des valeurs mais autrement
que via l'égalité, il est aussi possible d'utiliser un CASE.
o Comparaison entre attributs :
o Il est aussi possible d'utiliser ce test CASE pour comparer plusieurs
attributs entre eux.
o Syntaxe :
SELECT Attribut_1, attribute_2…
CASE
WHEN attribute_1 > 0 THEN valeur ou "texte"
WHEN attribute_2 < attribute_1 THEN valeur ou "texte"
WHEN attribute_4 == 0 THEN valeur ou "texte"
ELSE valeur ou "texte"
END AS name_colonne
FROM table_name;

• Agrégats:
o Dénombrements :
▪ Nombre de lignes d'une table
• Pour calculer le nombre de lignes d'une table, quel que soit les
valeurs dans celle-ci, le plus correct est d'utiliser COUNT(*).
▪ Nombre de valeurs d'un attribut
• Il est possible de spécifier un attribut dans le COUNT(). Ceci
permettra de compte combien il y a de lignes avec une valeur dans
cet attribut (non nulles).

6
 • Si on l'utilise sur une clé primaire, nous devrions obtenir le même
résultat que précédemment.
• Syntaxe : COUNT(attribut)
▪ Nombre de valeurs distinctes d'un attribut :
• Il est aussi possible d'ajouter la clause DISTINCT avant l'attribut,
pour obtenir le nombre de valeurs distincts de cet attribut.
• Syntaxe : COUNT(DISTINCT attribut)
▪ Restriction dans le dénombrement
• Pour dénombrer des sous-ensembles d'une table, il est bien
évidemment possible d'ajouter des restrictions à la requête.
o Calcul Statistiques simples :
▪ Somme : SUM(attribut)
▪ Moyenne : AVG(attribut)
▪ Médiane : MEDIAN(attribut)
▪ Minimum : MIN(attribut)
▪ Maximum : MAX(attribut)
o Restriction sur agrégats :
▪ Il est possible de restreindre les résultats avec une condition sur un calcul
d’agrégat.
▪ Pour effectuer cette restriction, on utilise la clause HAVING BY situé
obligatoirement après le GROUP BY.

SELECT attributs, calculs, agrégats

FROM tables
WHERE conditions
GROUP BY attributs
HAVING conditions
ORDER BY attributs
LIMIT nombre;

• Jointures
o Une jointure entre deux tables permet de combiner l'information contenue entre
les deux tables.
o Principe :
▪ La jointure naturelle (NATURAL JOIN) permet de recouper les lignes de
chaque table ayant les mêmes valeurs pour les attributs ayant le même
nom entre les deux tables.
▪ Exemple :
• Categorie (CodeCateg, NomCateg, Description)
• Produit (Refprod, Nomprod, NoFour, CodeCateg, QteParUnit,
PrixUnit, UnitesStock, UnitesCom, NiveauReap, Indisponible)
▪ Si nous souhaitons connaître le nom de la catégorie de chaque produit.
Pour cela, nous devons joindre les deux tables Produit et Categorie. Dans
les deux, il existe l'attribut CodeCateg. La jointure va donc permettre
d'ajouter, pour chaque produit, le nom de la catégorie (NomCateg) et la
descrition (Description).

SELECT *
FROM Produit NATURAL JOIN Categorie;

▪ On peut effectuer toute autre type d’opération.

7
 ▪ Si on souhaite avoir l'ensemble des colonnes d'une des tables, il est aussi
possible de l'indiquer dans le SELECT avec le formalisme table.*:
o Multiples jointures
▪ Il est possible de faire plusieurs jointures naturelles dans une même
requête.
▪ Pour cela, il faut ajouter des parenthèses chaque NATURAL JOIN (et les
tables concernées).
▪ Exemple :
• Fournisseur(NoFour, Societe, Contact, Fonction, Adresse,
Ville, Region, CodePostal, Pays, Tel, Fax, PageAccueil)
• Requête :
o SELECT * FROM (Produit NATURAL JOIN Categorie)
NATURAL JOIN Fournisseur;
▪ On a ajouté à la fois les informations de Catégorie mais aussi de
Fournisseur, à la table Produit.
o Limitations : Une jointure naturelle n'est donc réalisable lorsque :
▪ Les tables ont des attributs ayant le même nom qu'on ne cherche pas à
mettre en relation
▪ Les tables n'ont pas d'attributs avec le même nom

• Jointures internes :
o Une jointure interne (INNER JOIN) est faite pour pallier aux problèmes de la
jointure naturelle.
o On précise sur quel(s) attribut(s) nous allons chercher l'égalité. Si les attributs ont
le même nom entre les 2 tables, on peut utiliser le mot-clé USING.
o En reprenant le premier exemple précédent, voici la requête reliant les produits
avec les catégories, réalisée avec une jointure interne :
▪ SELECT * FROM Produit INNER JOIN Categorie USING
(CodeCateg);
o On peut aussi préciser explicitement quel attribut de chaque table on veut utiliser.
Ceci est utile quand les attributs n'ont pas le même nom.
o Attention, si un attribut est présent dans les deux tables, il va falloir préciser
auquel on fait référence en indiquant la table d'origine avant : [Link].
o Exemple :
▪ SELECT * FROM Produit INNER JOIN Categorie ON
[Link] = [Link];
o De même pour les jointures naturelles, il est possible de réaliser d'autres
opérations, en plus de la jointure.
o Exemple :
▪ SELECT NomProd, Societe FROM Produit INNER JOIN Fournisseur
USING (NoFour) WHERE Pays = "France";
o Jointures multiples :
▪ Il est possible d'enchaîner les jointures internes, autant de fois que
nécessaire. Ceci peut produire des requêtes très longues et difficiles à lire.
▪ Exemple :
• SELECT * FROM Produit INNER JOIN Categorie USING
(CodeCateg) INNER JOIN Fournisseur USING (NoFour);
o Lignes manquantes:

8
 ▪ Le défaut de ce type de jointure (naturelle ou interne) est qu'une ligne
d'une table n'ayant pas de correspondances dans l'autre table n'est pas
conservé dans le résultat.
• Jointures externes :
o Pour pallier à ce probleme, on utilise une jointure externe exprimé par le terme
OUTER JOIN.
o Celle-ci a pour but de garder toutes les lignes des deux tables (ou d'une seule des
deux).
o Une jointure se fait entre deux tables.
o Nous parlerons de jointure externe gauche (LEFT OUTER JOIN) quand nous
garderons les lignes de la table à gauche (la première citée donc).
o Et nous parlerons de jointure externe droite (RIGHT OUTER JOIN) quand nous
garderons les lignes de la table à droite (la deuxième donc).
o Enfin, si l'on souhaite garder toutes les lignes des deux tables, il faut faire une
jointure externe complète (FULL OUTER JOIN).
o Exemple :
o Si on veut tous les clients avec les détails de commande, tout en gardant la table
de résultat les clients sans commande, nous devons donc réaliser une jointure
externe gauche entre Client (à gauche) et Commande (à droite).
▪ SELECT * FROM Client Cl LEFT OUTER JOIN Commande Co ON
[Link] = [Link];
• Produit cartésien:
o On parle de produit cartésien quand on cherche à coupler toutes les lignes d'une
table avec chaque ligne de l'autre table. Considérons que la table A à nbA lignes,
et la table B nbB lignes. En résultat, nous obtenons donc une table avec nbA *
nbB lignes. Ce qui peut vite faire beaucoup.
o Par exemple, la table Client fait 94 lignes, la table Commande 830. Le produit
cartésien des deux tables produit une table de 78020 lignes. Il faut donc faire
attention quand on fait une telle opération.
o Exemple : SELECT * FROM Produit, Categorie;
o Elle associe chaque produit (84 lignes), avec chaque catégorie (8 lignes), ce qui
fait une table résultat de 672 lignes.
• Restriction sur produit cartésien :
o Une jointure est finalement une restriction sur produit cartésien, celle-ci
apparaissant dans le WHERE.
o Exemple : SELECT * FROM Produit, Categorie WHERE [Link] =
[Link];
• Sous-requêtes:
o Il est possible et souvent intéressant d'utiliser des sous-requêtes, renvoyant donc
une table, dans une requête.
o On peut ainsi:
▪ éviter des jointures, pouvant être parfois longue à effectuer
▪ faire des calculs et utiliser le résultat dans un autre
• dans WHERE:
o Il est déjà possible de comparer un attribut avec le résultat d'une requête.
o Ici, nous cherchons les commandes du client "Bon app". On peut bien sûr réaliser
cette opération avec une jointure, comme ci-dessous.
▪ SELECT NoCom FROM Commande NATURAL JOIN Client
WHERE Societe = "Bon app";
▪ Equivalent à :

9
 ▪ SELECT NoCom FROM Commande WHERE CodeCli = (SELECT
CodeCli FROM Client WHERE Societe = "Bon app");
o Avec plusieurs retours:
▪ Si la recherche concerne plusieurs valeurs, il faut donc utiliser
l'opérateur IN, qui teste si une valeur est présente dans une liste.
▪ Avec Jointure :
• SELECT NoCom FROM Commande NATURAL JOIN Client
WHERE Pays = "France";
• Equivalent à:
• SELECT NoCom FROM Commande WHERE CodeCli IN
(SELECT CodeCli FROM Client WHERE Pays = "France");
• dans le FORM
o On a aussi la possibilité de faire une sous-requête dans la partie FROM du
requête.
o Ceci peut permettre de faire une restriction avant la jointure. Ou aussi de faire des
calculs.
o En reprenant l'exemple du client "Bon app", on peut aussi faire la requête
suivante.
o Jointure :
▪ SELECT NoCom FROM Commande NATURAL JOIN (SELECT *
FROM Client WHERE Societe = "Bon app");
o Equivalent à:
▪ SELECT NoCom FROM Commande NATURAL JOIN (SELECT *
FROM Client WHERE Pays = "France");
• Opérateur EXISTS
o L'opérateur EXISTS permet de tester si une sous-requête renvoie un résultat ou
non. En faisant en plus référence à une valeur d'un attribut de la table dans la
première requête, cela permet de tester des existences de faits.
o Par exemple, si l'on souhaite avoir les clients ayant au moins une commande, on
peut faire comme suit :
▪ SELECT * FROM Client Cl WHERE EXISTS (SELECT *
FROM Commande WHERE CodeCli = [Link]);
o On peut faire aussi l'inverse de cette requête en cherchant les clients n'ayant pas de
commande.
▪ SELECT * FROM Client Cl WHERE NOT EXISTS (SELECT *
FROM Commande WHERE CodeCli = [Link]);

• Opérations ensemblistes
o Union: L'union est une opération ensembliste qui consiste à prendre les éléments
présents dans A et dans B, A et B étant deux ensembles obtenus grâce à des
requêtes, et réuni grâce à l'opérateur UNION.
o Exemple :
▪ SELECT Societe, Fonction, Pays FROM Client WHERE Pays =
"France"
UNION
SELECT Societe, Fonction, Pays FROM Client WHERE Fonction =
"Propriétaire";

10
o Ordre et limite : Si l'on souhaite faire un tri du résultat, et/ou se limiter aux
premières lignes, les commandes ORDER BY et LIMIT doivent se placer tout à
la fin.
▪ Exemple :
▪ SELECT Societe, Fonction, Pays FROM Client WHERE Pays =
"France"
UNION
SELECT Societe, Fonction, Pays FROM Client WHERE Fonction =
"Propriétaire"
ORDER BY 1;
o Résultats dupliqués : on ajoute ALL à la suite du terme UNION
o Intersection : l'opérateur INTERSECT, entre deux ensembles A et B, obtenus
grâce à deux requêtes, permet de ne récupérer que les lignes présentes dans les
deux ensembles.
o Différence : la différence entre deux éléments A et B, renvoie les éléments de A
qui ne sont pas présents dans B. Il faut donc faire attention à l'ordre des SELECT,
puisque les résultats ne seront pas identiques entre A - B et B - A. L'opérateur est
EXCEPT en SQL classique (et MINUS dans certains cas - Oracle par exemple).

11