Chapitre 4 : SQL A.Lasfar () - EST - Salé Département Informatique - ESTS
←
→
Transcription du contenu de la page
Si votre navigateur ne rend pas la page correctement, lisez s'il vous plaît le contenu de la page ci-dessous
EST – Salé
Département Informatique
Filière Génie Logiciel
Base de Données Relationnelles (BDR)
Chapitre 4 : SQL
A.Lasfar (ali.lasfar@gmail.com)
1Table des matières
Notions générales sur SQL .................................................................................................. 4
Langage ....................................................................................................................................... 4
Historique.................................................................................................................................... 4
SQL une norme et standard ......................................................................................................... 5
Les composants de SQL ................................................................................................................ 5
Les propriétés ACID ..................................................................................................................... 6
Implémentation physique des SGBDR .......................................................................................... 6
Type de données ......................................................................................................................... 7
Les domaines, ou la création de types spécifiques ....................................................................... 8
Contraintes de données ............................................................................................................... 8
Langage de définition de données .....................................................................................10
Création de tables : CREATE TABLE ............................................................................................ 10
Les contraintes ............................................................................................................................................. 10
NOT NULL ..................................................................................................................................................... 10
UNIQUE......................................................................................................................................................... 11
CHECK ........................................................................................................................................................... 11
Clé primaire .................................................................................................................................................. 11
Clé étrangère ............................................................................................................................................... 12
Langage de manipulation de données : select ..................................................................17
L'opérateur AS ........................................................................................................................... 18
Where ........................................................................................................................................................... 18
And, Or.......................................................................................................................................................... 19
BETWEEN .................................................................................................................................. 19
IN .................................................................................................................................................................. 20
LIKE ............................................................................................................................................................... 20
Les fonctions ................................................................................................................................................. 21
Group by : fonctions d’agrégation. ............................................................................................................... 22
HAVING ......................................................................................................................................................... 22
Alias .............................................................................................................................................................. 22
Les jointures .............................................................................................................................. 24
Syntaxe normalisée des jointures .............................................................................................. 25
Opérateur de jointure naturelle ................................................................................................. 25
Les jointures internes ................................................................................................................ 25
Les Sous-requête ...............................................................................................................32
Sous-requêtes renvoyant une seule valeur ................................................................................ 32
Dans la clause SELECT ................................................................................................................................... 32
Dans les filtres WHERE et HAVING ............................................................................................................... 33
Sous-requêtes renvoyant une liste (Opérateurs IN, ALL et ANY(SOME) ) .................................... 33
Dans le prédicat IN ....................................................................................................................................... 33
23
Notions générales sur SQL
Langage
SQL est un langage de type " déclaratif ". On spécifie ce que l'on veut sans décrire la manière
de l'obtenir et c'est la machine qui décide comment elle doit l'exécuter. Il permet la
communication avec une base de données (lecture, écriture, suppression de données …).
Créé en 1974 et normalisé depuis 1986, ce langage est reconnu par la grande majorité des
systèmes de gestion de bases de données relationnelles (SGBDR).
Les instructions SQL s'écrivent d'une manière qui ressemble à celle de phrases ordinaires en
anglais.
Historique
Premiers pas: 1970 publication d'un article : A Relational Model of Data for Large Shared Data
Banks.
Ce référentiel relationnel fondé sur la logique des prédicats a été reconnu comme un modèle
théorique, pour l'interrogation des bases de données, et a donné le langage Structured English
QUEry Language (SEQUEL) renommé ultérieurement SQL.
En 1979 est apparue la première version de SQL.
SQL a été adopté comme recommandation par l'Institut de normalisation américaine (ANSI)
en 1986, puis comme norme internationale par l'ISO en 1987 sous le nom de ISO/CEI 9075 -
Technologies de l'information - Langages de base de données - SQL.
La norme internationale SQL est passée par un certain nombre de révisions :
Année Appellation Commentaires
1986 SQL-86 ou Édité par l'ANSI puis adopté par l'ISO en 1987.
SQL-87
1989 SQL-89 ou Révision mineure.
SQL-1
1992 SQL-92 alias Révision majeure.
SQL2
1999 SQL-99 alias Expressions rationnelles, requêtes récursives, déclencheurs, types
SQL3 non-scalaires et quelques fonctions orientées objet.
42003 SQL:2003 Introduction de fonctions pour la manipulation XML, « window
functions », ordres standardisés et colonnes avec valeurs auto-
produites (y compris colonnes d'identité).
2008 SQL:2008 Ajout de quelques fonctions de fenêtrage (ntile, lead, lag, first
value, last value, nth value), limitation du nombre de ligne (OFFSET
/ FETCH), amélioration mineure sur les types distincts, curseurs et
mécanismes d'auto incréments.
2011 SQL:2011
SQL une norme et standard
SQL a des standards, il est utilisé sur plusieurs SGBDR et se trouve sous différents aspects.
La raison est que :
- Le standard SQL est complexe et il n’est pas pratique d’implémenter le standard entier
- Chaque fournisseur de bases de données a le besoin de différencier ses produits parmi
d’autres.
La syntaxe de SQL fait l'objet de la norme ISO 9075. Cette norme laisse la possibilité aux
producteurs de SGBD d'y ajouter des instructions spécifiques et non normalisées.
La norme a évolué au cours des années en vue de s'adapter aux demandes, et les éditeurs de
SGBD ont souvent ajouté des possibilités à leurs produits ce qui provoque des variations dans
la compréhension et l'interprétation qui est faite d'un code source en SQL par les différents
logiciels de SGBD.
Ces différences font qu'un code source écrit sans précautions pour un SGBD donné ne
fonctionnera pas forcément avec un autre SGBD.
Les composants de SQL
SQL comporte 5 grandes parties
- La définition des éléments d'une base de données (tables, colonnes, clefs, index,
contraintes...) noté souvent DDL,
- 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),
- La gestion des transactions
- SQL intégré.
• DDL : " Data Definition Language "
C'est la partie de SQL qui permet de créer des bases de données, des tables, des index, des
contraintes …(CREATE, ALTER, DROP)
• DML : " Data Manipulation Language "
C'est la partie de SQL qui s'occupe de traitement des données (INSERT, UPDATE, DELETE, SELECT).
• DCL : "Data Control Language"
5C'est la partie SQL qui s'occupe de gérer les droits d'accès aux tables (GRANT, REVOKE).
• TCL : " Transaction Control Language "
C'est la partie SQL chargé de contrôler la bonne exécution des transactions (SET
TRANSACTION, COMMIT, ROLLBACK).
Ces commandes permettent de gérer les propriétés ACID des transactions.
• SQL intégré : "Embedded SQL"
Il s'agit d'éléments procéduraux que l'on intègre à un langage hôte (SET, DECLARE CURSOR,
OPEN, FETCH...)
Les propriétés ACID
Le terme "ACID" fait référence aux termes suivants :
A - Atomicité : une transaction s'effectue ou pas (tout ou rien). Par exemple l'augmentation
des prix de 10% de tous les articles d'une table des produits ne saurait être effectuée
partiellement, même si le système connaît une panne en cours d'exécution de la requête.
C - Cohérence : le résultat ou les changements induits par une transaction doivent
impérativement préserver la cohérence de la base de données. Par exemple lors d'une fusion
de société, la concaténation des tables des clients des différentes entités ne peut entraîner la
présence de plusieurs clients ayant le même identifiant. Il faudra résoudre les conflits portant
sur le numéro de client avant d'opérer l'union des deux tables.
I - Isolation : les transactions sont isolées les unes des autres. Par exemple la mise à jour des
prix des articles ne sera visible pour d'autres transactions que si ces dernières ont démarré
après la validation de la transaction de mise à jour des données. Il n'y aura donc pas de vue
partielle des données pendant toute la durée de la transaction de mise à jour.
D - Durabilité : une fois validée, une transaction doit durer, c'est à dire que les données sont
persistantes même s'il s'ensuit une défaillance dans le système. Par exemple, dès lors qu'une
transaction a été validée, comme la mise à jour des prix, les données modifiées doivent être
physiquement stockées pour qu'en cas de panne, ces données soient conservées dans l'état
où elles ont été spécifiées à la fin de la transaction.
Implémentation physique des SGBDR
Il existe deux types d'implémentation physique des SGBD relationnels. Ceux qui utilisent un
service de fichiers associés à un protocole afin d'accéder aux données (SGBDR "fichier") et
ceux qui utilisent une application centralisée dite serveur de données (SGBDR client/serveur).
SGBDR "fichier"
6Le service est simple, il s'agit de placer dans une unité de stockage partagée (en général un disque d'un serveur de réseau) un ou plusieurs fichiers partageables. SGBDR "Client/Serveur" Le service consiste à faire tourner sur un serveur physique, un moteur qui assure une indépendance entre les données et les demandes de traitement de l'information venant des différentes applications. En effet, un poste client envoie, à l'aide d'un protocole de réseau, un ordre SQL. Le moteur répond par l'envoie des données. De plus le SGBDR assure des fonctions de gestions d'utilisateurs de manière indépendante aux droits gérés par l'OS. Type de données Type Description Type alphanumérique CHARACTER (ou Chaîne de caractères de longueur fixe n (n
Types " BLOBS " (hors du standard SQL 2)
TEXT : suite longue de caractères de longueur indéterminé
IMAGE : stockage d'image dans un format déterminé
OLE : stockage d'objet OLE (Windows)
Remarque
Pour les types réels NUMERIC, DECIMAL, DEC et FLOAT, on doit spécifier le nombre de chiffres
significatifs et la précision des décimales après la virgule.
Les constantes chaînes de caractères sont entourées par des apostrophes ('). Si la chaîne
contient une apostrophe, celle-ci doit être doublée. Exemple : 'aujourd''hui'.
Exemple
NUMERIC (15,2)
BOOLEAN (ou LOGICAL) : absent de la norme sql.
On peut par exemple implémenter un tel type de données, en utilisant une colonne de type
caractère longueur 1, non nul et restreint à deux valeurs (V / F ou encore T / F).
MONEY : est un sous type du type NUMERIC avec une précision de deux chiffres après la
virgule.
BYTES (ou BINARY) : Type binaire (octets) de longueur devant être précisée. Permet par
exemple le stockage d'un code barre.
AUTOINC : entier à incrément automatique par trigger.
Les domaines, ou la création de types spécifiques
Il est possible de créer de nouveau types de données à partir de types pré existants en utilisant
la notion de DOMAINE.
Dans ce cas, avant d'utiliser un domaine, il faut le recenser dans la base à l'aide d'un ordre
CREATE : CREATE DOMAIN nom_du_domaine AS type_de_donnée
CREATE DOMAIN car AS CHAR(5)
L'utilisation des domaines possède de nombreux avantages : ils peuvent être modifiés (ce qui
modifie le type de toutes les colonnes de table utilisant ce domaine d'un seul coup).
Contraintes de données
Dans la plupart des SGBDR il est possible de contraindre le formatage des données à l'aide de
différents mécanismes.
8Parmi les contraintes les plus courantes sur les données des tables on trouve :
• valeur minimum
• valeur maximum
• valeur par défaut
• valeur obligatoire
• valeur unique
• clef primaire
• index secondaire
• format ou modèle (par exemple 3 caractères majuscules suivi de 2 caractères
numériques)
• table de référence (recopie d'une valeur d'une table dans un champ d'une autre table
en sélectionnant par la clef) aussi appelé CHECK en SQL
Intégrité référentielle
Entre deux tables liées, il est souvent nécessaire de définir une contrainte de référence qui
oblige un enregistrement référencé par sa clef à être présent ou détruit en même temps que
l'enregistrement visé est modifié, inséré ou supprimé. Ce mécanisme est appelé INTÉGRITÉ
RÉFÉRENTIELLE.
9Langage de définition de données
Création de tables : CREATE TABLE
CREATE TABLE "nom de table"
("colonne 1" "type de données pour la colonne 1",
"colonne 2" "type de données pour la colonne 2",
... )
Exemple
CREATE TABLE customer
(First_Name char(50),
Last_Name char(50),
Address char(50),
City char(50),
Country char(25),
Birth_Date date)
Il est aussi possible d’attribuer une valeur par défaut à chaque colonne.
Pour spécifier une valeur par défaut, ajoutez Default [value] après la définition du type de
données.
CREATE TABLE customer
(First_Name char(50),
Last_Name char(50),
Address char(50) default 'Unknown',
City char(50) default 'Mumbai',
Country char(25),
Birth_Date date)
Les contraintes
On peut limiter le type d’informations que doit contenir une table ou une colonne à l'aide de
CONSTRAINT.
Les contraintes les plus communes sont :
- NOT NULL
- UNIQUE
- CHECK
- Clé primaire
- Clé étrangère
NOT NULL
Une colonne accepte par défaut une valeur NULL. Pour rejeter la valeur NULL dans une
colonne, il faut définir une contrainte sur cette colonne.
10CREATE TABLE Customer
(SID integer NOT NULL,
Last_Name varchar (30) NOT NULL,
First_Name varchar(30));
UNIQUE
La contrainte UNIQUE garantit que toutes les valeurs d’une colonne ne peuvent comporter de
doublons.
CREATE TABLE Customer
(SID integer Unique,
Last_Name varchar (30),
First_Name varchar(30));
CHECK
La contrainte CHECK garanti que toutes les valeurs d’une colonne satisfont des conditions
données.
CREATE TABLE Customer
(SID integer CHECK (SID > 0),
Last_Name varchar (30),
First_Name varchar(30));
La colonne "SID" ne peut accepter que des entiers supérieurs à 0.
Clé primaire
La clé primaire peut représenter une partie d’un enregistrement concret, ou être un champ
artificiel. Elle peut représenter un ou plusieurs champs d’une table.
Lorsque la clé primaire représente plusieurs champs, elle est appelée « clé composite ».
Il est possible de spécifier les clés primaires au moment de la création de la table (à l’aide de
CREATE TABLE) ou de la modification de la structure de la table existante (par le biais de ALTER
TABLE).
Avec CREATE TABLE
MySQL:
CREATE TABLE Customer
(SID integer,
Last_Name varchar(30),
First_Name varchar(30),
PRIMARY KEY (SID));
Oracle, SQL Server:
CREATE TABLE Customer
11(SID integer PRIMARY KEY,
Last_Name varchar(30),
First_Name varchar(30));
Avec ALTER TABLE
ALTER TABLE Customer ADD PRIMARY KEY (SID);
Remarque : avant d’utiliser la commande ALTER TABLE pour ajouter une clé primaire, le
champ doit être 'NOT NULL', ce champ n’accepte pas de valeur NULL.
Clé étrangère
La clé étrangère représente un champ (ou des champs) qui pointe vers la clé primaire d’une
autre table. L’objectif de la clé étrangère est d’assurer l’intégrité référentielle des données.
Par exemple, nous avons deux tables, l’une appelée CUSTOMER qui inclut toutes les données
du client, et l’autre ORDERS qui comprend ses commandes.
La contrainte ici est que toutes les commandes doivent être associées à un client qui se trouve
déjà référencé dans la table CUSTOMER.
La structure de ces deux tables sera comme suit :
Table CUSTOMER
nom de colonne caractéristique
SID Clé primaire
Last_Name
First_Name
Table ORDERS
nom de colonne caractéristique
Order_ID Clé primaire
Order_Date
Customer_SID Clé étrangère
Dans l’exemple ci-dessus, la colonne Customer_SID de la table ORDERS représente une clé
étrangère pointant vers la colonne SID de la table CUSTOMER.
12Avec CREATE TABLE
MySQL:
CREATE TABLE ORDERS
(Order_ID integer,
Order_Date date,
Customer_SID integer,
Primary Key (Order_ID),
Foreign Key (Customer_SID) references CUSTOMER(SID));
Oracle:
CREATE TABLE ORDERS
(Order_ID integer primary key,
Order_Date date,
Customer_SID integer references CUSTOMER(SID),
);
SQL Server:
CREATE TABLE ORDERS
(Order_ID integer primary key,
Order_Date datetime,
Customer_SID integer references CUSTOMER(SID),
);
Avec ALTER TABLE
MySQL:
ALTER TABLE ORDERS
ADD FOREIGN KEY (customer_sid) REFERENCES CUSTOMER(SID);
Oracle:
ALTER TABLE ORDERS
ADD (CONSTRAINT fk_orders1) FOREIGN KEY (customer_sid) REFERENCES CUSTOMER(SID);
SQL Server:
ALTER TABLE ORDERS
ADD FOREIGN KEY (customer_sid) REFERENCES CUSTOMER(SID);
• ALTER TABLE
- Ajouter une colonne
- Supprimer une colonne
- Changer un nom de colonne
- Changer les types de données d’une colonne
13La syntaxe SQL de ALTER TABLE est :
ALTER TABLE "nom de table"
[alter spécifications]
[alter spécifications] dépend du type de modification à effectuer. Pour les utilisations
mentionnées ci-dessus, les instructions [alter specification] sont :
• Ajouter une colonne : ADD "colonne 1" "type colonne 1"
• Supprimer une colonne : DROP "colonne 1"
• Changer un nom de colonne : CHANGE "vieux column" "nouveau nom" "type"
• Changer le type de données d’une colonne : MODIFY "colonne 1" "nouveau type de
données"
Pour ajouter une colonne appelée "Gender" (genre) à cette table, il faut saisir :
ALTER table customer add Gender char(1)
Pour renommer "Address" en "Addr", il suffit de saisir :
ALTER table customer change Address Addr char(50)
Pour changer le type de données pour "Addr" de char(50) à char(30):
ALTER table customer modify Addr char(30)
Finalement, pour supprimer la colonne "Gender", il suffit de saisir :
ALTER table customer drop Gender
La commande DROP TABLE
DROP TABLE "nom de table"
Pour supprimer les données tout en conservant la table on utilise la commande TRUNCATE
TABLE.
TRUNCATE TABLE "nom de table"
• INSERT INTO
Il existe deux manières pour INSÉRER des données dans une table : l’une consiste à insérer
des données une ligne à la fois, et l’autre plusieurs lignes à la fois.
Pour INSÉRER une ligne à la fois :
14INSERT INTO "nom de table" ("colonne 1", "colonne 2", ...)
VALUES ("valeur 1", "valeur 2", ...)
Ajout de plusieurs lignes à une table.
INSERT INTO "table1" ("column1", "column2", ...)
SELECT "column3", "column4", ...
FROM "table2"
Exemple
INSERT INTO vente (ville, montant, Date)
SELECT ville, montant, Date
FROM vente
WHERE Year(Date) = 1998
• La commande UPDATE
UPDATE "nom de table"
SET "colonne 1" = [nouvelle valeur]
WHERE {condition}
Exemple
UPDATE vente
SET montant = 500
WHERE ville = "Los Angeles"
AND Date = "08-Jan-1999"
Il est aussi possible de mettre à jour plusieurs colonnes à la fois.
UPDATE "nom de table"
SET colonne 1 = [valeur 1], colonne 2 = [valeur 2]
WHERE {condition}
• La commande DELETE
DELETE FROM "nom de table"
WHERE {condition}
DELETE FROM vente
WHERE ville = "Los Angeles"
1516
Langage de manipulation de données : select
La commande SELECT permet d’extraire les informations d’une BD ou de calculer de nouvelles
données à partir d'existantes...
Syntaxe générale d'une commande SELECT :
SELECT [options] colonnes
FROM tables ou vues
[WHERE prédicats] (conditions)
[GROUP BY ordre des groupes]
[HAVING condition]
[ORDER BY ] liste de colonnes
SELECT Spécification des colonnes
FROM Spécification des tables sur lesquelles porte l'ordre
WHERE Filtre (critères) portant sur les données (colonnes)
GROUP BY Définition d'un groupe (sous ensemble)
HAVING Filtre portant sur les résultats
ORDER BY Tri des données du résultat
Remarque
Pour spécifier une valeur de type texte il faut l'entourer de guillemets simples ( 'texte' ).
• DISTINCT
Les résultats de la commande SELECT retourneront souvent des redondances. Pour ne
sélectionner que des éléments distinct on ajoute DISTINCT après SELECT.
SELECT DISTINCT "nom de colonne"
FROM "nom de table"
• ORDER BY : classement
Le classement peut se faire dans un ordre ascendant ou descendant, ou peut être établi par
des valeurs saisies en chiffres ou en lettres. Pour cela il est possible d’utiliser le mot-clé ORDER
BY.
SELECT "nom de colonne"
FROM "nom de table"
[WHERE "condition"]
ORDER BY "nom de colonne" [ASC, DESC]
17si la clause WHERE est présente, elle se trouvera avant la clause ORDER BY. La clause ASC ou
DESC provoque respectivement un tri des résultats dans un ordre ascendant ou descendant.
Par défaut, la clause ASC est implicitement appelée.
Il est possible d’ordonner par plusieurs colonnes. ORDER BY "nom de colonne 1" [ASC, DESC],
"nom de colonne 2" [ASC, DESC]
Remarque
En plus du nom de colonne, il est également possible d’utiliser une position de colonne (basée
sur la requête SQL) pour indiquer la colonne à laquelle nous souhaitons appliquer la clause
ORDER BY. La première colonne est 1, la seconde 2, et ainsi de suite.
Table Store_Information
Store_Name Sales Date
Los Angeles 1500 05-Jan-1999
San Diego 250 07-Jan-1999
Los Angeles 300 08-Jan-1999
Boston 700 08-Jan-1999
SELECT store_name, Sales, Date
FROM Store_Information
ORDER BY 2
L'opérateur AS
L'opérateur AS sert à donner un nom à de nouvelles colonnes créées par la requête.
On peut ajouter autant de colonnes qu'on veut en utilisant le mot clef AS.
SELECT CLI_NOM as NOM, pre_cli as prenom
FROM T_CLIENT
Where
SELECT "nom de colonne"
FROM "nom de table"
WHERE "condition"
18Afficher tous les étudiants dont les numéros sont supérieurs à 100
SELECT *
FROM etudiant
WHERE numero > 100
And, Or
La condition de la clause where peut être une condition simple ou combinée. Les conditions
combinées se constituent de plusieurs conditions simples connectées par
AND ou OR.
SELECT "nom de colonne"
FROM "nom de table"
WHERE "condition simples"
[AND|OR] "condition simples"
Exemple
SELECT nom
FROM etudiant
WHERE ville ='casa' OR ville='Rabat'
BETWEEN
Le mot-clé BETWEEN permet de sélectionner un intervalle.
SELECT "nom de colonne"
FROM "nom de table"
WHERE "une colonne" BETWEEN valeur1 AND valeur2
Exemple
SELECT *
FROM Store_Information
WHERE Date BETWEEN '06-Jan-1999' AND '10-Jan-1999'
Pour access
select numero, nom, prenom
from etudiant
where date_nais BETWEEN #06-Jan-1999# AND #10-Jan-1999#
19IN
SELECT "nom de colonne"
FROM "nom de table"
WHERE "nom de colonne" IN ('valeur1', 'valeur2', ...)
Exemple
SELECT *
FROM etudiant
WHERE ville IN ('Los Angeles', 'San Diego')
Opérateurs mathématiques de base
On, peut utiliser les opérateurs mathématiques de base(,+,-, *, /,) pour combiner différentes
colonnes.
Exemple
SELECT ID, PRIX * 1.2 AS TARIF_TTC
FROM produit
LIKE
LIKE permet d’effectuer une recherche basée sur un modèle qu’une spécification exacte de ce
qui est souhaité.
SELECT "nom de colonne"
FROM "nom de table"
WHERE "nom de colonne" LIKE {modèle}
{modèle} représente souvent des caractères de remplacement :
'AZ?Z' : toutes les chaînes commençant par 'AZ' et se terminant par 'Z'. Par exemple, 'AZIZ' et
'AZOZ' satisferaient la condition.
• 'ABC*' : toutes les chaînes commençant par 'ABC'.
• '*XYZ' : toutes les chaînes terminant par 'XYZ'.
• '*AN*' : toutes les chaînes contenant le modèle 'AN' quelle que soit sa position.
Exemple
Pour rechercher tous les magasins dont le nom contient 'AN', il faut saisir :
SELECT *
FROM etudiant
WHERE ville LIKE '*AN*'
20Les fonctions
Utiliser des nombres :
- AVG
- COUNT
- MAX
- MIN
- SUM
La syntaxe pour utiliser ces fonctions est :
SELECT "nom de fonction" ("nom de colonne") as nom
FROM "nom de table"
Par exemple, pour obtenir la somme de toutes les ventes de la table suivante :
Table vente
ville montant Date
Los Angeles 1500 € 05-Jan-1999
San Diego 250 € 07-Jan-1999
Los Angeles 300 € 08-Jan-1999
Boston 700 € 08-Jan-1999
SELECT SUM(montant) as somme
FROM vente
Pour les données à type de caractères, plusieurs fonctions de chaînes sont disponibles, telles
que les fonctions de concaténation, de Trim et de sous-chaîne. Chaque fournisseur SGBDR
dispose de sa propre implémentation de fonctions de
• COUNT
Permet de compter le nombre de lignes incluses dans une table.
SELECT COUNT("nom de colonne")
FROM "nom de table"
Exemple
SELECT COUNT(ville)
FROM vente
Les clauses COUNT et DISTINCT peuvent être utilisées ensemble dans une instruction pour
obtenir le nombre d’entrées distinctes d’une table.
21Par exemple, pour déterminer le nombre des magasins différents, il faut saisir :
SELECT COUNT(DISTINCT ville)
FROM vente
Group by : fonctions d’agrégation.
SELECT "nom de colonne 1", SUM("nom de colonne 2")
FROM "nom de table"
GROUP BY "nom de colonne 1"
Pour retrouver les ventes totales de chaque magasin :
SELECT ville, SUM(montant)
FROM vente
GROUP BY ville
HAVING
Si on souhaite limiter la sortie basée sur les calculs correspondants (sur toute fonction
d’agrégation) on fait appel à la clause HAVING.
SELECT "nom de colonne 1", fonction("nom de colonne 2")
FROM "nom de table"
GROUP BY "nom de colonne 1"
HAVING (condition fonction)
Exemple
Visualiser uniquement les magasins dont le total des ventes est supérieur à 1 500 €.
SELECT ville, SUM(montant) as aaa
FROM vente
GROUP BY ville
HAVING aaa > 1500
Généralement, la clause HAVING est placée pratiquement en fin d’instruction SQL, avec
présence ou non de la clause GROUP BY.
Alias
Il existe deux types d’alias qui sont utilisés, alias de colonne et alias de table.
Les alias de colonne visent à améliorer la lisibilité d’une requête.
22Dans l’exemple précédent, les ventes totales sont listées comme SUM(montant). Cette
procédure est facile à comprendre, mais lors des cas où l’en-tête de colonne peut être
compliqué (provoquant plusieurs opérations arithmétiques), l’utilisation d’un alias de colonne
permet de rendre le résultat beaucoup plus lisible.
Les alias de table s’obtiennent en plaçant directement un alias après le nom de table dans la
clause FROM.
Les alias sont très utiles lorsque vous souhaitez obtenir des informations de deux tables
séparées (le terme technique est 'perform joins').
SELECT "table alias"."nom de colonne 1" "colonne alias"
FROM "nom de table" "table alias"
Les deux types d’alias sont directement placés après les éléments qu’ils représentent, séparés
par un espace blanc.
Exemple
SELECT A1.ville, SUM(A1.montant) as T
FROM vente A1
GROUP BY A1.ville
Having T>1000
23Les jointures
Les jointures sont faites pour mettre en relation deux (ou plusieurs) tables visant à rechercher la
réponse à des interrogations. Une jointure permet donc de combiner les colonnes de plusieurs tables.
La plupart des jointures entre tables s'effectuent en imposant l'égalité des valeurs d'une colonne d'une
table à une colonne d'une autre table. On parle alors de jointure naturelle ou équi-jointure. On trouve
aussi des jointures d'une table sur elle-même. On parle alors d'auto-jointure.
On trouve aussi des jointures externes, c'est-à-dire joindre une table à une autre, même si la valeur de
liaison est absente dans une table ou l'autre.
Enfin, dans quelques cas, on peut procéder à des jointures hétérogènes, c'est-à-dire que l'on remplace
le critère d'égalité par un critère d'inégalité ou de différence.
Une jointure entre tables peut être mise en oeuvre, soit à l'aide des éléments de syntaxe SQL, soit à
l'aide de la clause JOIN (une clause spécifique du SQL).
Supposons que nous avons les deux tables suivantes :
Table vente Table Géographie
ville montant Date region ville
Los East Boston
1500 € 05-Jan-1999
Angeles
East New York
San Diego 250 € 07-Jan-1999
West Los Angeles
Los
300 € 08-Jan-1999 West San Diego
Angeles
Boston 700 € 08-Jan-1999
• Afficher les ventes par région.
Afin d’obtenir les informations sur les ventes par région, il faut combiner les informations des
deux tables. En examinant les deux tables, nous constatons qu’elles sont mises en relation par
le champ commun "ville "
SELECT A1.region REGION, A2.montant montant
FROM Geographie A1, vente A2
WHERE A1.ville = A2.ville
SELECT A1.num_etudiant, A1.nom, A2.note
FROM etudiant A1, notes A2
WHERE A1.num_etudiant = A2.num_etudiant;
Joindre plusieurs tables
Afficher le nom de l'étudiant et sa note par matière.
24Remarque
Il est conseillé d'utiliser un opérateur de jointure normalisé (mot clef JOIN) que d'utiliser la
jointure dans where.
Les jointures faites dans la clause WHERE (ancienne syntaxe) ne permettent pas de faire la
distinction, à première vue, entre ce qui relève du filtrage et ce qui relève de la jointure.
La lisibilité des requêtes est plus grande en utilisant la syntaxe à base de JOIN, en isolant ce
qui est du filtrage et de la jointure.
Syntaxe normalisée des jointures
Les jointures normalisées s'expriment à l'aide du mot clef JOIN dans la clause FROM.
Opérateur de jointure naturelle
SELECT ...
FROM
NATURAL JOIN
[USING (colonne1 [, colonne2 ...])]
L'opérateur NATURAL JOIN permet d'éviter de préciser les colonnes concernées par la jointure.
Exemple
Afficher les noms et les notes des étudiants
Les jointures internes
Il s'agit de la plus commune des jointures et c'est cette jointure qui s'exerce par défaut si on
ne précise pas le type de jointure. On doit préciser le critère de jointure après le mot clef ON.
SELECT …
FROM table1 T1
INNER JOIN table2 T2
ON T1.colonne1=T2.colonne2
• SQL CROSS JOIN
Dans le langage SQL, la commande CROSS JOIN est un type de jointure sur 2 tables SQL qui permet
de retourner le produit cartésien.
25Pour effectuer un jointure avec CROSS JOIN, il convient d’effectuer une requête SQL respectant la
syntaxe suivante:
SELECT *
FROM table1
CROSS JOIN table2
Méthode alternative pour retourner les mêmes résultats :
SELECT *
FROM table1, table2
• Jointures externes
Les jointures externes sont extrêmement pratiques pour rapatrier le maximum d'informations
disponible, même si des lignes de table ne sont pas renseignées entre les différentes tables
jointes.
La syntaxe de la jointure externe est la suivante :
SELECT ...
FROM
LEFT | RIGHT | FULL OUTER JOIN
ON
Les mots clefs LEFT, RIGHT et FULL indiquent la manière dont le moteur de requête doit effectuer la
jointure externe.
Ils font référence à la table située à gauche (LEFT) du mot clef JOIN ou à la table située à droite (RIGHT).
Le mot FULL indique que la jointure externe est bilatérale.
SELECT …
FROM TGauche LEFT OUTER JOIN TDroite ON condition de jointure.
On recherche toutes les valeurs satisfaisant la condition de jointure précisée dans le prédicat, puis on
rajoute toutes les lignes de la table TGauche qui n'ont pas été prises en compte au titre de la
satisfaction du critère.
En général, la syntaxe dépend du SGBD utilisée.
Par exemple, dans Oracle, il faut placer un "(+)" dans la clause WHERE de l’autre côté de la
table dans laquelle nous souhaitons inclure toutes les lignes.
Pour trouver le montant des ventes de tous les magasins. Dans le cas d’une jointure régulière,
il n’est pas possible d’obtenir le critère de recherche souhaité étant donné que "New York"
n’apparaîtra pas dans la table Store_Information.
26Par conséquent, il est nécessaire d’exécuter une jointure externe sur les deux tables ci-dessus
:
Table Geography
region_name Store_name
East Boston
East New York
West Los Angeles
West San Diego
SELECT A1.store_name, SUM(A2.Sales) SALES
FROM Geography A1, Store_Information A2
WHERE A1.store_name = A2.store_name (+)
GROUP BY A1.store_name
Remarque
à défaut d’une correspondance dans la deuxième table, la valeur NULL sera retournée. Dans
ce cas, "New York" n’apparaîtra pas dans la table Store_Information, sa colonne "SALES"
correspondante contient une valeur NULL.
• Concaténation
Il est parfois nécessaire de combiner (concaténer) les résultats de plusieurs champs différents.
Chaque SGBD a sa propre méthode de concaténation:
• MySQL: CONCAT( )
• Oracle: CONCAT( ), ||
• SQL Server: +
Syntaxe :
CONCAT(str1, str2, str3, ...)
Remarque
Dans Oracle, la fonction CONCAT( ) ne permet que deux arguments. Mais '||', permet de
concaténer plus de deux chaînes.
27Exemple 1: MySQL/Oracle
SELECT CONCAT(region, ville) FROM Geographie
WHERE ville = 'Boston';
Exemple 2: Oracle
SELECT region || ' ' || ville FROM Geographie
WHERE ville = 'Boston';
Exemple 3: SQL Server
SELECT region+ ' ' + ville FROM Geographie
WHERE ville = 'Boston';
• Substring
La fonction de sous-chaîne en SQL est utilisée pour extraire une partie des données stockées.
Le nom de cette fonction diffère selon la base de données utilisée :
• MySQL: SUBSTR( ), SUBSTRING( )
• Oracle: SUBSTR( )
• SQL Server: SUBSTRING( )
Les utilisations les plus fréquentes :
SUBSTR(str,pos): sélectionne tous les caractères de en commençant par position .
SUBSTR(str,pos,N): en commençant par le caractère dans la chaîne , sélectionne
les N caractères suivants.
Exemple 1 :
SELECT SUBSTR(ville, 3)
FROM Geographie
WHERE ville= 'Los Angeles';
Exemple 2 :
SELECT SUBSTR(ville,2,4)
FROM Geographie
WHERE ville = 'San Diego';
• TRIM
La fonction TRIM permet de supprimer des préfixes ou suffixes spécifiques d’une chaîne de
caractères. Les modèles les plus fréquemment supprimés sont les espaces blancs.
Le nom de cette fonction diffère selon la base de données (SGBD) utilisée :
28• MySQL: TRIM( ), RTRIM( ), LTRIM( )
• Oracle: RTRIM( ), LTRIM( )
• SQL Server: RTRIM( ), LTRIM( )
La syntaxe de ces fonctions Trim est :
TRIM([[LOCATION] [remstr] FROM ] str)
[LOCATION] (LEADING, TRAILING ou BOTH) : Cette fonction efface le modèle précisé par
[remstr] à partir du début ou de la fin de la chaîne de caractères, ou des deux. Si [remstr] n’est
pas spécifié alors les espaces blancs seront effacés.
LTRIM(str): Efface tous les espaces blancs situés en début de chaîne.
RTRIM(str): Efface tous les espaces blancs situés en fin de chaîne.
Exemples
SELECT TRIM(' Sample ');
SELECT LTRIM(' exemple ');
SELECT RTRIM(' exemple ');
Le retour de cette fonction permet d’obtenir uniquement le mot "Exemple" sans les espaces de
début et de fin.
• UNION
L’objectif de la commande UNION de SQL est de combiner les résultats de deux requêtes.
La commande UNION est similaire à la Jointure du fait qu’elles sont utilisées pour mettre en
liaison des informations provenant de plusieurs tables.
Remarque
Une restriction de UNION est que toutes les colonnes correspondantes doivent inclure le
même type de données.
Aussi, lors de l’utilisation de UNION, seules les valeurs distinctes sont sélectionnées (similaire
à SELECT DISTINCT).
La syntaxe est comme suit :
[instructions SQL 1]
UNIO
[instructions SQL 2]
Soit la table suivante vente_Internet
29Date montant
07-Jan-1999 250 €
10-Jan-1999 535 €
11-Jan-1999 320 €
12-Jan-1999 750 €
Pour retrouver toutes les dates où il y a des ventes, il faut utiliser l’instruction SQL suivante :
SELECT Date FROM vente
UNION
SELECT Date FROM vente_Internet
Remarque
Avec «SELECT DISTINCT Date» pour les deux instructions SQL, nous obtiendrons le même jeu
de résultats.
• UNION ALL
L’objectif de la commande UNION ALL est aussi de combiner les résultats de deux requêtes
en sélectionnant toutes les valeurs (pas seulement des valeurs distinctes).
[instructions SQL 1]
UNION ALL
[instructions SQL 2]
Exemple
SELECT Date FROM vente
UNION ALL
SELECT Date FROM vente_Internet
• Intersection : INTERSECT
UNION agit comme un opérateur OR (la valeur est sélectionnée si elle apparaît dans la
première ou la deuxième instruction),
INTERSECT agit comme un opérateur AND (la valeur est sélectionnée seulement si elle
apparaît dans les deux instructions).
[instructions SQL 1]
INTERSECT
[instructions SQL 2]
30Trouver toutes les dates où il y a les deux types de ventes : au magasin et sur Internet.
SELECT Date FROM vente
INTERSECT
SELECT Date FROM vente_Internet
• MINUS
MINUS opère sur deux instructions SQL. Elle prend tous les résultats de la première instruction
SQL, puis soustrait ceux de la deuxième instruction SQL pour obtenir la réponse finale.
[instructions SQL 1]
MINUS
[instructions SQL 2]
Exemple :
Trouver toutes les dates où il y a des ventes au magasin, mais pas sur Internet.
SELECT Date FROM vente
MINUS
SELECT Date FROM vente_Internet
Certains SGBD peuvent utiliser EXCEPT au lieu de MINUS.
31Les Sous-requête
Il est possible d’imbriquer une instruction SQL dans une autre.
La partie de la deuxième select est considérée comme "requête interne", alors que la partie
de la première est considérée comme "requête externe".
Une requête (requête interne) peut être imbriquée dans la clause FROM d'une autre requête
(requête externe).
SELECT *
FROM
(
SELECT …
FROM MaTable
) TableReponse
TableReponse est le renommage en table du résultat de la requête, car la clause FROM doit
porter sur des tables nommées.
Exemple
select nom, prenom
from (
select * from etudiant
)T
Sous-requêtes renvoyant une seule valeur
Dans le cas des sous-requêtes ne renvoyant qu'une valeur unique, on peut l'utiliser comme
champ.
A la place de colonnes, on peut placer des sous-requêtes dans la clause SELECT, voir même
combiner par une opération, une colonne et une sous-requête.
Dans la clause SELECT
Afficher l'écart du montant par rapport à la moyenne des montants par date.
SELECT date, montant - (
SELECT AVG(montant)
FROM vente) AS MOYENNE
FROM vente
32GROUP BY date
Dans les filtres WHERE et HAVING
C'est l'endroit le plus classique pour placer une sous-requête.
Quelles sont les ventes au 01/01/2000 qui ont un prix voisin à + 10 ou - 10 € de la moyenne
des prix.
SELECT ville, montant
FROM vente
WHERE montant - (
SELECT AVG(montant)
FROM vente) BETWEEN -10 AND 10
AND DATE = '2000-01-01'
• Afficher les étudiants dont la note est supérieure à la moyenne.
Sous-requêtes renvoyant une liste (Opérateurs IN, ALL et
ANY(SOME) )
Une liste de valeurs ne peut être utilisée comme critère de comparaison que par des
opérateurs spécialisés.
C'est le cas de l'opérateur IN, mais aussi des opérateurs ALL et ANY (ou SOME).
SELECT " colonne 1", "nom de colonne 2",..
FROM " table 1"
WHERE "nom de colonne" [opérateur de comparaison: IN, ALL, ANY]
(SELECT "nom de colonne"
FROM "nom de table 2"
WHERE [condition])
Dans le prédicat IN
Une requête renvoyant une seule colonne avec plusieurs valeurs peut être imbriquée dans le
prédicat IN de la première requête, mais aussi dans les prédicats ALL, SOME(ANY).
SELECT *
FROM Matable
WHERE uneColonne IN (SELECT colonne FROM MaTable )
Exemple
En utilisant une sous-requête, trouver le total des ventes de tous les magasins dans la région
West (Ouest).
33SELECT SUM(montant) FROM vente
WHERE ville IN
(SELECT ville FROM Geographie
WHERE region = 'West')
Une requête renvoyant une valeur unique peut être imbriquée partout où une constante peut
figurer...
SELECT *
FROM MaTable
WHERE MaColonne =
(SELECT AVG(colonne)
FROM UneTable)
SELECT COUNT(*), MaColonne
FROM MaTable
GROUP BY MaColonne
HAVING COUNT(*) = (SELECT …FROM UneTable)
Exemple
Afficher les étudiants dont la note est inférieure à la moyenne.
select *
from notes
where note> ( SELECT avg(note) FROM notes )
Une requête renvoyant des valeurs ou pas peut être imbriquée dans un prédicat EXISTS,
UNIQUE et MATCH.
EXISTS
Cet opérateur teste si la requête interne retourne une ligne au moins.
Si elle le fait, la requête externe peut s’exécuter. Sinon, elle ne s’exécutera pas, et l’instruction
SQL entière ne retournera aucun résultat.
SELECT "nom de colonne 1"
FROM "nom de table 1"
WHERE EXISTS
(SELECT *
FROM "nom de table 2"
WHERE [condition])
34Exemple
SELECT SUM(montant) FROM vente
WHERE EXISTS
(SELECT * FROM Geographie
WHERE region = 'West')
• Sous-requête corrélée
Si la requête interne dépend de la requête externe, nous aurons une sous-requête corrélée.
Trouver les clients qui ont un prénom en commun. Autrement dit pour qu'un client soit
sélectionné, il faut qu'un autre client porte le même prénom.
Une première idée consiste à faire :
SELECT ID, NOM, PRENOM
FROM CLIENT
WHERE PRENOM IN
(SELECT PRENOM
FROM CLIENT)
La réponse donne tous les clients
Pour avoir une réponse correcte il faut retirer dans la sous-requête la référence au client que
l'on scrute dans la requête principale.
SELECT ID, NOM, PRENOM
FROM CLIENT C1
WHERE PRENOM IN
(SELECT PRENOM
FROM CLIENT C2
WHERE C1.ID C2.ID)
Ou avec l'opérateur exists :
SELECT ID, NOM, PRENOM
FROM CLIENT C1
WHERE EXISTS (
SELECT *
35FROM CLIENT C2
WHERE C1. ID C2. ID
AND C1. PRENOM = C2. PRENOM )
Remarque
Remplacer exists par UNIQUE
• CASE
SELECT CASE ("nom de colonne")
WHEN "condition1" THEN "résultat1"
WHEN "condition2" THEN "résultat2"
...
[ELSE "résultatN"]
END
FROM "nom de table"
La "condition" peut être une valeur ou une expression statique. La clause ELSE est optionnelle.
Exemple
Pour multiplier le montant des ventes de 'Los Angeles' par 2 et le montant des ventes de 'San
Diego' par 1,5, il faut saisir :
SELECT ville, CASE (ville)
WHEN 'Los Angeles' THEN montant * 2
WHEN 'San Diego' THEN montant * 1.5
ELSE montant
END
"Nouvelles Ventes",
Date
FROM vente
"Nouvelles Ventes" est le nom donné à la colonne avec l’instruction CASE.
SELECT id, nom, prix_unitaire, quantite,
CASE
WHEN quantite=1 THEN prix_unitaire
WHEN quantite >1 THEN prix_unitaire*2
ELSE prix_unitaire/2
END
FROM achat
3637
38
39
Vous pouvez aussi lire
