Transcript Diapositive 1

PSI DAKHLA
Prof: YOUSSEF EL MARZAK
16/07/2015
CPGE DAKHLA
1
I. Introduction:
L'algèbre relationnelle est la base du développement du langage SQL (Structured Query
Langage). Ce langage textuel permet de communiquer avec une base de données
relationnelle. Il a été réalisé par IBM puis est devenu un standard ANSI (American National
Standards Institute) approuvé par l'ISO (International Standards Organization) en 1987.
SQL/92 est la norme très répandue. Le dernier standard validé est SQL3 appelé bien
souvent SQL/99. Toutefois, pour avoir un langage plus complet, les concepteurs de SGBD/R
ajoutent certaines fonctionnalités au SQL standard.
Parmi les différentes fonctionnalités SQL, il est possible de retrouver les catégories de
commandes suivantes :
- DDL (Data Définition Language) qui permet de définir et de modifier le schéma d'une base
de données relationnelle.
- DML (Data Manipulation Language) qui permet la modification d'une base de données
relationnelle.
- DQL (Data Query Language) qui permet l'interrogation de la base de données
relationnelle.
- DCL (Data Contrôle Language) pour contrôler la sécurité et l'intégrité de la base de
données relationnelle.
Seules l'interrogation et la manipulation des données seront abordées.
16/07/2015
CPGE DAKHLA
2
II. Création, modification et suppression des tables
Le SQLite prend en charge les trois commandes suivantes:
CREATE
ALTER TABLE
DROP
À. Création des tableaux
Définition
- Les tables constituent l'unité de base du stockage des données.
- Définir un nom, les attributs
- pour chaque attribut :
- Définir le type de données,
- La ou les contrainte(s)
16/07/2015
CPGE DAKHLA
3
Type de donnée:
INTEGER - un entier signé
REAL une valeur à virgule flottante
TEXT - une chaîne de texte
NUMERIC- type numerique
DATETIME- type date
Syntaxe générale
Create table nom_table
(
nom_colonne_1 type_données_1 [contrainte],
nom_colonne_2 type_données_2 [contrainte],
.
nom_colonne_n type_données_2 [contrainte]
);
16/07/2015
CPGE DAKHLA
4
Exemple :
CREATE TABLE etudiant (
Numero_etudiant INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT
UNIQUE,
nom TEXT,
ville TEXT
);
TABLE etudiant :
Numero etudiant
16/07/2015
nom
ville
CPGE DAKHLA
5
B.La suppression d ’une table
L'instruction DROP est utilisé pour supprimer une table d'une base
de données.
Syntaxe :
Drop table nom_de_la_table ;
Ou
DROP TABLE IF EXISTS nom_de_la_table ;
Essayer de supprimer une table qui n'existe pas conduit à une erreur. Avec
la clause IF EXISTS nous pouvons éviter cette erreur.
Exemple:
DROP TABLE IF EXISTS
16/07/2015
etudiant;
CPGE DAKHLA
6
C. modifier une table
SQLite prend en charge un sous-ensemble limité de l'instruction ALTER
TABLE. Cette déclaration en SQLite permet à un utilisateur de renommer
une table ou d'ajouter une nouvelle colonne à une table existante.
Renommer une table
Exemple
CREATE TABLE Names(Id INTEGER, Name TEXT);
id
name
Laissez-nous créer une table appelée noms que nous voulons renommer.
ALTER TABLE Names RENAME TO NamesOfFriends;
 ajouter une nouvelle colonne à la table.
ALTER TABLE NamesOfFriends ADD COLUMN Email TEXT;
 L'instruction SQL ajoute une nouvelle colonne nommée Email à la table name.
