chapitre 1 généralités sur les bases de...

Chapitre 1 Généralités sur les bases de données

I. Définition d’un SGBD Une base de données, généralement appelée BD est un ensemble structuré et organisé permettant le stockage de grandes quantités d'informations afin d'en faciliter l'exploitation (ajout, mise à jour, recherche de données) et accessibles de façon sélective par plusieurs utilisateurs.

La gestion et l'accès à une base de données sont assurés par un ensemble de programmes qui constituent le Système de gestion de base de données (SGBD). Un SGBD héberge généralement plusieurs bases de données, qui sont destinées à des logiciels différents ou des thématiques différentes.

II. Fonctions d’un SGBD D'une manière générale, un SGBD doit avoir les caractéristiques suivantes :

- Indépendance physique : Le niveau physique peut être modifié indépendamment du niveau conceptuel. Cela signifie que tous les aspects matériels de la base de données n'apparaissent pas pour l'utilisateur, il s'agit simplement d'une structure transparente de représentation des informations.

- Indépendance logique : le niveau conceptuel doit pouvoir être modifié sans remettre en cause le niveau physique, c'est-à-dire que l'administrateur de la base doit pouvoir la faire évoluer sans que cela gêne les utilisateurs.

- Manipulabilité : des personnes ne connaissant pas la base de données doivent être capables de décrire leurs requêtes sans faire référence à des éléments techniques de la base de données. Ceci peut se faire à travers un dictionnaire de données ou un catalogue système.

- Rapidité des accès : le système doit pouvoir fournir les réponses aux requêtes (recherches d’informations à partir d’une ou plusieurs bases de données) le plus rapidement possible, cela implique des algorithmes de recherche rapides.

- Différents langage d’accès : le SGBD doit au moins supporter un langage adressant les concepts du modèle (par exemple, dans le cas du modèle relationnelle, ce langage est SQL). Néanmoins, ce type de langage ne permet pas tous les types de manipulation. Pra conséquent, soit les SGBD proposent un langage plus complet avec la possibilité de définir des accès à la base de données, soit ils proposent un couplage d’un langage de type SQL avec un langage de programmation conventionnel.

- Administration centralisée : le SGBD doit permettre à l'administrateur de pouvoir manipuler les données, insérer des éléments, vérifier son intégrité de façon centralisée.

- Limitation de la redondance : le SGBD doit pouvoir éviter dans la mesure du possible des informations redondantes, afin d'éviter d'une part un gaspillage d'espace mémoire mais aussi des erreurs.

- Vérification de l'intégrité : les données doivent être cohérentes entre elles, de plus lorsque des éléments font références à d'autres, ces derniers doivent être présents.

- Partage des données : le SGBD doit permettre à plusieurs utilisateurs d’accéder à la base de données de manière simultanée et transparente.

- Sécurité des données : le SGBD doit permettre de spécifier qui a le droit d’accéder ou de modifier tout ou une partie d’une base de données. Il faut donc présenter des mécanismes permettant de gérer les droits d'accès aux données selon les utilisateurs afin de se prémunir contre les manipulations illicites intentionnelles ou accidentelles.

- Résistance aux pannes : le SGBD doit garantir la cohérence de l’information et des traitements en cas de panne. Les opérations sur les bases de données pouvant être très longues, il faut fournir un mécanisme de reprise en cas de panne matérielle ou logicielle, intentionnelle ou fortuite.

Base de données 2

- Capacité de stockage élevée : le SGBD doit permettre de gérer des données très volumineuses, pouvant atteindre plusieurs milliards d’octets. Les unités de stockage sont passées du mégaoctet Mo (106 octets) au gigaoctet Go (109), puis au téraoctet To (1012), puis petaoctet Po (1016), voir même au exaoctet Eo (1018) et zettaoctet Zo (1021).

III. Avantages de l’utilisation des SGBD Avant l’arrivée des bases de données (et encore dans beaucoup de cas aujourd’hui), chaque application écrite pour un organisme travaillait avec ses propres fichiers.

Une même information (l’adresse d’un client par exemple) peut alors être enregistrée dans plusieurs fichiers disjoints. Ceci occasionne des délais de mise à jour et peut amener les différentes applications à travailler sur des données contradictoires.

Quand la gestion se fait avec une base de données centralisée (centralisée « logiquement » mais pas nécessairement physiquement si la base de données est répartie sur plusieurs sites), chaque donnée n’est enregistrée qu’en un seul endroit de la base et il ne peut y avoir ce genre de problèmes. Cette centralisation facilite donc le maintien de l’intégrité des données.

Les facilités offertes par les SGBD pour contrôler l’accès des utilisateurs aux données de la base et les reprises automatisées après incident accroissent la sécurité dans le traitement des données.

Les SGBD offrent aussi des instructions très puissantes pour le traitement des données : un seul ordre SELECT du langage SQL peut correspondre à des dizaines de lignes de programmation dans un langage de troisième génération comme le langage C. La productivité des programmeurs est ainsi fortement augmentée.

En plus de l’indépendance des programmes vis-à-vis de l’implantation physique des données, d’autres avantages importants sont apportés par l’utilisation des SGBD évolués des dernières générations (en particulier par les SGBD relationnels). Ces SGBD offrent : - L’indépendance des programmes vis-à-vis de la structure logique des données (stratégie d’accès aux

données, manière de regrouper les données,…) - L’interrogation directe de la base par les utilisateurs dans un langage non procédural.

Ces différents points facilitent grandement la maintenance des applications et permettent plus de souplesse pour le traitement des données enregistrées.

IV. Niveaux de description des bases de données Trois niveaux de description des données ont été définis par la norme ANSI/SPARC. - Niveau interne : description du stockage des données au niveau des unités de stockage, des fichiers, ...

On appelle cette description le schéma interne.

- Niveau conceptuel : description de la structure de toutes les données qui existent dans la base, description de leurs propriétés (relations qui existent entre elles) c'est-à-dire de leur sémantique inhérente, sans soucis d'implémentation physique ni de la façon dont chaque groupe de travail voudra s'en servir. On appelle cette description le schéma conceptuel.

- Niveau externe : description pour chaque utilisateur de sa perception des données. On appelle cette description le schéma externe ou vue.

Ce cours abordera plus particulièrement le niveau conceptuel.

V. Type d’utilisateurs d’une base de données L’administrateur de la base est chargé du contrôle de la base de données. Il est chargé de permettre l’accès aux données aux applications ou individus qui y ont droit et de conserver de bonnes performances d’accès à ces données. Il est aussi chargé des sauvegardes et des procédures de reprise après panne.

Base de données 3

Le programmeur d’applications utilise la base de données pour construire ses applications. Il a droit de créer de nouvelles tables et les structures associées (vue, index, cluster,…). Il définit avec l’administrateur de la base les droits qui seront accordés aux utilisateurs des applications qu’il développe.

L’utilisateur final n’a accès qu’aux données qui lui sont utiles. L’administrateur de la base peut lui accorder certains droits : consultation, modification, suppression des données. En général, il n’a pas le droit de créer de nouvelles tables ni d’ajouter ou d’enlever des index.

VI. Les différents types de SGBD Le type d'un SGBD est caractérisé par le type du modèle de données qu'il implémente. Il existe ainsi cinq types de modèles de données :

- Le modèle hiérarchique : les données sont stockées hiérarchiquement, selon une arborescence descendante. Ce modèle s’apparente à l’organisation des répertoires d’un ordinateur. Ce type de SGBD est particulièrement adapté à la modélisation de nomenclatures. Si le principe de relation « 1 vers N » n’est pas respecté, alors la hiérarchie doit être transformée en un réseau. Les structures de données hiérarchiques ont été très utilisées dans les premiers SGBD car très simple d’implémentation.

- Le modèle réseau : ce modèle est une extension du modèle précédent, il est alors possible d’établir des relation « 1 vers N » en définissant des associations entre tous les types d’enregistrements. Cependant, pour retrouver une donnée dans une telle modélisation, il faut connaitre le chemin d’accès, ce qui rend les programmes encore dépendants de la structure de données.

Directeur

Directeur commercial Directeur technique Directeur des ressources humaines

Directeur technique adjointAssistant Responsable du personnel

Responsable logistique Responsable fabrication

- Le modèle déductif : les données sont modélisées dans des tables, mais leur manipulation se fait par calcul de prédicats. C'est le modèle le moins courant.

- Le modèle objet (SGBDOO, Système de Gestion de Bases de Données Orienté Objet) : les données sont stockées sous forme d'objets, c'est-à-dire de structures appelées classes présentant des données membres qui les décrivent et représentent leur état. Les objets contiennent aussi la logique qui permet des les utiliser et des les modifier. Tous ces objets sont classés hiérarchiquement dans une base de données à objets.

- Le modèle relationnel (SGBDR, Système de Gestion de Bases de Données Relationnelles) : les données sont modélisées dans des tables ou relations. La manipulation de ces données se fait selon la théorie mathématique des relations.

PERSONNE VILLE ID Nom Prénom DateNaiss VilleNaiss ID Nom Polulation Superficie Région 1 Dupont Bob 01/01/1950 1 1 Paris 2 153 600 105.40 km² 2 2 Durand Gérard 29/04/1998 3 2 Lyon 466 400 47.95 km² 3 3 Marchand Daniel 26/12/2005 1 3 Marseille 820 900 260.62 km² 4

Père Nom : Gérard Age : 35 ans

Fils Nom : Eric Age : 2 ans

Fils Nom : Jean Age : 7 ans

Fils Nom : Tom Age : 10 ans

Famille

Base de données 4

La souplesse apportée par cette représentation et les études théoriques appuyés sur la théorie mathématique des relations ont permis le développement de langages puissants non procéduraux. Dans ces langages, l’utilisateur ou le programmeur indique quelles informations il veut obtenir e c’est le SGBD qui trouve la manière d’arriver au résultat. Le programme ou l’utilisateur n’a plus à navigue dans la base pour retrouver ses données. Ces langages peuvent être utilisés par des non-informaticiens et permettent l’écriture de programmes indépendants de la structure logique et physique des données. Le langage SQL est un standard parmi tous ces langages.

L’inventeur du modèle relationnel est Codd qui travaillait dans les laboratoires d’IBM. Il a énoncé douze règles que doivent vérifier les SGBD pour être relationnels. En fait, aucun SGBD ne respecte actuellement toutes ces règles. Certains cependant s’approchent de cette « perfection » relationnelle. Voici ces douze règles (certaines notions seront développées plus tard dans ce cours) :

• Règle 1 : toutes les informations sur les données sont représentées au niveau logique et non physique (pas besoin d’informations sur la façon dont sont enregistrées physiquement les données).

• Règle 2 : les données sont accessibles uniquement par la combinaison du nom de la table, de la clé primaire et du nom de la colonne (pas de chemin à donner).

• Règle 3 : une valeur spéciale doit représenter l’absence de valeur (valeur NULL).

• Règle 4 : la description de la base de données doit être accessible comme les données ordinaires (un dictionnaire des données est enregistré dans la base).

• Règle 5 : un langage doit permettre de définir les données, définir des vues (visions particulières de la base, enregistrées comme des relations), manipuler les données, définir les contraintes d’intégrité, des autorisations et gérer des transactions.

• Règle 6 : on peut faire des mises à jour par les vues lorsque c’est logiquement possible.

• Règle 7 : le langage doit comporter des ordres effectuant l’insertion, la mise à jour et la suppression de données (un seul ordre pour effectuer chacune des fonctions).

• Règle 8 : indépendance des programmes vis-à-vis de l’implantation physique des données.

• Règle 9 : indépendance des programmes vis-à-vis de l’implantation logique des données (si les informations manipulées par les programmes n’ont pas été modifiées ou supprimées).

• Règle 10 : les contraintes d’intégrité doivent pouvoir être définies dans le langage relationnel et enregistrées dans le dictionnaire des données.

• Règle 11 : indépendance vis-à-vis de la répartition des données sur divers sites.

• Règle 12 : on ne peut jamais contourner les contraintes (d’intégrité ou de sécurité) imposées par le langage du SGBD en utilisant un langage de plus bas niveau (par exemple le langage C).

A la fin des années 90 les bases relationnelles sont les bases de données les plus répandues (environ trois quarts des bases de données).

Chapitre 2 Modèle Conceptuel de données

I. Introduction Le modèle conceptuel de données MCD (ou modèle entité-association MEA, ou Entity-RelationShip Model en anglais) a été introduit dans les années 70 comme une amélioration du modèle relationnel introduit par Codd en 1970: le MCD est plus facile à lire pour la construction de bases de données. Il devient le modèle le plus utilisé pour représenter dans un premier temps la structure de données. Actuellement, il n’y a pas de standard Entité-Association, il existe une large variété de notations et de concepts.

Deux utilisations des schémas EA : − Concevoir le schéma de la base de données avant que la moindre donnée ne soit stockée : c’est la

conception conceptuelle. A partir d’un tel schéma, il est plus clair de raisonner sur les concepts à stocker, les attributs dont on a besoin, les relations entre les concepts… Une fois terminée, un tel schéma est traduit selon des règles précises en son schéma relationnel correspondant. La construction du schéma entité-association ainsi que son passage au modèle relationnel seront vus dans les chapitres 3 et 4.

− Faire de la réingénierie : à partir d’une base existante complexe, dont la documentation est inexistante, on peut créer un schéma EA pour avoir une première vue synthétique de la situation et prendre des décisions comme restructurer la base, la normaliser, en créer une nouvelle plus large permettant de stocker les données de l’ancienne,…

II. Concepts de base

1. Modèle entité-association (EA) Le modèle EA propose une description sur la base des trois concepts de base qui sont l’identifications des objets, des liens entre ces objets et des propriétés de ces objets : - objet → entité - lien → association - propriété → attribut

2. Définitions

a. Entités Une entité est un objet concret ou abstrait du monde réel à propos duquel on veut enregistrer des informations.

ex : M. Dupont, Mme Dupont, un crayon, l’atelier de distribution, le bureau du directeur…

Un type d’entité (TE) est un ensemble d’entités qui possèdent les mêmes caractéristiques.

ex : Personne (représentation de l’ensemble des personnes telles que les entités M. Dupont et Mme Dupont), Employé (représentation de l’ensemble des employés), Article (représentation de l’ensemble des articles tels que les crayons et les livres)…

Un attribut d’une entité est une propriété associée à un TE. L’ensemble des attributs d’un TE représente l’ensemble des informations inhérentes que l’on souhaite conserver sur les entités du TE.

ex : (nom, prénom, salaire) sont des attributs du TE Employé…

Base de données 6

Une entité munie de ses attributs sera modélisée de la manière suivante :

On distingue deux types d’entités :

− Entité forte = entité qui n’a pas besoin d’une autre entité pour exister.

− Entité faible = entité qui a besoin d’une autre entité pour pouvoir être définie. Elles sont notées avec un double rectangle. On distingue deux cas :

o 1er cas : Employé est une entité faible car l’ensemble des numéros de sécurité sociale des élèves est contenu dans l’ensemble des numéros de sécurité sociale des personnes. On dit qu’il y a un lien d’héritage entre les deux entités.

o 2nd cas : Appartement est une entité faible car sa clé (on définira cette notion par la suite) est composée de l’attribut clé de Bâtiment (N°Bâtiment) et d’un autre attribut (N°Appart.). On dit qu’il y a un lien d’identification entre les deux entités.

b. Associations Une association (ou une relation) est un lien entre plusieurs entités, où chaque entité liée joue un rôle déterminé ; si l’association lie des entités du même type, elle est dite cyclique ou réflexive et, dans ce cas, la spécification des rôles est indispensable.

ex : lien de travail entre l’employée M. Durant et le service de gestion, lien de mariage entre M. X et Mme Y.

Un type d’association (TA) est un ensemble d’associations qui possèdent les mêmes caractéristiques (liant des entités de mêmes types avec mêmes rôles et mêmes propriétés, respectifs)

ex : le TA « fabrique » lie le TE « Atelier de fabrication » au TE « Article », le TA « travaille » lie « Employé » à « Service », le TA « est-marié-avec » lie « Personne » à lui-même.

Un attribut d’une association est une propriété associée à un TA. L’ensemble des attributs d’un TA représente l’ensemble des informations inhérentes que l’on souhaite conserver sur les associations du TA.

ex : (quantité-en-fabrication) est un attribut du TA fabrique…

Employé nom

prénom salaire

attributs de l’entité (ou propriétés)

nom de l’entité

Personne N°SécuritéSoc

Nom Prénom

DateNaissance LieuNaissance

Employé N°SécuritéSoc

Nom Prénom

DateNaissance LieuNaissance

Bâtiment N°Bâtiment NombreApp. DateConstr.

Appartement N°Bâtiment N°Appart.

Taille Etage

Base de données 7

Une association sera modélisée de la manière suivante : − Association binaire : C’est une association qui relie deux entités.

− Association n-aire (ici, avec n = 3) : C’est une association qui relie n entités différentes.

− Association réflexive : C’est une association qui agit sur la même entité, mais avec des rôles différents.

Le nom des associations peut-être (entre autres) : − Un verbe (plutôt pour une association binaire ou réflexive) pour décrire des rôles réciproques

entre deux entités ; − Un nom (plutôt pour les associations n-aires) pour représenter une entité complexe définie à

partir d’autres entités.

Les associations peuvent avoir des significations différentes : − Composition :

Le sens de l’asso-ciation est de définir l’entité Vélo comme composé d’autres en-tités (Roue et Cadre). Ce type d’association est à utiliser avec précaution car on peut modéliser, dire tout et n’importe quoi avec ce lien de composition.

− Héritage : Pour représenter ce lien d’héritage, on peut utiliser les deux notations ci-contre. Quelle que soit la notation, la clé de Pilote est sont attribut N°Employé. Même si celui-ci n’est pas noté, il fait quand même partie de la liste des attributs de Pilote.

Article nomA type

Fournisseur nomF

adresse

Rayon nomR étage

LIVRAISON quantité

Employé nom

salaire CHEF

subalterne

supérieur

Article nomA type

Rayon nomR étage

VENTE quantité

EST UN Employé N°Employé

Pilote Nom

Prénom

Employé N°Employé

Pilote Nom

Prénom

Roue type

épaisseur

Cadre matériau forme

Vélo Type Poids

COMP. DE

Base de données 8

− Identification : Pour représenter ce lien d’identification, on utiliser la notation ci-contre. La clé de Episode est son couple d’attributs (Nom, Numéro). Même si l’attribut Nom n’est pas noté, il fait quand même partie de la liste des attributs de Episode.

− Muni d’attributs : On peut ajouter des attributs propres à une association, ils dépendent de toutes les entités reliées par cette association. Prix est un attribut propre à l’association Catalogue : le Prix dépend à la fois du Fournisseur et du Produit.

− Associations considérées comme entités : Certaines associations peuvent être vues comme des entités, pour notamment pouvoir construire des associations d’associations.

Exemple : Supposons que l’on ait à représenter un ensemble de départements universitaires avec leurs serveurs et les logiciels qui y sont installés. On veut représenter le fait qu’un département qui a acheté un logiciel l’a forcément installé sur un serveur. Avec une association ternaire (3-aire), ou pourrait représenter les choses ainsi de la manière. Malheureusement, les cardinalités ne nous permettent pas de spécifier que pour un couple (logiciel, département), il existe obligatoirement au moins 1 serveur. Pour cela, il convient de créer une association supplémentaire que l’on utilisera comme entité.

Produit NumProduit

Type

Fournisseur Numéro

Nom

CATALOGUE Prix

ID Série Nom

Producteur

Episode Numéro

Département

Serveur

Logiciel

INSTALL ACHAT

Département

Serveur

Logiciel

INSTALL ACHAT

Base de données 9

c. Occurrence et population On appelle occurrence d’un TE (TA) toute entité (association) appartenant à l’ensemble décrit par le TE (TA). Une occurrence de TE est un ensemble de valeurs (éventuellement vide) pour chaque attribut du TE. Une occurrence de TA est un ensemble de valeurs (éventuellement vide) pour chaque attribut du TA et chaque occurrence de Tes qui joue un rôle dans le TA.

On appelle population d’un TE (TA) l’ensemble des occurrences du TE (TA).

III. Diagrammes Entité-Association

1. Diagramme Le modèle entité-association permet une représentation graphique assez lisible du schéma d’une BD, appelée diagramme entité-association (diagramme EA)

Les TE sont représentés par des rectangles, les TA par des hexagones ou autres symboles similaires (ovale, losange, …), les attributs sont soit rattachés au TE (TA) par des traits, et représentés par des ovales, soit listés à l’intérieur du rectangle (hexagone), au dessous du nom du TE (TA) et séparés de celui-ci par une barre.

2. Contraintes de cardinalité Les cardinalités d’un lien entre un TE et un TA sont le minimum (min) et le maximum (max) de fois qu’une entité peut intervenir dans une association de ce type.

Formellement : si un TA A lie n TEs (E1, E2, …, En) et si (ai,bi) représente les cardinalités du lien entre Ei et A, alors ai et bi décrivent respectivement le nombre minimum et le nombre maximum de (n – 1)-uplets de E1 × … × Ei – 1 × Ei + 1 × … × En auxquels une instance quelconque de Ei est reliée.

Remarque : - La cardinalité maximum bi est toujours ≥ 1. - Si une cardinalité est connue et vaut k > 1, on considère parfois qu’elle est indéterminée N, de telle

sorte qu’on ne puisse avoir que des cardinalités 0, 1 ou N. - Il est impossible d’avoir un couple de cardinalités (a,b) avec a > b.

Propriétés : - min = 0 : toute entité peut exister tout en étant impliquée dans aucune association ; on parle de

participation partielle du TE au TA. - min = 1 : aucune entité ne peut exister sans être impliquée dans au moins une association ; on parle

de participation totale du TE au TA. - min = N : aucune entité ne peut exister sans être impliquée dans plusieurs associations (cas rare et

complexe). - max = 0 : toute entité ne peut pas être impliquée dans une association (cas à éviter) - max = 1 : toute entité peut être impliquée dans au plus une association. - max = N : toute entité peut être impliquée dans plusieurs associations.

Classification Classification d’une association binaire A selon les cardinalités maximums des entités participantes E et F : - A est 1:1 si maxCard(E,A) = 1 et maxCard(F,A) = 1 - A est 1:N si maxCard(E,A) = 1 et maxCard(F,A) = N (ou vice-versa) - A est M:N si maxCard(E,A) = N et maxCard(F,A) = N

Base de données 10

Exemple :

Dans l’exemple ci-dessus, expliquons les contraintes de cardinalité qui entoure l’association : - EMPLOI :

EMPLOI Employé Rayon Commentaires

e1

e1

r1

r2

Un employé e1 peut être employé dans aucun rayon (minimum = 0) et peut travailler dans un seul rayon r1 au maximum (maximum = 1), ce qui explique la contrainte de cardinalité <0,1> entre Employé et EMPLOI.

