langage Sql : Créer Et Interroger Une Base - Accueillysop/bd/seance 7-SQL2.pdf · L3-Informatique...

L3-Informatique Paris 8 Base de données Rim Chaabane – [email protected] - Séance 7 -

1

Langage SQL : créer et interroger une base Dans ce chapitre, nous revenons sur les principales requêtes de création de table et d’accès aux données. Nous verrons aussi quelques fonctions d’agrégation (MAX, SUM, COUNT, ..). Nous revenons pour finir sur les opérations de l’algèbre relationnelle et les traduisons en requêtes SQL. Avant d’aborder la création et d’interrogation des tables avec la commande SELECT, nous présentons quelques règles d’écritures en SQL.

Nommage des objets en SQL Un nom d’objet (table, base, colonne contrainte, vue, etc…) doit avoir les caractéristiques suivantes : - Ne pas dépasser 128 caractères - Commencer par une lettre - Etre composé de lettre, de chiffre, du caractère ‘_’ - Ne pas être un mot réservé en SQL { moins d’être mis entre guillemets - Pas de caractères accentués Il faut noter que les noms d’objets sont insensibles { la casse. Voici quelques exemples de noms bien et mal formés :

valable Interdit T_CLIENT T CLIENT

Xyz _XyZ_ IBM_COM Ibm.com

″SELECT″ SELECT CLI_NUM CLI#

MS_sql_Server Microsoft/SQLserver

Remarque : une bonne habitude consiste à donner un nom pertinent aux objets des bases de données.

Commentaires Les commentaires en mysql s’ecrivent { la manière C : /* mon commentaire sur plusieurs lignes */ Mais un commentaire sur une seule lignes est introduit par : ‘—‘ ou ‘#’. Mais pour éviter toute confusion du caractère ‘—‘ avec des opérations mathématiques avec le ‘-‘, préférez le ‘#’ pour vos commentaires sur une seule ligne.


2

1. CREATE TABLE

La syntaxe de création de table est la suivante : CREATE [TEMPORARY] TABLE [IF NOT EXISTS] {tbl_name |

db.name.tbl_name }

<col_name> <type> [NOT NULL | NULL] [DEFAULT <value>] [<contrainte

de colonne>]

[, {<col_name> <type> [DEFAULT <value>] [<contrainte de colonne>] |

<contrainte_de_table>}

[, ...]] ) [SELECT…] ;

2.1. Les contraintes d’intégrité sur les colonnes de tables

Les contraintes d’intégrités permettent aux SGBD-R de garantir la cohérence des données lorsque ces dernières sont mises à jour. Ces contraintes correspondent à des contraintes du monde réel que la base de données cherche à représenter. Comme par exemple, le nom d’un mois doit être une chaine de caractères, ou l’âge un nombre…Il y aussi les clés primaires et clés étrangères, mais aussi bien d’autres contraintes que les bases de données peuvent exprimer. Ainsi si une mise à jour viole une de ces contraintes, elle sera alors tout simplement rejetée.

Contraintes de domaine On entend par domaine le type des attributs d’une table. Il ne peut y avoir de comparaison entre deux valeurs d’attributs si ces derniers ne sont pas définit sur le même domaine. Le SGBD-R se charge de vérifier la validité des valeurs d’attributs. Un enregistrement ne peut être inséré dans une table que si chaque champ de l’enregistrement vérifie la contrainte d’intégrité de domaine de la colonne pour laquelle il est destiné. Pour exemple prenons une table cours qui contient deux colonnes intitule et nbEtudiants. Dans ce cas la commande pour créer cette table est : CREATE TABLE cours (

Intitule VARCHAR,

NbEtudiants INTEGER) ;


3

Contrainte de non nullité (NOT NULL)

La contrainte de non nullité impose que la valeur d’un attribut soit renseignée (la valeur du champ ne peut être à NULL). Prenons pour exemple, la colonne intitule de la table cours. Il est cohérent d’imposer que l’intitulé soit toujours renseigné. Ainsi la commande de création de la table devient :

CREATE TABLE cours (

Intitule VARCHAR NOT NULL,

NbEtudiants INTEGER) ;

Contrainte de vérification (CHECK) La contrainte de vérification est une contrainte qui permet de spécifier que la valeur d’une colonne particulière doit satisfaire une expression booléenne. Attention : si l’expression booléenne compare deux valeurs de colonnes, et que ces dernières contiennent la valeur NULL, elles ne seront pas considérées comme égales. Par exemple le nombre d’étudiants ne peut être que supérieur { zéro. La commande de création de table devient donc : CREATE TABLE cours (


NbEtudiants INTEGER CHECK(NbEtudiants > 0 OR NbEtudiants IS

NULL) ;

Contrainte de clé unique (UNIQUE) et clé primaire (PRIMARY KEY)

La contrainte d’unicité permet de préciser les attributs clés d’une table. Elle permet de garantir que deux lignes de cette table ne peuvent en aucun cas recevoir les mêmes valeurs pour ces attributs. Aussi, comme deux valeurs NULL ne sont pas considérées par le SGBD-R comme égales, nous pouvons avoir (aves la seule contrainte UNIQUE) deux valeurs de clé à NULL. Or, une clé primaire ne peut être nulle. De ce fait, il est nécessaire d’accompagner la contrainte UNIQUE par la contrainte de non nullité lorsqu’il s’agit de clés primaires : UNIQUE NOT NULL. La contrainte de clé primaire PRIMARY KEY permet justement d’exprimer ces deux contraintes (UNIQUE NOT NULL).


4

Introduisons par exemple un attribut sigle (ex : INF1010, INF2705, LOG2410, MTH1006, PHS1101, …) et qui est une clé pour la table cours. On aurait alors comme commande de création de table : CREATE TABLE cours (

sigle CHAR(7) UNIQUE NOT NULL,



NULL) ;

Qui est identique à celle-ci : CREATE TABLE cours (

sigle CHAR(7) PRIMARY KEY,



NULL) ;

Contrainte d’intégrité de référence (REFERENCES) La contrainte d’intégrité de référence est la contrainte de clé étrangère. Elle permet de préciser qu’une colonne ou groupe de colonnes correspondent aux valeurs qui apparaissent dans les lignes d’une autre table. Ce type de contrainte permet de maintenir une intégrité entre deux tables. Par exemple, dans l’exemple de la table cours, pour préciser l’enseignant qui dispense le cours, il faut introduire une colonne id_enseignant qui fait référence à la colonne id_personne de la table personne. Quand on supprime une ligne de la table personne, le SGBD doit vérifier qu’aucune ligne de la table cours, par l’intermédiaire de l’attribut id_enseignant, n’a la ligne qui doit être supprimée. Sinon (i.e. la ligne à supprimer se trouve dans la table cours), trois situations sont possibles : la suppression est interdite dans la table maître (personne) et dans la table courante

(ici cours) où la contrainte d’intégrité est définie comme suit :


Id_enseignant INTEGER

REFERENCES personne (id_personne) RESTRICT,



NbEtudiants INTEGER CHECK(NbEtudiants > 0 OR NbEtudiants

IS NULL) ;


5

la suppression se fait dans la table maitre (ici personne) ainsi que dans la table courante (cours) dans laquelle la contrainte d’intégrité est comme suit :



REFERENCES personne (id_personne) ON DELETE CASCADE,




IS NULL) ;

La suppression se fait dans la table maitre (personne) mais dans la table courante

(cours), la valeur NULL est affectée dans la colonne id_enseignant pour toutes les lignes qui vérifient l’identifiant supprimé dans la table maitre.



REFERENCES personne(id_personne) ON DELETE SET NULL,




IS NULL) ;

Les déclencheurs (TRIGGERS)

L’utilisation de déclencheurs permet de matérialiser d’autres contraintes d’intégrité sous forme d’une action déclenchée { la survenue d’un événement. L'événement est généralement une action de mise à jour de la base. Nous reviendrons sur cette notion dans le dernier chapitre du cours.

2.2. Les contraintes d’intégrité sur la table

Les contraintes de tables portent sur plusieurs colonnes de la table. Ces contraintes ont la syntaxe suivante : [ CONSTRAINT <nom_contrainte> { PRIMARY KEY (<nom_col>[, <nom_col>…]) | FOREIGN KEY <nom_col>[, <nom_col>…]) REFERENCES <nom_tablel> [ (<nom_col>…) ] [ ON DELETE {CASCADE |SET NULL} ] CHECK (<condition>) }


6

CONSTRAINT

Cette partie optionnelle permet de donner un nom à une contrainte de table. Si la contrainte est violée, le nom de la contraint est présent dans les messages d’erreur.

PRIMARY KEY

Cette contrainte permet de spécifier une clé primaire composée de plusieurs attributs.

FOREIGN KEY ( <nom_col> [, …])

REFRENCES <table-maitre> [ ( <nom_col_maitre> [, …]) ] [ ON DELETE {CASCADE | SET NULL | RESTRICT} ] Cette contrainte permet de définit un ensemble d’attributs comme clés étrangères. Les clés de la table maitres doivent être définies comme PRIMARY KEY ou UNIQUE.

CHECK (<condition>)

Cette contrainte permet d’exprimer une condition qui doit exister entre plusieurs attributs de la ligne.

2. SELECT

2.1. La syntaxe

Nous voyons plus en détail la syntaxe de la commande SELECT dans cette section : SELECT [ALL | DISTINCT] { * | <expression>[, …] } FROM <liste des tables> [WHERE <condition>] [ORDER BY <expression> [ASC|DESC] [,…]]

- ALL: Permet de récupérer toutes les lignes vérifiant la condition du WHERE, même si les lignes comportent des doublons. C’est le comportement du SELECT par défaut.

- DISTINCT: Permet de récupérer les lignes vérifiant la condition sans les doublons.


7

- * : Permet de récupérer tous les champs des colonnes vérifiant la condition.

- <expression> : L’expression peut être : o un nom de colonne o le résultat d’une sous-requête ne retournant qu’une seule ligne est une

seule colonne Ex : SELECT * FROM (SELECT DISTINCT id_etudiant, nom, prenom FROM personne, suivre WHERE

personne.id_personne=suivre.id_etudiant) AS

etudiant, cours WHERE

etudiant.id_etudiant=cours.id_enseignant ; AS permet de renommer une table créée pour pouvoir ensuite u faire référence. Comme ici la table etudiant a été créée à partir de la sous-requête. Elle contient les colonnes id_etudiant, nom, prenom.

o le résultat d’une fonction, d’une opération sur des expressions Ex : SELECT id_etudiant, id_cours, note/2 FROM suivre ;

- <Liste des tables> : Indique l’ensemble des tables (séparées par des ‘,’) sur lesquelles opère la requête.

- <condition>: La condition peut contenir AND, OR, NOT La comparaison peut se faire à :

o Une valeur : Condition = {expr1 op expr2 | expr IS NULL | expr IS NOT NULL} Où les expressions peuvent contenir : attributs, +, -, *, / Et op peut être : = , !=, <, >, <=, >=

o Une plage de valeurs : Condition = {expr[NOT] BETWEEN val1 AND val2} Ex: SELECT nom, prenom, age FROM passagers WHERE age BETWEEN 18 AND 30;

o Une liste de valeurs :

Condition = {expr [NOT] IN (liste de valeurs)} Ex : SELECT * FROM vols WHERE arrive IN (‘Londres’, ‘Rome’, ‘Amsterdam’);

o Une expression régulière (ou filtre) :

Condition = {[colonne] [NOT]LIKE <modèle de chaîne>}


8

‘_’ remplace un caractère ‘%’ remplace une séquence de longueur quelconque

Ex : SELECT * FROM companies_aeriennes WHERE pays LIKE

‘F%’;

SELECT * FROM passagers WHERE nom LIKE ‘A%d%’ AND

prenom LIKE ‘J__%’ AND adresse LIKE ‘__Rue M%’;

ORDER BY <expression>: cette clause permet de trier les lignes du

résultat. Ex : SELECT id_personne, nom, prenom FROM personne ORDER

BY nom DESC, prenom DESC;

Les personnes sont affichées par ordre décroissant de leur nom et de leur prénom.

2.2. Traduction des opérateurs de projection, sélection, produit cartésien et équi-jointure de l’algèbre relationnelle

La projection : (A1, A2, ..,An) (relation) SELECT DISTINCT A1, A2, …An FROM relation;

Exemple :

(modele, serie) (Voiture)

SELECT DISTINCT modele, serie FROM Voiture;


9

Sélection : σ(prédicat)(relation)

SELECT * FROM relation WHERE condition;

Ou bien on sélectionne les voitures dont la marque a un ‘e’ en deuxième position : SELECT * FROM Occaz WHERE Marque LIKE ‘_e%’

Ou bien encore, on sélectionne les voitures dont la marque est Peugeot ou Ford : SELECT * FROM Occaz WHERE Marque IN (‘Peugeot’, ‘Ford’)

Produit cartésien : relation1 relation2

σ (compteur <100000) (Voiture)

SELECT * FROM Voiture WHERE (compteur <100000);


10

SELECT * FROM relation1, relation2

Equi-jointure : relation1 ⋈(A1= A2) relation2 SELECT * FROM relation1, relation2 WHERE relation1.A1 =

relation2.A2;

SELECT * FROM relation1 JOIN relation2 ON relation1.A1 =

relation2.A2;

SELECT * FROM relation1 INNER JOIN relation2 ON

relation1.A1 = relation2.A2;

Toutes ces requêtes sont équivalentes.

Jointure naturelle : relation1 ⋈(A1, A2) relation2 SELECT * FROM relation1 NATURAL JOIN relation2;

SELECT * FROM relation1 NATURAL INNER JOIN relation2;

SELECT * FROM relation1 JOIN relation2 USING (A1, A2);

SELECT * FROM relation1 INNER JOIN relation2 USING (A1,

A2);

Toutes ces requêtes sont équivalentes.

Jointure : relation1 ⋈(A1=val1, A2) relation2

SELECT * FROM passagers p, reservations r, vols v WHERE

p.idP=r.idR AND r.idV = v.idV AND p.ville = ‘Paris’ AND

v.arrivee = ‘Londres;

Union : relation1 ∪ relation2 SELECT * FROM relation1 UNION SELECT * FROM relation2;

Intersection : relation1 ∩ relation2

SELECT * FROM relation1 INTERSECT SELECT * FROM

relation2;

Différence : relation1 - relation2 SELECT * FROM relation1 EXCEPT SELECT * FROM relation2;

langage Sql : Créer Et Interroger Une Base - Accueillysop/bd/seance 7-SQL2.pdf · L3-Informatique...

Documents

Transcript of langage Sql : Créer Et Interroger Une Base - Accueillysop/bd/seance 7-SQL2.pdf · L3-Informatique...