Introduction 1/39 2/39 Introduction Anne-Cécile Caron Licence MIAGE - BDD 2015-2016 A partir de l algèbre relationnelle s est construit un langage informatique permettant d interroger les données : SQL Actuellement, le langage SQL comporte plusieurs aspects : I Langage d interrogation et modification des données (DML) I Langage de définition du schéma (DDL) I Aspects système : contrôle d accès, transactions I et depuis la norme SQL3 (1999), des modules stockés, triggers, aspects orientés objets... Aujourd hui nous allons voir le langage d interrogation et modification. Introduction Introduction 3/39 4/39 Objectifs A la fin de ce cours et après avoir fait les TD, TP correspondants vous devez être capables de : I traduire une expression algébrique en requête SQL I traduire une requête du langage naturel vers SQL, requête d interrogation ou de mise à jour I traduire une requête SQL en langage naturel ( que fait cette requête? ) Le schéma exemple Base de données (très simplifiée!) de commandes de produits. CLIENT(num client, nom, prénom, solde) COMMANDE(num commande, date commande,num client) CONTIENT(num commande, num produit, quantité) PRODUIT(num produit, nom, prix unitaire)
Introduction 5/39 6/39 Les données instances du schéma exemple Sélection - Projection client: 1 SOPHIE 500.00 2 LAURENT 500.00 3 DUPONT JULIE 0.00 produit: 1 dentifrice 2.50 2 cahier 2.00 3 crayons 7.50 5 lait 6.50 6 eau 5.50 7 yop 0.80 8 cafe 4.75 4 stylo plume 21.65 commande: 1 2015-01-15 1 2 2015-02-18 1 3 2015-03-16 2 4 2015-04-21 2 contient: 1 2 5 1 3 1 1 4 1 2 5 1 2 7 2 3 5 1 3 6 1 4 1 1 4 2 3 4 8 2 produits de prix supérieur à 4 prix unitaire 4(produit) select * where prix_unitaire >= 4 ; 3 crayons 7.5 4 stylo plume 21.65 5 lait 6.5 6 eau 5.5 8 cafe 4.75 num produit, nom ( prix unitaire 4(produit)) select num_produit, nom where prix_unitaire >= 4 ; 3 crayons 4 stylo plume 5 lait 6 eau 8 cafe 7/39 8/39 Conditions de sélection I On peut bien sûr utiliser les opérateurs booléens : NOT, AND, OR I Opérateurs de comparaison = <= >=!= <> I Attention, pourtesterl absencedevaleur:is NULL ou son contraire IS NOT NULL I colonne in (v1,v2,...,vk) (on verra ensuite qu on peut remplacer cette liste fixe par une sous-requête) I colonne between exp1 and exp2 select num_produit, nom where prix_unitaire in (2,3) ; num_produit nom -------------+--------- 2 cahier Conditions de sélection Pour comparer des chaînes de caractères, on peut utiliser I l opérateur LIKE I ou des expressions régulières à la Unix, opérateur REGEXP_LIKE d Oracle select * where nom like or nom like c% and prix_unitaire<3 ; select * where regexp_like(nom, ^[a-z]{4}$, i ) or regexp_like(nom, ^c, i ) and prix_unitaire<3 num_produit nom prix_unitaire -------------+--------+--------------- 2 cahier 2 <- commence par c et prix < 3 5 lait 6.5 <-- nom avec 4 carac. 8 cafe 4.75 <-- idem
9/39 10 / 39 Entorse au modèle relationnel Le résultat d une requête est un multi-ensemble select nom ; nom -------- DUPONT (3 rows) On dispose de l opérateur distinct pour enlever les résultats identiques. select distinct nom ; nom -------- DUPONT (2 rows) Ordre select * order by nom,prenom ; 3 DUPONT JULIE 0.00 2 LAURENT 500.00 1 SOPHIE 500.00 select nom, prenom where solde > 0 order by nom, prenom LAURENT SOPHIE select * order by prix_unitaire desc, nom asc; 4 stylo plume 21.65 3 crayons 7.5 5 lait 6.5 6 eau 5.5 8 cafe 4.75 1 dentifrice 2.5 2 cahier 2 7 yop 0.8 11 / 39 12 / 39 Groupes I par défaut, 1 relation forme 1 groupe I On peut partitionner une relation en utilisant des valeurs d attributs : group by en SQL I On peut appliquer des fonctions sur chaque groupe : I count(a) :comptelenombredevaleursdanslacolonnea. count(distinct A) :nombredevaleurs emdi é r e n t e s. I sum(a) : fait la somme des valeurs de la colonne A. sum(distinct A) :sommedesvaleursdi é r e n t e. s I min(a) :donnelapluspetitevaleurdelacolonnea. I max(a) :donnelaplusgrandevaleurdelacolonnea. I avg(a) :donnelamoyennedesvaleursdelacolonnea. avg(distinct A) :moyennedesvaleursdi é r e n t e. s Fonction de groupe avg(prix unitaire)(produit) select avg(prix_unitaire) ; avg(prix_unitaire) ------------------ 6.4 nom,count( )(client) select nom, count(*) group by nom ; nom count(*) --------+---------- 2 DUPONT 1
13 / 39 14 / 39 Condition sur les groupes compter le nombre de produits di érents par commande num commande,count( )(contient) select num_commande,count(*) from contient group by num_commande ; num_commande count(*) --------------+---------- 1 3 2 2 3 2 4 3 count( )>2( num cmde,count( ) (contient)) select num_commande,count(*) from contient group by num_commande having count(*) > 2 ; num_commande count(*) --------------+---------- 1 3 4 3 Imbrication de fonctions nombre moyen de produits di érents par commande : select avg(count(*)) as nb_moyen_cmdes from contient group by num_commande ; Le résultat a 1 seule ligne, 1 seule colonne de nom NB MOYEN CMDES : nb_moyen_cmdes -------------------------- 2.5 Remarque : dans cette requête, on a utilisé AS pour renommer une colonne. 15 / 39 16 / 39 Plusieurs relations Pour l instant, les requêtes données en exemples utilisent 1 seule relation. Il existe des opérateurs binaires, qui permettent d utiliser plusieurs relations : I produit cartésien et jointure(s) I union, intersection, di é r e n c e Produit cartésien Exemple : client produit cette requête n a pas beaucoup de sens! I SQL1 : select *,produit ; I SQL2 : select * CROSS JOIN produit ; 1 SOPHIE 500.00 1 dentifrice 2.5 2 LAURENT 500.00 1 dentifrice 2.5 3 DUPONT JULIE 0.00 1 dentifrice 2.5 1 SOPHIE 500.00 2 cahier 2 2 LAURENT 500.00 2 cahier 2 3 DUPONT JULIE 0.00 2 cahier 2... 1 SOPHIE 500.00 4 stylo plume 21.65 2 LAURENT 500.00 4 stylo plume 21.65 3 DUPONT JULIE 0.00 4 stylo plume 21.65 au total CLIENT PRODUIT lignes, i.e. 24 lignes.
17 / 39 18 / 39 Jointure les commandes et les clients qui les ont passées : commande on client I SQL1 : select num_commande, date_commande, nom, prenom from commande, client where commande.num_client = client.num_client ; I SQL2 : select num_commande, date_commande, nom, prenom from commande JOIN client ON commande.num_client = client.num_client ; select num_commande, date_commande, nom, prenom from commande NATURAL JOIN client ; num_commande date_commande nom prenom --------------+---------------+-------+---------- 1 2015-01-15 SOPHIE 2 2015-02-18 SOPHIE 3 2015-03-16 LAURENT 4 2015-04-21 LAURENT Jointure les clients et tous les articles qu ils ont commandés select client.nom, client.prenom, produit.nom, contient.quantite JOIN commande ON client.num_client = commande.num_client JOIN contient ON commande.num_commande = contient.num_commande JOIN produit ON contient.num_produit = produit.num_produit ; nom prenom nom quantite -------+----------+-------------+---------- SOPHIE cahier 5 SOPHIE crayons 1 SOPHIE stylo plume 1 SOPHIE lait 1 SOPHIE yop 2 LAURENT lait 1 LAURENT eau 1 LAURENT dentifrice 1 LAURENT cahier 3 LAURENT cafe 2 19 / 39 20 / 39 Jointure et fonction de groupe les clients et les sommes qu ils ont dépensées select client.nom, client.prenom, sum(quantite*prix_unitaire) as a_depense JOIN commande ON client.num_client = commande.num_client JOIN contient ON commande.num_commande = contient.num_commande JOIN produit ON contient.num_produit = produit.num_produit group by client.num_client, client.nom, client.prenom ; nom prenom a_depense -------+----------+----------- LAURENT 30 SOPHIE 47.25 Jointure externe I Permet de faire apparaître les lignes d une table qui n ont pas de correspondant dans l autre table lors d une équi-jointure (ou inner join). I variantes : left (outer) join, right (outer) join, full (outer) join. Exemple : tous les produits avec le nombre de commandes (même 0) dans lesquels ils figurent. select produit.num_produit, count(contient.num_commande) left join contient on produit.num_produit = contient.num_produit group by produit.num_produit ; -- ou bien select produit.num_produit, count(contient.num_commande) from contient right join produit on produit.num_produit = contient.num_produit group by produit.num_produit ;
Résultat on suppose, juste pour cette requête, que l on a ajouté la ligne (9, sucre,2.50) dans la table PRODUIT num_produit count(contient.num_commande) -------------+------- 1 1 2 2 3 1 4 1 5 2 6 1 7 1 8 1 9 0 <-- pas cette ligne si simple jointure 21 / 39 Opérateurs ensemblistes Union nom(produit) [ nom(client) select nom union select nom ; -- remarque : le résultat n est -- pas forcément dans cet ordre nom ------------ DUPONT cafe cahier crayons dentifrice eau lait stylo plume yop 22 / 39 Le résultat d une union, intersection ou di érence ne contient pas de doublons. Opérateurs ensemblistes Di é r e n c e nom,prénom (client) select nom,prenom except select nom, prenom natural join commande ; nom prenom --------+-------- DUPONT JULIE nom,prénom (client on commande) cet opérateur s appelle minus sous Oracle 23 / 39 Opérateurs ensemblistes Intersection nom, prix unitaire ( nom like c% (produit)) \ nom, prix unitaire ( prix unitaire 7 (produit)) select nom,prix_unitaire where nom like c% intersect select nom,prix_unitaire where prix_unitaire >= 4 ; nom prix_unitaire ---------+--------------- crayons 7.5 cafe 4.75 24 / 39
25 / 39 26 / 39 Opérateurs ensemblistes L élimination des doublons a un coût, c est pourquoi on peut utiliser une union multi-ensembliste : nom ------------ select nom dentifrice union all cahier select nom ; crayons stylo plume lait eau yop cafe DUPONT Sous-requête En SQL, on a la possibilité d imbriquer les requêtes. On peut ainsi trouver une sous requête I pour exprimer une condition, dans la clause WHERE ou HAVING. L expression conditionnelle utilisée va contraindre le type du résultat de la sous requête. I pour représenter une relation, dans la clause FROM. Dans ce cas, la sous-requête aura pour résultat un ensemble de tuples de valeurs. I pour calculer un résultat, dans la clause SELECT. Dans ce cas, la sous-requête aura pour résultat 1 valeur. 27 / 39 28 / 39 Sous-requête Sous-requête non corrélative : le résultat de la sous-requête est calculé, indépendamment de la requête qui l englobe. Exemple : les clients qui n ont pas passé commande select nom,prenom where num_client not in (select num_client from commande) ; Le résultat de la sous-requête est un ensemble de nombres. nom prenom --------+-------- DUPONT JULIE Opérateurs pour les sous-requêtes I IN teste l appartenance à une relation (NOT IN pour la non-appartenance) I EXISTS teste si la relation est non vide (NOT EXISTS sinon) I UNIQUE teste si la relation est un singleton (NOT UNIQUE sinon) I combiné avec un opérateur de comparaison, I op ANY La comparaison est vraie pour au moins 1 élément de la sous-requête. I op ALL La comparaison est vraie pour tous les éléments de la sous-requête. remarque : IN est équivalent à =ANY et NOT IN est équivalent à <>ALL.
29 / 39 30 / 39 Sous-requête le(s) produit(s) le(s) plus cher(s) select nom,prix_unitaire where prix_unitaire >= all( select prix_unitaire ) ; select nom,prix_unitaire where prix_unitaire = ( select max(prix_unitaire) ) ; Sous-requête les produits qui ne sont pas les moins chers select nom,prix_unitaire where prix_unitaire > any( select prix_unitaire ) ; select nom,prix_unitaire where prix_unitaire > ( select min(prix_unitaire) ) ; Expression conditionnelle de la forme valeur >= all sous-requete. Ici, la sous-requête a pour résultat un ensemble de nombres. nom prix_unitaire ------------------+---------------------- stylo plume 21.65 Expression conditionnelle de la forme valeur = sous-requete. Ici, la sous-requête a pour résultat 1 nombre. nom prix_unitaire ------------+---------------------- stylo plume 21.65 crayons 7.5 lait 6.5 eau 5.5 cafe 4.75 dentifrice 2.5 cahier 2 tous sauf le Yop qui vaut 0.8 31 / 39 32 / 39 Sous-requête corrélative Produits qui ont fait l objet d au moins 2 commandes. select nom where 1 < (select count(*) from contient where contient.num_produit = produit.num_produit) ; nom -------- cahier lait Expression conditionnelle de la forme valeur < sous-requete. La sous-requête a pour résultat 1 nombre. Ici, on évalue la sous-requête pour chaque ligne de la table PRODUIT, la sous-requête est dépendante de la requête qui l englobe. Pour cet exemple, on peut écrire une requête équivalente, sans sous-requête. Sous-requête corrélative Pour chaque commande, le produit qui a le plus grand prix unitaire. select co.num_commande, p.nom, p.prix_unitaire from commande co join contient c on c.num_commande = co.num_commande join produit p on p.num_produit = c.num_produit where p.prix_unitaire = (select max(prix_unitaire) p2 join contient c2 on c2.num_produit = p2.num_produit where c2.num_commande = c.num_commande) num_commande nom prix_unitaire -------------+-------------+----------------- 1 stylo plume 21.65 3 lait 6.5 2 lait 6.5 4 cafe 4.75
33 / 39 34 / 39 Sous-requête dans la clause SELECT Le nombre de commandes par client. select nom, prenom, (select count(*) from commande co where co.num_client = client.num_client) nb_commandes nom prenom nb_commandes -------+---------+-------------- SOPHIE 2 LAURENT 2 DUPONT JULIE 0 Sous-requête dans la clause FROM Les numéro des commandes dans lesquelles il y a (au moins) un produit coûtant plus de 5 euros. select distinct co.num_commande from (select * where prix_unitaire >= 5) p join contient co on co.num_produit = p.num_produit NUM_COMMANDE ---------------------- 1 2 3 La sous-requête a pour résultat un ensemble de tuples. Modifications Insert 35 / 39 Modifications Insert 36 / 39 Insertion Insertion - exemple I insertion d un tuple dans une relation d arité p insert into T values (v 1,..., v p ) insert into client values (1,, SOPHIE,500); T est le nom de la table où il faut insérer le tuple (v 1,...,v p ). I Si on veut insérer un tuple dont on ne connaît pas toutes les valeurs des colonnes, on peut préciser pour quelles colonnes on fait l insertion : insert into T (nomcol 1,...,nomcol n ) values (v 1,...,v n ) Dans ce cas, les colonnes absentes prennent la valeur NULL ou une valeur par défaut selon la définition du schéma de la table T. I Il est aussi possible d insérer dans une table le résultat d une requête. La table où l on insère doit avoir un schéma compatible avec le résultat de la requête. insert into T requete insert into client(num_client,nom,prenom) values (3, DUPONT, JULIE ); --> insère la ligne (3, DUPONT, JULIE,0) ici, l attribut solde prend la valeur 0, et non la valeur NULL, car l attribut solde a été défini avec la valeur 0 par défaut. insert into Tbis select * from T ; insert into T3(nom) select nom prenom ;
Modifications Delete 37 / 39 Modifications Update 38 / 39 Suppression Modification I On peut supprimer tous les tuples qui satisfont une condition. delete from T where condition I Sans clause where, on supprime tous les tuples de la relation I On peut modifier tous les tuples qui satisfont une condition, en remplaçant la valeur de certaines colonnes update T set col 1 = e 1,...,col p = e p where condition I La condition suit la même syntaxe que pour une requête de sélection. I Exemple : I Par exemple : delete where nom like DUV% ; supprime les tuples (1,, SOPHIE,500) et (2,, LAURENT,500) de la table CLIENT. update client set nom= DUPOND, prenom= JULIETTE where nom= DUPONT ; cette instruction remplace Julie Dupont par Juliette Dupond. I autre exemple : delete where num_produit not in (select num_produit from contient); supprime les produits qui ne sont pas commandés. Modifications Update 39 / 39 Modification - exemples I En l absence de clause where, tous les tuples seront modifiés. l instruction suivante ajoute donc 100 à tous les soldes des clients. update client set solde = solde+100 ; I On veut enlever du solde des clients la somme qui correspond à leurs commandes. La fonction nvl permet de remplacer une valeur NULL par autre chose. Ici, on remplace NULL par 0 dans le cas où un client n a pas passé de commande. update client set solde = solde - (select nvl(sum(prix_unitaire*quantite),0) join contient on contient.num_produit = produit.num_produit join commande on commande.num_commande = contient.num_commande where client.num_client = commande.num_client )