e1

e2

…

r1

r1

r1

Dans un rayon, on peut avoir aucun employé qui y travaille (minimum = 0) mais on peut en avoir autant que l’on veut (maximum = N), ce qui explique la contrainte de cardinalité <0,N> entre Rayon et EMPLOI.

- LIVRAISON : LIVRAISON Fournisseur Rayon Article Commentaires

f1 f1 f1 f1 f1

r1 r1 r2 r2 …

a1 a2 a2 a1 …

Un fournisseur f1 peut être faire l’objet de la livraison d’aucun article dans aucun rayon (minimum = 0). De plus, un fournisseur f1 peut fournir plusieurs articles (a1, a2,…) dans plusieurs rayons (r1, r2,…) différents (maximum = N), ce qui explique la contrainte de cardinalité <0,N> entre Fournisseur et LIVRAISON.

f1 f1 f2 f2 …

r1 r1 r1 r1 r1

a1 a2 a2 a1 …

Un rayon r1 peut être faire l’objet de la livraison par aucun fournisseur ou d’aucun article (minimum = 0). De plus, un rayon r1 peut être rempli grâce à plusieurs articles (a1, a2,…) et par plusieurs fournisseurs (f1, f2,…) différents (maximum = N), ce qui explique la contrainte de cardinalité <0,N> entre rayon et LIVRAISON.

f1 f1

f2 …

r1 r2 r1 …

a1 a1 a1

a1

Un article a1 peut être faire l’objet de la livraison par aucun fournisseur ou dans aucun rayon (minimum = 0). De plus, un article a1 peut être fourni par un seul fournisseur f1 mais dans plusieurs rayons (r1, r2,…) différents (maximum = N), ce qui explique la contrainte de cardinalité <0,N> entre article et LIVRAISON.

3. Cardinalités d’un attribut Les cardinalités d’un attribut spécifient le nombre de valeurs de cet attribut qui sont autorisées (au minimum, au maximum) dans : - une occurrence du TE (TA), si l’attribut est directement rattaché à un TE (TA). - une valeur de l’attribut dont il est composant, sinon.

Un attribut est dit : - simple s’il n’est pas décomposé en d’autres attributs : ses valeurs sont atomiques; un domaine lui

est associé ; - complexe s’il est décomposé en d’autres attributs; ses valeurs sont composées ;

Article nomA type

Fournisseur nomF

adresse

Rayon nomR étage

Employé nom

salaire

EMPLOI

CHEF

LIVRAISON quantité

<0,N>

<0,N>

<0,N> <0,N>

<0,N>

<0,N>

<0,N>

<0,1>

<0,1>

VENTE quantité

Base de données 11

- monovalué s’il ne peut prendre qu’une seule valeur par occurrence (maxCard = 1) ; - multivalué s’il peut prendre plusieurs valeurs par occurrence (maxCard > 1) ; - obligatoire s’il doit prendre une valeur au moins par occurrence (minCard = 1) ; - facultatif s’il peut ne pas prendre de valeur dans une occurrence (minCard = 0).

4. Identifiants des TE et TA Un identifiant d’un TE (TA) est constitué par un ou plusieurs attributs qui doivent avoir une valeur unique pour chaque entité (association) de ce type Les attributs appartenant à un identifiant doivent être de cardinalité (1,1). Un TE (TA) peut avoir aucun ou plusieurs identifiants :

ex : n°employé et (nom+prénoms) sont deux identifiants du TE Employé, si dans cette entreprise il n’y a jamais deux employés ayant les mêmes nom et prénoms, ou le même numéro

Les identifiants (ou clés primaires) peuvent être représentés sur le diagramme en les soulignant. Pour éviter des surcharges, les identifiants des TA peuvent être précisés textuellement en commentaire du diagramme.

Règles : - si le TA a des cardinalités (1,1) pour un des TE liés, alors tout identifiant de ce TE est identifiant

du TA. - si plusieurs occurrences du TA lient les mêmes occurrences des TE, alors chaque identifiant du

TA contient au moins un attribut du TA.

TE faible : Un TE E est dit faible si aucun sous-ensemble de ses attributs ne constitue un identifiant et qu’un identifiant peut être défini en intégrant un identifiant d’un autre TE qui lui est lié par un TA binaire (d’identification ) de cardinalité (1,1) pour E. L’identifiant d’un TE faible (qui est le même que celui du TA d’id.) est constitué de l’identifiant du TE dont il dépend et d’un (ou plusieurs) attributs du TE faible

IV. Contraintes d’intégrité

1. Définition Une contrainte d’intégrité (CI) est un ensemble de règles de contrôle de cohérence des valeurs prises par les différentes entités et associations d’une BD et qui ne peut pas être décrite avec les concepts du modèle.

ex : Si une personne participe à l’association Mariage, alors la valeur de son attribut « état civil » doit être « mariée » :

∀ x,y ∈ Personne, <x,y> ∈ Mariage ⇒ x.état-civil = ‘marié’

ex : Seuls les hommes peuvent participer à l’association mariage dans le rôle « époux »

∀ x,y ∈ Personne, <époux:x,y> ∈ Mariage ⇒ x.sexe = ‘M’

2. Contraintes d’intégrité sur les attributs Les CI les plus fréquentes limitent les valeurs d’un attribut à certaines valeurs du domaine sous-jacent.

ex : Age ∈ [0 , 130].

Les limites peuvent être définies en fonction du contexte (valeur d’un autre attribut, participation à une association, …)

ex : Si mois ∈ {4,6,9,11} alors jour ∈ [1:30], sinon si mois = 2 alors jour ∈ [1:29] sinon jours ∈ [1:31].

ex : Si une personne participe à l’association Mariage, alors la valeur de son état civil doit être « marié ».

Chapitre 3 Construction d’un schéma EA

I. Introduction Afin de pouvoir construire le schéma entité-association répondant aux besoins d’une entreprise, le concepteur étudie les différents modèles existants, les dsifférents besoins et supports de l’entreprise en recensant les divers documents… Afin de pouvoir réunir les différentes connaissances de l’entreprise et lui permettre de gérer au mieux les employés et les différents services, le concepteur procède à différentes taches : – Etablir la liste des entités ; – Lister leurs attributs et déterminer les identifiants ; – Identifier les différentes associations reliant ces entités en établissant les différentes cardinalités ; – Lister leurs attributs ; – Établir les règles d’intégrité ; – Vérifier la cohérence et la pertinence du schéma obtenu. Exemple : Dans une agence bancaire, le directeur explique : « Nous gérons des comptes bancaires, mais aussi nous permettons aux clients d’établir une épargne et d’avoir une assurance. Les comptes bancaires, épargnes et assurances possèdent un numéro d’identification et d’une date de création. Le client possède lui aussi un numéro d’identification. Nous permettons à un client de réaliser diverses opérations sur ses comptes bancaires et épargne, et nous luis envoyons une fois par mois, à une date précise, le relevé de ses comptes. »

De l’exposé précédent on peut extraire les informations suivantes : – quatre TE : Client, Compte, Opération, Relevé. – N° d’identification du client : attribut du TE Client – N° d’identification, Type et Date de création du compte : attributs du TE Compte – un TA : Ouvrir entre Client et Compte ; cette association a pour cardinalité (0,N) pour le TE Compte Les choix de représentation dépendent du point de vue du concepteur. C’est donc seulement en examinant l’utilisation des données qu’il est possible de déterminer la représentation adéquate.

II. Règles de modélisation Règle de représentation par un type d’entité Tout ensemble d’objets similaires utiles pour l’application est représenté par une entité.

Règle de représentation par un type d’association Tout ensemble de liens similaires et de même sémantique, utiles pour qualifier l’application, entre deux ou plusieurs objets représentés par des entités est représenté par une association.

Règle de représentation par un attribut Toute information utile et descriptive d’un objet ou d’un lien, ne faisant l’objet d’aucun traitement en dehors de cet objet ou de ce lien est représentée par un attribut.

Remarque importante : Par rapport à la réalité, un schéma est une représentation : – incomplète : il ne représente que les informations qui sont jugées utiles pour l’application ; – partiale : il représente le point de vue du concepteur ; – infidèle : il ne représente pas la réalité telle qu’elle est, mais telle qu’elle intéresse le concepteur.

Base de données 13

III. Vérification du diagramme EA Une fois le diagramme EA établi, plusieurs types de vérifications sont effectués : – vérification syntaxique : il s’agit de vérifier que les règles du modèle EA sont respectées ; – par jeu d’essai : vérifier grâce à une mini BD que le diagramme permet effectivement de stocker les

informations nécessaires à l’entreprise ; – complétude par rapport aux traitements : vérifier que le diagramme contient tous les types

d’informations nécessaires à l’exécution des traitements prévus ; – par les utilisateurs : présenter le diagramme accompagné des définitions aux futurs utilisateurs et

vérifier que les informations contenues correspondent bien aux besoins.

Chaque oubli, erreur, modification, …, détecté lors des vérifications entraîne une mise à jour du diagramme et relance les différentes phases de vérification.

IV. Notion de dépendance Pour un TE (ou un TA) donné, on dit qu’il y a dépendance d’un attribut, ou un ensemble d’attributs, A vers un attribut, ou un ensemble d’attributs, B, si toutes les occurrences qui ont même valeur pour A ont toujours même valeur pour B : on note cette dépendance A → B, et on dit que B dépend de A ou que A détermine B. Par définition, l’identifiant d’un TE (TA) détermine tous les autres attributs du TE (TA).

Formellement, quelles que soient deux occurrences du TE (TA) de valeurs (a,b) et (a’,b’) pour (A,B) : a = a’ b = b’ ⇒

Soient E1 et E2 deux entités liées par une association A. On dit qu’il y a dépendance de E1 vers E2 (notée E1 → E2), si pour chaque occurrence de E1, l’association A lui associe toujours la même occurrence de E2.

V. Règles de validation d’un diagramme EA L’élaboration d’un schéma EA se fait en plusieurs étapes : une de celles-ci est celle qui consiste à vérifier le schéma en utilisant un certain nombre de règles dites de vérification et de normalisation. Ces règles permettent d’obtenir un schéma dans lequel les erreurs de mises à jour, d’insertion et de suppression, ainsi que les redondances logiques, sont les plus limitées possibles.

1. Règles concernant les entités Règle n°1 : Existence d’un identifiant pour chaque entité.

Cette règle permet d’aider le concepteur quand celui-ci hésite entre modéliser un concept par une entité ou par une association.

Exemple : On représente une situation où des clients commandent des produits. Si le concept commande inclut un numéro de commande unique pour chaque commande, alors il faut modéliser le concept commande par une entité – cf. solution 1. Sinon, on peut le modéliser par une associa-tion : la clé sera alors le couple clé (Client,Produit) – cf solution 2.

Produit Code

Client N°Client

Nom Prénom

Commande N°Commande

PASSER

Solution 1

Produit Code

Client N°Client

Nom Prénom

COMMANDE

Solution 2

Base de données 14

Règle n°2 : Tous les attributs autres que l’identifiant doivent être en dépendance fonctionnelle complète et directe de l’identifiant.

La notion de dépendance fonctionnelle est celle du paragraphe précédent : quelle que soit l’instance de l’entité considérée, la valeur de la clé est unique (deux instances différentes ne peuvent pas avoir la même valeur de clé) et pour tous les attributs non clé, il n’existe qu’une seule valeur (les attributs sont monovalués : la valeur d’un attribut est une valeur simple et non un ensemble de valeurs). Ceci correspond à la première forme normale qui sera vue dans le chapitre 8 (1NF). La notion de dépendance complète stipule que les valeurs des attributs non clé dépendent de la valeur de toute la clé et non d’une partie seulement.

Exemple : L’entité Episode, sur la figure ci-contre, a pour clé le couple d’attributs (Nom_Série,Numéro). Si on fait l’hypothèse que toute série n’a qu’un producteur, alors il y a une dépendance fonctionnelle Nom_Série → Producteur. Donc Episode ne suit pas la règle 2.

Pour suivre la règle 2, il faut transformer Episode grâce à la méthode suivante. On crée une nouvelle entité formée des attributs qui constituent la DF, et on enlève de Episode la partie droite de la DF (c’est à dire l’attribut Producteur). Comme, alors, il reste Nom_Série et Numéro dans Episode, et que Nom_Série est clé primaire de Production, Episode devient une entité faible, reliée à Production par une association d’identification. Cette notion de dépendance complète

correspond à la deuxième forme normale qui sera vue dans le chapitre 8 (2NF). La notion de dépendance directe stipule que tout attribut dépend directement de la clé, c’est à dire qu’il n’y a pas de DF avec une partie gauche différente de la clé.

Exemple :

Dans l’entité Voiture sont présents les attributs Marque et Modèle. Or quand on connaît la valeur de Modèle, on connaît forcément la Marque. Il y a donc une DF Modèle → Marque avec comme partie gauche Modèle qui n’est pas la clé. Donc voiture ne suit pas la règle numéro 2.

Comme précédemment, on résout le problème en construisant une nouvelle entité dont les attributs sont les attributs de la DF et en ôtant la partie droite de la DF de l’entité d’origine. On obtient les deux entités à gauche.

Cette notion de dépendance directe correspond à la troisième forme normale qui sera vue dans le chapitre 8 (3NF). En résumé, appliquer la règle 2 revient à mettre le schéma EA en troisième forme normale.

2. Règle concernant les associations : Règle n°3 : Tous les attributs d’une association doivent dépendre complètement de la clé de cette association, c'est-à-dire de l’ensemble des clés de toutes les entités associées. Chaque attribut doit dépendre de toute la clé et non d’une partie de la clé seulement.

Exemple : L’association Achat du premier schéma relie 3 entités : Client, Produit et Fournisseur. La clé de Achat est donc (N°Client, Code, N°Fournisseur). Deux attributs supplémentaires figurent dans Achat : Date d’achat et Prix. Il est clair que la date d’achat dépend à la fois du client qui achète, du produit acheté et du fournisseur. Par contre, le prix ne dépend que du fournisseur et du produit (on suppose que le client ne peut pas marchander). On a donc la dépendance fonctionnelle (Code,N°Fournisseur) → Prix. Ici, la partie gauche n’est pas toute la clé de Achat, mais seulement une partie. Donc Achat ne suit pas la règle 3. Pour résoudre le problème, on crée une nouvelle association à partir des attributs de la dépendance fonctionnelle et on enlève la partie droite de la dépendance fonctionnelle de l’association d’origine.

ID Production Episode Nom_Série Producteur

Numéro

Episode Nom_Série

Numéro Producteur

Voiture Immatriculation

Couleur Marque Modèle Voiture

Immatriculation Couleur Modèle

Modèle Modèle Marque

Base de données 15

On obtient le deuxième schéma.

Remarque : On a stocké ici la date d’achat comme attribut de Achat. Cela signifie que pour un achat, c’est-à-dire pour un triplet (client,produit,fournisseur), il n’y a qu’une seule date correspondante. Autrement dit on ne peut pas stocker plusieurs achats identiques à deux dates différentes. Si on voulait le faire, il faudrait faire une entité spéciale pour Date et relier cette entité à l’association Achat qui serait alors 4-aire.

FournisseurN°Fournisseur

Nom Adresse

Produit Code

Description

Client N°Client

Nom Prénom

ACHAT Date d’achat

Prix

<1,N> <0,N>

<0,N>

3. Validation d’un TA (arité) Règle 4 : Soit un TA bien construit, liant les TE E1,…,En ; s’il y a une dépendance (E1,…,Ei) → Ei + 1, alors il y a la dépendance (E1,…,Ei) → (Ei + 1,…,En).

Donc si un TA comporte l’une de ces dépendances sans les autres, il faut décomposer le TA, afin de matérialiser cette dépendance par un nouveau TA de cardinalité maximum 1 pour le rôle source de la dépendance.

Dans l’exemple ci-dessus, cette dépendance traduit la règle d’entreprise : chaque projet est réalisé dans un et un seul laboratoire. Le diagramme précédent n’est pas correct. La dépendance doit être décrite par un TA binaire reliant les deux TE Projet et Labo, le TE restant sera lié par un TA binaire au TE source de la dépendance.

Chercheur TRAVAILLE<0,N>

<1,N>

<0,N>

Projet

Laboratoire

Client Produit ACHAT

Date d’achat

FournisseurN°Fournisseur

Nom Adresse

Code Description

<1,N> <0,N>

<0,N>

PRIX Montant

N°Client Nom

Prénom <1,N>

<1,N>

Base de données 16

La correction du diagramme est donnée ci-après.

4. Elimination des types d’association (TA) redondants Un TA est redondant si les associations correspondantes peuvent être établies sans ambiguïté par composition des associations d’autres TA

Si pour l’application on veut conserver un TA redondant, il faut alors déclarer par une contrainte d’intégrité que ce TA est dérivé d’autres.

5. Transformation des attributs référence Si l’on trouve dans un TE E1 un attribut dont la valeur est égale à celle de l’identifiant d’un TE E2, cet attribut exprime un lien entre E1 et E2. Ce lien doit être explicitement décrit comme une association entre les deux TE et l’attribut supprimé de E1.

6. TE ou attribut complexe ? Si un TE retenu a priori se révèle ne présenter d’intérêt pour aucun traitement de l’application mais qu’il faut néanmoins conserver l’information correspondante, il convient de rattacher celle-ci, sous forme d’un attribut, au TE (TA) où elle est pertinente.

EnseignantCoursEtudiant INSCRIT ASSURE<1,N>

EST ELEVE DE

<1,N>

<1,N>

<1,N> <1,N>

<1,N>


Nom Prénom

TRAVAILLE<1,1> <1,N> Service

N°Service Etage Nom


Nom Prénom

#N°Service

Service N°Service

Etage Nom

Chercheur TRAVAILLE<0,1>

<1,1>

<1,N>Projet

AFFECTE

<0,N>

Laboratoire

Base de données 17

Un TE qui n’a qu’un seul attribut doit être transformé en attribut des TE auxquels il est relié.

Si un TE possède un attribut complexe qui fait l’objet de traitements indépendamment du TE en question, il faut le remplacer par un TE, plus un TA qui conserve le lien avec le TE d’origine.

Cours N°Cours Intitulé Horaire

A LIEU<1,1> <0,1>

Salle N°Salle

Cours N°Cours Intitulé Horaire N°Salle

Etudiant N°Etudiant

Nom Prénom

INSCRIT<0,N> <0,N> Cours

Intitulé Salle

Horaire

Etudiant N°Etudiant

Nom Prénom

Cours Intitulé Salle

Horaire

Employé Service N°Employé

Nom Prénom



Nom Prénom

Service


Base de données 18

VI. Description d’un schéma EA 1. Entités :

Une entité est décrite par : – le nom du type d’entité ; – une définition précisant la population exacte de l’entité ; – la description des attributs de l’entité ; – la composition des identifiants de l’entité, s’il en existe. Exemple (TE Employé de la BD hypermarché) : – nom : Employé – définition : « toute personne employée de l’entreprise en ce moment » – attributs : nom, salaire (avec leur description) – identifiant : nom

Remarque : Deux TE différents peuvent avoir le même nom. La définition libre est une partie importante de la description du TE et permet de définir exactement, de façon non ambiguë, la population du TE.

2. Associations : Une association est décrite par : – le nom du type d’association ; – une définition précisant la population exacte du TA ; – les noms des entités participant à l’association, avec le nom du rôle si nécessaire ; – pour chaque rôle, ses cardinalités : min ≥ 0, max ≥ 1 ; – la description des attributs du TA, s’il en existe ; – la composition des identifiants du TA, s’il en existe.

Exemple (TA Emploi de la BD hypermarché) : – nom : Emploi – définition : « lie un employé au rayon dans lequel celui-là travaille aujourd’hui » – TE participants : Employé, Rayon – cardinalités : Employé: 0:1 Rayon: 0:n – identifiants : (Employé.nom + Rayon.nomR)

3. Attributs : Un attribut est décrit par les spécifications suivantes : – le nom de l’attribut ; – une définition (libellé clair) ; – la cardinalités ; – le domaine de valeurs si l’attribut n’est pas composé d’autres, la description des attributs

composants sinon.

Exemple (attribut « date de naissance » d’un TE Personne) : – nom : date de naissance – définition : « date de naissance de la personne » – cardinalités : min = 1, max = 1 – composition :

– nom : jour ; définition : « jour de naissance de la personne » ; cardinalités : min = 1, max = 1 ; domaine : l’intervalle entier [1,31]

– nom : mois ; définition : « mois de naissance de la personne » ; cardinalités : min = 1, max = 1 ; domaine : l’intervalle entier [1,12]

– nom : année ; définition : « année de naissance de la personne » ; cardinalités : min = 1, max = 1 ; domaine : l’intervalle entier [1870,2004]

Chapitre 4 Modèle Relationnel

I. Introduction Le modèle relationnel est un modèle d’informations structurées un tableau de valeurs. Les relations sont des tables avec des restrictions : – l’ordre des lignes (tuples) n’est pas significatif ; – l’ordre de colonnes (attributs) n’est pas significatif ; – pas de duplication de lignes.

II. Concepts de base :

1. Domaine Un domaine est un ensemble de valeurs que peut prendre un attribut : – Dnom : chaine de caractères de longueur maximale 30 ; – Djour : {lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche} ; – Dmois : {janvier, février, mars, avril, …, octobre, novembre, décembre} ; – Dcouleur : {rouge, vert, bleu, jaune, ..., violet} ; – Dâge : [0,125] ; – Dsalaire : R+.

2. Relation Une relation est définie par son schéma de relation et ses valeurs.

Schéma d’une relation : R(A1:D1,…,An:Dn) – R : nom de la relation – A1,…,An : attributs, tous distincts – D1,…,Dn : domaines des attributs, non nécessairement tous distincts – (A1:D1,…,An:Dn) : structure (type de tuple)

Tuple : {A1:d1,…,An:dn} un ensemble de couples <attribut,valeur>

Valeur d’une relation : sous-ensemble de tuples de l’ensemble : {{ A1:d1,…,An:dn } | di ∈ Di}

Exemple – Schéma de la relation Etudiant :

Etudiant ( N étud:Dnum, Nom:Dnom, Prénom:Dnom, Age:Dâge ) – Une valeur de la relation Etudiant :

Age Prénom Nom N°étud 21 Marc Rochat 147 20 André Duval 101 20 Annie Aubry 253 19 Jean Rochat 136

III. Base de données relationnelle

1. Introduction Un schéma d’une BD relationnelle est un ensemble de schémas de relations auquel on ajout les contraintes d’intégrité.. Une base de données relationnelle est un ensemble de relations. Une valeur d’une BD est un ensemble de valeurs de relations.

Base de données 20

2. Clés d’une relation a. Définitions