id
16/07/2015
name
CPGE DAKHLA
email
7
III. Insertion, mise à jour et suppression de données
Dans cette partie du cour sur SQLite, nous allons insérer, mettre
à jour et supprimer des données d’une table. Nous allons utiliser
les clauses INSERT , DELETE , et UPDATE .
A. Insertion des données
L’ instruction INSERT est utilisée pour insérer des données dans
des tables. .
Syntaxe:
INSERT INTO nom-TABLE VALUES ( ' valeur1 ',' valeur2 ‘,….) ;
OU
INSERT INTO nom-TABLE(col1,col2) VALUES ( ' valeur1 ',' valeur2 ') ;
Nous créons une nouvelle table livres , avec Id , titre , auteur ,
et code_bare colonnes.
exemple:
16/07/2015
CREATE TABLE livres(Id INTEGER PRIMARY KEY, titreTEXT, auteurTEXT,
code_bare TEXT DEFAULT 'not available');
CPGE DAKHLA
8
Id
Titre
Auteur
Code_bare
INSERT INTO livres(Id, titre, Auteur, code_bare) VALUES(1, 'War and Peace', 'Leo
Tolstoy', '978-0345472403');
INSERT INTO livers VALUES(2, 'Crime and Punishment', 'Fyodor Dostoevsky',
'978-1840224306');
INSERT INTO livres (Id, Titre) VALUES (3, 'Paradise Lost ‘);
On obtiens:
Id
titre
1
War and Peace
2
3
16/07/2015
auteur
Code_bare
Leo Tolstoy
978-0345472403
Crime and
Punishment
Fyodor Dostoevsky
978-1840224306
Paradise Lost
NULL
not available
CPGE DAKHLA
9
B. Suppression des données
DELETE est utilisé pour supprimer les données de tables. Tout d'abord, nous
allons supprimer une ligne d'une table. Nous allons utiliser le table livres, que
nous avons créé précédemment.
Syntaxe:
DELETE FROM nom-table
[WHERE condition;
Exemple:
DELETE FROM livres WHERE Id=1;
On obtiens:
Id
Titre
2
3
16/07/2015
Auteur
Code_bare
Crime and
Punishment
Fyodor
Dostoevsky
978-1840224306
Paradise Lost
NULL
not available
CPGE DAKHLA
10
C.la mise à jour des données
instruction est utilisée pour modifier la valeur des colonnes
dans les lignes sélectionnées d'une table.
UPDATE
Syntaxe:
UPDATE <nom de la table>
SET <attribut>=<' valeur '>
[WHERE <condition>] ;
UPDATE livres SET Auteur=Nikolayevich Tolstoy' WHERE Id=1;
Id
Titre
1
War and Peace
2
Crime and
Punishment
Fyodor Dostoevsky
'978-1840224306
3
Paradise Lost
NULL
'not available
16/07/2015
auteur
code-_bare
Nikolayevich Tolstoy '978-0345472403
CPGE DAKHLA
11
IV. Contraintes dans SQLite
Nous avons les contraintes suivantes:
NOT NULL
UNIQUE
PRIMARY KEY
FOREIGN KEY
CHEK
DEFAULT
A. contrainte NOT NULL
Une colonne avec un NOT NULL contrainte ne peut pas avoir NULL valeurs.
Exemple:
CREATE TABLE personnes (id INTEGER, NOM TEXTE NOT NULL,
Prénom TEXTE NOT NULL, Ville TEXTE);
INSERT INTO personnes(id, NOM,
Prénom, Ville ) VALUES (1, 'Hanks', 'Robert', 'New York');
INSERT INTO personnes(id, NOM,
Prénom, Ville ) VALUES (2, NULL, 'Marianne', 'Chicago');
Error: personnes.NOM may not be NULL
ne NOM peut pas être NULL .
16/07/2015 le message d'erreur indique la colonne
CPGE DAKHLA
12
B.Contrainte UNIQUE
L' UNIQUE contrainte garantit que toutes les données sont uniques dans une colonne.
Exemple:
CREATE TABLE Marques (Id INTEGER, NOMMarques TEXT
UNIQUE);
INSERT INTO Marques VALUES (1, 'Coca-Cola');
INSERT INTO Marques VALUES(2, 'Pepsi');
INSERT INTO Marques VALUES(3, 'Pepsi');
Error: column NOMMarques is not unique
Nous obtenons une erreur «colonne NOMMarques n'est pas
unique. Il ne peut y avoir que une seule marque Pepsi.
16/07/2015
CPGE DAKHLA
13
C. Clé primaire
La PRIMARY KEY contrainte identifie de façon unique chaque enregistrement d'une table de
base de données. Il peut y avoir plus UNIQUE colonnes, mais seulement une clé primaire dans
une table. Les clés primaires sont importantes lors de la conception des tables de base de
données. Les clés primaires sont des identifiants uniques. Nous les utilisons pour désigner
les lignes du tableau. Les clés primaires deviennent des clés étrangères dans d'autres tables
lors de la création de relations entre les tables. Grâce à un «contrôle de codage de longue
date», les clés primaires peuvent être NULL dans SQLite. Ce n'est pas le cas avec d'autres
bases de données.
Exemple
CREATE TABLE Marque(Id INTEGER PRIMARY KEY,
NOMMARQUE TEXT);
INSERT INTO Marque (NOMMarque) VALUES('Coca Cola');
INSERT INTO Marque (NOMMarque) VALUES('Pepsi');
INSERT INTO Marque (NOMMarque) VALUES(‘sun');
INSERT INTO Marque (NOMMarque) VALUES ('Oracle');
On obtiens:
ID
NOMMarque
1
Coca Cola
2
Pepsi
3
Sun
4
'Oracle
SQLite si une colonne est INTEGER et PRIMARY KEY , il est également autoincrémenté.
16/07/2015
CPGE DAKHLA
14
D.Clé étrangère
FOREIGN KEY (contrainte d’intégrité référentielle)
Indique que la colonne est clé étrangère qui fait rèfèrence à la colonne de la
table rèfèrence.
Si aucune colonne de la table référentielle n’est indiquée, c’est la clé
primaire de la table référentielle qui est prise par défaut.
Sur une table:
FOREIGN KEY (col1, col2,....) REFERENCES table_ref (colr1, colr2,....)
CREATE TABLE Authors(AuthorId INTEGER PRIMARY KEY, Name
TEXT);
CREATE TABLE Books(BookId INTEGER PRIMARY KEY, Title TEXT,
AuthorINTEGER,
FOREIGN KEY(Author) REFERENCES Authors(AuthorId));
Nous créons Books table. Ici, nous avons un AuthorId nom de la colonne, qui
agit comme une clé étrangère. Il fait référence à la clé primaire de
la Authors table.
16/07/2015
CPGE DAKHLA
15
E.CHECK (condition):
Cette contrainte permet de spécifier des conditions que la
ou les colonnes devront vérifier :
CREATE TABLE Orders(Id INTEGER PRIMARY KEY, OrderPrice INTEGER
CHECK(OrderPrice>0),
Customer TEXT);
Nous regardons la définition de la table Orders. Nous voyons
un CHECK contrainte imposée sur la colonne OrderPrice . Logiquement, le prix
d'une commande doit être une valeur positive.
INSERT INTO Orders(OrderPrice, Customer) VALUES(-10, 'Johnson');
Error: constraint failed
Si on cherche à insérer une valeur non valide, nous obtenons une
erreur en disant ‘contrainte échoué’.
16/07/2015
CPGE DAKHLA
16
F.contrainte par défaut
Le DEFAULT contrainte insère une valeur par défaut dans la colonne si aucune valeur n'est disponible.
CREATE TABLE Hotels(Id INTEGER PRIMARY KEY, Name TEXT,
City TEXT DEFAULT 'not available');
INSERT INTO Hotels(Name, City) VALUES(‘ATLAS', MARRAKECH');
INSERT INTO Hotels(Name) VALUES(SAHARA');
16/07/2015
id
name
city
1
ATLAS
MARRAKECH
2
SAHARA
not available
CPGE DAKHLA
17
V. Les requêtes SQLITE
A)
Les requêtes simples
1- les principaux mots
Mots
SELECT
FROM
WHERE
GROUP BY
HAVING
ORDER BY
Arguments
Attribut(s)
Table(s)
Condition(s) sur une ligne
Attribut(s) de partitionnement
Condition(s) de sélection sur un
groupe de lignes
Attribut(s) de tri
2- Les opérations
16/07/2015
CPGE DAKHLA
18
soit le schéma relationnel est le suivant :
CANDIDAT
PK_CANDIDAT
NUMCANDIDAT
NO MCANDIDAT
DATENAISSANCE
LIEUNAISSANCE
EMPRUNT ER
PK_EMPRUNTER
NUMCANDIDAT
CO DELIVRE
LIVRE
DATEEMPRUNT
DATERETOUR
PK_L IVRE
CO DELIVRE
CO DEEDIT EUR
NO MLIVRE
NBREPAGES
GENRE
EDITEUR
PK_EDITEUR
CO DEEDIT EUR
REALISER
NO MEDITEUR
ADRESSEEDITEUR
CPEDIT EUR
VILLEEDIT EUR
Liste des CANDIDATS
Numéro
Candidat
12
Nom Candidat
Date Naissance
Lieu Naissance
BERTRAND
20/08/1978
RENNES
10
FAURE
12/12/1977
CAEN
8
HIRARD
20/12/1978
LILLE
15
FAURE
01/11/1977
ST LO
Liste des LIVRES
16/07/2015
Code Livre
Nom Livre
Nbre de Pages
Genre
I101
Info.
100 Informatique
FOU1
I102
Info.
123 Informatique
DUN1
F021
OMG
43 Gestion
DUN1
E120
FISCALITÉ
67 Gestion
FOU1
CPGE DAKHLA
Code Editeur
19
Liste des EDITEURS
Code Editeur
Nom Editeur
Adresse Editeur
CP Editeur
Ville Editeur
FOU1
Foucher
31, rue de Fleurus
75006
PARIS
DUN1
Dunod
14, rue de Prague
75008
PARIS
HA2
Hachette
5, rue d'Italie
75006
PARIS
Liste des EMPRUNTS
Numéro candidat
Code Livre
Date Emprunt
Date Retour
10
I101
1/10/2003
1/11/2003
8
I101
1/11/2003
12/11/2003
10
I102
14/12/2003
16/07/2015
CPGE DAKHLA
20
a) La projection
Rappel : Une projection permet d'extraire des colonnes spécifiées d'une table.
Une projection s'exprime à l'aide de SQLITE par la commande :
SELECT [ALL | DISTINCT] [colonne1 , colonne2 .....]
FROM nomtable ;
Par défaut, SQLite n'élimine pas les doubles à moins que cela soit explicitement demandé par le mot clé
DISTINCT
Exemple : Pour obtenir la liste des noms des candidats avec leur date de naissance de la table CANDIDAT il sera
nécessaire d'écrire :
SELECT NomCandidat, DateNaissance FROM candidat ;
Si l'on souhaite éliminer les doubles, il faudrait noter :
SELECT DISTINCT NomCandidat, DateNaissance FROM candidat ;
16/07/2015
CPGE DAKHLA
21
b) La sélection
On parle également à ce niveau de restriction.
Une sélection s'exprime à l'aide de SQLite par la commande :
SELECT * FROM nomtable
WHERE condition ;
Le symbole * signifie que l'on affiche toutes les colonnes d'une table. La combinaison avec une
projection s'effectue en remplaçant * par la liste des colonnes à projeter.
Exemple 1 : On désire connaître les caractéristiques du ou des candidats dont le nom est
FAURE.
SELECT *FROM CANDIDAT
WHERE NomCandidat IN('Faure') ;
De manière plus générale, la condition suivant la commande WHERE peut inclure
différents opérateurs de comparaison et différents opérateurs booléens :
* les opérateurs de comparaison
16/07/2015
SYMBOLE
SIGNIFICATION
=
Égal
<>
Différent
=!
<
Inférieur
>
Supérieur
<=
Inférieur ou égal
CPGE
DAKHLA
>=
Supérieur ou égal
22
l'opérateur LIKE
Où chaîne est une chaîne de caractères pouvant contenirs l’un des caractères jokers :
_ : Remplace exactement un caractère.
% : Remplace une chaîne de caractères de longueur quelconque, y compris
de longueur nulle.
Exemple:
Quels sont les condidats dont le nom commence par M ?
SELECT NomCandidat FROM CANDIDAT
WHERE NomCandidat LIKE ‘M%’ ;
* les opérateurs logiques
SYMBOLE
Between...AND...
Like
IS NULL
IN
SIGNIFICATION
Entre ... et ...
Comme
Dont la valeur est nulle
Compris dans la liste
* les opérateurs booléens
16/07/2015
SYMBOLE
AND
OR
NOT(1)
SIGNIFICATION
ET
OU
NON
CPGE DAKHLA
23
le tri
*
Il est possible de trier les résultats suivant l'ordre ascendant (mot clé : ASC)
ou descendant (mot clé : DESC) d'une ou plusieurs colonnes.
La commande SQLITE sera la suivante :
ORDER BY {expression | position} [ASC | DESC] [,{expression | position} [ASC
| DESC] ....]
Exemple : on désire relever les candidats dont le nom est FAURE en
affichant N°candidat et le lieu de naissance. Les données seront
présentées dans l'ordre croissant des lieux de naissance. L'instruction
SQLITE sera la suivante
SELECT NumCandidat, Lieu naissance FROM CANDIDAT
WHERE NomCandidat IN('Faure')
ORDER BY Lieu naissance ;
l'on veut obtenir les mêmes données mais en affichant les lieux de
naissance dans un ordre décroissant, l'instruction SQLITE peut être la
suivante :
Si
16/07/2015
CPGE DAKHLA
24
SELECT NumCandidat, Lieu naissance FROM CANDIDAT
WHERE NomCandidat IN('Faure')
ORDER BY Lieu naissance DESC ;
On remarque que l'on a utilisé une syntaxe qui consiste à indiquer la
position de la colonne dans la commande SELECT.
c) la jointure
Cette opération consiste à joindre 2 tables avec un critère de sélection. Une sélection s'exprime
à l'aide de SQLITE par la commande :
SELECT *
FROM nomtable1, nomtable2
WHERE nomtable1.clé=nomtable2.clé ;
Exemple : on veut joindre la table EMPRUNTER et la table CANDIDAT.
L'instruction SQLITE sera la suivante :
SELECT *
FROM Candidat , Emprunter
WHERE Candidat.NumCandidat=Emprunter.NumCandidat ;
16/07/2015
CPGE DAKHLA
25
Il est possible de renommer les tables par des alias. Cela permet notamment
d'écrire plus rapidement le code pour réaliser des requêtes et de réduire les
erreurs de frappe. Ainsi pour l'exemple précédent, il est possible d'écrire la
même requête de la manière suivante :
SELECT *
FROM Candidat C , Emprunter E
WHERE C.NumCandidat=E.NumCandidat ;
Avec le langage SQLITE , il est possible de combiner les différentes opérations.
Il est ainsi possible de donner la liste des livres (nom des livres, genre et code
éditeur) empruntés par les candidats FAURE. Dans la table on fera également
apparaître le N° candidat pour distinguer éventuellement les candidats ayant le
même nom.
Les différentes instructions sont les suivantes :
SELECT Condidat.NumCandidat, Nom livre, Genre, Code_Editeur
FROM Candidat C, Emprunter E, Livre L
WHERE C. NomCandidat IN('FAURE')
AND C.NumCandidat = E.NumCandidat
AND E.code_livre = L.code_livre ;
16/07/2015
CPGE DAKHLA
26
d) Les fonctions de calcul et les regroupements
* Les fonctions de calcul
Il est possible d'effectuer dans une requête SQL, des calculs horizontaux
sur des lignes en utilisant les opérateurs +, -, *, / aussi bien dans la
commande SELECT que dans la commande WHERE. Les arguments des
opérateurs sont des noms de colonnes de type numérique ou des
constantes.
Exemple : on souhaite afficher la table EMPRUNTER avec des dates
d'emprunt décalées de 2 jours et ne pas afficher les dates de retour.
L'instruction SQLITE sera la suivante
SELECT NumCandidat, CodeLivre, DateEmprunt+2
FROM Emprunter ;
Exemple : on souhaite afficher le numéro des candidats qui ont
rendu le livre après 20 jours d'emprunt.
SELECT NumCandidat
FROM Emprunter
WHERE DateRetour > DateEmprunt +20 ;
16/07/2015
CPGE DAKHLA
27
* Les fonctions agrégatives
Elles permettent d'effectuer des calculs verticaux pour l'ensemble ou un
sous-ensemble des valeurs d'une colonne.
Les fonctions principales sont les suivantes :
FONCTIONS
SUM
SYMBOLE
permet d'effectuer la somme des valeurs d'une colonne numérique
AVG
permet d'effectuer la moyenne des valeurs d'une colonne numérique
MAX
permet de rechercher la valeur maximale d'une colonne numérique
MIN
permet de rechercher la valeur minimale d'une colonne numérique
COUNT(1)
permet de compter le nombre de valeurs d'une colonne
(1)
- Pour compter le nombre de lignes sélectionnées, la fonction doit être utilisée
avec l'argument *.
- Pour compter le nombre de valeurs distinctes prises par une colonne, il faut
indiquer l'argument DISTINCT suivi de l'argument considéré.
16/07/2015
CPGE DAKHLA
28
- instructions portant sur l'ensemble d'une colonne
Il n'y a pas ici de difficultés particulières
Exemple 1
Vous souhaitez déterminer le nombre de candidats.
SELECT COUNT(NumCandidat) AS NbCandidat
FROM CANDIDAT ;
Exemple 2
Vous cherchez à déterminer le total des pages à lire.
SELECT SUM(NbrePages) AS SommePages
FROM LIVRE
Exemple 3
On désire déterminer la moyenne des pages pour les livres. La requête sera la suivante :
SELECT AVG(NbrePages) AS MoyPage
FROM LIVRE ;
16/07/2015
CPGE DAKHLA
29
- Instructions portant sur les sous-ensembles d'une colonne
° Le partitionnement
Il doit permettre d'effectuer des calculs statistiques pour chaque sous-ensemble de lignes vérifiant un
même critère. Le partitionnement s'exprime en SQLITE par la commande GROUP BY suivie du nom
des colonnes de partitionnement.
Exemple 1
Vous souhaitez déterminer le nombre d'emprunt pour chaque candidat ayant emprunté un livre.
SELECT NumCandidat, COUNT(NumCandidat) AS
FROM EMPRUNTER
GROUP BY NumCandidat ;
Nbd'emprunt
Exemple 2
Vous cherchez à déterminer le total des pages par code éditeur
SELECT CodeEditeur, SUM(NbrePages) AS SommePages
FROM LIVRE
GROUP BY CodeEditeur ;
Exemple 3
Vous cherchez à déterminer la moyenne du nombre moyen de pages par éditeur.
SELECT CodeEditeur, AVG(NbrePages) AS MoyPage
FROM LIVRE
GROUP BY CodeEditeur ;
16/07/2015
CPGE DAKHLA
30
° Les conditions sur des classes de lignes.
Lorsqu'une condition de recherche doit être exprimée non pas sur les lignes (WHERE)
d'une table mais sur les classes de lignes introduites par un partitionnement, il est
nécessaire d'utiliser la commande HAVING.
Vous cherchez à sélectionner et visualiser pour chaque éditeur le nombre moyen de
pages proposées. Seuls les éditeurs proposant une moyenne du nombre de pages
supérieure à 100 devront être visualisés.
SELECT CodeEditeur, AVG(NbrePages) AS MOYPAGE
FROM LIVRE
GROUP BY CodeEditeur
HAVING AVG(NbrePages) >100 ;
B) Les requêtes imbriquées
Elles sont appelées également sous-requêtes. Il s’agit d’une requête incorporée
dans la commande WHERE ou HAVING d’une autre requête (requête principale).
Cette dernière utilise les résultats de la sous-requête.
Certaines sous-requêtes permettent de remplacer les jointures. Les sous-requêtes
renvoient une ou plusieurs valeurs.
16/07/2015
CPGE DAKHLA
31
1- La requête ne renvoie qu’une seule valeur.
L’imbrication de la requête avec la sous-requête se fera avec un opérateur de comparaison (=, >, etc)
On souhaite connaître le code éditeur et le nom de l’éditeur du livre I101
La requête SQLITE peut alors être la suivante :
SELECT CodeEditeur, NomEditeur
FROM EDITEUR, LIVRE
WHERE CodeEditeur.EDITEUR=CodeEditeur.LIVRE
AND CodeLivre IN ('I101')
Elle peut également être la suivante :
SELECT CodeEditeur,NomEditeur
FROM EDITEUR
WHERE CodeEditeur =
(SELECT CodeEditeur
FROM LIVRE
WHERE CodeLivre IN('I101')) ;
16/07/2015
CPGE DAKHLA
32
Remarque : La sous-requête est notée entre parenthèses.
Les requêtes imbriquées sont particulièrement adaptées avec des fonctions statistiques dans
la sous-requête.
Exemple :
- Quel est le CodeLivre ayant le nombre de pages le plus élevé ?
SELECT CodeLivre
FROM LIVRE
WHERE NbrePages =
(SELECT Max(NbrePages)
FROM LIVRE );
16/07/2015
CPGE DAKHLA
33
2- La sous-requête renvoie plusieurs valeurs
L’imbrication se fera avec bien souvent l’opérateur logique IN
Exemple :
On souhaite connaître le code editeur et le nom de l’éditeur des livres appelés INFO
La requête SQLITE peut alors être la suivante :
SELECT Distinct CodeEditeur, NomEditeur
FROM EDITEUR, LIVRE
WHERE CodeEditeur.EDITEUR=CodeEditeur.LIVRE
AND NomLivre IN('Info')
Elle peut également être la suivante :
SELECT CodeEditeur,NomEditeur
FROM EDITEUR
WHERE CodeEditeur IN
(SELECT CodeEditeur
FROM LIVRE
WHERE NomLivre IN('Info')) ;
Dans la première formulation, la mention DISTINCT permet d’éliminer les doublons.
ORDER BY ne peut être noté dans une sous-requête.
16/07/2015
CPGE DAKHLA
34