Les clés d’une relation sont des ensembles d’attributs qui déterminent tous les autres attributs de la relation. Ainsi, les clés d’une relation ont la propriété d’identification unique de tuples lorsque deux tuples n’ont jamais la même valeur pour cet ensemble d’attributs.

Formellement, quelles que soient tuples de la relation R de valeurs (a,b) et (a’,b’) pour (A,B) : a est un clé de la relation R si : a = a’ ⇒ b = b’

Une super-clé est un ensemble d’attributs qui identifie de manière unique un tuple de la relation Une clé est une super-clé minimale, c'est-à-dire une superclé dont on ne peut enlever aucun attribut sans lui faire perdre son statut de superclé; en général, une relation a plusieurs clés (on parle de clés candidates).

La définition des clés est une information intentionnelle (appartient au schéma), donc valide pour toutes les extensions possibles de la relation

b. Clé primaire Une clé primaire est une clé privilégiée choisie parmi les clés candidates. Ses valeurs doivent toujours être connues (sans valeur NULL). Son choix est arbitraire, peut se faire par des heuristiques (e.g. plus simple), mais elle peut être inventée pendant la phase de conception de la BD. Dans le schéma de relation, la clé primaire sera soulignée.

Exemple Etudiant (Code_per, Nom, Prenom, Adresse, Date_nais, Lieu_nais, NASS) Quelles sont les clés candidates ? Code_per, NASS, (Nom,Prenom,Adresse) Quelle clé primaire choisir ? Code_per

c. Clé étrangère Soit R2 une relation, un sous-ensemble d’attributs FK dans R2 est dit clé étrangère lorsque : – il existe une relation R1 de clé primaire PK (R1 peut être R2) – à tout instant, chaque valeur de FK dans R2 est identique à une valeur de PK dans R1 On fera précéder les clés étrangères du caractère dièse (#).

Exemple Etudiant(N°étud, nom, prénom, âge) Cours(NomC, horaire, prof) Suit(#N°étud, #NomC)

Propriétés − Il n’est pas nécessaire d’avoir pour toute valeur de PK dans R1 une valeur identique de FK

dans R2 ; − Un attribut d’une clé étrangère peut faire partie d’une clé candidate de sa relation ; − Chaque attribut d’une clé étrangère doit être défini sur le même domaine que son équivalent

dans la clé primaire correspondante.

3. Contraintes d’intégrité a. Définition :

Contrainte : c’est une assertion vérifiée par les données de la base à tout moment sans être définie au niveau de la structure. Les contraintes relationnelles comprennent : – Les contraintes structurelles : liées au modèle relationnel, à l’unicité des valeurs de clés,… – Les contraintes comportementales : liées aux applications – Les contraintes intra-relationnelles : mettant en jeu une seule relation sur la non nullité d’un

attribut – Les contraintes inter-relationnelles : mettant en jeu plusieurs relations sur l’intégrité

référentielle (existence des clés étrangères)

Base de données 21

Remarque : Une contrainte est tout ce que l’on souhaiterait exprimer au niveau de la structure de la BD (i.e., le schéma) et que l’on ne peut pas exprimer avec le mécanisme de description disponible dans le modèle de données.

b. Intégrité référentielle Typiquement relationnelle, l’intégrité référentielle résulte de l’expression de liens avec égalité de valeurs, exprime une information de comparabilité (comme les domaines) pour deux attributs différents. Une fois déclarée la clé étrangère FK de R2 sur R1 : – le SGBD vérifie toutes les insertions dans R2 (il vérifie que la valeur de FK existe dans R1) ;

il vérifie de la même façon toutes les modifications dans FK ; – Il vérifie toutes les suppressions de tuples dans R1 (il vérifie qu’il n’existe pas de tuple dans

R2 référençant ce tuple à supprimer).

c. Nom spéciaux pour les contraintes – Intégrité de clés : chaque relation a une clé primaire + d’éventuelles clés candidates ; – Intégrité de domaines : les attributs doivent respecter la définition de leur domaine ; – Intégrité d’entités : les valeurs d’une clé primaire ne peuvent être NULL ; – Intégrité de clés candidates : les valeurs d’une clé doivent être uniques ; – Intégrité de colonnes : contraint d’avantage l’intégrité de domaine (e.g., la date de prise de

fonction du gérant est une date après 1970) ; – Intégrité de lignes : concerne un tuple singulier (e.g., si Date_Naiss < 1950, alors salaire ≥

4000).

IV. Relations de base et relations dérivées

1. Définitions Les relations de base sont celles dans le schéma commun, elles sont stockées sur disque.

Les relations dérivées sont produites en combinant relations de base et/ou relations dérivées par des opérations du modèle relationnel.

2. Relations dérivées : Vues Les vues sont des relations virtuelles, toujours logiquement consistantes avec les relations de base sous-jacentes. Les vues simplifient les programmes d’application. Elles peuvent être utilisées pour contrôler les accès. Les vues peuvent être ou ne pas être stockées sur disque. Les stocker : – introduit de la redondance et complique le renforcement d’intégrité ; – accélère les requêtes et ralenti les mises à jour.

V. Opérations sur le modèle relationnel Langage de Définition de Données (LDD) : simple – déclarer une relation, une contrainte, des structures physiques

Langage de Manipulation de Données (LMD) : – l’algèbre, les calculs de domaines et de tuples sont généralement considérés comme faisant partie du

modèle ; – SQL a redéfini les opérations correspondantes et défini quelques extensions, notamment pour les

fonctions de groupe.

Opérations de mise à jour : simples

Base de données 22

– création, suppression, modification d’une relation dans le schéma ; – insertion, suppression, modification d’un tuple.

VI. Passage du schéma EA au relationnel Le modèle EA possède deux principales constructions : entités et associations. Le modèle relationnel ne possède que des relations : – entités ↔ relations ; – associations ↔ relations ; – attributs multi-valués↔ relations.

Sans donner un algorithme, on présente ici les règles qui permettent de traduire les composants de base des schémas entité-association en composant de schémas relationnels.

1. Règle concernant les entités Règle n°1 : Chaque entité E est exprimée sous la forme d’une relation R (d’une table). Règle n°2 : Chaque attribut de l’entité E est traduit en attribut de la relation R (en une colonne de la table). Règle n°3 : Chaque clé (identifiant) d’une entité E devient clé primaire de la relation R correspondante.

2. Règle concernant les associations binaires A leur tour, les associations seront transformées en relation (tables) suivant leur cardinalité.

Règle n°4 : Une association binaire ayant N en cardinalités max des deux côtés donnera naissance à une relation (table) dont la clé primaire est la concaténation des clés primaires des tables correspondant aux entités associées. Chaque clé d’une entité associée deviendra en plus clé étrangère de la nouvelle relation.

Exemple : Schéma relationnel correspondant : CLIENT (N°Client, Nom, Prénom) PRODUIT (Code) COMMANDE (#N°Client, #Code)

Règle n°5 : Une association binaire ayant 0,1 en cardinalités sur un des deux côtés donnera naissance ou non à une relation (à une table) suivant que le SGBD tolère ou non les valeurs NULL. Ne pas oublier de créer les clés étrangères adéquates. Si le SGBD tolère les valeurs NULL, les attributs de l’association deviennent des attributs de la relation correspondant à l’entité ayant 1 en cardinalité max.

Exemple avec des cardinalités max à 1 d’un coté, et N de l’autre : Si le SGBD ne supporte pas les valeurs NULL (noter qu’ici, prix dépend à la fois du client et du tableau), le schéma relationnel correspondant est : CLIENT (N°Client, Nom, Prénom) TABLEAU (Réf., Peintre) ACHETE (#N°Client, #Réf., Prix)

Si le SGBD autorise les valeurs NULL (noter qu’ici, prix ne dépend que du tableau), le schéma relationnel correspondant est :

Client Produit

Code N°Client

Nom Prénom

COMMANDE <1,N> <0,N>

Tableau Réf.

Peintre

Client N°Client

Nom ACHAT

<1,N> <0,1>

Prix Prénom

Tableau Réf.

Peintre Prix

Client N°Client

Nom Prénom

ACHAT <1,N> <0,1>

Base de données 23

CLIENT (N°Client, Nom, Prénom) TABLEAU (Réf., Peintre, #N°Client, Prix)

Exemple avec des cardinalités max à 1 des deux côtés : Si le SGBD ne supporte pas les valeurs NULL, le schéma relationnel correspondant est : FEMME (N° SSépouse, Nom, Prénom) HOMME (N° SSépoux, Nom, Prénom) MARIER(#N°SSépouse, #N°SSépoux)

Si le SGBD autorise les valeurs NULL, le schéma relationnel correspondant est : FEMME (N°SSépouse, Nom, Prénom, #N°SSépoux) HOMME (N°SSépoux, Nom, Prénom, #N°SSépouse)

Règle n°6 : Une association binaire ayant 1,1 en cardinalités sur un des deux côtés ne donnera naissance à aucune relation, mais dans l’entité qui a les cardinalités 1,1 est insérée la clé de l’autre entité. Cette clé devient clé étrangère de la relation correspondant à l’entité qui a les cardinalités 1,1.

Exemple : Schéma relationnel correspondant : CLIENT (N°Client, Nom, Prénom) TABLEAU (Référence, Peintre, #N°Client)

Règle n°7 : Une association réflexive est transformée en une relation quelle que soit la valeur de ses cardinalités.

Exemple : Ce schéma EA a pour traduction en relationnel : EMPLOYE (N°, Nom, Prénom) HIERARCHIE (#N°Supérieur, #N°Employé)

Cette règle peut être nuancée en fonction des cas particuliers correspondants aux cardinalités impli-quées dans l’association réflexive. Mais en faisant ainsi, on est sûr de ne pas se tromper.

Homme N° SSépoux

Nom Prénom

Femme N° SSépouse

Nom Prénom

MARIER <0,1> <0,1>

Tableau Réf.

Peintre

Client N°Client

Nom Prénom

ACHAT <1,N> <1,1>

EmployéN°

Nom Prénom

HIERARCHIE

3. Règle concernant les associations n-aires Règle n°8 : Une association n-aire (avec n > 2) est transformée en une relation (en une table) quelle que soit la valeur de ses cardinalités. Si toutes les cardinalités max sont N, alors la clé de cette relation est constituée comme la concaténation des clés des relations obtenues à partir des entités associées. Sinon, chaque clé d’une entité qui a 1 en cardinalité max dans l’association est clé primaire de la nouvelle relation.

Exemple : <0,N>

C c1 c2 c3

B b1 b2

A a1 a2 a3

Le schéma EA de droite est traduit en relationnel par le schéma suivant : A (a1, a2, a3) B (b1, b2) C (c1, c2, c3) R (#a1, #b1, #c1, #c2, r1)

R r1

<0,1>

<0,N>

<0,N>

<0,1>

supérieur

subalterne

<0,1> <0,N>A B

R r1

a1

C c1 c2 c3

b1 b2

a2 a3

<0,1>

Base de données 24

Exemple : Le schéma EA de gauche est traduit en relationnel par le schéma suivant : A (a1, a2, a3) B (b1, b2)

C (c1, c2, c3) R (#a1, #b1, #c1, #c2, r1) ou R (#a1, #b1, #c1, #c2, r1) → 2 clés primaires possibles, en choisir une.

4. Cas de l’héritage et de l’identification a. Héritage

Exemple : Cette deuxième notation n’est jamais employée, c’est juste pour comprendre le passage en relationnel. Ainsi on obtient le schéma relationnel suivant : EMPLOYE (N°Employé) PILOTE (#N°Employé, Nom, Prénom)

b. Identification Exemple : Cette deuxième notation n’est jamais employée, c’est juste pour comprendre le passage en relationnel. Ainsi on obtient le schéma relationnel suivant : SERIE (Nom, Producteur) EPISODE (Numéro, #Nom_Série)

VII. Modèle Entité-Association vs Modèle Relationnel Le modèle EA est plus compact que le modèle relationnel (meilleur intuition), mais on a une perte d’information : – perte de précision : un seul concept relationnel (relation) représente trois concepts EA (entité,

association, attribut multi-valué) ; – la perte d’information se situe dans la correspondance avec le monde réel.

Chapitre 5 Algèbre relationnel

I. Introduction Les langages tels que SQL reposent sur l'algèbre relationnelle. L'algèbre relationnelle est un langage algébrique qui utilise un ensemble d'opérateurs relationnels combinés pour construire des opérations sur une ou plusieurs tables. Le langage algébrique est un langage formel qui offre une base théorique solide au modèle relationnel. Le résultat d'une opération est une table.

Codd a initialement introduit huit opérations (implémentées par le langage SQL), dont certaines peuvent être composées à partir d'autres. Ces opérations peuvent être regroupées en deux types d'opérateurs : – Les opérateurs relationnels ensemblistes :

o union o intersection o différence o produit cartésien

– Les opérateurs relationnels spécifiques : o restriction ou sélection o projection o jointure o division o renommage ou changement de nom

Les opérateurs sont de deux types : – unaire : opère sur une relation – binaire : opère sur deux relations

Le tableau suivant récapitule les opérateurs relationnels dans les différentes catégories présentées précédemment :

OPERATEURS UNAIRES BINAIRES

ENSEMBLISTES

union intersection différence

produit cartésien

SPECIFIQUES restriction ou sélection

projection renommage

jointure division

Les cinq opérations fondamentales sont : l'union, l'intersection, la selection, la projection, la jointure et le renommage. Les autres opérations peuvent se déduire aisément à partir de ces opérations fondamentales. C'est la raison pour laquelle, certains SGBD n'implémentent pas toutes ces opérations mais n'utilisent que les opérations fondamentales pour répondre à tout type de requête.

II. Les opérateurs ensemblistes Les opérateurs suivants sont des opérateurs binaires : ils opèrent sur deux relations.

1. Union Définition : L'union est une opération portant sur deux relations de même schéma R1 et R2. Elle consiste à construire une relation RESULT de même schéma que R1 et R2 ayant pour tuples ceux appartenant à R1 ou R2 ou aux deux relations.

Notation : RESULT = UNION (R1,R2) = R1 ∪ R2

Base de données 26

Remarques : L'union ne peut porter que sur deux relations ayant le même schéma de table c'est-à-dire sur deux tables ayant strictement les mêmes attributs. On dit dans ce cas que les relations sont compatibles.

Exemple : Relation R1 Immatriculation Marque Couleur Puissance Prix

4578QS59 Renault Noire 7 20 000 1952LM62 Rover Bleue 5 28 000 3664PN75 Citroën Rouge 6 30 000

Relation R2 Immatriculation Marque Couleur Puissance Prix 3664PN75 Citroën Rouge 6 30 000 3671KH60 Peugeot Verte 6 10 000 4691TR95 Renault Jaune 7 35 000

La relation RESULT renvoie les tuples présents dans R1 ou R2, ou dans les deux.

Relation RESULT Immatriculation Marque Couleur Puissance Prix 4578QS59 Renault Noire 7 20 000 1952LM62 Rover Bleue 5 28 000 3664PN75 Citroën Rouge 6 30 000 3671KH60 Peugeot Verte 6 10 000 4691TR95 Renault Jaune 7 35 000

2. Intersection Définition : L'intersection est une opération portant sur deux relations de même schéma R1 et R2. Elle consiste à construire une relation RESULT de même schéma que R1 et R2 ayant pour tuples ceux appartenant à la fois à R1 et R2.

Notation : RESULT = INTERSECT (R1,R2) = AND (R1, R2) = R1 ∩ R2

Remarques : L'intersection ne peut porter que sur deux relations ayant le même schéma de table c'est-à-dire sur deux tables ayant strictement les mêmes attributs.




La relation RESULT renvoie les tuples présents à la fois dans R1 et dans R2.

Relation RESULT Immatriculation Marque Couleur Puissance Prix 3664PN75 Citroën Rouge 6 30 000

3. Différence Définition : La différence est une opération portant sur deux relations de même schéma R1 et R2. Elle consiste à construire une relation RESULT de même schéma que R1 et R2 ayant pour tuples ceux appartenant à R1 et n'appartenant pas à R2.

Notation : RESULT = MINUS (R1,R2) = R1 – R2 = R1 \ R2

Base de données 27

Remarques : La différence n'est pas commutative, ce qui signifie que R1 – R2 est différent de R2 – R1. La différence ne peut porter que sur deux relations ayant le même schéma de table c'est-à-dire sur deux tables ayant strictement les mêmes attributs.




La relation RESULT renvoie tous les tuples appartenant à R1 mais pas à R2.

Relation RESULT Immatriculation Marque Couleur Puissance Prix 4578QS59 Renault Noire 7 20 000 1952LM62 Rover Bleue 5 28 000

4. Produit Définition : Le produit cartésien de deux relations R1 et R2 (de schéma quelconque) consiste à construire une relation RESULT ayant pour schéma la concaténation des attributs des deux relations et pour tuples toutes les combinaisons possibles des tuples des relations opérandes.

Notation : RESULT = PRODUCT (R1, R2) = R1 × R2

Remarques : La relation RESULT comporte autant de lignes que le produit du nombre de lignes de R1 par le nombre de lignes de R2. Les deux relations n’ont pas besoin d’avoir le même schéma de relation.

Exemple : Relation R1 Immatriculation Marque Couleur Puissance Relation R2 Prix

4578QS59 Renault Noire 7 30 000 1952LM62 Rover Bleue 5 10 000 3664PN75 Citroën Rouge 6

La relation RESULT renvoie la concaténation de chaque tuple de R1 avec chaque tuple de R2.

Relation RESULT Immatriculation Marque Couleur Puissance Prix 4578QS59 Renault Noire 7 30 000 1952LM62 Rover Bleue 5 30 000 3664PN75 Citroën Rouge 6 30 000 4578QS59 Renault Noire 7 10 000 1952LM62 Rover Bleue 5 10 000 3664PN75 Citroën Rouge 6 10 000

III. Les opérateurs relationnels spécifiques

1. Restriction Définition : La restriction, encore appelée sélection, est une opération unaire. Elle consiste à sélectionner un ensemble de lignes d'une relation en fonction d'un critère de sélection (prédicat ou expression logique de prédicats). Le résultat d'une restriction est une relation de même schéma que la relation initiale.

Base de données 28

Notation : RESULT = RESTRICT (R1, Attribut(s) = Valeur(s)) = σ Attribut(s) = Valeur(s) (R1)


4578QS59 Renault Noire 7 20 000 1952LM62 Rover Bleue 5 28 000 3664PN75 Citroën Rouge 6 30 000 3671KH60 Peugeot Verte 6 10 000 4691TR95 Renault Jaune 7 35 000

La relation RESULT = σ Marque=‘Renault’ (R1) renvoie la restriction de R1 sur le prédicat Marque = ‘Renault’.

Relation RESULT Immatriculation Marque Couleur Puissance Prix 4578QS59 Renault Noire 7 20 000 4691TR95 Renault Jaune 7 35 000

2. Projection Définition : La projection est une opération unaire qui sélectionne un ensemble de colonnes d'une relation, en éliminant les tuples identiques, c'est à dire supprime les tuples (lignes) ayant le même ensemble de valeurs (doublons).

Notation : RESULT = PROJECT (R1, Attribut(s)) = Π Attribut(s) (R1)



La relation RESULT = ΠMarque,Puissance (R1) renvoie la projection de R1 sur les attributs Marque et Puissance.

Relation RESULT Marque Puissance Renault 7 Rover 5 Citroën 6 Peugeot 6

3. Jointure La jointure est une des opérations essentielles de l'algèbre relationnelle. La jointure permet de composer deux relations à l'aide d'une condition de rapprochement des tables appelée critère de jointure. Elle peut être vue comme une restriction du produit cartésien par une condition permettant de comparer des attributs.

Définition : La jointure est une opération binaire. Elle consiste à rapprocher (selon une condition) les tuples de deux relations R1 et R2 afin de former une troisième relation RESULT. Cette relation RESULT contient l'ensemble de tous les tuples obtenus en concaténant un tuple de R1 et un tuple de R2 qui vérifient la condition de rapprochement.

Lorsque le critère de restriction est l'égalité, on parle d'équijointure, sinon on parle de theta-jointure. La condition de rapprochement des tables doit porter sur des colonnes compatibles. La condition de rapprochement ne porte pas nécessairement sur les attributs clés.

Base de données 29

Notation : RESULT = JOIN (R1, R2, R1.attribut = R2.attribut) = R1 R2



Relation R2 Immatriculation numPersonne dateAchat

4578QS59 1591259 12/12/2001 1952LM62 2630662 08/11/1998 4691TR95 1120606 05/09/1997

La relation RESULT = = R1 R2 renvoie la jointure de R1 et R2 portant sur la clé Immatriculation.

Relation RESULT Immatriculation Marque Couleur Puissance Prix numPersonne dateAchat

4578QS59 Renault Noire 7 20 000 1591259 12/12/2001 1952LM62 Rover Bleue 5 28 000 2630662 08/11/1998 4691TR95 Renault Jaune 7 35 000 1120606 05/09/1997

4. Division La division permet de rechercher dans une relation les sous-tuples qui sont complétés par tous ceux d'une autre relation. Elle permet ainsi d'élaborer la réponse à des questions de la forme « quel que soit X, trouver Y » de manière simple.

Définition : La division est une opération consistant à construire le quotient de la relation R1 (A1,…,Ap, Ap+1,…,An) par la relation R2 (Ap+1,…,An). Le résultat de la division est la relation RESULT (A1,…,Ap) dont les tuples sont ceux qui, concaténés à tout tuple de R2, donnent un tuple de R1.

Notation : RESULT = DIVISION (R1, R2) = R1 / R2 = R1 ÷ R2

Remarques : Il est à noter que si R1 possède N1 tuples et R2 en possède N2, alors la division de R1 par R2 possédera au plus N1 / N2 tuples. La division n'est pas commutative, ce qui signifie que R1 / R2 est différent de R2 / R1.

Exemple : Relation R1 Marque Couleur Puissance Prix

Renault Noire 7 20 000 Rover Bleue 5 28 000 Citroën Rouge 6 30 000 Peugeot Verte 6 10 000 Renault Jaune 7 35 000

Relation R2 Prix 30 000 10 000

La relation RESULT renvoie la division de R1 par R2, c'est-à-dire que ceci correspond à une requête qui détermine toutes les marques de voiture dont le prix est soit 10 000, soit 30 000.

Relation RESULT Marque Couleur Puissance Citroën Rouge 6 Peugeot Verte 6

Base de données 30

5. Renommage Le renommage ou le changement de nom permet de renommer différemment un attribut ou une liste d’attributs d’une relation afin de pouvoir réaliser plus aisément les huit opérations précédentes.

Définition : Le renommage est une opération unaire consistant à renommer un ou plusieurs attributs Ap+1,…,An de la relation R1 (A1,…,Ap, Ap+1,…,An) en BBp+1,…,Bn. Le résultat du renommage est la relation RESULT(A1,…An, Bp+1,…,Bn)B .

Notation : RESULT = RENAME (R1, (Ap+1,…,An)→( Bp+1,…,Bn)) = ρ Attribut(s) _A : Attribut(s) _B (R1)

= δ Attribut(s) _A : Attribut(s) _B (R1)

Exemple : Relation R1 Marque Couleur Puissance Prix

Renault Noire 7 20 000 Rover Bleue 5 28 000 Citroën Rouge 6 30 000 Peugeot Verte 6 10 000 Renault Jaune 7 35 000

La relation RESULT renvoie le renommage de la colonne « Puissance » par « CV » de R1.

Relation RESULT Marque Couleur CV Prix Renault Noire 7 20 000 Rover Bleue 5 28 000 Citroën Rouge 6 30 000 Peugeot Verte 6 10 000 Renault Jaune 7 35 000

IV. Définitions ensemblistes des opérateurs algébriques Pour chaque opération algébrique des paragraphes précédents, on retrouve la définition ensembliste parmi la liste suivante : – Union : r ∪ s = { t | [(t ∈ r) ou (t ∈ s)] et (R = S) }

– Intersection : r ∩ s = { t | [(t ∈ r) et (t ∈ s)] et (R = S) }

– Différence : r – s = r \ s = { t | [(t ∈ r) et (t ∉ s)] et (R = S) }

– Produit cartésien : r × s = { t[RS] | [(t[R] ∈ r) et (t[S] ∈ s)] et (R ∩ S = ∅) }

– Restriction : σ F (r) = { t ∈ r | r est satisfaite par la condition F }

ex : σ Y = y (r) = { t ∈ r | (t[Y] = y) et (Y ⊆ R) }

– Projection : Π X (r) = { t[Y] | (t ∈ r) et (Y = X ∩ R) }

– Jointure : r s = { t[RS] | [(t[R] ∈ r) et (t[S] ∈ s)] et (R ∩ S ≠ ∅) }

– Division : r / s = r ÷ s = { t[Y] | [(t ∈ r) et (t[S] ∈ s)] et (Y = R – S) }

– Renommage : ρ Y : X (r) = δ Y : X (r) = { t ∈ r | on renomme Y par X }

Où r et s sont deux relations définies respectivement sur les schémas de relation R et S ; X et Y sont un ensemble de colonnes, y est la valeur d’un n-uplet défini sur Y. Remarque : On note l’union entre deux schémas de relation R et S par RS = R ∪ S, et on note la restriction d’un tuple à X par t[X].

Base de données 31

V. Quelques propriétés ensemblistes Voici quelques propriétés qui peuvent être démontrées à l’aide des définitions ensemblistes précédentes :

– Opérateurs ensemblistes : 1. (r ∪ s) ∪ z = r ∪ (s ∪ z) = r ∪ s ∪ z.

2. (r ∩ s) ∩ z = r ∩ (s ∩ z) = r ∩ s ∩ z.

3. (r ∪ s) ∩ z = (r ∪ z) ∩ (s ∪ z)

4. (r ∩ s) ∪ z = (r ∩ z) ∪ (s ∩ z)

– Sélection avec conditions simples ou complexes : 1. σ F (r) = σ F [σ F (r)].

2. σ F1 ∩ F2 (r) = σ F1 [σ F2 (r)] = σ F2 [σ F1 (r)]

3. σ F1 ∪ F2 (r) = σ F1 (r) ∪ σ F2 (r).

– Projection : 1. Pour tout X et Y tels que Y ⊆ X ⊆ R : Π Y [Π X (r)] = Π X (r)

– Sélection et opérateurs ensemblistes (pour les trois propriétés ci-dessous, on a R = S) : 1. σ F (r – s) = σ F (r) – σ F (s) = σ F (r) – s

2. σ F (r ∪ s) = σ F (r) ∪ σ F (s)

3. σ F (r ∩ s) = σ F (r) ∩ σ F (s) = σ F (r) ∩ s = r ∩ σ F (s)

– Projection et opérateurs ensemblistes (pour les trois propriétés ci-dessous, on a R = S) : 1. Π X (r ∪ s) = Π X (r) ∪ Π X (s)

2. Π X (r ∩ s) ⊆ Π X (r) ∩ Π X (s)

3. Π X (r) – Π X (s) ⊆ Π X (r – s)

– Jointure et opérateurs ensemblistes : 1. Si R = S, alors r s = r ∩ s

2. Si Q = R, alors (q ∪ r) s = (q s) ∪ (r s)

3. Si Q = R, alors (q ∩ r) s = (q s) ∩ (r s)

4. Si Q = R, alors (q – r) s = (q s) – (r s)

– Produit cartésien et opérateurs ensemblistes (pour les trois propriétés ci-dessous, on a Q = R) : 5. (q ∪ r) × s = (q × s) ∪ (r × s)

6. (q ∩ r) × s = (q × s) ∩ (r × s)

7. (q – r) × s = (q × s) – (r × s)

– Règles de commutativité : 1. σ F1 [σ F2 (r)] = σ F2 [σ F1 (r)].

2. r ∪ s = s ∪ r

3. r ∩ s = s ∩ r

4. r × s = s × r

5. r s = s r

– Règles d’associativité : 1. (r s) z = r (s z) si [(R ∩ S = ∅) et (Z ∩ S = ∅)] ou [(R ∩ S ≠ ∅) et (Z ∩ S ≠ ∅)]

2. (r × s) × z = r × (s × z) si [(R ∩ S = ∅) et (Z ∩ S = ∅)]

Base de données 32

– Jointure, sélection, projection et produit cartésien : 1. Pour tout R et S tel que R ⊆ Q et S ⊆ Q et R ∩ S ≠ ∅, on a : Π RS (q) ⊆ Π R (q) Π S (q)

2. σ F (r s) = σ F (r) σ F (s)

3. Π X (r s) =Π X (r) Π X (s)

4. σ F1 ∩ F2 ∩ F3 (r × s) = σ F3 (σ F1 (r) × σ F2 (s)) si la condition F1 est définie sur R seulement, la condition F2 sur S seulement, et la condition F3 sur R et S.

– Réécriture des opérateurs déduits : 1. Intersection :

Soit deux schémas de relation R et S tels que R=S, et deux relations r et s définies respectivement sur R et S. Alors on peut écrire l’opération d’intersection par : r ∩ s = r – (r – s) = s – (s – r)

r ∩ s = (r ∪ s) – [(r – s) ∪ (s – r)]

2. Jointure : Soit deux schémas de relation R et S tels que R ∩ S ≠ ∅, et deux relations r et s définies respectivement sur R et S. On note R = XY et S = YZ. Alors on peut écrire l’opération de jointure naturelle par : r s = Π RS [σ Y = Y’ (r × δ Y : X (s))] = Π RS [σ Y = Y’ (s × δ Y : X (r))]

3. Division : Soit deux schémas de relation R et S tels que S ⊆ R, et deux relations r et s définies respectivement sur R et S. Alors on peut écrire l’opération de division par : r / s = Π R – S (r) – Π R – S [(Π R – S (r) × s) – r]

Chapitre 6 Calcul relationnel

I. Introduction Le calcul relationnel est basé sur la logique de premier ordre et repose sur le calcul des prédicats. Cette théorie mathématique étudie les formules logiques construites avec un ensemble de prédicats (c'est-à-dire de propositions qui peuvent être vraie ou fausses dans un certain contexte), les opérateurs et, ou, négation, implication logique, des variables et les opérateurs quel que soit et il existe.

A chaque formule logique correspond l’ensemble des données qui vérifient cette formule. L’interrogation de la base de données consiste donc à énoncer une formule qui correspond aux données que l’on souhaite extraire de la base.

Il existe deux variantes du calcul relationnel : - Le calcul relationnel à variable domaine, où les variables tiennent lieu d'attributs de tuples. - Le calcul relationnel à variable n-uplets, où les variables tiennent lieu de tuples.

II. Calcul relationnel à variable n-uplets Une expression générale du calcul relationnel à variable n-uplets est de la forme :

[ ] [ ] [ ] ( ){ }1 1 2 2 1 2 1, , ..., | , , ..., , , ...,N N N N N Mt A t A t A COND t t t t t+ +

avec ti où i varie de 1 à N + M, sont des variables n-uplets non nécessairement distinctes deux à deux, et Ai sont des attributs de relations associées aux ti, et COND est une formule du calcul relationnel à variable n-uplets. L'expression de la forme ti[Ai] exprime la valeur du n-uplet ti suivant l'attribut de nom Ai (terme de projection).

Une formule est construite à partir de prédicats atomiques (atomes) qui sont d'une des formes suivantes : - Un atome de la forme R(ti) où R est un nom de relation et ti est une variable n-uplet. Cet atome identifie

le domaine de la variable ti comme celui de la relation de nom R. - Un atome de la forme ti[A] op tj[B] où op est un opérateur de comparaison classique, ti et tj des

variables n-uplets, et A, B des attributs des relations associées. - Un atome de la forme ti[A] op c ou c op tj[B], où c est une constante.

Une formule est constituée d'atomes connectés par les opérateurs logiques et, ou, négation et se définit de la manière suivante : - Tout atome est une formule. - Si F1 et F2 sont des formules, alors (F1 et F2), (F1 ou F2), négation(F1) sont des formules. - Si F est une formule, alors (il existe t) (F) est une formule avec t variable nuplet. - Si F est une formule, alors (quel que soit t) (F) est une formule avec t variable nuplet.

Remarque : - Une variable est dite libre si elle n'est pas quantifiée dans sa portée, liée sinon. - Les opérateurs et, ou, négation, implication logique, quel que soit et il existe sont respectivement

notés : ∧, ∨, ¬, →, ∀ et ∃.

Exemples : Considérons les relations suivantes : - REPAS ( date , invité ). - MENU ( date , plat ). - PREFERENCES ( personne , plat ).

{ r[invite] | REPAS(r) ∧ r[date]=‘01/05/97’ }

Cette requête en calcul relationnel à variable n-uplets permet de récupérer la liste des invités du repas du 01/05/97.

Base de données 34

{ m[plat] | ∃r (REPAS(r) ∧ MENU(m) ∧ m[date]=r[date] ∧ r[invité]=‘Alice’) }

Cette requête en calcul relationnel à variable n-uplets permet d’avoir la liste des plats servis à Alice.

{ r[invité] | ∃m,p (REPAS(r) ∧ MENU(m) ∧ PREFERENCES(p) ∧ m[date]=r[date] ∧

m[plat]=p[plat] ∧ r[invité]=p[personne]) }

Cette requête en calcul relationnel à variable n-uplets permet de récupérer la liste des invités qui, lors d’un repas, ont eu au moins un de leur plat préféré.

{ r,p | REPAS(r) ∧ PREFERENCES(p) }

Cette requête en calcul relationnel à variable n-uplets permet de réaliser le produit cartésien entre REPAS et PEREFERENCES.

{ p[personne] | ∀r (PREFERENCES(p) ∧ REPAS(r) ∧ r[invité]!=p[personne]) }

Cette requête en calcul relationnel à variable n-uplets permet d’avoir la liste des personnes qui n’ont jamais été invités.

{ R[date] | REPAS(r) } → EDATE { r[invité] | ∀e (REPAS(r) ∧ EDATE(e) ∧ r[date]=e[date]) }

Cette requête en calcul relationnel à variable n-uplets permet d’avoir la liste des invités qui sont venus à tous les repas.

III. Calcul relationnel à variable domaine Une expression générale du calcul relationnel à variable domaine est de la forme :

( ){ }1 2 1 2 1, , ..., | , , ..., , , ...,N N Nx x x COND x x x x x+ +N M

avec xi où i varie de 1 à N + M, sont des variables domaines (non nécessairement distinctes deux à deux) d’attributs et COND est une formule du calcul relationnel à variable domaine.

Une formule est construite à partir de prédicats atomiques (atomes) qui sont d'une des formes suivantes : - Un atome de la forme R(x1,…,xj) où R est un nom de relation de degré j et chaque xi est une variable.

< x1,…,xj > représente un n-uplet de la relation R et xi la ième valeur dans le n-uplet. - Un atome de la forme xi op xj où op est un opérateur de comparaison classique, xi et xj des variables

domaines. - Un atome de la forme xi op c ou c op xj, où c est une constante.

Une formule est constituée d'atomes connectés par les opérateurs logiques et, ou, négation et se définit de la manière suivante : - Tout atome est une formule. - Si F1 et F2 sont des formules, alors (F1 et F2), (F1 ou F2), négation(F1) sont des formules. - Si F est une formule, alors (il existe t) (F) est une formule avec t variable nuplet. - Si F est une formule, alors (quel que soit t) (F) est une formule avec t variable nuplet.

Remarque : - Une variable est dite libre si elle n'est pas quantifiée dans sa portée, liée sinon. - Les opérateurs et, ou, négation, implication logique, quel que soit et il existe sont respectivement

notés : ∧, ∨, ¬, →, ∀ et ∃.

Base de données 35

Exemples : Considérons les relations suivantes : - REPAS ( date , invité ). - MENU ( date , plat ). - PREFERENCES ( personne , plat ).

{ i | ∃d (REPAS(invité:i,date:d) ∧ d=‘01/05/97’) }

Cette requête en calcul relationnel à variable n-uplets permet de récupérer la liste des invités du repas du 01/05/97.

{ p | ∃r (REPAS(invité:i,date:d) ∧ MENU(date:d,plat:p) ∧ i=‘Alice’) }

Cette requête en calcul relationnel à variable n-uplets permet d’avoir la liste des plats servis à Alice.

{ i | ∃d,p (REPAS(invité:i,date:d) ∧ MENU(date:d,plat:p) ∧ PREFERENCES(plat:p, personne:i)) }

Cette requête en calcul relationnel à variable n-uplets permet de récupérer la liste des invités qui, lors d’un repas, ont eu au moins un de leur plat préféré.

{ d,i,pe,p | REPAS(invité:i,date:d) ∧ PREFERENCES(plat:p,personne:pe) }

Cette requête en calcul relationnel à variable n-uplets permet de réaliser le produit cartésien entre REPAS et PEREFERENCES.

{ pe | ∃p ∀i (REPAS(invité:i) ∧ PREFERENCES(plat:p,personne:pe) ∧ i!=pe) }

Cette requête en calcul relationnel à variable n-uplets permet d’avoir la liste des personnes qui n’ont jamais été invités.

{ i | ∀d (REPAS(invité:i,date:d) }

Cette requête en calcul relationnel à variable n-uplets permet d’avoir la liste des invités qui sont venus à tous les repas.

IV. Algèbre relationnelle contre calcul relationnel L'algèbre relationnelle et le calcul relationnel ont la même puissance d'expression ; donc toutes les requêtes qui peuvent être formulées en utilisant l'un peuvent aussi l'être grâce à l'autre. Ce fut vérifié en premier par E.F. Codd en 1972. La preuve est fondée sur un algorithme (appelé « algorithme de réduction de Codd ») par lequel une expression arbitraire du calcul relationnel peut être réduite à une expression au sens équivalent de l'algèbre relationnelle.

Certains déclarèrent que les langages basés sur le calcul relationnel sont de « haut niveau » ou « plus déclaratifs » que les langages basés sur l'algèbre relationnelle parce que ce dernier spécifie (partiellement) l'ordre des opérations tandis que le calcul laisse le compilateur ou l'interpréteur déterminer l'ordre d'évaluation le plus efficace.

Chapitre 7 Langage SQL

I. Introduction SQL (Structured Query Language, ou langage de requêtes structurées) est l'interface externe la plus répandue pour gérer une base de données. C'est un langage déclaratif dans le sens où il suffit d'exprimer ce que l'on veut obtenir, sans devoir expliquer la méthode pour y parvenir. Ainsi, les opérations directement utilisables par les usagers sont en général celles des langages dits assertionnels.

Ces langages, bâtis sur l'algèbre relationnelle, permettent de manipuler des bases de données relationnelles. Nous pouvons citer à titre d'exemple : - QUEL (QUEry Language) par Zook en 1977 - QBE (Query By Example) par Zloof en 1977 - SQL (Structured Query Language) par IBM

Aujourd'hui, le langage SQL est normalisé et constitue le standard d'accès aux bases de données relationnelles. Les autres interfaces par menus, fenêtres, grilles ou de programmation type langage de 3ème ou 4ème génération (L3G et L4G) sont le plus souvent offertes au-dessus du langage SQL. Celui-ci constitue donc le point d'entrée des SGBD relationnels. Il a été normalisé à quatre reprises (ISO et ANSI sont des organismes chargés de la normalisation) :

- 1986 : SQL 86 - ANSI* - 1989 : - ISO* et ANSI - 1992 : SQL 2 - ISO et ANSI - 1999 : SQL 3 - ISO

II. Présentation de SQL SQL est un langage de gestion de bases de données relationnelles. Il étend l'algèbre relationnelle et permet : - de créer des bases de données - d'ajouter, modifier et consulter des données d'une base de données existante - de contrôler les accès aux informations d'une BD

SQL est un langage ensembliste qui : - respecte l’indépendance des niveaux - garantit la sécurité - permet une gestion multi-utilisateurs - utilise un dictionnaire - respecte les contraintes d’intégrité - est portable (standardisation)

SQL étend l'algèbre relationnelle, cependant il utilise les termes table, ligne et colonne au lieu des termes relationnels relation, tuple et attribut. Une instruction SQL peut s'écrire sur plusieurs lignes. Pour être exécutée, l'instruction doit se terminer par un point-virgule. SQL est un langage de requête, pas un langage de programmation. Par conséquent, il n'y pas de variables ni de structures de contrôles (if, while, for). C'est pourquoi on peut éventuellement l'intégrer dans un langage de programmation comme PL/SQL, C ou Java.

III. Les 3 facettes de SQL SQL se subdivise en 3 sous-langages : - LDD (Langage de Définition de Données) : création, modification et suppression des objets que peut

manipuler une BD (tables, vues et index, etc). - LMD (Langage de Manipulation de Données) : ajout, suppression, modification et extraction des

données. - LCD (Langage de Contrôle de Données) : sécurisation et validation des données.

Base de données 37

Chacun de ces sous-langages propose ses mots-clés propres. Voici les principales primitives que nous verrons au cours de ce chapitre :

LDD LMD LCD CREATEALTERDROP

SELECTINSERTUPDATEDELETE

GRANT REVOKE COMMIT

ROLLBACK

IV. Le Langage de Définition de Données (LDD) Définition : Le langage de définition de données permet la définition du schéma d'une base de données ainsi que certaines de ses contraintes d'intégrité. Il comporte également les opérations de mise à jour de schéma telles que la suppression d'une table ou la modification de la définition d'une table.

Le LDD est donc composé de 3 primitives : - CREATE pour la création d'un objet (table, index, vue, etc). - ALTER pour la modification d'un objet. - DROP pour la suppression d'un objet.

1. Création de table La création de table se fait grâce au mot-clé CREATE TABLE.

Chaque table est définie par : - son nom - sa liste d'attributs - sa liste de contraintes sur table

Chaque attribut est défini par : - son type - sa valeur par défaut - sa liste des contraintes sur attribut

Le type des attributs est à choisir parmi un ensemble fini de types. Les principaux types possibles sont selon les standards: - VARCHAR2(n) : chaîne de caractères de longueur variable (maximum n) - CHAR(n) : chaîne de caractères de longueur fixe (n caractères) - NUMBER : nombre entier (40 chiffres au maximum) - NUMBER(n,m) : nombre entier de longueur totale n avec m décimales - INTEGER : entier - FLOAT : réel - DATE : date (DD-MON-YY est le format par défaut) - ...

Syntaxe de définition d'une table en SQL

CREATE TABLE nom_table

(attribut1 type1 [DEFAULT valeur_par_défaut] [contrainte sur attribut1], …, attributN typeN [DEFAULT valeur_par_défaut] [contrainte sur attributN],

CONSTRAINT contrainte1 sur relation), …, CONSTRAINT contrainteM sur relation);

Base de données 38

Notation (les éléments entre [ ] sont optionnels) : - Valeur_par_défaut doit être compatible avec le type de l'attribut. Elle peut prendre une des valeurs

parmi : o constante o NULL

- Contrainte sur attribut décrit les contraintes mono-attributs. Elle peut prendre une valeur parmi : o NOT NULL o UNIQUE o REFERENCES nom_de_relation2 (pour les clés étrangères) o CHECK (expression logique) o PRIMARY KEY

Les contraintes sur attribut restreignent les valeurs d'un attribut (ex : l'âge d'une personne – attribut Age – ne peut pas être négatif et ne dépasse pas 130 ans). Remarque : S'il y a plusieurs contraintes sur un attribut, elles sont séparées par des virgules.

- Contrainte sur relation décrit les contraintes multi-attributs. Elle peut prendre une valeur parmi : o UNIQUE (liste d'attributs) o PRIMARY KEY (liste d'attributs) o FOREIGN KEY (liste d'attributs) REFERENCES nom_de_relation2 (liste d'attributs)

S'il y a plusieurs contraintes multi-attribut, elles sont séparées par des virgules.

Les contraintes sur relation définissent des règles sémantiques entre plusieurs attributs. Il n'y a pas d'ordre dans la définition des attributs ou des contraintes sur relation.

Les définitions d'attributs et de contraintes sont séparées par des virgules. Chaque définition de relation se termine par un point-virgule.

Il est recommandé de donner des noms de contraintes explicites (après le mot clé CONSTRAINT) afin de retrouver plus facilement l'origine des erreurs qui pourront être signalées par le SGBD, suite à des violations de ces contraintes.

La signification des différents mots-clés (NULL, NOT NULL, UNIQUE,…) est donnée dans la suite du chapitre.

a. Règles d'écriture des contraintes Les contraintes sur attribut (C/A) ou sur relation (C/R) doivent satisfaire les règles d'écriture suivantes :

1. La clause NOT NULL dans les C/A et la valeur par défaut NULL sont incompatibles. Un attribut ne peut pas être NULL et NOT NULL en même temps.

2. La clause UNIQUE (aussi bien dans les C/A que dans les C/R) ne peut être spécifiée que sur des attributs déclarés NOT NULL.

3. L'expression logique de la condition CHECK ne peut contenir que des prédicats de comparaison d'attributs avec des constantes. La comparaison avec d'autres attributs ou l'usage de fonctions ou de sous-requêtes ne sont pas autorisés.

4. Les attributs de la clause PRIMARY KEY doivent être préalablement déclarés avec la clause NOT NULL.

5. Dans les contraintes de relation, les clauses FOREIGN KEY et REFERENCES doivent apparaître simultanément

6. Les attributs de la clause FOREIGN KEY doivent correspondre soit à des attributs déclarés comme PRIMARY KEY dans une autre relation, soit à des attributs déclarés UNIQUE dans une autre table. La première option correspond à une contrainte référentielle avec la clé primaire, la seconde correspond à une contrainte référentielle avec une clé candidate.

7. Si les attributs de FOREIGN KEY correspondent à une clé primaire dans une autre relation, la clause REFERENCES ne spécifie que le nom de cette dernière.

Base de données 39

8. Si les attributs de FOREIGN KEY correspondent à une clé candidate dans une autre relation, la clause REFERENCES doit mentionner le nom de cette relation ainsi que la liste des attributs composant la clé candidate.

9. Les clauses PRIMARY KEY, UNIQUE et NOT NULL sont redondantes lorsqu'il n'y a qu'une clé par relation. L'une ou l'autre des clauses suffit à la spécifier. Selon la clause utilisée, il faut assurer la cohérence de la définition des contraintes référentielles en utilisant respectivement la règle 7 ou la règle 8.

10. Il faut enfin noter que l'ordre des CREATE TABLE peut être très important par rapport aux contraintes : les tables référencées doivent apparaître avant les tables référençantes.

b. Exemple

CREATE TABLE VOITURE ( Immatriculation VARCHAR(8), Marque VARCHAR(20), Couleur VARCHAR(15), Prix INTEGER CONSTRAINT C1 CHECK (Prix>=0), CONSTRAINT C2 PRIMARY KEY (Immatriculation) );

Cette instruction SQL crée la table VOITURE suivante :

Immatriculation Marque Couleur Prix Texte Texte Texte Nombre

On aperçoit qu'on a inclut une contrainte sur l'attribut Prix, à savoir qu'un prix ne peut pas être négatif. On a également indiqué que le numéro d'immatriculation est la clé primaire de la relation VOITURE.

CREATE TABLE PERSONNE ( NuméroSS INTEGER NOT NULL UNIQUE, Nom VARCHAR ), (30 Prénom VARCHAR 20), ( Adresse VARCHAR(80) );

Cette instruction SQL crée la table PERSONNE suivante :

NuméroSS Nom Prénom AdresseNombre Texte Texte Texte

Ici, on a déclaré la clé primaire NuméroSS, d'une autre manière que précédemment : dans la relation VOITURE, la clé primaire avait été déclarée grâce à la contrainte de relation PRIMARY KEY alors qu'ici, nous l'avons déclarée grâce aux contraintes sur attribut NOT NULL et UNIQUE.

Base de données 40

CREATE TABLE ACHAT ( numImmatriculation VARCHAR(8), numPersonn INTEGER, e dateAchat DATE, CONSTRAINT C3 PRIMARY KEY (numImmatriculation, numPersonne), CONSTRAINT C4 FOREIGN KEY (numImmatriculation) REFERENCES VOITURE(Immatriculation), CONSTRAINT C5 FOREIGN KEY (numPersonne) REFERENCES Personne(NuméroSS) );

Cette instruction SQL crée la table ACHAT suivante :

numImmatriculation numPersonne dateAchatTexte Nombre Date

Dans cette instruction, nous avons déclaré dans la contrainte C3, la clé primaire (clé composée de numImmatriculation et numPersonne) et, dans les contraintes C4 et C5, les dépendances avec les tables VOITURE et PERSONNE via les clés étrangères.

c. Définition d'une table par requête Il est possible de créer une table par récupération des tuples d'une autre table. On peut, par exemple, créer une table appelée ma_table par récupération de la structure et du contenu de autre_table :

CREATE TABLE ma_table as SELECT * FROM autre_table;

On peut également créer une table appelée ma_table par récupération d'une partie seulement de la structure et du contenu de ACHAT. On renomme dans l'exemple ci-dessous les colonnes numImmatriculation et nomPersonne en num et nom :

CREATE TABLE ma_table ( num integer, nom varchar(20) ) as SELECT numImmatriculation, nomPersonne FROM ACHAT;

2. Modification d'une table La modification d'une table se fait grâce au mot-clé ALTER TABLE.

Les principales modifications sur la structure d'une table sont : - l'ajout d’un attribut - la modification d'un attribut - la suppression d'un attribut

Cependant, la modification de schéma est une opération délicate qui peut mettre en péril l'intégrité de la base de données. Aussi toutes les opérations de suppression ou de modification de relation, d'attribut ou de contrainte doivent être faites avec précaution. Pour éviter les erreurs, la plupart des systèmes

Base de données 41

restreignent ou interdisent certaines de ces opérations. La syntaxe suivante d'ORACLE donne un aperçu de ces opérations.

Syntaxe de modification d'une table en SQL

ALTER TABLE nom_table [ ADD (attribut1 type1 [DEFAULT valeur_par_défaut] [contraintes sur attribut1], ..., attributN typeN [DEFAULT valeur_par_défaut] [contraintes sur attributN]); ] | [ADD (contrainte sur relation);] | [ MODIFY (attribut1 type1 [DEFAULT valeur_par_défaut] [contraintes sur attribut1], ..., attributN typeN [DEFAULT valeur_par_défaut] [contraintes sur attributN]); ] | [DROP CONSTRAINT nom_de_contrainte;] | DROP COLUMN nom_de_colonne;

Notation (les éléments entre [ ] sont optionnels) : - Le symbole "|" signifie "ou" ; ainsi dans l'instruction ALTER TABLE, ADD porte soit sur une

contrainte d'attribut soit sur une contrainte de relation. - Le mot-clé ADD permet donc d'ajouter soit un attribut et éventuellement les contraintes associées

à cet attribut, soit une contrainte sur la relation. - Le mot-clé MODIFY permet de modifier la définition d'un attribut. - Le mot-clé DROP CONSTRAINT permet de supprimer une contrainte sur relation. - Le mot-clé DROP COLUMN permet de supprimer une colonne (et donc un champ).

a. Règles Dans une table ayant déjà des tuples, l'ajout d'un attribut implique la mise à NULL de toute la colonne correspondant à cet attribut. Ceci implique que la clause NOT NULL ne doit pas être spécifiée pour cet attribut dans sa définition.

La suppression d'un attribut doit obéir aux quelques règles suivantes : - On ne peut supprimer un attribut-clé ou faisant partie de la clé. - La suppression d'une clé étrangère mono-attribut (une référence à la clé d'une autre table)

entraîne automatiquement la suppression de la contrainte référentielle correspondante (puisque cette contrainte est définie en même temps que l'attribut).

- La suppression d'une clé étrangère multi-attribut doit être précédée de la suppression de la contrainte référentielle correspondante (puisque cette dernière est déclarée à part). Sans cette suppression de la contrainte, toute mise à jour ultérieure de ces attributs peut entraîner une anomalie dans le contrôle de l'intégrité référentielle.

La modification d'un attribut doit respecter les règles suivantes : - Si le nom d'une clé change, il faut propager cette modification sur toutes les tables qui

référencent cette clé. - Toute modification d'une contrainte sur attribut doit respecter les règles de cohérence des

contraintes 1 à 9 spécifiées dans la leçon relative à la création de table.

Base de données 42

La suppression de contrainte est une relaxation de contrainte qui rend les futures requêtes plus permissives qu'elles ne l'étaient avant. Cette suppression ne met pas particulièrement en péril l'intégrité de la base. - Toute suppression de contrainte doit conserver les règles sur contraintes 1 à 9 spécifiées

dans la leçon relative à la création de table.

La suppression de contrainte nécessite que cette contrainte possède un nom.

b. Exemple On désire ajouter les attributs Type et Puissance à la table VOITURE. Voici l'instruction SQL permettant d'ajouter ces attributs.

ALTER TABLE VOITURE ADD(type VARCHAR(20), puissance INTEGER);

Cette instruction SQL modifie la table VOITURE en conséquence :

Immatriculation Marque Couleur Prix Type Puissance Texte Texte Texte Nombre Texte Nombre

On souhaite désormais modifier la contrainte portant sur l'attribut Puissance. En effet, nous aimerions contraindre cette valeur pour qu'elle soit positive. Voici l'instruction SQL résultante :

ALTER TABLE VOITURE ADD (CONSTRAINT C8 (CHECK (Puissance>=0)));

3. Suppression d'une table La suppression d'une table se fait grâce au mot-clé DROP TABLE.

Syntaxe de suppression d'une table en SQL

DROP TABLE nom_table [CASCADE CONSTRAINTS];

Notation (les éléments entre [ ] sont optionnels) : Le mot-clé CASCADE CONSTRAINTS dans la clause DROP TABLE permet de supprimer toutes les références à cette table dans les autres tables.

a. Règles L'opération de suppression de table peut se faire moyennant certaines précautions : - Avant de supprimer une table, il faut supprimer toutes les références à cette table dans les

autres tables (ou utiliser le CASCADE CONSTRAINTS). - Avant de supprimer une table, il faut avoir redéfini ou supprimé toutes les vues impliquant

cette table (nous reviendrons un peu plus loin sur la définition des vues).

La suppression d'une table implique de redéfinir ou supprimer toutes les requêtes impliquant la table supprimée.

b. Exemple On désire supprimer la table VOITURE. Voici l'instruction SQL permettant d'effectuer cette requête :

DROP TABLE VOITURE CASCADE CONSTRAINTS;

Base de données 43

Remarque : on insère la clause CASCADE CONSTRAINTS afin de supprimer les références à la table VOITURE dans la table ACHAT.

4. Renommage d’une table Le renommage d'une table se fait grâce au mot-clé RENAME.

Syntaxe de renommage d'une table en SQL

RENAME nom_table TO nouvelle_table;

5. Consultation d’une table La consultation d'une table se fait grâce au mot-clé DESC[RIBE].

Syntaxe de consultation d'une table en SQL

DESC[RIBE] nom_table;

V. Le Langage de Manipulation de Données (LMD) Définition : Le Langage de Manipulation de Données permet de : - afficher ; - insérer ; - mettre à jour ; - supprimer des données dans les tables.

Le LMD est donc composé de 4 primitives : - SELECT pour l'affichage des données des tables. - INSERT pour l'insertion de données dans les tables. - UPDATE pour la mise à jour des données. - DELETE pour la suppression des données.

1. SELECT L'affichage des données d'une ou plusieurs tables se fait grâce au mot-clé SELECT.

Syntaxe de la primitive SELECT en SQL

SELECT * | [DISTINCT | ALL] <attributs> FROM <tables> [WHERE <condition logique de niveau tuple>] [GROUP BY <attributs> [HAVING <condition logique de niveau groupe>]] [ORDER BY <attributs>];

Notation (les éléments entre [ ] sont optionnels) : - Le symbole "|" signifie "ou" ; ainsi on peut faire suivre le mot-clé SELECT par une * OU par

<attributs> précédé le cas échéant par DISTINCT ou ALL.

La clause SELECT décrit la relation résultat, <attributs> désigne : - soit une liste d'attributs ; - soit une expression obtenue à l'aide des fonctions statistiques SUM (somme), AVG (moyenne),

COUNT (compte), MIN et MAX ; - soit une expression.

Base de données 44

Les mots-clés DISTINCT et ALL permettent respectivement d'éliminer ou de conserver les doublons après une projection mise en œuvre par l'ordre SELECT suivi d'une liste d'attributs.

La clause FROM désigne les relations concernées par la requête. Chaque nom de relation peut être suivi d'un alias (variables synonymes pour chaque relation). Cet alias permet parfois des économies d'écritures, mais il permet surtout de lever des ambiguïtés sur les noms d'attributs (plusieurs relations qui possèdent le même nom d'attribut). Des exemples de définition d'alias sont proposés dans la partie présentant des exercices corrigés.

La clause WHERE, optionnelle, spécifie les critères de sélection. La condition logique de niveau tuple est une expression logique spécifiant les prédicats de restriction ou de jointure à satisfaire par la réponse. On peut également insérer dans la clause WHERE, une nouvelle instruction SELECT (requête imbriquée) ce qui permet de travailler sur un ensemble de tuples restreints par cette sélection.

Lorsque ces critères portent sur des fonctions de groupe, on utilise la clause HAVING.

La clause GROUP BY partitionne la relation en groupes. La liste des attributs spécifiés dans cette clause indique le critère de groupement.

La clause ORDER BY permet de trier les résultats obtenus selon un tri ascendant (ASC) ou descendant (DESC). On veillera à choisir des colonnes de tri présent dans les attributs du SELECT.

a. La clause SELECT et la clause FROM La clause SELECT et la clause FROM sont liées. En effet, lors de chaque opération de sélection, le mot-clé FROM permet d'identifier la ou les tables nécessaires à la construction du résultat de la requête.

SELECT * FROM VOITURE;

Cette instruction SQL permet d'afficher tous les tuples de la table VOITURE :

Immatriculation Marque Couleur Puissance Prix 4578QS59 Renault Noire 7 20 000 1952LM62 Rover Bleue 5 28 000 3664PN75 Citroën Rouge 6 30 000 3671KH60 Peugeot Verte 6 10 000 4691TR95 Renault Jaune 7 35 000

Remarque : le symbole * dans la clause SELECT signifie qu'on désire récupérer TOUS les champs de la table.

SELECT Marque FROM VOITURE;

Cette instruction SQL permet d'afficher le contenu du champ Marque des tuples de la table VOITURE :

MarqueRenault Rover

Citroën Peugeot Renault

Remarque : la requête ne porte que sur un seul champ, cela équivaut à une projection de la table VOITURE sur ce champ. On peut ajouter autant d’attributs que l’on désire afficher.

SELECT DISTINCT Marque FROM VOITURE;

Base de données 45

Cette instruction SQL permet d'afficher le contenu du champ Marque des tuples de la table VOITURE, sans répétition de Marque, c'est-à-dire sans doublon de Marque :

MarqueRenault Rover

Citroën Peugeot

b. Les prédicats Une condition est appelée prédicat en SQL. Un prédicat permet de comparer 2 expressions de valeurs : - la première expression contenant des spécifications de colonnes est appelée terme ; - la seconde expression contenant seulement des spécifications de constantes est appelée

constante.

Il existe une grande diversité de prédicats en SQL, on trouve en effet :

1. un prédicat de comparaison permettant de comparer un terme à une constante à l'aide des opérateurs suivants : - = : égal - <> ou != : différent - > : plus grand que - >= : plus grand ou égal - < : plus petit que - <= : plus petit ou égal Ces opérateurs sont valables pour les types NUMBER (NUMBER est un terme englobant les types INTEGER et FLOAT désignant les nombres, ce type n'est cependant pas disponible pour tous les SGBD), CHAR, VARCHAR, DATE et valent NULL si un des termes de la comparaison est NULL.

2. un prédicat d'intervalle BETWEEN permettant de tester si la valeur d'un terme est comprise entre la valeur de 2 constantes ;

3. un prédicat de comparaison de texte noté LIKE permettant de tester si un terme de type chaîne de caractères contient une ou plusieurs sous-chaînes (ce prédicat est donc réservé aux types CHAR et VARCHAR). Le caractère % remplace une chaîne de caractères quelconque y compris la chaîne vide, le caractère _ remplace n'importe quel caractère unique ;

4. un prédicat de test de nullité qui permet de tester si un terme a une valeur convenue NULL, signifiant que sa valeur est inconnue ou que le champ n'a pas été renseigné. Pour tester la nullité, on utilise IS NULL, et la non nullité par IS NOT NULL ;

5. un prédicat d'appartenance noté IN qui permet de tester si la valeur d'un terme appartient à une liste de valeurs constantes.

c. La clause WHERE La clause WHERE spécifie une condition de sélection. Une condition de sélection définit un critère qui, appliqué à un tuple, est vrai, faux ou inconnu (mettant en cause un attribut de valeur NULL). Cette condition peut inclure des opérateurs booléens (AND, OR, NOT), des conditions élémentaires et des parenthèses.

Les tableaux ci-après donnent les tables de vérité permettant de calculer les valeurs de vérité d'une condition de sélection. Seuls les tuples satisfaisant la condition de sélection sont pris en compte par la requête.

AND Vrai Faux InconnuVrai Vrai Faux Inconnu Faux Faux Faux Faux

Inconnu Inconnu Faux Inconnu

Base de données 46

OR Vrai Faux InconnuVrai Vrai Vrai Vrai Faux Vrai Faux Faux

Inconnu Vrai Faux Inconnu

NOT Vrai Faux Inconnu Faux Vrai Inconnu

SELECT * FROM VOITURE WHERE Puissance <= 6 AND Prix >= 20 000;

Cette instruction SQL permet d’affiche les tuples de la table VOITURE dont la Puissance est inférieure ou égale à 6 chevaux et dont le prix est supérieur ou égal à 20 000 € :

Immatriculation Marque Couleur Puissance Prix 1952LM62 Rover Bleue 5 28 000 3664PN75 Citroën Rouge 6 30 000

AND : permet de vérifier TOUTES les conditions simultanément.

SELECT * FROM VOITURE WHERE Puissance <= 6 OR Prix >= 20 000;

Cette instruction SQL permet d’affiche les tuples de la table VOITURE dont la Puissance est inférieure ou égale à 6 chevaux ou dont le prix est supérieur ou égal à 20 000 € :

Immatriculation Marque Couleur Puissance Prix 4578QS59 Renault Noire 7 20 000 1952LM62 Rover Bleue 5 28 000 3664PN75 Citroën Rouge 6 30 000 3671KH60 Peugeot Verte 6 10 000 4691TR95 Renault Jaune 7 35 000

OR : permet de vérifier AU MOINS UNE des conditions.

SELECT * FROM VOITURE WHERE NOT (Puissance = 6);

Cette instruction SQL permet d’affiche les tuples de la table VOITURE dont la Puissance n’est égale à 6 chevaux :

Immatriculation Marque Couleur Puissance Prix 4578QS59 Renault Noire 7 20 000 1952LM62 Rover Bleue 5 28 000 4691TR95 Renault Jaune 7 35 000

NOT : permet de donner la négation de la condition.

Remarque : Les opérateurs logiques peuvent être combinés entre eux. Cependant, il faut veiller à respecter un ordre de priorité. Ainsi, on trouve, du plus prioritaire au moins prioritaire : - NOT - AND - OR L'emploi de parenthèses est possible pour changer l'ordre d’évaluation ou rendre la lecture plus facile.

Base de données 47

Prédicats divers :

SELECT * FROM VOITURE WHERE Prix BETWEEN 25 000 AND 40 000;

Cette instruction SQL permet d’afficher les tuples de la table VOITURE dont le Prix est compris entre 25 000€ et 40 000€ :

Immatriculation Marque Couleur Puissance Prix 1952LM62 Rover Bleue 5 28 000 3664PN75 Citroën Rouge 6 30 000 4691TR95 Renault Jaune 7 35 000

BETWEEN min AND max : permet de récupérer les données dont les valeurs sont comprises entre min et max (bornes incluses).

SELECT FROM VOI * TURE WHERE Marque LIKE 'Ren%' AND Couleur IN ('Noire', 'Bleue', 'Jaune') AND Prix IS NOT NULL;

Cette instruction SQL permet d’afficher tous les tuples de la table VOITURE dont le Marque commence par ‘Ren’, dont la couleur est soit noire, bleue ou jaune, et dont le prix n’est pas inconnu (donc connu) :

Immatriculation Marque Couleur Puissance Prix 4578QS59 Renault Noire 7 20 000 4691TR95 Renault Jaune 7 35 000

d. Les opérateurs arithmétiques Les opérateurs arithmétiques ('+', '−', '×', '/') peuvent être utilisés dans les clauses SELECT, WHERE et HAVING.

Ces opérateurs sont valables pour les types NUMBER et DATE. Si une des opérandes est NULL, le résultat est NULL. Ces opérateurs peuvent être combinés entre eux mais respectent une priorité d'évaluation : - '×' et '/' - '+' et '−'

Cet ordre peut, bien entendu, être modifié à l'aide de parenthèses.

e. Les fonctions statistiques Les fonctions statistiques (MAX, MIN, SUM, AVG, COUNT, STDDEV, VARIANCE) peuvent être utilisées dans les clauses SELECT, WHERE et HAVING. Les fonctions statistiques sont appliquées à l'ensemble d'une colonne (ou d'un groupe) et fournissent une valeur unique.

La fonction MAX et la fonction MIN Les fonctions MAX et MIN renvoient respectivement le maximum et le minimum d'un champ. Ces fonctions sont utilisables pour les types CHAR, VARCHAR2, DATE et NUMBER.

SELECT MAX(Prix) FROM VOITURE;

Cette requête permet d'afficher le prix maximal parmi les tuples de la table VOITURE.

MAX(Prix)35 000

Base de données 48

La fonction COUNT La fonction COUNT comptabilise le nombre de lignes pour lesquelles l'expression est non NULL. Une * est souvent utilisée avec COUNT pour indiquer le nombre de lignes. Si on ne veut pas compter plusieurs fois les valeurs identiques d'une même colonne, il faut utiliser le mot-clé DISTINCT suivi du nom de la colonne (sauf s'il s'agit d'un attribut clé de la relation).

SELECT COUNT(DISTINCT Marque) FROM VOITURE WHERE Puissance > 6;

Cette requête permet d'afficher le nombre de tuples vérifiant la condition "Puissance supérieure à 6 chevaux" de la table VOITURE, en ne comptant qu'une seule fois la marque même si elle vérifie de nouveau la condition (3 tuples comptés, on ne compte qu'une fois la Renault).

COUNT(Marque)1

SELECT COUNT(*) FROM VOITURE WHERE Puissance > 6;

Cette requête permet d'afficher le nombre de tuples vérifiant la condition "Puissance supérieure à 6 chevaux" de la table VOITURE, en comptant toutes les lignes (4 tuples comptés).

COUNT(Marque)2

La fonction SUM La fonction SUM effectue, pour un ensemble de tuples, la somme des valeurs d'un attribut. Cette fonction est uniquement utilisable pour le type NUMBER.

SELECT SUM(Prix) FROM VOITURE WHERE Puissance = 6;

Cette requête permet de calculer la somme des prix des VOITURES ayant une Puissance de 6 chevaux.

SUM(Prix)45 000

La fonction AVG La fonction AVG calcule, pour un ensemble de tuples, la moyenne arithmétique des valeurs d'un attribut. Cette fonction est uniquement utilisable pour le type NUMBER. Elle vérifie la formule suivante : AVG = Somme des valeurs non NULL / nombre de valeurs non NULL.

SELECT AVG(Prix) FROM VOITURE WHERE Puissance = 6;

Cette requête permet de calculer le prix moyen des VOITURES ayant une Puissance de 6 chevaux.

AVG(Prix)20 000

La fonction VARIANCE La fonction VARIANCE calcule, pour un ensemble de tuples, la variance des valeurs d'un attribut. Cette fonction est uniquement utilisable pour le type NUMBER. Elle vérifie la formule suivante : VARIANCE = Somme des carrés de la différence entre attribut de valeur non NULL et la moyenne arithétique / nombre d’attributs de valeur non NULL.

Base de données 49

SELECT VARIANCE(Prix) FROM VOITURE WHERE Puissance = 6;

Cette requête permet de calculer la variance des prix des VOITURES ayant une Puissance de 6 chevaux.

VARIANCE(Prix)100 000 000

La fonction STDDEV La fonction STDDEV calcule, pour un ensemble de tuples, l’écart type des valeurs d'un attribut. Cette fonction est uniquement utilisable pour le type NUMBER. Elle vérifie la formule suivante : STDDEV = racine carrée de la variance.

SELECT STDDEV(Prix) FROM VOITURE WHERE Puissance = 6;

Cette requête permet de calculer l’écart type des prix des VOITURES ayant une Puissance de 6 chevaux.

STDDEV(Prix)10 000

f. La clause GROUP BY La clause GROUP BY permet de partitionner la relation résultat selon les valeurs d'un ou de plusieurs attributs. Les seuls noms de colonnes (en dehors des fonctions statistiques) qui peuvent apparaître dans le SELECT sont celles qui figurent dans le GROUP BY.

SELECT SUM(Prix), Puissance FROM VOITURE GROUP BY Puissance;

Cette commande permet de créer des partitions selon la Puissance dans la table VOITURE. On aura donc, pour notre exemple, 3 partitions correspondant aux puissances 5, 6 et 7 chevaux. La somme des Prix s'affichera pour chacune de ces partitions.

Puissance SUM(Prix)5 28 000 6 40 000 7 55 000

g. La clause HAVING La clause HAVING définit les conditions que les groupes doivent respecter pour être retenus, elle sélectionne les partitions désirées. Elle ne peut comprendre que des conditions dont le premier terme est une fonction statistique. La clause HAVING est aux groupes (GROUP BY) ce que la clause WHERE est aux lignes (SELECT).

SELECT MAX(Prix), Puissance FROM VOITURE GROUP BY Puissance HAVING COUNT(*)>1;

Base de données 50

Cette commande permet de créer des partitions selon la Puissance dans la table VOITURE. Elle calculera le prix maximum sur ces partitions. La clause HAVING limite l'affichage aux partitions contenant au moins 2 éléments (tuples) : COUNT(*)>1 . On aura donc, pour notre exemple, 2 partitions correspondant aux puissances 6 et 7 chevaux (la partition relative à la Puissance de 5 chevaux n'a pas été retenue car elle ne contient pas assez d'éléments pour satisfaire la condition énoncée dans la clause HAVING).

Puissance MAX(Prix)6 30 000 7 35 000

h. La clause ORDER BY La clause ORDER BY permet de trier les tuples du résultat final. La clause ORDER BY permet d'ordonner la relation résultat sur un ou plusieurs attributs, l'ordre pouvant être croissant (grâce au mot-clé ASC) ou décroissant (grâce au mot-clé DESC), ASC étant l'ordre par défaut.

Remarque : Dans une requête SQL, la clause ORDER BY se situe juste après une clause WHERE ou après une clause GROUP BY.

SELECT * FROM VOITURE ORDER BY Puissance [ASC];

Ces 2 requêtes (avec ASC ou sans ASC) sont identiques et permettent d'afficher l'ensemble des tuples de la table VOITURE triés sur l'attribut Puissance selon un ordre croissant.

Immatriculation Marque Couleur Puissance Prix 1952LM62 Rover Bleue 5 28 000 3664PN75 Citroën Rouge 6 30 000 3671KH60 Peugeot Verte 6 10 000 4578QS59 Renault Noire 7 20 000 4691TR95 Renault Jaune 7 35 000

La clause ORDER BY permet également un tri sur plusieurs attributs : le tri sera effectué prioritairement sur le premier attribut, puis sur le second et ainsi de suite.

SELECT * FROM VOITURE ORDER BY Puissance DESC, Couleur;

Cette requête permet d'afficher l'ensemble des tuples de la table VOITURE triés sur l'attribut Puissance selon un ordre décroissant puis sur l'attribut Couleur (ordre alphabétique) selon un ordre croissant .

Immatriculation Marque Couleur Puissance Prix 4691TR95 Renault Jaune 7 35 000 4578QS59 Renault Noire 7 20 000 3664PN75 Citroën Rouge 6 30 000 3671KH60 Peugeot Verte 6 10 000 1952LM62 Rover Bleue 5 28 000

i. Les opérateurs relationnels Les opérateurs relationnels en SQL sont basés sur les opérateurs relationnels vus dans le chapitre Modèle Relationnel. En SQL, les principaux opérateurs sont UNION, INTERSECTION, MINUS (différence). Les deux relations R1 et R2 sur lesquelles sont appliqués les opérateurs UNION, INTERSECTION et MINUS doivent absolument avoir avoir le même schéma de table (nombre équivalent d'attributs et attributs identiques deux à deux).

Base de données 51

SELECT * FROM VOITURE WHERE Puissance = 5 UNION SELECT * FROM VOITURE WHERE Puissance = 7;

Cette requête permet d'afficher l'ensemble des tuples de la table VOITURE dont la Puissance est égale à 5 ou à 7 chevaux.

Immatriculation Marque Couleur Puissance Prix 1952LM62 Rover Bleue 5 28 000 4578QS59 Renault Noire 7 20 000 4691TR95 Renault Jaune 7 35 000

j. La jointure Le procédé de la jointure en SQL est celui énoncé dans le chapitre Algèbre Relationnelle. La jointure est formulée dans la clause WHERE

Syntaxe de la primitive SELECT en SQL

SELECT <attributs> FROM <liste_de_noms_de_relations> WHERE <expression de jointure>;

Cas de l'équijointure

SELECT Immatriculation, numPersonne, dataAchat, Marque, Couleur, Puissance, Prix FROM VOITURE, ACHAT WHERE Immatriculation = numImmatriculation;

Cette requête permet de faire la jointure entre la table VOITURE et la table ACHAT ; cette jointure porte sur le numéro d'immatriculation. Cette requête renverra donc tous les tuples de la table VOITURE et de la table ACHAT qui ont même numéro d'immatriculation (on n’a pas affiché numImmatriculation).

Immatriculation numPersonne dateAchat Marque Couleur Puissance Prix 4578QS59 1591259 12/12/2001 Renault Noire 7 20 000 1952LM62 2630662 08/11/1998 Rover Bleue 5 28 000 4691TR95 1120606 05/09/1997 Renault Jaune 7 35 000

Pour les autres types de jointure (non équijointure, autojointure, jointure externe), le principe est identique, seule l'expression de jointure diffère.

Cas de la jointure naturelle

SELECT <attributs> FROM relation1 NATURAL JOIN relation2;

Cas de la thêta-jointure

SELECT <attributs> FROM relation1 JOIN relation2 ON relation1.attrbut1 = relation2.attribut2;

Base de données 52

Cas de la clause AS (c'est-à-dire deux relations identiques qui ont le même attribut)

SELECT <attributs> FROM relation R1, relation R2 WHERE R1.attribut = R2.attribut;

k. La requête imbriquée et les quantificateurs En SQL, il est possible d'imbriquer plusieurs requêtes. L'imbrication se fait dans la clause WHERE.

SELECT * FROM ITURE VO WHERE Prix > (SELECT AVG(Prix) FROM VOITURE);

Cette requête permet d'afficher tous les tuples de la table VOITURE dont le prix est supérieur à la moyenne des prix de tous les tuples de cette même table :

Immatriculation Marque Couleur Puissance Prix 1952LM62 Rover Bleue 5 28 000 3664PN75 Citroën Rouge 6 30 000 4691TR95 Renault Jaune 7 35 000

Remarque : Toute requête de jointure peut se mettre sous forme de requête imbriquée. Mais l'inverse n'est pas vrai comme l'illustre l'exemple proposé ci-dessus.

Dans une requête imbriquée, il est possible d’ajouter un quantificateur. Il permet de faire une comparaison entre une ligne et toutes les lignes d’une table retournée par un select imbriqué. Le ALL correspond à ∀ et le SOME (ou ANY) à ∃.

SELECT * FROM COMMANDE dateCommande > ( WHERE ALL SELECT dateLivraison FROM LIVRAISON);

Cette requête permet d'afficher tous les tuples de la table COMMANDE dont la date de commande est passée après la dernière livraison.

SELECT * FROM MMANDE CO WHERE dateCommande < SOME(SELECT dateLivraison FROM LIVRAISON);

Cette requête permet d'afficher tous les tuples de la table COMMANDE dont la date de commande est passée avant la dernière livraison.

l. Les alias Les alias concourent à améliorer la lisibilité et la concision d'une requête. Il existe deux types d'alias : les alias de tables et les alias de champs. Ils peuvent également s'appliquer à une fonction d'agrégation retournant des données sous forme de colonnes.

SELECT Alias_table.nom_champ AS Alias_champ FROM nom_table AS Alias_table;

Base de données 53

La clause AS, affectant un alias à une table ou une colonne, peut être remplacée par un simple espace blanc.

SELECT Alias_table.nom_champ Alias_champ FROM nom_table Alias_table;

Les alias de champs peuvent être des chaînes de caractères composées de mots et d'espaces. Dans ce cas, il faut placer l'alias entre simple guillemet.

SELECT Alias_table.nom_champ AS ‘Un alias de champ’ FROM nom_table AS Alias_table;

Lors de l'affichage des lignes résultantes, les alias de champs se substitueront aux noms de colonnes. De cette manière, il devient possible d'attribuer des noms de colonnes plus explicites pour les utilisateurs de la base de données.

Les alias sont particulièrement utiles dans le cadre des jointures et des requêtes imbriquées. Dans les deux cas, il devient possible de faire appel à des champs de noms identiques en les distinguant par des préfixes qui sont les alias de table.

Cas de la jointure

SELECT v.Immatrivulation, v.Marque, v.Couleur, v.Puissance, v.Prix, a.numPersonne, a.dateAchat FROM Voiture v, Achat a WHERE v.Immatriculation = a.numImmatriculation;

Cas de la jointure réflexive

SELECT v.*, a.* FROM Voiture AS v, Achat AS a WHERE v.Immatriculation = a.numImmatriculation;

Cas de la requête imbriquée

SELECT v.*, a.* FROM Voiture AS v, Achat AS a WHERE v.Immatriculation = a.numImmatriculation AND v.Prix >(SELECT AVG(Prix) FROM VOITURE);

2. INSERT L'opération d'insertion se fait grâce au mot-clé INSERT. Elle permet d'ajouter un ou plusieurs tuples à une relation.

Syntaxe de la primitive INSERT en SQL

INSERT INTO <nom_table> [attribut1, attribut2, …] VALUES (val1, val2, …) | clause SELECT;

Base de données 54

Exemples :

INSERT INTO VOITURE VALUES (‘2759QF78’, ‘BMW’, ‘Grise’, 8, 45 000);

Cette commande permet d'insérer le tuple ('2759QF78', 'BMW', 'Grise', 8, 45 000) dans la table VOITURE :

Immatriculation Marque Couleur Puissance Prix 4578QS59 Renault Noire 7 20 000 1952LM62 Rover Bleue 5 28 000 3664PN75 Citroën Rouge 6 30 000 3671KH60 Peugeot Verte 6 10 000 4691TR95 Renault Jaune 7 35 000 2759QF78 BMW Grise 8 45 000

Les domaines des valeurs insérées doivent correspondre aux types déclarés.

INSERT INTO VOITURE (Immatriculation, Couleur, Prix) VALUES (‘1379FG09’, ‘Rouge’, 29 500);

Cette commande permet d'insérer un nouveau tuple ayant les valeurs '1379FG09' pour l'Immatriculation, une couleur 'Rouge', et un Prix de 29 500€ dans la table VOITURE.

Immatriculation Marque Couleur Puissance Prix 4578QS59 Renault Noire 7 20 000 1952LM62 Rover Bleue 5 28 000 3664PN75 Citroën Rouge 6 30 000 3671KH60 Peugeot Verte 6 10 000 4691TR95 Renault Jaune 7 35 000 2759QF78 BMW Grise 8 45 000 1379FG09 NULL Rouge NULL 29 500

Les champs autres champs de ce tuple prendront la valeur NULL (ils ne devront pas avoir été déclarés NOT NULL).

INSERT INTO VOITURE_ACHETEES (Immatriculation) SELECT numImmatriculation FROM ACHAT;

Cette commande permet de créer des tuples dans la table VOITURE_ACHETEES (qui aura été créée préalablement) initialisés avec les numéros d'immatriculation présents dans la table ACHAT. Les autres attributs étant initialisés à NULL.

Immatriculation4578QS591952LM624691TR95

3. UPDATE La commande UPDATE permet de mettre à jour un ou plusieurs tuples d'une relation.

Base de données 55

Syntaxe de la primitive UPDATE en SQL

UPDATE <nom_table> SET <attribut1> = <expression1>, <attribut2> = <expression2>, … [WHERE <condition>];

La clause WHERE est optionnelle ; cependant sans le WHERE, la mise à jour affectera TOUS les tuples de la relation.

Exemples :

UPDATE VOITURE SET Prix = Prix x 1.10;

Cette commande permet d'augmenter le Prix de vente de 10% (on multiplie par le coefficient 1.10) de tous les tuples de la table VOITURE :


Ceci permet de modifier rapidement une colonne pour la globalité d’une table.

UPDATE VOITURE SET Prix = Prix x 1.10 WHERE Marque = ‘Renault’;

Cette commande permet d'augmenter le Prix de vente de 10% uniquement sur les voitures de Marque Renault dans la table VOITURE.


Ceci permet de modifier rapidement une colonne pour une partie de la table.

UPDATE VOITURE SET Prix = Prix x 1.10 WHERE Marque = ‘Renault’ AND Prix > SELECT AVG(Prix) FROM VOITURE);

Cette commande permet d'augmenter le Prix de vente de 10% uniquement sur les voitures de Marque Renault dont le prix est supérieur au prix moyen de toutes les voitures de la table VOITURE.

Base de données 56


4. DELETE La suppression de tuples se fait grâce à la commande DELETE. La suppression peut concerner tous les tuples d'une relation ou un sous-ensemble de tuples qui vérifie une condition de sélection. Il faut noter que DELETE opère sur le contenu d'une relation, c'est-à-dire que le schéma d'une relation persiste après suppression de tous les tuples de la relation.

Syntaxe de la primitive DELETE en SQL

DELETE FROM <nom_table> [WHERE <condition>];

La clause WHERE est optionnelle ; cependant sans le WHERE, la mise à jour affectera TOUS les tuples de la relation.

Exemples :

DELETE FROM VOITURE;

Cette commande permet de supprimer tous les tuples de la table VOITURE. Le schéma de la table persiste cependant.

Immatriculation Marque Couleur Puissance Prix

Ceci permet de supprimer rapidement tous les tuples d’une table.

DELETE FROM VOITURE WHERE Marque = ‘Renault’;

Cette commande permet de supprimer toutes les voitures de Marque Renault de la table VOITURE.

Immatriculation Marque Couleur Puissance Prix 1952LM62 Rover Bleue 5 28 000 3664PN75 Citroën Rouge 6 30 000 3671KH60 Peugeot Verte 6 10 000 2759QF78 BMW Grise 8 45 000 1379FG09 NULL Rouge NULL 29 500

Ceci permet de modifier rapidement une partie des tuples de la table.

DELETE FROM VOITURE WHERE Marque = ‘Renault’ AND Prix > SELECT AVG(Prix) FROM VOITURE);

Cette commande permet de supprimer toutes les voitures de Marque Renault dont le prix est supérieur au prix moyen de toutes les voitures de la table VOITURE.

Base de données 57

Immatriculation Marque Couleur Puissance Prix 4578QS59 Renault Noire 7 22 000 1952LM62 Rover Bleue 5 28 000 3664PN75 Citroën Rouge 6 30 000 3671KH60 Peugeot Verte 6 10 000 2759QF78 BMW Grise 8 45 000 1379FG09 NULL Rouge NULL 29 500

VI. Le Langage de Contrôle de Données (LCD) Définition : Les instructions de contrôle des données donnent à l'administrateur de base de données le pouvoir de contrôler la sécurité de la base. Le LCD est composé de 4 commandes SQL : - GRANT - REVOKE - COMMIT - ROLLBACK

GRANT et REVOKE sont utilisées pour exercer un contrôle sur l'accès des données. COMMIT et ROLLBACK sont utilisées pour préserver l'intégrité des données. Pour utiliser une base de données, l'utilisateur doit passer par une procédure de connexion. Lors de cette procédure, il doit saisir un login (par exemple PDupont) et un mot de passe (par exemple xyz2V12). Ce login permet d'identifier chaque utilisateur et sert de repère pour lui accorder (ou lui enlever) des droits de manipulation de la base.

1. La commande GRANT La commande GRANT permet d'autoriser un accès aux données de la base soit total, soit à des degrés limités. Ainsi, il est possible, par exemple, d'autoriser la consultation de certaines tables sans possibilité de les modifier.

a. La syntaxe de la commande GRANT Syntaxe de la commande GRANT en SQL

GRANT ALL PRIVILEGES | accès_spécifique ON nom_table | nom_vue TO PUBLIC nom_autorisé | [WITH GRANT OPTION];

Avec la convention suivante : - Il est possible de donner tous les types de droits d'accès (consultation, modification,

suppression,…) avec ALL PRIVILEGES ou d'accorder des privilèges spécifiques (accès_spécifique).

- nom_autorisé (ou login) : nom donné par l'utilisateur lors de sa connexion à la base de données (créé par l'administrateur)

- PUBLIC : tout le monde reçoit le privilège accordé (accès_spécifique) ou tous les privilèges (ALL PRIVILEGES).

- WITH GRANT OPTION : celui qui reçoit le privilège peut lui-même l'accorder à un autre (opération dangereuse, à éviter).

Concernant les types de droits d'accès, si des tables de la base sont identifiées à l'aide du nom du créateur de la base, cet utilisateur peut (si on lui a accordé le privilège requis) autoriser l'accès à ses tables pour d'autres utilisateurs.

Base de données 58

GRANT ALL PRIVILEGES ON VOITURE TO Martin WITH GRANT OPTION;

Cette instruction SQL permet à l'administrateur de la base de donner à Martin tous les droits sur la table VOITURE, il lui accorde également l'autorisation de transférer ces privilèges.

b. Les droits d'accès La gestion des droits d'accès aux tables est décentralisée : il n'existe pas d'administrateur global attribuant des droits. Seul le propriétaire (créateur) d'une table peut attribuer des droits sur celle-ci. Les principaux droits d'accès spécifiques sont : - sélection (SELECT) - insertion (INSERT) - suppression (DELETE) - mise à jour (UPDATE) - indexation (INDEX) - référencer la table dans une contrainte (REFERENCES)

Il peut ensuite passer ses droits sélectivement à d'autres utilisateurs ou à tout le monde (PUBLIC). Un droit peut être passé avec le droit de le transmettre (WITH GRANT OPTION) ou non. L'ensemble des droits d'accès (ALL PRIVILEGES) inclut les droits d'administration (changement de schéma et destruction de la relation).

GRANT SELECT, UPDATE ON VOITURE, ACHAT TO Smith;

Cette commande permet de passer des droits de consultation et de mise à jour de la table VOITURE et de la table ACHAT à l'utilisateur Smith.

GRANT ALL PRIVILEGES (Immatriculation, Prix) ON VOITURE TO Smith, Vandenbrouck, Dubois;

Cette commande permet de passer l'ensemble des droits d'accès aux utilisateurs Smith, Vandenbrouck et Dubois uniquement sur les colonnes Immatriculation et Prix de la table VOITURE.

GRANT INSERT ON PERSONNE TO PUBLIC;

Cette commande attribue le droit d'insérer de nouveaux enregistrements dans la table PERSONNE à tous ceux qui, dans la société, disposent d'une identification pour se connecter sur la BD.

2. La commande REVOKE La commande REVOKE permet de retirer l'accès, c'est la commande inverse de GRANT.

Base de données 59

Syntaxe de la commande REVOKE en SQL

REVOKE ALL PRIVILEGES | accès_spécifique ON nom_table | nom_vue FROM nom_utilisateur | PUBLIC;

Exemples :

REVOKE SELECT, UPDATE ON VOITURE, ACHAT FROM Smith;

Cette commande supprime les droits de consultation et de mise à jour de la table VOITURE et de la table ACHAT qui avait été accordés à l'utilisateur Smith.

REVOKE ALL PRIVILEGES ON VOITURE FROM Martin;

Cette commande retire tous les privilèges accordés sur la table VOITURE à Martin.

3. Le contrôle d'intégrité Les commandes COMMIT et ROLLBACK constituent des contrôles (cf. le chapitre sur les transactions) nécessaires à la préservation de l'intégrité de la base.

Des systèmes multi-utilisateurs disponibles dans le commerce emploient des contrôles supplémentaires comme par exemple la commande LOCK pour empêcher les valeurs de changer pendant qu'un utilisateur examine ou travaille sur ces valeurs (nous étudierons plus en détails ces notions dans le chapitre sur les transactions).

4. La commande COMMIT La commande COMMIT permet à l'utilisateur de fixer le moment où les modifications en cours affecteront la base de données. Dans ce cadre, on utilise le concept de transaction.

La transaction est une suite d'opérations telle que chaque opération de cette suite est nécessaire pour atteindre un résultat unitaire.

C'est la raison pour laquelle SQL propose à l'utilisateur de n'enregistrer les modifications dans la base qu'au moment où la transaction est achevée grâce à la commande COMMIT.

Une transaction (ou une partie de transaction) qui n'a pas encore été enregistrée définitivement n'est visible que pour l'utilisateur qui l'introduit. Elle n'affecte pas la base tant que l'instruction n'est pas exécutée.

Avant l'exécution de l'instruction COMMIT, il est possible de restaurer la base par ROLLBACK, c'est-à-dire d'éliminer les modifications récentes. Après l'enregistrement définitif d'une transaction par COMMIT, il n'est plus possible de restaurer l'état antérieur par ROLLBACK. S'il apparaît après coup qu'une transaction doive être modifiée ou corrigée, on ne pourra effecteur cette modification qu'au moyen d'une autre instruction SQL comme UPDATE ou DELETE.

5. La commande ROLLBACK La commande ROLLBACK permet à l'utilisateur de ne pas valider les dernières modifications en cours dans la base de données.

Par exemple, si au cours du déroulement d'une transaction, l'utilisateur fait une erreur ou si, pour une certaine raison, une transaction ne peut pas être achevée, l'utilisateur peut supprimer les modifications

Base de données 60

afin d'éviter des incohérences dans la base grâce à la commande ROLLBACK. Cette commande élimine tous les changements depuis la dernière validation.

Dans le cas d'une défaillance du système, l'intégrité de la base peut être préservée par une option ROLLBACK automatique qui élimine les transactions inachevées et empêche donc qu'elles soient introduites dans la base.

6. La commande SAVEPOINT Une transaction étant une séquence de séquence de commandes SQL considérée comme unitaire, indivisible, il peut être nécessaire de pouvoir revenir en arrière, à n’importe quel endroit dans la transaction courante.

Pour cela, il suffit de réaliser des points de sauvegarde grâce à la commande SAVEPOINT <nom> à l’intérieur d’une transaction pour situer un point éventuel de retour vers l’état de la base de données. Le retour en arrière s’effectue grâce à la commande ROLLBACK WORK TO SAVEPOINT <nom>.

7. Terminaison d'une transaction

VII. Les vues Définition : Une vue est une relation virtuelle au sens où ses instances n'existent pas physiquement mais sont calculées à chaque invocation de la vue. Une vue est définie par une requête qui utilise des relations ou des vues existantes.

Syntaxe de la commande CREATE VIEW en SQL

CREATE VIEW nom_de_la_vue AS <clause SELECT>;

Exemples :

CREATE VIEW VOITURES_CHERES AS SELECT * FROM VOITURE WHERE Prix > 15 000;

La vue VOITURES_CHERES a le même schéma que la relation VOITURE.

Base de données 61

SELECT * FROM VOITURES_CHERES;

On peut accéder grâce à cette vue à toutes les voitures dont le Prix est supérieur à 15 000 €.

CREATE VIEW VOITURES_PUISSANTES (immat_voiture, marquee_voiture) AS SELECT Immatri ulation, Marque c FROM VOITURE WHERE Puissance > 6;

La vue Voitures-puissantes comporte les attributs Immatriculation et Marque renommés en immat_voiture et marque_voiture. Elle permet d'accéder à toutes les voitures dont la puissance est supérieure à 6 chevaux.

En interrogation, une vue est utilisée comme toute autre relation. La seule différence réside dans le fait que ses tuples ne sont pas stockés mais ils sont le résultat de l'évaluation de la requête de définition.

En mise à jour, toute modification des relations ayant servi à la définition de la vue est répercutée sur la vue (lors d'une nouvelle évaluation de la requête de définition de la vue). Par contre, la mise à jour d'une base de données "à travers" une vue n'a pas trouvé de solution générale : le problème vient du fait qu'il est parfois impossible de répercuter la mise à jour de la vue sur les relations sur lesquelles elle est définie. Cependant, quand des contraintes logiques ne viennent pas l'empêcher la mise à jour au travers des vues est possible.

A titre d'exemple, si une vue comporte une colonne obtenue par une fonction d'agrégation, la mise à jour de cette colonne supposerait que l'on soit capable de mettre à jour les tuples concernés par la fonction d'agrégation, étant donnée la valeur introduite, ce qui est logiquement impossible.

Il est, de ce fait, nécessaire de consulter la documentation du système dont on dispose pour connaître les types de mises à jour autorisés en utilisant une vue.

Enfin la suppression d'une vue est faite explicitement par DROP VIEW.

VIII. Les séquences Définition : Définir une séquence équivaut à définir une suite de nombres entiers. L'évolution de cette suite est régie par un certain nombre de paramètres. L'utilisation d'une séquence permet donc d'avoir à disposition une suite de valeurs. Ceci peut permettre de : - générer des clés uniques dans des tables - avoir un compteur à titre informatif, que l'on incrémente quand on veut - etc...

1. Création du séquence Syntaxe de la commande CREATE SEQUENCE en SQL

CREATE SEQUENCE nom_de_la_sequence [START WITH valeur_initiale] [INCREMENT BY ] incrément [NOMAXVALUE NOMINVALUE | MAXVALUE maximum | MINVALUE minimum] | [NOCYCLE | CYCLE] [CACHE nombre_de_valeurs];

Notation (les éléments entre [ ] sont optionnels) : - START WITH permet de fixer la valeur initiale de la séquence. - INCREMENT BY permet de fixer le pas d’incrémentation. Si celui-ci est positif, la séquence est

croissante, sinon elle décroît.

Base de données 62

- NOMAXVALUE et NOMMINVALUE permet de ne pas fixer de limite dans la séquence. Si l’on désire fixer un plafond à ne pas dépasser (pour une séquence ascendante), on utilise MAXVALUE. Si l’on désire fixer un plancher (pour une séquence descendante), on utilise MINVALUE.

- L’option CYCLE permet une fois la limite du compteur atteint, de reprendre le comptage à la valeur MINVALUE (pour une séquence ascendante) ou MAXVALUE (pour une suite descendante). Si l’on désire arrêter la séquence une fois la limite du compteur atteint, il suffit d’utiliser l’option NOCYCLE.

- L’option CACHE permet de mettre nombre_de_valeurs valeurs dans la mémoire cache afin d’optimiser l’utilisation des séquences et avoir un effet significatif sur les performances, surtout lorsque nombre_de_valeurs est élevé.

CREATE SEQUENCE SEQUENCE_VOITURE START WITH 5 INCREMENT BY 3;

Cette commande SQL permet de créer une séquence SEQUENCE_VOITURE commençant à la valeur 5 avec un pas d’incrémentation de 3. La séquence obtenue est alors : 5, 8, 11, 14, 17, 20, …

CREATE SEQUENCE SEQUENCE_VOITURE START WITH 5 INCREMENT BY 3 MAXVALUE 30;

Cette commande SQL permet de créer une séquence SEQUENCE_VOITURE commençant à la valeur 5 avec un pas d’incrémentation de 3, avec pour valeur maximale 30. La séquence obtenue est alors : 5, 8, 11, 14, 17, 20, 23, 26, 29.

CREATE SEQUENCE SEQUENCE_VOITURE START WITH 5 INCREMENT BY 3 [NOMAXVALUE NOMINVALUE];

Cette commande SQL (avec ou sans l’option NOMAXVALUE NOMINVALUE) permet de créer une séquence SEQUENCE_VOITURE commençant à la valeur 5 avec un pas d’incrémentation de 3 sans limite. La séquence obtenue est alors : 5, 8, 11, 14, 17, 20, …

CREATE SEQUENCE SEQUENCE_VOITURE START WITH 1 MAXVALUE 10 MINVALUE -10 CYCLE;

Cette commande SQL permet de créer une séquence SEQUENCE_VOITURE commençant à la valeur 1 avec un pas d’incrémentation de 1, avec pour valeur maximale 10 et pour valeur minimale -10. La séquence est cyclique, si bien que l’on a la séquence : 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, -10, -9, -8, -7, -6, …

CREATE SEQUENCE SEQUENCE_VOITURE CACHE 100;

Cette commande SQL permet de créer une séquence SEQUENCE_VOITURE en stockant les 100 premières valeurs dans la mémoire cache. Par défaut, la valeur est 20.

Base de données 63

2. Interroger la séquence L'interrogation d'une séquence se fait par l'utilisation des "pseudo-colonnes" CURRVAL et NEXTVAL. On parle de pseudo-colonne car cela se manipule un peu comme une colonne de table, mais ce n'est pas une colonne de table. - La pseudo-colonne CURRVAL retourne la valeur courante de la séquence. - La pseudo-colonne NEXTVAL incrémente la séquence et retourne la nouvelle valeur.

SELECT SEQUENCE_VOITURE.NEXTVAL FROM DUAL; SELECT SEQUENCE_VOITURE.CURRVAL FROM DUAL;

Lors de la première utilisation d’un séquence, il faut utiliser NEXTVAL pour l’initialiser. Ensuite, CURRVAL permet d’obtenir la valeur courante de la séquence.

3. Modifier une séquence Syntaxe de la commande ALTER SEQUENCE en SQL

ALTER SEQUENCE nom_de_la_sequence [INCREMENT BY incrément] [NOMAXVALUE NOMINVALUE | MAXVALUE maximum | MINVALUE minimum] | [NOCYCLE | CYCLE] [CACHE nombre_de_valeurs];

Exemple :

ALTER SEQUENCE SEQUENCE_VOITURE INCREMENT BY 3;

Cette commande SQL permet de modifier le pas d’incrémentation (valeur : 3) de la séquence SEQUENCE_VOITURE.

4. Création d’une colonne de table auto-incrémentée (pour une clé primaire) Le principe est le suivant : - créer une séquence qui permettra de générer des valeurs entières uniques - créer un TRIGGER qui se déclenchera à chaque INSERT, pour alimenter le champ voulu avec

une valeur unique.

CREATE TRIGGER RIGGER_CL ITURE T E_PRIMAIRE_VOBEFORE INSERT ON VOITURE FOR EACH ROW BEGIN SELECT SEQUENCE_VOITURE.NEXTVAL INTO :VOITURE.cle_primaire FROM DUAL; END;

Cet exemple ne gère pas le contrôle d'unicité de la valeur que l'on va insérer, mais si le champ n'est alimenté QUE par l'utilisation de la séquence qui lui est dédiée, et si cette séquence n'est pas paramétrée pour reboucler, il n'y a pas de raison qu'une erreur de clé en double surgisse...

Base de données 64

IX. BLOCS PL/SQL

1. L'intro de l'intro PL/SQL est un langage qui intègre SQL et permet de programmer de manière procédurale. Globalement, avec PL/SQL on aura à notre disposition un vrai langage de programmation moins intuitif mais aussi plus puissant que le SQL. Les 2 langages sont éminemment complémentaires.

Les principaux avantages / inconvénients sont les suivants : - ne dispense pas de connaître le SQL ; - permet le traitement par bloc de SQL et donc optimise le trafic réseau ; - l'utilisation de variable de stockage et de type simple et structuré dynamique (%TYPE,

%ROWTYPE, …) ; - des traitements plus complexes, notamment pour la gestion des cas particuliers et des erreurs

(traitement des exceptions) ; - un paramétrage et la création d'ordres SQL dynamiques.

Le PL/SQL peut être utilisé sous 3 formes : - un bloc de code, exécuté comme une commande SQL, via un interpréteur standard - un fichier de commande PL/SQL - un programme stocké (procédure, fonction, package ou trigger)

2. Ordres SQL supportés dans PL/SQL Les instructions du langage de manipulation de données (LMD) et certaines instructions de gestion de transaction, à savoir : - INSERT, UPDATE, DELETE, SELECT ; - COMMIT, ROLLBACK, SAVEPOINT.

3. Blocs et sections PL/SQL Les blocs de code s'appellent également des blocs anonymes. Ils commenceront simplement par un 'BEGIN' ou un 'DECLARE'. Ils sont composés de 1 à 3 sections :

Type de section Obligatoire ? Mots clés section déclarative non DECLARE … section exécutable oui BEGIN … END;

section de traitement des exceptions non EXCEPTION

La section 'EXCEPTION', quand elle est présente, est incluse dans la section et NON PAS à la suite de celle ci.

BEGIN NULL; END;

Le bloc précédent est le plus petit bloc PL/SQL au monde. Le bloc ne peut pas être vide et doit contenir au moins une instruction…

Syntaxe de bloc en PL/SQL (avec des exceptions)

DECLARE -- mes déclarations de variables -- BEGIN -- début de la section exécutable -- -- mes ordres SQL et PL/SQL -- EXCEPTION -- mon traitement des exceptions -- END; -- la fin du bloc exécutable --

Base de données 65

Afin de pouvoir utiliser une exception, il faut tout d’abord déclarer une variable d’exception dans la partie DECLARE (ex : DECLARE erreur EXCEPTION;).

Ensuite, dans la partie entre le BEGIN et le END, pour appeler une exception et stopper le bloc PL/SQL, on utilise la commande RAISE nom_exception (ex : RAISE erreur;). Cette commande stoppe le bloc PL/SQL et va dans la partie EXCEPTION.

Dans cette partie, pour afficher un message d’erreur, on utilise la commande suivante : WHEN nom_exception THEN RAISE_APPLICATION_ERROR ( numero_erreur , message ); − numero_erreur : représente le numéro de l’erreur utilisateur. Ce numéro doit être compris entre

–20000 et –20999. − message : chaîne de caractères d’une longueur maximale de 2048 octets qui contient le message

associé à l’erreur.

Les exceptions prédéfinies sont : − NO_DATA_FOUND : cas où l’on n’a aucune donnée à la sortie d’un SELECT. − TO_MANY_ROWS : cas où l’on a trop de données à la sortie d’un SELECT. − VALUE_ERROR : cas où l’on a une erreur de valeur. − ZERO_DIVIDE : cas d’une division par zéro. − INVALIDE_NUMBER : cas d’un nombre invalide.

4. Procédure PL/SQL Une procédure est simplement un programme PL/SQL nommé, compilé et stocké dans la base.

Syntaxe de procédure en PL/SQL (avec des exceptions)

CREATE [OR REPLACE] PROCEDURE nom_de_procédure ( par1 type1, par2 type2, … ) IS BEGIN -- mes ordres SQL et PL/SQL -- EXCEPTION -- mon traitement des exceptions -- END;

Ce code est une commande SQL, qui crée la procédure PL/SQL, et donc compile et stocke dans la base le bloc PL/SQL compris entre le BEGIN et le END, en le référençant par ‘nom_de_procédure’. Et pour exécuter cette procédure de manière autonome, on utilise la commande : ‘EXECUTE nom_de_procédure’. Les paramètres d’entrée doivent être déclarés (nom et type).

CREATE OR REPLACE PROCEDURE Client (nom VARCHAR2, ville VARCHAR2) IS BEGIN INSERT INTO CLIENTS (numclient,nomclient,villeclient) VALUES (SEQUENCE_NUM_CLIENT.NEXTVAL, nom, ville); COMMIT; END;

Cette commande permet de créer une procédure nommée Client, dont les paramètres d’entrée sont des chaînes de caractères nom et ville. La procédure permet d’insérer un nouveau tuple dans la table CLIENTS de valeurs SEQUENCE_NUM_CLIENT.NEXTVAL (pour créer automatiquement une nouvelle valeur de clé primaire), nom et ville.

5. Fonctions PL/SQL Une fonction est une procédure retournant une valeur.

Base de données 66

CREATE [OR REPLACE] FUNCTION nom_de_fonction ( par1 type1, par2 type2, …) RETURN type_de_sortie IS variable_de_sortie type_de_sortie IS BEGIN -- mes ordres SQL et PL/SQL -- EXCEPTION -- mon traitement des exceptions -- END;

Ce code est une commande SQL, qui crée la fonction PL/SQL, et donc compile et stocke dans la base le bloc PL/SQL compris entre le BEGIN et le END, en le référençant par ‘nom_de_fonction’. La valeur retournée en sortie correspond à la variable_de_sortie dont le type est type_de_sortie. Les paramètres d’entrée doivent être déclarés (nom et type).

CREATE OR REPLACE FUNCTION solde (numero NUMBER) RETURN REAL IS le_solde REAL BEGIN SELECT solde INTO le_solde FROM clients WHERE numclient = numero; RETURN le_solde; END;

Cette commande permet de créer une fonction nommée solde, dont le paramètre d’entrée est le numéro de client. La fonction permet de retourner en sortie, dans la variable réelle le_solde, le solde du compte du client identifié par numero. Pour appeler cette fonction et utiliser son résultat au sein d’un ordre SQL, il suffit d’exécuter la commande suivante : ‘SELECT solde(1000) FROM DUAL’.

6. Trigger Les déclencheurs (Triggers) sont des procédures stockées appartenant à une table précise et s'exécutant lorsqu'une action spécifique se produit sur la table concernée. Le déclenchement d'une telle procédure s'effectue subséquemment à une instruction de manipulation de données (DML) comme INSERT, DELETE ou UPDATE. Il existe donc trois types de déclencheurs : sur insertion, sur mise à jour et sur suppression.

Une table peut comporter plusieurs déclencheurs d'un type donné, à condition que chacun possède un nom différent. Cependant, un déclencheur donné ne peut être assigné qu'à une seule et unique table tout en s'appliquant à la fois, à l'insertion, la mise à jour et la suppression d'enregistrements sur la table en question. Une table ne peut posséder qu'un seul déclencheur INSTEAD OF d'un type donné.

Les déclencheurs se produisent soit après (AFTER), soit avant (BEFORE) soit à la place (INSTEAD OF) d'une action DML : - Un déclencheur sur INSERT s'exécute à chaque opération d'insertion lancée par l'utilisateur ou

par un programme. Lors d'une insertion, l'enregistrement est inséré à la fois dans la table cible est dans une table temporaire dénommée inserted. Une telle table peut permettre de vérifier la cohérence des enregistrements.

- Un déclencheur sur DELETE s'exécute à chaque opération de suppression lancée par l'utilisateur ou un programme. Lors d'une suppression, l'enregistrement est supprimé physiquement de la table cible et l'insère dans une table temporaire dénommée deleted. Cela peut permettre de récupérer l'enregistrement supprimé.

- Un déclencheur sur UPDATE s'exécute à chaque opération de mise à jour lancée par l'utilisateur ou par un programme. Lors d'une mise à jour, l'ancien enregistrement est supprimé et inséré dans la table temporaire deleted, tandis que le nouveau est inséré à la fois dans la table cible et dans la table inserted.

Base de données 67

La suppression des déclencheurs s'effectue par l'intermédiaire de l'instruction DROP.

DROP TRIGGER nom_trigger1 [,…, nom_triggerN ];

La modification des déclencheurs s'effectue par l'intermédiaire de l'instruction ALTER. La syntaxe complète de la commande ALTER TRIGGER est en fait identique à celle de CREATE TRIGGER.

ALTER TRIGGER nom_trigger ON nom_table FOR INSERT | UPDATE | DELETE AS instruction_SQL…;

Tous les déclencheurs (ALL) ou certains peuvent être activés (ENABLE) ou désactivés (DISABLE) au moyen de l'instruction ALTER TABLE.

ALTER TABLE nom_table { ENABLE | DISABLE } TRIGGER { ALL | nom_trigger1 [,…,nom_triggerN]};

Syntaxe de création de trigger en PL/SQL

CREATE [OR REPLACE] TRIGGER nom_trigger AFTER | BEFORE | INSTEAD OF { [INSERT [OR DELETE [OR UPDATE OF nom_colonne1,…,nom_colonneN] ] ] } nom_tableON FOR EACH ROW [WHEN (condition)] Instruction_PL/SQL | instruction_prodécure;

Notation (les éléments entre [ ] sont optionnels) : - La commande OR REPLACE recrée le déclencheur s'il existe déjà. - La clause BEFORE indique que le déclencheur doit être lancé avant l'exécution de l'événement. - La clause AFTER indique que le déclencheur doit être lancé après l'exécution de l'événement. - Les instructions INSERT et DELETE indique au déclencheur de s'exécuter lors respectivement

d'une insertion ou d'une suppression dans la table. - La clause UPDATE OF indique que le déclencheur doit être lancé lors de chaque mise à jour

d'une des colonnes spécifiées. Si elle est omise, n'importe quelle colonne de la table modifiée provoque le déclenchement du Trigger.

- La clause ON désigne le nom de la table associé à son schéma pour lequel le déclencheur a été spécifiquement créé.

- La clause FOR EACH ROW désigne le déclencheur pour être un déclencheur de ligne. Oracle lance un déclencheur de ligne une fois pour chaque ligne qui est affectée par l'instruction de déclenchement. Si la clause est omise, le déclencheur est un déclencheur d'instruction. Oracle lance un déclencheur de d'instruction une fois seulement lorsque l'instruction déclenchante est émise si la contrainte du déclencheur optionnelle est rencontrée.

CREATE TABLE TABLE_1 ( numero NUMBER, chaine CHAR(20) ); CREATE TABLE DELETE_LOG ( table CHAR(20), action CHAR(50), jour CHAR(20) ); CREATE OR REPLACE TRIGGER declencheur_suppression AFTER DELETE ON TABLE_1

Base de données 68

FOR EACH ROW DECLARE action_utilisateur VARCHAR2(50); BEGIN SELECT user INTO action_utilisateur FROM DUAL; INSERT INTO DELETE_LOG VALUES ('table_1',action_utilisateur,TO_CHAR(SYSDATE, 'DD/MON/YYYY-HH24:MI:SS')); END;

Cette commande SQl'intérieur de DELET

L permet de créer deux tables puis crée un déclencheur qui insère un champ log à E_LOG, pour chaque ligne supprimée dans la table TABLE_1.

CREATE TABLE TABLE_1 ( numero NUMBER, chaine CHAR(20) ); CREATE TABLE TABLE_2 ( chaine CHAR(20), numero NUMBER) ); CREATE TRIGGER declencheur_insertion AFTER INSERT ON TABLE_1 FOR EACH ROW WHEN (NEW.numero <= 10) BEGIN INSERT INTO TABLE_2 VALUES (:NEW.numero, :NEW.chaine); END;

Cette commande insère un enregistr

SQL permet de créer deux tables TABLE_1 et TABLE_2 puis crée un déclencheur qui ement à l'intérieur de TABLE_2 lorsqu’une opération d'insertion s'est accomplie dans

TABLE_1. Le déclencheur vérifie si le nouvel enregistrement possède un premier composant inférieur ou égal à 10 et si c'est le cas, inverse les enregistrements à l'intérieur de TABLE_2.

Les variables spéciales NEW et OLD sont disponibles pour se référer respectivement à des nouveaux ou d'anciens enregistrements. Les deux points (:) précédent NEW et OLD dans VALUES sont dans ce

WHENcas obligatoires, par contre dans la clause conditionnelle , ils doivent être omis.

CREATE TABLE EMP ( EmpNo NUMBER, Enom CHAR(20), Job CHAR(20), Sal NUMBER ); CREATE TABLE SALGRADE ( jobclass CHAR(20), minSal NUMBER, maxSal NUMBER ); CREATE TRIGGER sal_check BEFORE INSERT OR UPDATE OF sal, job ON EMP FOR EACH ROW DECLARE minSal NUMBER NUMBER; sal_hors_rang EXCEPTION; ; maxSal BEGIN SELECT minS xSal INTOal, ma minSal, maxSal FROM SALGRADE WH .job; ERE jobclass = :NEW IF (:NEW.sal<minSal OR :NEW.sal>maxSal) THEN RAISE sal_hors g; _ran END IF; EXCEPTION WHEN sal_hors_rang THEN RAISE_APPLICATION_ERROR(-20300,‘Salaire ’||TO_CHAR (:NEW.sal)||‘ hors rang’); WHEN NO_DATA_FOUND THEN RAISE_APPLICATION_ERROR(-20322,‘Job invalide’); END;

Cette commandesalaires), puis crée

SQL permet de créer deux tables EMP (employés) et SALGRADE (grades de un déclencheur pour vérifier, avant une insertion ou modification de sal et job dans

la table EMP, que le nouveau salaire soit valide (c'est-à-dire que le nouveau salaire ne soit pas inférieur à minSal et ne soit pas supérieur à maxSal) pour le nouvel emploi.

Base de données 69

X. CURSEURS Les curseurs sont des pointeurs sur une zone mémoire pour les données extraites de la base. Il existe des curseurs implicites et explicites. Oracle ouvre toujours un curseur implicite pour traiter une instruction SQL, celui-ci ne se rapporte qu’à la dernière instruction SQL exécutée et il se nomme « SQL ». Le curseur contient des attributs (%NOTFOUND, %FOUND, %ROWCOUNT) qui fournissent des informations sur l’exécution des instructions INSERT, UPDATE, DELETE, SELECT INTO. Un curseur implicite pour une instruction SELECT INTO ne peut gérer qu’une seule ligne. Le curseur explicite quant à lui place le résultat d’une requête multi-lignes dans un tampon mémoire et libère les lignes les unes après les autres lors du traitement.

Le curseur se définit dans la partie déclarative du bloc PL/SQL (la requête n’est pas exécutée à ce moment-là). Dans cette déclaration, il est possible de donner une clause FOR UPDATE OF nom_colonne(s) qui permet de verrouiller les lignes sélectionnées (aucun autre utilisateur ne peut mettre à jour tant que le verrou n’est pas retiré). La commande OPEN nom_curseur exécute la requête et place le curseur en mémoire, elle ne retourne aucun résultat. L’instruction FETCH nom_curseur INTO variable extrait la ligne courante du curseur, la place dans une variable et fait avancer le curseur à la ligne suivante. Pour parcourir toutes les lignes du curseur, il faut utiliser une boucle LOOP. La clause CURRENT OF nom_curseur est utilisée dans le WHERE d’une commande UPDATE pour modifier la ligne courante (si un FOR UPDATE a été utilisé préalablement). L’arrêt de la boucle est obtenu grâce à nom_curseur%NOTFOUND qui retourne false s’il ne reste plus de lignes. Pour libérer l’espace mémoire, il faut fermer explicitement le curseur en utilisant CLOSE nom_curseur.

Un curseur peut accepter des paramètres en entrée, ils servent à passer des informations au curseur et sont généralement utilisés dans un WHERE pour limiter la requête. Les paramètres ont un type associé qui ne peut pas avoir d’indication de longueur. Ils sont passés lors de la commande OPEN.

Syntaxe de la commande DECLARE CURSOR en SQL

DECLARE nom1 table1.attribut1%TYPE; …; omN tableN.attributN%TYPE; n CURSOR nom_du_curseur [(paramètre1 type1 [,…,paramètreN typeN])] [RETURN type_du_retour] IS SELECT attribut(s) FROM table(s) WHERE condition(s); BEGIN instruction_curseurs; END;

Il est également possible de passer des paramètres à un curseur. Suite au DECLARE, on trouve la déclaration des variables utiles au curseur en les définissant par nom table.attribut%TYPE.

DECLARE employe EMP.Ena %TYPE; me salaire EMP.Sal%TYPE; CURSOR curseur (nom VARCHAR2, sal NUMBER) IS SELECT e.Empno, e.Ename, e.Job, r.Sal FROM EMP AS e, REMNUERATION AS r WHERE e.Ename = nom AND r.Sal = sal; BEGIN OPEN curseur(‘DUPONT’,3000); LOOP FETCH curseur INTO @employe, @salaire; EXIT WHEN curseur%NOTFOUND; END LOOP; CLOSE curseur; END;

La commande SQL crée un curseur dont les paramètres d’entrée sont le nom et le salaire d’un employé. La structure de sélection permet de récupérer la liste des employés (numéro, nom, métier) et de leur salaire. Dans la structure BEGIN…END, on retrouve l’opération d’ouverture du curseur suivi de la commande FETCH…INTO… qui permet d’extraire les différentes lignes des tuples renvoyé par la structure de sélection afin de les sauvegarder dans les variables employe et salaire définies dans la déclaration du

Base de données 70

curseur. L'attribut Oracle %NOTFOUND retourne FALSE si la dernière instruction FETCH renvoie un enregistrement ou TRUE en cas d'échec. Suite à la fin de son utilisation, le curseur peut être fermé afin de ne plus consommer de ressources.

XI. FONCTIONS SQL

1. Fonctions arithmétiques - ABS(nb) : Renvoie la valeur absolue de nb. - CEIL(nb) : Renvoie le plus petit entier supérieur ou égal à nb. - COS(n) : Renvoie le cosinus de n, n étant un angle exprimé en radians. - COSH(n) : Renvoie le cosinus hyperbolique de n. - EXP(n) : Renvoie e puissance n. - FLOOR(nb) : Renvoie le plus grand entier inférieur ou égal à nb. - LN(n) : Renvoie le logarithme népérien de n qui doit être un entier strictement positif. - LOG(m,n) : Renvoie le logarithme en base m de n. m doit être un entier strictement supérieur à 1,

et n un entier strictement positif. - MOD(m,n) : Renvoie le reste de la division entière de m par n, si n vaut 0 alors renvoie m.

Attention, utilisée avec au moins un de ses arguments négatifs, cette fonction donne des résultats qui peuvent être différents d'un modulo classique. Cette fonction ne donne pas toujours un résultat dont le signe du diviseur.

- POWER(m,n) : Renvoie m puissance n, m et n peuvent être des nombres quelconques entiers ou réels mais si m est négatif n doit être un entier.

- ROUND(n[,m]) : Si m est positif, renvoie n arrondi (et non pas tronqué) à m chiffres après la virgule. Si m est négatif, renvoie n arrondi à m chiffres avant la virgule. m doit être un entier et il vaut 0 par défaut.

- SIGN(nb) : Renvoie -1 si nb est négatif, 0 si nb est nul, 1 si nb est positif. - SIN(n) : Renvoie le sinus de n, n étant un angle exprimé en radians. - SINH(n) : Renvoie le sinus hyperbolique de n. - SQRT(nb) : Renvoie la racine carrée de nb qui doit être un entier positif ou nul. - TAN(n) : Renvoie la tangente de n, n étant un angle exprimé en radians. - TANH(n) : Renvoie la tangente hyperbolique de n. - TRUNC(n[,m]) : Si m est positif, renvoie n arrondi tronqué à m chiffres après la virgule. Si m est

négatif, renvoie n tronqué à m chiffres avant la virgule. m doit être un entier et il vaut 0 par défaut.

SELECT nom, ROUND(salaire/22.2) FROM EMP;

Cette instruction SQL permet d’afficher le nom et le salaire journalier, arrondi à l’entier le plus proche, de chaque employé de la table EMP.

2. Expressions et fonctions sur les chaînes de caractères - CONCAT(chaîne1,chaîne2) = chaîne1 || chaîne2 : Renvoie la chaîne obtenue en concaténant

chaîne1 à chaîne2. Cette fonction est équivalente à l'opérateur de concaténation | |. - INITCAP(chaîne) : Renvoie chaîne en ayant mis la première lettre de chaque mot en majuscule et

toutes les autres en minuscule. Les séparateurs de mots sont les espaces et les caractères non alphanumériques.

- LOWER(chaîne) : Renvoie chaîne en ayant mis toutes ses lettres en minuscules. - LPAD(chaîne,long,[char]) : Renvoie la chaîne obtenue en complétant, ou en tronquant, chaîne

pour qu'elle ait comme longueur long en ajoutant éventuellement à gauche le caractère (ou la chaîne de caractères) char. La valeur par défaut de char est un espace.

- LTRIM(chaîne[,ens]) : Renvoie la chaîne obtenue en parcourant à partir de la gauche chaîne et en supprimant tous les caractères qui sont dans ens. On s'arrête quand on trouve un caractère qui n'est pas dans ens. La valeur de défaut de ens est un espace.

- REPLACE(chaine,avant,après) : Renvoie chaine dans laquelle toutes les occurrences de la chaîne de caractères avant ont été remplacés par la chaîne de caractères après.

Base de données 71

- RPAD(chaîne,n,[char]) : Renvoie la chaîne obtenue en complétant, ou en tronquant, chaîne pour qu'elle ait comme longueur n en ajoutant éventuellement à droite le caractère (ou la chaîne de caractères) char. La valeur par défaut de char est un espace.

- RTRIM(chaîne[,ens]) : Renvoie la chaîne obtenue en parcourant à partir de la droite chaîne et en supprimant tous les caractères qui sont dans ens. On s'arrête quand on trouve un caractère qui n'est pas dans ens. La valeur de défaut de ens est un espace.

- SOUNDEX(chaîne) : Renvoie la chaîne de caractères constituée de la représentation phonétique des mots de chaîne.

- SUBSTR(chaîne,m[,n]) : Renvoie la partie de chaîne commençant au caractère m et ayant une longueur de n.

- TRANSLATE(chaîne,avant,après) : Renvoie une chaîne de caractères en remplaçant chaque caractère de chaîne présent dans avant par le caractère situé à la même position dans après. Les caractères de chaîne non présents dans avant ne sont pas modifiés. avant peut contenir plus de caractères que après, dans ce cas les caractères de avant sans correspondant dans après seront supprimés de chaîne.

- UPPER(chaîne) : Renvoie chaîne en ayant mis toutes ses lettres en majuscules. - number = INSTR(chaîne,sous-chaîne,debut,occ) : Renvoie la position, noté number, du premier

caractère de chaîne correspondant à l'occurrence occ de sous-chaîne en commençant la recherche à la position début.

- number = LENGTH(chaîne) : Renvoie la longueur de chaîne, noté number, exprimée en nombre de caractères.

SELECT UPPER nom FROM EMP;

Cette instruction SQL permet d’afficher le nom des employés de la table EMP en majuscule.

3. Expressions et fonctions sur les dates

a. Opérateurs sur les dates - date +/– nombre : le résultat est une date obtenue en ajoutant/soustrayant le nombre de jours

nombre à la date date. - date2 – date1 : le résultat est le nombre de jours entre les deux dates.

b. Fonctions sur les dates - ADD_MONTHS(date,n) : Renvoie la date obtenue en ajoutant n mois à date. n peut être un

entier quelconque. Si le mois obtenu a moins de jours que le jour de date, le jour obtenu est le dernier du mois.

- LAST_DAY(date) : Renvoie la date du dernier jour du mois de date. - MONTHS_BETWEEN(date2, date1) : Renvoie le nombre de mois entre date2 et date1, si

date2 est après date1 le résultat est positif, sinon le résultat est négatif. Si les jours date2 et date1 sont les mêmes, ou si ce sont les derniers jours du mois, le résultat est un entier. La partie fractionnaire est calculée en considérant chaque jour comme 1/31ème de mois

- NEXT_DAY(date,nom_du_jour) : Renvoie la date du prochain jour de la semaine dont le nom est nom_de_jour.

- ROUND(date[,précision]) : Renvoie date arrondie à l'unité spécifiée dans précision. L'unité de précision est indiquée en utilisant un des masques de mise en forme de la date. On peut ainsi arrondir une date à l'année, au mois, à la minute,... Par défaut la précision est le jour.

- SYSDATE : Renvoie la date et l'heure courantes du système d'exploitation hôte. - TRUNC(date[,précision]) : Renvoie date tronquée à l'unité spécifiée dans précision. Les

paramètres sont analogues à ceux de la fonction ROUND.

SELECT NEXT_DAY(embauche,’MONDAY’) FROM EMP;

Base de données 72

Cette instruction SQL permet d’afficher la date du lundi suivant l’embauche de chaque employé de la table EMP.

SELECT ROUND(embauche,’Y’) FROM EMP;

Cette instruction SQL permet d’afficher la date d’embauche de chaque employé de la table EMP arrondie à l’année.

SELECT ROUND(SYSDATE-embauche) FROM EMP;

Cette instruction SQL permet d’afficher le nombre de jours depuis l’embauche de chaque employé de la table EMP.

4. Fonctions de conversion - ASCII(chaîne) : Renvoie le nombre correspondant au code ascii du premier caractère de chaine. - CHR(nombre) : Renvoie le caractère dont nombre est le code ascii. - TO_CHAR(nombre,format) : Renvoie la chaîne de caractères en obtenue en convertissant nombre

en fonction de format. Format est une chaîne de caractères pouvant contenir les caractères suivants :

o 9 : représente un chiffre (non représenté si non significatif) o 0 : représente un chiffre (représenté même si non significatif) o . : point décimal apparent o V : définit la position du point décimal non apparent o , : une virgule apparaîtra à cet endroit o $ : un $ précédera le premier chiffre significatif o B : le nombre sera représenté par des blancs s'il vaut 0 o EEEE : le nombre sera représenté avec un exposant (le spécifier avant MI ou PR) o MI : le signe négatif sera à droite o PR : un nombre négatif sera entre <>

- TO_CHAR(date,format) : Renvoie conversion d'une date en chaîne de caractères. Le format indique quelle partie de la date doit apparaître, c'est une combinaison des codes suivants :

o scc : siècle avec signe o cc : siècle o sy,yyy : année (avec signe et virgule) o y,yyy : année( avec virgule) o yyyy : année o yyy : 3 derniers chiffres de l'année o yy : 2 derniers chiffres de l'année o y : dernier chiffre de l'année o q : numéro du trimestre dans l'année o ww : numéro de la semaine dans l'année o w : numéro de la semaine dans le mois o mm : numéro du mois o ddd : numéro du jour dans l'année o dd : numéro du jour dans le mois o d : numéro du jour dans la semaine o hh ou hh12 : heure (sur 12 heures) o hh24 : heure sur 24 heures o mi : minutes o ss : secondes o sssss : secondes après minuit o j : jour du calendrier julien

Base de données 73

Les formats suivants permettent d'obtenir des dates en lettres (en anglais) : o syear ou year : année en toutes lettres o month : nom du mois o mon : nom du mois abrégé sur 3 lettres o day : nom du jour o dy : nom du jour abrégé sur 3 lettres o am ou pm : indication am ou pm o bc ou ad : indication avant ou après Jésus Christ

Les suffixes suivants modifient la présentation du nombre auquel ils sont accolés : o th : ajout du suffixe ordinat st, nd, rd, th o sp : nombre en toutes lettres

Tout caractère spécial inséré dans le format sera reproduit tel quel dans la chaîne de caractères résultat.

- TO_DATE(chaîne,format) : Permet de convertir une chaîne de caractères en donnée de type date. Le format est identique à celui de la fonction TO_CHAR.

- TO_NUMBER(chaîne) : Convertit chaîne en sa valeur numérique.

Remarque : On peut également insérer dans le format une chaîne de caractères quelconque, à condition de la placer entre guillemets "".

SELECT TO_CHAR(embauche,‘DD/MM/YY HH24:MI:SS’) FROM EMP;

Cette instruction SQL permet d’afficher les dates d’embauche de chaque employé de la table EMP sous le format jour/mois/année heure:minute:seconde.

SELECT nom FROM EMP WHERE SOUNDEX(nom)=SOUNDEX(‘DUPONT’);

Cette instruction SQL permet d’afficher la liste de tous les employés de la table EMP dont le nom ressemble à ‘DUPONT’.

SELECT LTRIM(nom,‘LE’) FROM EMP;

Cette instruction SQL permet d’afficher la liste de tous les employés de la table EMP en ayant supprimé tous les ‘L’ et les ‘E’ en tête des noms.

SELECT TRANSLATE(nom,‘AM’,‘**’) FROM EMP;

Cette instruction SQL permet d’afficher la liste de tous les employés de la table EMP en ayant remplacé les ‘A’ et les ‘M’ par des ‘*’ dans les noms.

SELECT TO_CHAR(salaire,‘<MATH>99900.00’) FROM EMP;

Cette instruction SQL permet d’afficher les salaires de chaque employé de la table EMP avec un $ en tête et au moins trois chiffres (dont deux décimales).

Base de données 74

5. Autres fonctions - GREATEST(expr1,expr2,…) : Renvoie la plus grande des valeurs expr1, expr2,.... Toutes les

expressions sont converties au format de expr1 avant comparaison. - LEAST(expr1,expr2,…) : Renvoie la plus petite des valeurs expr1, expr2,.... Toutes les

expressions sont converties au format de expr1 avant comparaison. - NVL(expr1,expr2) : Prend la valeur expr1, sauf si expr1 est NULL auquel cas NVL prend la

valeur expr2. Une valeur NULL en SQL est une valeur non définie. Lorsque l'un des termes d'une expression a la valeur NULL, l'expression entière prend la valeur NULL. D'autre part, un prédicat comportant une comparaison avec une expression ayant la valeur NULL prendra toujours la valeur faux. La fonction NVL permet de remplacer une valeur NULL par une valeur significative.

- DECODE(crit,val_1,res_1[,val_2,res_2…],def) : Cette fonction permet de choisir une valeur parmi une liste d'expressions, en fonction de la valeur prise par une expression servant de critère de sélection. Le résultat récupéré est :

o res_1 si l'expression crit a la valeur val_1 o res_2 si l'expression crit a la valeur val_2 o def (la valeur par défaut) si l'expression crit n'est égale à aucune des expressions val_1,

val_2,...,. Les expressions résultats res_1, res_2, ..., def peuvent être de types différents : caractère et numérique, ou caractère et date (le résultat est du type de la première expression rencontré dans le DECODE). La fonction DECODE permet également de mélanger dans une colonne résultat des informations venant de plusieurs colonnes d'une même table.

SELECT nom, salaire, comm, salaire+NVL(comm,0) FROM EMP;

Cette instruction SQL permet d’afficher le salaire, la commission et le total des gains de chaque employé de la table EMP.

SELECT nom, DECODE(function,'PRESIDENT',1,'DIRECTEUR',2,3) FROM EMP;

Cette instruction SQL permet d’afficher la liste des employés de la table EMP avec pour chacun d'eux sa catégorie (président = 1, directeur = 2, autre = 3).

SELECT DECODE(Detpno,10,fonction,nom) FROM EMP;

Cette instruction SQL permet d’afficher la liste des employés de la table EMP en les identifiant par leur fonction dans le département 10 et par leur nom dans les autres départements.

Chapitre 8 Comparaison des requêtes algébriques, en calcul relationnel et requêtes SQL

I. Introduction Nous avons vu dans les chapitres précédents qu’il existait un certain nombre de langage pôur traduire une requête portant sur une base de données préalablement créée. Ces langages étaient les suivants : - Le langage algébrique en utilisant l’algèbre relationnelle. - Le calcul relationnel à variable domaine ou n-uplets. - Le langage SQL dont l'interface est la plus répandue pour gérer une base de données.

Nous allons voir dans les paragraphes suivants quelles équivalences il existe entre ces différents langages afin de pouvoir passer de l’un à l’autre, sans se limiter à un langage précis.

II. Comparaisons des différents opérateurs Pour les différents opérateurs, on considère deux schémas de relations R(r1,…rn) et S(s1,…sm), et deux relations r et s définies respectivement sur R et S. On note X et Y deux schémas de relations.

1. Union Hypothèse : R = S.

Algèbre relationnelle : r ∪ s.

Calcul relationnel à variable domaine : { (a1,…,an) | ∃(r1,…,rn,s1,…,sn) R(r1,…,rn) ∧ S(s1,…,sn) ∧ [[(a1 = r1) ∧ …

∧ (an = rn)] ∨ [(a1 = s1) ∧ … ∧ (an = sn)]] }

Calcul relationnel à variable n-uplets : { a | ∃r,s R(r) ∧ S(s) ∧ [(a = r) ∨ (a = s)] }

Langage SQL : SELECT * FROM R UNION SELECT * FROM S;

2. Intersection Hypothèse : R = S.

Algèbre relationnelle : r ∩ s.

Calcul relationnel à variable domaine : { (a1,…,an) | R(a1,…,an) ∧ S(a1,…,an) }

Calcul relationnel à variable n-uplets : { t | R(t) ∧ S(t) }

Langage SQL : SELECT * FROM R INTERSECT SELECT * FROM S;

Base de données 76

3. Différence Hypothèse : R = S.

Algèbre relationnelle : r – s = r \ s.

Calcul relationnel à variable domaine : { (a1,…,an) | ∃(s1,…,sn) R(a1,…,an) ∧ S(s1,…,sn) ∧ [(a1 ≠ s1) ∨ … ∨

(an ≠ sn)] }

Calcul relationnel à variable n-uplets : { a | ∃s R(a) ∧ S(s) ∧ (a ≠ s) }

Langage SQL : SELECT * FROM R MINUS SELECT * FROM S;

4. Produit cartésien Hypothèse : R ∩ S = ∅.

Algèbre relationnelle : r × s.

Calcul relationnel à variable domaine : { (r1,…,rn,s1,…,sn) | R(r1,…,rn) ∧ S(s1,…,sn) }

Calcul relationnel à variable n-uplets : { r,s | R(r) ∧ S(s) }

Langage SQL : SELECT R.r1,…,R.rn,S.s1,…,S.sm FROM R,S;

5. Sélection Hypothèse : F est une condition définie sur R.

Algèbre relationnelle : σ F (r).

Calcul relationnel à variable domaine : { (r1,…,rn) | R(r1,…,rn) ∧ F(r1,…,rn) }

Calcul relationnel à variable n-uplets : { r | R(r) ∧ F(r) }

Langage SQL : SELECT * FROM R WHERE F;

6. Projection Hypothèse : X ⊆ R.

Algèbre relationnelle : Π X (r).

Calcul relationnel à variable domaine : { (r1,…,rp) | R(r1,…,rp) }

Calcul relationnel à variable n-uplets : { r’ | R(r’,r”) ∧ F(r) }

Langage SQL : SELECT R.x1,…,R.xp FROM R;

Base de données 77

7. Jointure Hypothèse : R ∩ S ≠ ∅.

Algèbre relationnelle : r s.

Calcul relationnel à variable domaine : { r1,…,rn,sp,…,sm | ∃(s1,…,sp-1) R(r1,…,rn) ∧ S(s1,…,sm) ∧ (r1 = s1) ∧ … ∧

(rp-1 = sp-1) }

Calcul relationnel à variable n-uplets : { r,p,s | R(r,p) ∧ S(p,s) }

Langage SQL : SELECT R.r1,…,R.rn,S.sp,…,S.sm FROM R,S WHERE R.r1 = S.s1 AND … AND R.rp-1 = S.sp-1;

8. Division Hypothèse : Y = R – S.

Algèbre relationnelle : r / s = r ÷ s.

Calcul relationnel à variable domaine : { r1,…,rp-1 | ∃(rp,…,rn) R(r1,…,rn) ∧ S(rp,…,rn) }

Calcul relationnel à variable n-uplets : { r | R(r,p) ∧ S(p) }

Langage SQL : SELECT A.r ,…,A.r FROM R A WHERE NOT EXISTS 1 p-1

(SELECT * FROM S WHERE NOT EXISTS (SELECT * FROM R B WHERE (A.r1 = B.r1 AND … AND A.rp-1 = B.r p-1) AND B.r(GROUP BY ,…,A.r

p = S.rp AND … AND B.rn = S.rn))) A.r1 p-1

HAVING COUNT(*) = (SELECT COUNT (DISTINCT S.rp,…,S.rn) FROM S);

chapitre 1 généralités sur les bases de...

Documents