Ivan Kurzweg ik-r@wanadoo.fr 2007 Ivan KURZWEG, ivan.kurzweg@wanadoo.fr Permission to use, copy, modify, and distribute this documentation for any purpose with or without fee is here by granted, provided that the above copyright notice and this permission notice appear in all copies. Ce document propose une approche orientée "développement d'application" du SGBDR MySQL. Y sont développés les points suivants : Création de base sous MySQL : types de base, de tables, de données, clefs, index, requêtes SQL; Manipulation de données sous MySQL : requêtes de sélection, d'insertion/modification/suppression d'enregistrements; Optimisation et sécurisation de MySQL : optimisation, sauvegarde, restauration, outils complémentaire; Les exemples du cours ont été réalisés dans un environnement FreeBSD. Tous les exemples sont proposés à partir de l'outil en ligne de commande mysql, mais, pour des raisons de lisibilité, les présentations en cours se feront via les interfaces graphiques MySQL GUI Tools. Les exercices d'applications du cours sont à réaliser sur la base de données proposée sur le site sqlpro.developpez.com Fr~d~ric Brouard. Je vous conseille particulièrement la lecture de ce site, qui éclairera certains points du cours, et donnera une vision plus "générale" des possibilités des SGBDRs. Dans ce chapitre, après une courte introduction à MySQL, nous allons examiner dans un premier temps les différents types de données que nous propose MySQL, puis les différentes étapes nécessaires à la création d'une base de données MySQL. Une base de données est une entité dans laquelle il est possible de stocker des données de façon structurée et avec le moins de redondance possible. Ces données doivent pouvoir être utilisées par des programmes, par des utilisateurs différents. Ainsi, la notion de base de données est généralement couplée à celle de réseau, afin de pouvoir mettre en commun ces informations, d'o~ le nom de base. Le concept permet de stocker et d'organiser une grande quantité d'information. Les SGBD (Système de Gestion de Base de Données) permettent de naviguer dans ces données et d'extraire (ou de mettre à jour) les informations voulues au moyen d'une requête. Les données apparaissent comme stockées dans des tables qu'on peut mettre en relation. Une table elle-même est une relation, mais entre les différents champs qui la composent. Ce système se démarque donc totalement en termes d'interface des bases de données de type hiérarchique, même si au plan de l'implémentation, et en fonction des statistiques d'accès à la base, un modèle hiérarchique sera utilisé, qui n'aura jamais besoin d'être pris en compte par l'utilisateur. De plus les données d'une table sont souvent subordonnées à un des champs (une clé). Ce modèle relationnel conduit à : une grande simplicité d'usage une transparence pour l'utilisateur de toute réorganisation technique de la base (la seule différence pour l'utilisateur se situera, si l'opération est réussie, dans les temps de réponse). une facilité de combinaison du contenu de plusieurs tables (opération join ou jointure). Les tables possèdent un certain nombre de colonnes ou champs permettant de décrire des n-uplets (lignes ou enregistrements). La non-duplication (absence de redondance) des n-uplets est théoriquement assurée par le SGBDR. Dans les relations, nous avons vu qu'il est possible de définir deux types de clés : clé primaire : permet d'identifier un et un seul n-uplet (par exemple le numéro de sécurité sociale). clé étrangère : c'est un attribut d'une relation qui est clé primaire dans une autre relation. Elle permet donc de lier deux tables entre elles. Pour accéder aux données, on utilise différents opérateurs logiques, notamment la sélection (ou projection), mais aussi les jointures (dont il existe différents types). Les opérations sont communiquées sous forme de requêtes aux SGBDR (Système de Gestion de Base de Données Relationnelle). La plupart utilisent le langage normé SQL. Dans une base de données relationnelle, le but est de séparer les informations au maximum pour éviter les doublons et la redondance, et d'empêcher la perte de qualité d'information (par exemple, l'adresse d'un fournisseur n'est mise à jour qu'une et une seule fois : la modification sera alors prise en compte sur l'ensemble des courriers). Cette bonne organisation des données nous est normalement garanti si le Modèle relationnel conçu est valide ... MySQL est créé en 1995 par une société suédoise. Il est aujourd'hui développé et distribué par la société commerciale MySQL AB. MySQL est passé en Open Source (GPL) depuis sa version 3.3, mais il est également proposé en version licencié. MySQL AB fournit différents types de logiciels : Le serveur MYSQL et les scripts de démarrage : mysqld est le serveur MySQL mysqld_safe , mysql.server et mysqld_multi sont les scripts de démarrage. mysql_install_db initialise le dossier de données et les premi~res bases. Logiciels clients pour accéder au serveur : mysql est un client en ligne de commande, pour éxécuter des commandes SQL, interactivement, ou en mode batch. mysql-query-browser est un client interactif graphique, pour exécuter des commandes SQLadministrer le serveur mysql-admin est un client interactif graphique pour administrer le serveur mysqladmin est un client d'administration mysqlcheck effectue les opérations de maintenance sur les tables mysqldump etmysqlhotcopy font les sauvegardes de bases mysqlimport importe des fichiers de données mysqlshow affiche des informations sur les bases et les tables Utilitaires qui fonctionnent indépendamment du serveur : myisamchk effectue les opérations de maintenance des tables myisampack produit des tables compressées, en lecture seule mysqlbinlog est un outil pour traiter les fichiers de logs binaires perror affiche le message associé ~ un code d'erreur Extrait du manuel de référence de MySQL : MySQL est un serveur de bases de données relationnel.Un serveur de bases de données stocke les données dans des tables séparées plutà´t que de tout rassembler dans une seule table. Cela améliore la rapidité et la souplesse de l'ensemble. Les tables sont reliées par des relations définies, qui rendent possible la combinaison de données entre plusieurs tables durant une requête. Le SQL dans `` MySQL '' signifie `` Structured Query Language '' : le langage standard pour les traitements de bases de données. MySQL est Open Source . Open Source (Standard Ouvert) signifie qu'il est possible à  chacun d'utiliser et de modifier le logiciel. Tout le monde peut télécharger MySQL sur Internet, et l'utiliser sans payer aucun droit. Toute personne en ayant la volonté peut étudier et modifier le code source pour l'adapter à  ses besoins propres. Le logiciel MySQL utilise la licence GPL ( GNU General Public License ), pour définir ce que vous pouvez et ne pouvez pas faire avec ce logiciel, dans différentes situations. Si vous ne vous sentez pas confortable avec la licence GPL ou bien que vous devez intégrer MySQL dans une application commerciale, vous pouvez acheter une licence commercial auprès de MySQL AB. Licences MySQL . Pourquoi utiliser le serveur de bases de données MySQL ?Le serveur de bases de données MySQL est très rapide, fiable et facile à  utiliser. Si c'est ce que vous recherchez, vous devriez faire un essai. Le serveur de bases de données MySQL dispose aussi de fonctionnalités pratiques, développées en coopération avec nos utilisateurs. Vous pouvez trouver une comparaison des performances du serveur MySQL avec d'autres systèmes de bases de données dans nos pages de tests de performances. La suite de tests comparatifs de MySQL .Le serveur MySQL a été développé à  l'origine pour gérer de grandes bases de données plus rapidement que les solutions existantes, et a été utilisé avec succès dans des environnements de production très contraints et très exigeants, depuis plusieurs années. Bien que toujours en développement, le Le serveur MySQL offre des fonctions nombreuses et puissantes. Ses possibilités de connexions, sa rapidité et sa sécurité font du serveur MySQL une serveur hautement adapté à  Internet. Les caractéristiques techniques du serveur MySQL .Le logiciel de bases de données MySQL est un système client/serveur, constitué d'un serveur SQL multi-threadé qui supporte différents systèmes de stockage, plusieurs logiciels clients et librairies, outils d'administration, ainsi que de nombreuses interfaces de programmation (des API ).Nous fournissons aussi le serveur MySQL sous la forme d'une librairie multi-threadé que vous pouvez inclure dans vos applications, pour obtenir un produit plus compact, plus rapide et plus facile à  gérer. Toutes les manipulations sur les bases de données, que ce soit en terme d'administration ou d'exploitation, se feront via une connexion au serveur MySQL, qui peut être hébergé ou distant. Dans le cadre de ce cours, il sera proposé deux méthodes de travail : via les outils GUI ou via la ligne de commande. Nous verrons dans la partie consacré aux privilèges que les autorisations de connexions au serveur sont définies en fonction du couple login/password des utilisateurs MySQL, mais aussi en fonction du poste appelant. Néanmoins, vous devriez pouvoir vous connecter sur votre environnement de développement en utilisant les comptes par défaut (root, que nous n'avons pas encore sécurisé). La création d'une base de données va nécessiter l'exécution d'une requête sur le serveur, nous allons devoir nous y connecter, soit en utilisant l'outil graphique mysql-query-browser soit en ligne de commande avec mysql. ]]> Créer une base de données sous MySQL se fait via une requête normalisée SQL. Lors de la création, MySQL effetue les opérations suivantes : Création des répertoires qui stockeront les fichiers de données (données, index, etc..) Mise à jour de la base information_schema, qui contient les options des différentes bases de données hébergées La requête de création de base CREATE DATABASE est la suivante : CREATE DATABASE [IF NOT EXISTS] db_name [create_specification [, create_specification] ...] create_specification: [DEFAULT] CHARACTER SET charset_name | [DEFAULT] COLLATE collation_name Les options permettent de ne ne créer la base de données que si elle n'existe pas (sinon, la requête retourne une erreur en cas de conflit), et de préciser les jeux de caractères utilisés dans les tables. Par défault, il s'agit de latin1, qui représente l'encodage ISO 8859-1 West European. La collation (les règles qui régissent les méthodes de comparaison et de classement des caractères) qui y est associée est latin1_swedish_ci. Tout au long de ce cours, nous allons travailler sur un exemple de base de données, relatif à la gestion d'un bibliothèque personnelle. Nous allons donc créer la base de données bibliotheque. CREATE DATABASE bibliotheque; Query OK, 1 row affected (0.00 sec) ]]> Dans ce premier exemple de requête SQL, on peut noter l'emploi de convention de nommage de la base (pas d'accents, de caractères spéciaux, d'espace, etc..), et un premier apperçu de la structure du langage SQL, avec en particulier le point- virgule qui termine chaque instructions du langage. La liste des bases de données créées sur le serveur peut être obtenues en utilisant la commande SHOW DATABASES : SHOW DATABASES; +--------------------+ | Database | +--------------------+ | information_schema | | bibliotheque | | database | | location_planche | | mysql | | test | +--------------------+ 6 rows in set (0.00 sec) ]]> Le serveur MySQL pouvant héberger plusieurs bases de données, il est nécessaire avant toute manipulation de données de sélectionner la base de travail, opération réalisée par l'instruction USE : mysql> USE bibliotheque Database changed ]]> Nous avons vu dans le cours sur la modélisation des données que nous devons typer les données stockées dans le système d'informations. Si nous sommes restés jusque là relativement éloigné de l'implémentation physique des données, nous allons devoir maintenant choisir avec précision les types de données utilisés dans les tables MySQL supporte un grand nombre de types de colonnes, qui peuvent être rassemblés en trois groupes : les nombres, les dates et les chaînes de caractères. Les types de données de MySQL sont listés ci-dessous. Les codes suivants sont utilisés pour préciser les modes d'affichages : M : Indique la taille maximale d'affichage. Le maximum légal est 255. D : S'applique aux nombres à  virgule flottante, et indique le nombre de décimales qui suivent la virgule. Le nombre maximum est de 30, mais ne doit pas être plus grand que M -2. UNSIGNED : Indique si la propriété optionnelle indiquant si un type de données est toujours positif est autorisée. Si UNSIGNED est présent, le nombre est toujours positif. ZEROFILL : la présence de cette propriété optionnelle indique que des zéros doivent être placés comme caractère de remplissage. Par exemple, pour un type INT(5) ZEROFILL, la valeur 4 sera lue 0004. Le tableau ci-dessous cite les différents types de données numériques sous MySQL. M indique la taille d'affichage, et D (valable pour les nombres en virgule flottante), représente le nombre de chiffres après la virgule. Type Borne inférieure Borne supérieure TINYINT -128 (unsigned : 0) 127 (unsigned : 255 ) SMALLINT -32768 (unsigned : 0) 32767 (unsigned : 65535) MEDIUMINT -8388608 (unsigned : 0) 8388607 (unsigned : 16777215) INT -2147483648 (unsigned : 0) 2147483647 (unsigned : 4294967295) BIGINT -9223372036854775808 (unsigned : 0) 9223372036854775807 (unsigned : 18446744073709551615) FLOAT -3.402823466E+38 3.402823466E+38 DOUBLE -1.7976931348623157E+308 1.7976931348623157E+308 Type TIME : MySQL lit et affiche les colonnes de type TIME au format 'HH:MM:SS'. Les valeurs TIME non valides sont transformées en date zéro '00:00:00' Type DATE : Le type DATE est prévu lorsque vous souhaitez stocker une date. MySQL affiche les valeurs de type DATE au format ' AAAA-MM-JJ '. L'intervalle de validité va de '1000-01-01' à  '9999-12-31'. Les dates non valides sont transformées en "0000-00-00" Type DATETIME : Le type DATETIME est prévu lorsque vous souhaitez stocker une date et une heure. MySQL affiche les valeurs de type DATETIME au format ' AAAA-MM- JJ HH:MM:SS' Type TIMESTAMP : Le type TIMESTAMP est prévu pour stocker automatiquement l'heure courante lors d'une commande INSERT ou UPDATE . Si vous avez plusieurs colonnes de type TIMESTAMP , seule la première colonne sera mise à  jour automatiquement. CHAR(L) : dans ce cas, quelque soit la longueur effective de la chaîne, elle sera toujours stockés sur un nombre d'octets fixe, L. Par exemple, si vous définissez CHAR (10) et que vous entrez la chaîne "Bonjour", elle sera complétée par trois espace dans la table. CHAR(L) BINARY: identique mais insensible à la casse lors de tris et des recherches VARCHAR(L) : dans ce cas, MySQL stocke la chaîne, plus un octet définissant la longueur effecctive de l'enregistrement. Dans notre exemple "bonjour", cette chaîne occupera 7+1 octets dans la base. TINYTEXT, TEXT, MEDIUMTEXT, LONGTEXT : ces types de données peut en fait être considéré comme un VARCHAR, mais dont les tailles maximales respectives sont : 225, 65535, 16777215, 4294967295 TINYBLOB, BLOB, MEDIUMBLOB, LONGBLOB : ces types de données peut en fait être considéré comme un VARCHAR BINARY, et ainsi contenir des données binaires dont tailles maximales respectives sont : 225, 65535, 16777215, 4294967295 Un attribut de type ENUM peut prendre une valeur parmi celles déinies lors de la crétion de la table plus la chaîe vide ainsi que NULL si la déinition le permet. Ces valeurs sont exclusivement des chaînes de caract~res. Une énumération peut contenir 65535 éléments au maximum. La définition d'un tel attribut se fait de la manière suivante : nom_attribut ENUM("valeur 1","valeur 2", ...) nom_attribut ENUM("valeur 1","valeur 2", ...) NULL A chaque valeur est associée un index allant de 0 à N si N valeurs ont été définies. L'index 0 est associé à la chaîne nulle, l'index 1 à la première valeur, lindex NULL est associé à la valeur NULL. Un attribut de type SET peut prendre pour valeur la chaîne vide, NULL ou une chaîne contenant une liste de valeurs qui doivent être déclarées lors de la définition de l'attribut. Il ne peut être défini que 64 éléments maximum. Par exemple, un attribut déclaré comme suit : SET("dvd",vhs","divx") peut prendre les valeurs suivantes : "" (chaîne vide) "dvd,divx" "dvd",vhs","divx" et autres combinaisons de listes des trois valeurs définie plus haut, avec en plus la valeur NULL. La base de données que l'on a créé dans le chapitre précédent relative à la gestion d'une bibliothèque personnelle doit reprendre le modèle relationnel suivant : LIVRE(_LIV_NUM_, LIV_TITRE, LIV_SS_TITRE, #COL_NUM) COLLECTION(_COL_NUM_, COL_NOM, COL_EDITEUR) AUTEUR(_AUT_NUM_, AUT_NOM, AUT_PRENOM, AUT_DATE_NAISSANCE) ECRIT(_ #LIV_NUM, #AUT_NUM_, ECR_ANNEE) LIV_NUM : Entier de 0 à 65536 LIV_TITRE : chaîne de caractères de longueur maximale 60 LIV_SS_TITRE : chaîne de caractères de longueur maximale 60 COL_NUM : Entier de 0 à 255 COL_NOM : chaîne de caractères de longueur maximale 60 COL_EDITEUR : chaîne de caractères de longueur maximale 60 AUT_NUM : Entier de 0 à 65536 AUT_NOM : chaîne de caractères de longueur maximale 60 AUT_PRENOM : chaîne de caractères de longueur maximale 60 AUT_DATE_NAISSANCE : Date ECR_ID : Entier de 0 à 65536 ECR_ANNEE : Année Il est à remarquer la convention de nommage des champs des relations par rapport aux noms des relations.. Pour des raisons de mise en page, les identifiants ne sont pas soulignés, mais encacdrés de signe "_". Exercice : Donnez le MCD correspondant à ce modèle relationnel La création d'une table en SQL se fait via la requête CREATE TABLE. La documentation de MySQL vous donnera la syntaxe complète de cette instruction, mais en voici un synopsys simplifié : CREATE TABLE nom_table ( nom_champ1 type_champ [NULL|NOT NULL] [AUTO_INCREMENT] [PRIMARY KEY], nom_champ1 type_champ [NULL|NOT NULL] [AUTO_INCREMENT], ... ) TYPE= {BDB|HEAP|ISAM|InnoDB|MERGE|MRG_MYISAM|MYISAM}; Les options NOT NULL/NULL (possibilité que la valeur d'un champ n'existe pas pour un enregistrement ou non) et AUTO_INCREMENT (incrémentation automatique d'un identifiant) sont facultatives. La clause PRIMARY KEY permet de spécifier que le champ joue le rôle de clef primaire. Le type de la table a sont importance : en effet, selon les types choisi, la manière de stocker les informations pour MySQL sera différente (organisation de fichiers, modes d'acès, ..). Les types les plus couramment utilisés sont : MYISAM : moteur issu du moteur de stockage originel de MySQL (Isam), rapide, masi ne supporte pas les transactions et les clefs étrangères InnoDB : réputé plus lent, supporte transactions et clefs étrangères De manière générale, nous utiliserons les types de tables InnoDB. Nous allons maintenant créer une première table de la base de données bibliothèque, la table COLLECTION : mysql> CREATE TABLE COLLECTION ( -> COL_NUM TINYINT UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY, -> COL_NOM VARCHAR(60) NOT NULL, -> COL_EDITEUR VARCHAR(60) NOT NULL -> ); Query OK, 0 rows affected (0.00 sec) Nous pouvons vérifier la bonne création de la table en utilisant les instructions SQL SHOW TABLES et DESC : mysql> SHOW TABLES; +------------------------+ | Tables_in_bibliotheque | +------------------------+ | COLLECTION | +------------------------+ 1 row in set (0.00 sec) mysql> DESC COLLECTION; +-------------+---------------------+------+-----+---------+----------------+ | Field | Type | Null | Key | Default | Extra | +-------------+---------------------+------+-----+---------+----------------+ | COL_NUM | tinyint(3) unsigned | NO | PRI | NULL | auto_increment | | COL_NOM | varchar(60) | NO | | | | | COL_EDITEUR | varchar(60) | NO | | | | +-------------+---------------------+------+-----+---------+----------------+ 3 rows in set (0.00 sec) Exercice : En respectant les types de données indiquée plus haut, créez la table AUTEUR Lors de la recherche d'informations dans une relation, MySQL parcours la table correspondante dans n'importe quel ordre. Dans le cas d'un grand nombre de lignes, cette recherche est très longue du fait du parcours de toute la table. Pour y remédier, une optimisation possible et fortement recommandée, est d'utiliser des index. La création d'un index associé à un attribut ou à un ensemble ordonné d'attributs va créer une liste ordonnée des valeurs de ces attributs et de l'adresse de la ligne associée. C'est sur les valeurs de cette liste que se feront les recherches et les tris. Les algorithmes de recherche et de tri sur des ensembles ordonnées sont énormément plus rapides ! Ainsi, d'une recherche à coût prohibitif, on passe à une recherche sur un ensemble déjà trié. On gagne donc énormément en temps d'accès aux informations. Bien que cela ralentisse les mises à jour (insertion, suppression, modification de clé). On choisira de créer des index sur les attributs qui seront les plus sollicités par les recherches ou utilisés comme critère de jointure. Par contre, on épargnera les attributs qui contiennent peu de valeurs différentes les unes des autres et ceux dont les valeurs sont très fréquemment modifiées. Pour créer un index, on utilise l'instruction INDEX. Un index peut porter sur 15 colonnes maximum. Une table peut posséder au maximum 16 indexes. Un index peut avoir une taille d'au maximum 256 octets et ne doit porter que sur des attributs NOT NULL.Un exemple de création d'index vous est proposé dans le paragraphe suivant Nous avons vu toute l'importance des contraintes d'intégrité référentielle, et des clefs étrangères en particulier. Pour créer des clefs étrangères lors de la création des tables, il faut que : les champs existent en tant que clef primaires de tables déjà créées le type des champs clefs dans les deux tables soient les mêmes des index soient créés sur les champs Ainsi, la création de la table LIVRE de notre exemple se ferait avec l'instruction suivante : mysql> CREATE TABLE LIVRE ( -> LIV_NUM SMALLINT UNSIGNED NOT NULL AUTO_INCREMENT , -> LIV_TITRE VARCHAR(60) NOT NULL, -> LIV_SS_TITRE VARCHAR(60) NULL, -> COL_NUM TINYINT UNSIGNED , -> PRIMARY KEY (LIV_NUM), -> FOREIGN KEY(COL_NUM ) REFERENCES COLLECTION(COL_NUM) ON DELETE RESTRICT ON UPDATE CASCADE, -> INDEX(COL_NUM) -> ); Query OK, 0 rows affected (0.00 sec) Dans le précédent exemple : le champs COL_NUM existe en tant que clef primaire COLLECTION le type de COL_NUM est bien le même dans la table COLLECTION et dans la table LIVRE. un index est créé sur COL_NUM on indique à MySQL de modifier (UPDATE)en cascade les enregistrements de la table LIVRE si on modifie un enregistrement lié de la table COLLECTION on indique à MySQL d'empêcher (RESTRICT) la suppression d'un enregistrement de la table COLLECTION si est lié dans la table LIVRE La création d'une relation par CREATE TABLE n'en rend pas définitives les spécifications. Il est possible d'en modifier la définition par la suite, à tout moment par la commande ALTER TABLE : ajouter/supprimer un attribut. créer/supprimer une clé primaire. ajouter une contrainte d'unicité (interdire les doublons). changer la valeur par défaut d'un attribut. changer totalement la définition d'un attribut. changer le nom de la relation. ajouter/supprimer un index. La syntaxe générale de l'instruction est : ALTER TABLE relation MODIFY attribut definition_relative ALTER TABLE relation ALTER attribut { SET DEFAULT valeur | DROP DEFAULT } ALTER TABLE relation ADD UNIQUE (attributs) ALTER TABLE relation DROP attribut ALTER TABLE relation ADD definition ALTER TABLE relation ADD INDEX index (attributs) ALTER TABLE relation DROP INDEX index Exercice : Modifiez la table LIVRE de manière à faire apparître un nouveau champ : LIV_GENRE, qui soit une énumération ayant pour valeurs possible : "policier", "science-fiction", "historique" Supprimer une table se fait par l'instruction DROP TABLE nom_table. Nous avons vu dans les exercices du cours sur la modélisation le MCD d'une base de données pour la gestion d'un hôtel. Nous utiliserons cette base et son contenu dans plusieurs exercices au long de ce cours. En utilisant l'interface de votre choix, créez en local la base de données HOTEL, qui hébergera les données de gestion de l'hôtel. Pour que nous partions tous sur la même base de données, je vous propose d'exécuter le script cree_hotel.sql, qui contient la définition de toutes les tables de la base de données Téléchargez le ici et exécutez le sur votre serveur. Donnez la liste complète des instructions qui permettent de vérifier que les tables et les colonnes ont bien été créées. On souhaite rajouter les informations suivantes : les chambres peuvent disposer ou non d'une prise ethernet pour l'accès à Internet (par défaut elles le sont toutes, sauf quelques unes) les chambres peuvent être équipées d'un frigo (par défaut non) Donnez les requêtes SQL permettant de faire ces modifications dans la structure de la base. On vous fournit le MR suivant : FILM(CodeFilm, TitreFilm, Annee, Duree, Resume, #CodeGenre) GENRE(CodeGenre, IntGenre) ACTEUR(CodeActeur, NomActeur, PrenomActeur) JOUER_UN_ROLE(#CodeFilm, #CodeActeur) SUPPORT(CodeSupport, IntSupport) FILM_SUPPORT(#CodeFilm,#CodeSupport) EMPRUNTEUR(CodePers, NomPers, PrenomPers, AdrPers, TelPers) EMPRUNT(#CodeFilm, #CodePers, DatePret, DateRetour) Vous devez me présenter Le modèle conceptuel des données Les requêtes nécéssaires à  la traduction du schéma relationnel sachant que : Les types de données : Valeurs entières : clés primaires (sauf Date de prêt), Durée du film Chaînes de caractères : Titre de film(80), Année(4), Résumé( ?), Genre(20), Nom de l'acteur (25), prénom de l'acteur(25), support(10), emprunteur(nom : 25, prénom : 25, adresse : 50, téléphone : 14) Dates : Date de prêt, date de retour Les contraintes : Toutes les informations concernant l'emprunteur sont obligatoires, ainsi que : le nom de l'acteur, le genre, le support et le titre de film Ecrire les requêtes permettant: D'indiquer que le champ « PrenomActeur » ne soit jamais nul. D'ajouter la colonne « DatNaiss » dans la table ACTEUR. De créer un index sur le champ « TitreFilm » Effectuer les modifications nécessaires au stockage : Des informations qui concernent les réalisateurs (nom, prénom et sexe) Du fait qu'un réalisateur peut réaliser de 0 à  n films Du fait qu'un film ait pu être réalisé par plusieurs réalisateurs Du fait que le sexe ne peut contenir que M (Masculin) ou F (Féminin) (M par défaut) Du fait qu'un film puisse appartenir à  une série de films Insérer une ligne dans une table MySQL revient à exécuter la commande INSERT : INSERT INTO nom_table (Champ1, Champ2, ....) VALUES (Valeur1, Valeur 2, ... ) La liste des colonnes fournies à la suite du nom de la table correspond aux différentes colonnes que l'on souhaite remplir pour la ligne, avec les valeurs (ordonnées) qui suivent le mot clef VALUE. Dans le cas où une colonne n'est pas citée, elle prendra soit la valeur par défaut indiquée lors de la création de la table, soit la valeur NULL si elle autorisée. mysql> INSERT INTO collection(COL_NOM, COL_EDITEUR) -> VALUES ("Ailleurs et Demain", "Robert Laffont"); Query OK, 1 row affected (0.01 sec) Dans cet exemple, on ne donne pas la valeur de l'identifiant, qui sera automatiquement incrémenté. Dans le cas d'insertions multiples, il est possible de les concentrer sur la même instruction, en séparant les listes de valeurs par une virgule : mysql> INSERT INTO collection(COL_NOM, COL_EDITEUR) -> VALUES ("Ailleurs et Demain Classiques", "Robert Laffont"), -> ("Antologie de la Science Fiction","J'ai Lu"), -> ("Special Suspens","Robert Laffont"); Query OK, 3 rows affected (0.01 sec) Records: 3 Duplicates: 0 Warnings: 0 mysql> insert into auteur (AUT_NOM, AUT_PRENOM, AUT_DATE_NAISSANCE) -> VALUES ("Herbert", "Brian", "1944-12-10"), -> ("Anderson", "Kevin", "1962-03-27"), -> ("Herbert", "Frank", "1920-10-08"); Query OK, 3 rows affected (0.00 sec) Records: 3 Duplicates: 0 Warnings: 0 L'insertion au moyen de la requête INSERT renvoie une erreur si la valeur de l'identifiant est déjà prise : mysql> INSERT INTO collection(COL_NUM, COL_NOM, COL_EDITEUR) -> VALUES (3, "Fleuve Noir", "Livre de Poche"); ERROR 1062 (23000): Duplicate entry '3' for key 1 mysql> Dans ce cas il est possible d'utiliser la commande REPLACE qui écrasera la ligne : mysql> REPLACE INTO collection(COL_NUM, COL_NOM, COL_EDITEUR) -> VALUES (3, "Fleuve Noir", "Livre de Poche"); Query OK, 2 rows affected (0.01 s) Pour visualiser le contenu la table après ces insertions, il nous faut utiliser la commande SELECT (nous la verrons en détail dans le chapitre suivant) : mysql> select * from collection; +---------+---------------------------------+----------------+ | COL_NUM | COL_NOM | COL_EDITEUR | +---------+---------------------------------+----------------+ | 2 | Ailleurs et Demain | Robert Laffont | | 3 | Fleuve Noir | Livre de Poche | | 4 | Ailleurs et Demain Classiques | Robert Laffont | | 5 | Antologie de la Science Fiction | J'ai Lu | | 6 | Special Suspens | Robert Laffont | +---------+---------------------------------+----------------+ 5 rows in set (0.00 sec) Mettre des données à jour en SQL se fait généralement via les instructions UPDATE. Cette instruction permet la mise à jour des lignes correspondant à une (des) conditions(s). C'est pourquoi elle est généralement couplée à la clause WHERE : UPDATE relation SET attribut=valeur, ... [ WHERE condition ] Dans le cas où la clause WHERE est absente, la mise-à-jour s'appliquera sur toutes les lignes de la table. La clause WHERE, que nous verrons en détail dans le chapitre suivant, contient des expressions logiques que doivent vérifier les lignes sur lesquelles portent les modifications : mysql> UPDATE collection -> SET COL_EDITEUR = "Le Livre de Poche" -> WHERE COL_NOM LIKE "Antologie de la Science Fiction"; Query OK, 1 row affected (0.02 sec) Rows matched: 1 Changed: 1 Warnings: 0 mysql> UPDATE auteur set AUT_DATE_NAISSANCE = "1944-10-12" -> WHERE AUT_NOM="Herbert" -> AND AUT_PRENOM ="Brian"; Query OK, 1 row affected (0.01 sec) Rows matched: 1 Changed: 1 Warnings: 0 Il est également possible d'utiliser la valeur de la première de la colonne dans le calcul de la nouvelle valeur : mysql> UPDATE auteur SET AUT_NOM = UPPER(AUT_NOM); Query OK, 3 rows affected (0.01 sec) Rows matched: 3 Changed: 3 Warnings: 0 Dans cet exemple, la mise à jour va s'appliquer à toute les lignes de la table (pas de clause WHERE). La fonction UPPER permet de passer une chaîne de caractère en majuscule. mysql> SELECT * FROM auteur; +---------+----------+------------+--------------------+ | AUT_NUM | AUT_NOM | AUT_PRENOM | AUT_DATE_NAISSANCE | +---------+----------+------------+--------------------+ | 1 | HERBERT | Brian | 1944-10-12 | | 2 | ANDERSON | Kevin | 1962-03-27 | | 3 | HERBERT | Frank | 1920-10-08 | +---------+----------+------------+--------------------+ 3 rows in set (0.00 sec) La suppression d'un ou plusieurs enregistrement est définitive. La requête DELETE permet de réaliser cette tâche : DELETE [ LOW_PRIORITY ] FROM relation [ WHERE condition ]; Comme pour l'instruction UPDATE, si la clause WHERE est omise, la table entière est détruite, et une table vide recréée. Si la clause WHERE est précisée, seules les lignes satisfaisant à la (aux) condition(s) sont supprimées. La clause LOW_PRIORITY permet de spécifier à MySQL d'attendre que les éventuels accès en lecture soient terminés pour procéder à l'effacement. mysql> DELETE FROM collection -> WHERE COL_NOM = "Fleuve Noir"; Query OK, 1 row affected (0.01 sec) Si la ligne est impliqué dans une intégrité référentielle de type clef étrangère, la requête peut échouer : mysql> DELETE FROM collection -> WHERE COL_NOM = "Ailleurs et Demain" -> ; ERROR 1451 (23000): Cannot delete or update a parent row: a foreign key constraint fails (`bibliotheque/livre`, CONSTRAINT `livre_ibfk_1` FOREIGN KEY (`COL_NUM`) REFERENCES `collection` (`COL_NUM`) ON UPDATE CASCADE) Afin de pouvoir réaliser les exercices d'applications et les différents exemples du cours, vous pouvez télécharger les scripts de création de base et d'insertion des enregistrements : Base de données "Hotel" : création de la base et insertion des données Base de données "vidéothèque" :création de la base et insertion des données Base de données "bibliothèque" : création de la base et insertion des données Vous serez, selon la configuartion des systèmes, peut-être amené à modifier l'encodage des caractères. L'instruction SQL permettant d'extraire des données dans une table est SELECT. Les possibilités de conditions de sélection et de traitement des enregistrements peuvent conduire à des requêtes complexes. La syntaxe générale de la requête est : SELECT [ DISTINCT ] attributs [ FROM relation ] [ WHERE condition ] [ GROUP BY attributs [ ASC | DESC ] ] [ HAVING condition ] [ ORDER BY attributs ] Les différentes clauses sont : attributs : la liste des colonnes à afficher en résultat (éventuellement les fonctions à exécuter sur les colonnes) DISTINCT : permet d'ignorer les doublons FROM : le nom de la table (ou des tables) , éventuellement aliasé dans laquelle (lesquelles) sélectionner les enregistrements WHERE : les conditions de sélection que doivent respecter les enregistrements GROUP BY : permet de grouper les résultats selon un ou plusieurs attributs HAVING : des critères de sélection sur des ensembles de valeurs d'un attributs après groupement ORDER BY : tri du resultats (ASC ou DESC) mysql> SELECT * FROM collection; +---------+---------------------------------+-------------------+ | COL_NUM | COL_NOM | COL_EDITEUR | +---------+---------------------------------+-------------------+ | 2 | Ailleurs et Demain | Robert Laffont | | 4 | Ailleurs et Demain Classiques | Robert Laffont | | 5 | Antologie de la Science Fiction | Le Livre de Poche | | 6 | Special Suspens | Robert Laffont | +---------+---------------------------------+-------------------+ 4 rows in set (0.00 sec) mysql> SELECT COL_EDITEUR FROM collection; +-------------------+ | COL_EDITEUR | +-------------------+ | Robert Laffont | | Robert Laffont | | Le Livre de Poche | | Robert Laffont | +-------------------+ 4 rows in set (0.00 sec) mysql> SELECT DISTINCT COL_EDITEUR FROM collection; +-------------------+ | COL_EDITEUR | +-------------------+ | Robert Laffont | | Le Livre de Poche | +-------------------+ 2 rows in set (0.35 sec) mysql> SELECT DISTINCT COL_EDITEUR FROM collection ORDER BY COL_EDITEUR ASC; +-------------------+ | COL_EDITEUR | +-------------------+ | Le Livre de Poche | | Robert Laffont | +-------------------+ 2 rows in set (0.00 sec) Les prédicats de sélection de la clause WHERE sont une série de tests logiques sur la valeur des colonnes de chaque enregistrement. La requête parcourt tous les enregistrements de la table, ne renvoyant que les lignes qui satisfont aux conditions. Nous examinons ces conditions dans les paragraphes suivant. Il est possible d'intégrer des calculs ou des opérations logiques dans les prédicats de sélection et dans l'affichage des résultats. Les tableaux suivants résument ces opérateurs et fonctions : Opérateur Symbole Arithmétiques +, -, *, /, % Relationnels <, <=, =, >, >=, <>, LIKE Logiques AND, OR, NOT, BETWEEN, IN mysql> SELECT * FROM auteur -> WHERE AUT_NOM = "HERBERT"; +---------+---------+------------+--------------------+ | AUT_NUM | AUT_NOM | AUT_PRENOM | AUT_DATE_NAISSANCE | +---------+---------+------------+--------------------+ | 1 | HERBERT | Brian | 1944-10-12 | | 3 | HERBERT | Frank | 1920-10-08 | +---------+---------+------------+--------------------+ 2 rows in set (0.00 sec) mysql> SELECT * FROM collection -> WHERE COL_NOM LIKE "AIllEUrs%"; +---------+-------------------------------+----------------+ | COL_NUM | COL_NOM | COL_EDITEUR | +---------+-------------------------------+----------------+ | 2 | Ailleurs et Demain | Robert Laffont | | 4 | Ailleurs et Demain Classiques | Robert Laffont | +---------+-------------------------------+----------------+ 2 rows in set (0.00 sec) Fonction Description TRIM(x) Supprime les espaces de début et de fin de chaîne LOWER(x) Converti en minuscules UPPER(x) Converti en majuscules LOCATE(x,y) Renvoie la position de lpremière occurence de x dans y, 0 si pas trouvé CONCAT(x,y,...) Concatène les arguments SUBSTRING(s,i,n) Retourne les n derniers caractères de s à partir de i SOUNDEX(x) Retourne une présentation phonétique de x LENGTH(x) Renvoi la longueur de x mysql> SELECT AUT_NOM, AUT_PRENOM, UPPER(CONCAT(SUBSTRING(AUT_NOM,1,1) , SUBSTRING(AUT_PRENOM,1 ,1))) AS INITIALES -> FROM auteur; +----------+------------+-----------+ | AUT_NOM | AUT_PRENOM | INITIALES | +----------+------------+-----------+ | HERBERT | Brian | HB | | ANDERSON | Kevin | AK | | HERBERT | Frank | HF | +----------+------------+-----------+ 3 rows in set (0.00 sec) Fonction Description NOW() Retourne la date et heure du jour TO_DAYS(x) Conversion de la date X en nombre de jours depuis la date 0 DAYOFWEEK(x) Retourne un entier indiquant la position de la date dans la semaine DAYOFMONTH(x) Retourne un entier indiquant la position de la date dans le mois DAYOFYEAR(x) Retourne un entier indiquant la position de la date dans l'année SECOND(x), MINUTE(x),HOUR(x), MONTH(x),YEAR(x), WEEK(x) Retournent respectivement les secondes, minutes, heures, mois, anné et semaine de la ate. mysql> SELECT * FROM auteur -> WHERE YEAR(AUT_DATE_NAISSANCE) > 1940; +---------+----------+------------+--------------------+ | AUT_NUM | AUT_NOM | AUT_PRENOM | AUT_DATE_NAISSANCE | +---------+----------+------------+--------------------+ | 1 | HERBERT | Brian | 1944-10-12 | | 2 | ANDERSON | Kevin | 1962-03-27 | +---------+----------+------------+--------------------+ 2 rows in set (0.00 sec) Fonction Symbole COUNT([DISTINCT]x,y,...) Compte le nombre de lignes renvoyées par une requêtes MIN(x), MAX(x), AVG(x), SUM(x) Calculent respectivement le minimum, le maximum, la moyenne et la somme des valeurs de l'attribut X mysql> SELECT COUNT(*) as NB_AUTEURS FROM auteur; +------------+ | NB_AUTEURS | +------------+ | 3 | +------------+ 1 row in set (0.00 sec) Fonction Description ABS(x) Valeur absolue de X SIGN(x) Signe de X, retourne -1, 0 ou 1 FLOOR(x) Arrondi à l'entier inférieur CEILING(x) Arrondi à l'entier supérieur ROUND(x) Arrondi à l'entier le plus proche EXP(x), LOG(x), SIN(x),COS(x), TAN(x), PI() Exponentiel, logarithme, sinus ... POW(x,y) Retourne X à la puissance Y RAND(x) Retourne un nombre aléatoire entre 0 et X TRUNCATE(x,y) Tronque le nombre X à la Yème décimale SQL dispose de fonctions d'agrégats vues dans la paragraphe précédents : MAX, MIN, SUM, AVG, COUNT. Elles permettent d'effectuer des calculs statistiques sur des lignes résultant de requêtes de sélection, et sont souvent employées avec la clause GROUP BY, permettant d'opérer ces calculs sur des sous-ensembles de lignes. De manière générale on peut dire que le GROUP BY doit porter sur l'ensemble des attributs listés hors des fonctions d'agrégats : mysql> SELECT COUNT(COL_NOM), COL_EDITEUR -> FROM collection -> GROUP BY COL_EDITEUR; +----------------+-------------------+ | COUNT(COL_NOM) | COL_EDITEUR | +----------------+-------------------+ | 1 | Le Livre de Poche | | 3 | Robert Laffont | +----------------+-------------------+ 2 rows in set (0.00 sec) mysql> select count(LIV_NUM) as NB_LIV, COL_NOM, COL_EDITEUR -> FROM livre -> JOIN collection -> ON collection.COL_NUM = livre.COL_NUM -> GROUP BY COL_NOM, COL_EDITEUR; +--------+-------------------------------+----------------+ | NB_LIV | COL_NOM | COL_EDITEUR | +--------+-------------------------------+----------------+ | 8 | Ailleurs et Demain | Robert Laffont | | 2 | Ailleurs et Demain Classiques | Robert Laffont | +--------+-------------------------------+----------------+ 2 rows in set (0.00 sec) mysql> select count(LIV_NUM) as NB_LIV, COL_NOM, COL_EDITEUR -> FROM collection -> LEFT JOIN livre -> ON collection.COL_NUM = livre.COL_NUM -> GROUP BY COL_NOM, COL_EDITEUR ;+--------+---------------------------------+-------------------+ | NB_LIV | COL_NOM | COL_EDITEUR | +--------+---------------------------------+-------------------+ | 8 | Ailleurs et Demain | Robert Laffont | | 2 | Ailleurs et Demain Classiques | Robert Laffont | | 0 | Antologie de la Science Fiction | Le Livre de Poche | | 0 | Special Suspens | Robert Laffont | +--------+---------------------------------+-------------------+ 4 rows in set (0.00 sec) Le groupage des résultats se faisant après la sélection des données, il n'est pas possible de fixer des contraintes sur les fonctions d'agrégats dans la clause WHERE. HAVING permet ainsi d'éffectuer des sélections sur les calculs statistiques : mysql> SELECT AUT_NOM, AUT_PRENOM, COUNT(ECR_NUM_LIVRE) AS NB_LIVRES -> FROM auteur, ecrit -> WHERE auteur.AUT_NUM = ecrit.ECR_NUM_AUTEUR -> GROUP BY AUT_NOM, AUT_PRENOM; +----------+------------+-----------+ | AUT_NOM | AUT_PRENOM | NB_LIVRES | +----------+------------+-----------+ | ANDERSON | Kevin | 1 | | HERBERT | Brian | 4 | | HERBERT | Frank | 2 | +----------+------------+-----------+ 3 rows in set (0.00 sec) mysql> SELECT AUT_NOM, AUT_PRENOM, COUNT(ECR_NUM_LIVRE) AS NB_LIVRES -> FROM auteur, ecrit -> WHERE auteur.AUT_NUM = ecrit.ECR_NUM_AUTEUR -> AND NB_LIVRES > 2 -> GROUP BY AUT_NOM, AUT_PRENOM; ERROR 1054 (42S22): Unknown column 'NB_LIVRES' in 'where clause' mysql> SELECT AUT_NOM, AUT_PRENOM, COUNT(ECR_NUM_LIVRE) AS NB_LIVRES -> FROM auteur, ecrit -> WHERE auteur.AUT_NUM = ecrit.ECR_NUM_AUTEUR -> GROUP BY AUT_NOM, AUT_PRENOM -> HAVING NB_LIVRES > 2; +---------+------------+-----------+ | AUT_NOM | AUT_PRENOM | NB_LIVRES | +---------+------------+-----------+ | HERBERT | Brian | 4 | +---------+------------+-----------+ 1 row in set (0.00 sec) Exercice : Lister les livres qui ont été co-écrits. Il n'est pas possible de combiner les fonctions d'agrégats entre elles : mysql> SELECT AUT_NOM, AUT_PRENOM, MAX(COUNT(ECR_NUM_LIVRE)) AS NB_LIVRES -> FROM auteur, ecrit -> WHERE auteur.AUT_NUM = ecrit.ECR_NUM_AUTEUR -> GROUP BY AUT_NOM, AUT_PRENOM; ERROR 1111 (HY000): Invalid use of group function Connaître l'auteur dont on a le plus d'ouvrages dans la base nécessite l'emploi de sous-requêtes, que nous allons voir dans le prochain chapitre. Les jointures sont l'opération algébrique qui consiste à recouper les enregistrements de plusieurs tables de manière à retrouver les dépendances exprimées dès le modèle conceptuel des données. Une première méthode pour les jointures consistent à indiquer dans les prédicats de sélection l'égalité d'attributs (généralement la clef primaire et la clef étrangère) : mysql> SELECT COL_NOM, LIV_TITRE, LIV_SS_TITRE FROM livre, collection -> WHERE livre.COL_NUM = collection.COL_NUM; +-------------------------------+------------------------+-------------------------+ | COL_NOM | LIV_TITRE | LIV_SS_TITRE | +-------------------------------+------------------------+-------------------------+ | Ailleurs et Demain | Dune | | | Ailleurs et Demain | Dune | Le Messie de Dune | | Ailleurs et Demain | Dune | L'empereur Dieu de Dune | | Ailleurs et Demain | Dune | Les hérétiques de Dune | | Ailleurs et Demain | Dune | Les enfants de Dune | | Ailleurs et Demain | Dune, la génèse | La Guerre des machines | | Ailleurs et Demain | Dune, la génèse | Le Jihad Butlérien | | Ailleurs et Demain | Dune, la génèse | La Bataille de Corrin | | Ailleurs et Demain Classiques | L'Effet Lazare | | | Ailleurs et Demain Classiques | L'Homme de deux mondes | | +-------------------------------+------------------------+-------------------------+ 10 rows in set (0.00 sec) Les attributs portant le même nom dans les deux tables, nous sommes obligés de les préfixer du nom de chaque table. Les requêtes utilisant souvent des jointures, MySQL implémente ces opérations de manière optimisé en utilisant la clause JOIN : SELECT attributs FROM table1 INNER JOIN table1 ON table1.att1 = table2.att2 mysql> SELECT * FROM collection; +---------+---------------------------------+-------------------+ | COL_NUM | COL_NOM | COL_EDITEUR | +---------+---------------------------------+-------------------+ | 2 | Ailleurs et Demain | Robert Laffont | | 4 | Ailleurs et Demain Classiques | Robert Laffont | | 5 | Antologie de la Science Fiction | Le Livre de Poche | | 6 | Special Suspens | Robert Laffont | +---------+---------------------------------+-------------------+ 4 rows in set (0.00 sec) mysql> SELECT COL_NOM, LIV_TITRE, LIV_SS_TITRE FROM collection -> INNER JOIN livre -> ON collection.COL_NUM = livre.COL_NUM; +-------------------------------+------------------------+-------------------------+ | COL_NOM | LIV_TITRE | LIV_SS_TITRE | +-------------------------------+------------------------+-------------------------+ | Ailleurs et Demain | Dune | | | Ailleurs et Demain | Dune | Le Messie de Dune | | Ailleurs et Demain | Dune | L'empereur Dieu de Dune | | Ailleurs et Demain | Dune | Les hérétiques de Dune | | Ailleurs et Demain | Dune | Les enfants de Dune | | Ailleurs et Demain | Dune, la génèse | La Guerre des machines | | Ailleurs et Demain | Dune, la génèse | Le Jihad Butlérien | | Ailleurs et Demain | Dune, la génèse | La Bataille de Corrin | | Ailleurs et Demain Classiques | L'Effet Lazare | | | Ailleurs et Demain Classiques | L'Homme de deux mondes | | +-------------------------------+------------------------+-------------------------+ 10 rows in set (0.00 sec) Dans le cas de INNER JOIN, seules les lignes de la première table étant liées avec des enregistrements de la deuxième table apparaissent. Dans l'exemple, certaines collections ne sont donc pas listées. Cette jointure est appelée jointure interne, et est la plus utilisée. Le mot clef INNER est ainsi facultatif. Les clauses LEFT JOIN (respectivement RIGHT JOIN) permettent de lister tous les enregistrements de la première table (respectivement la deuxième), même si ils n'ont pas de correspondance dans l'autre table. Dans ce cas, l'attribut non renseigné est noté NULL. mysql> SELECT COL_NOM, LIV_TITRE, LIV_SS_TITRE FROM collection -> LEFT JOIN livre -> ON collection.COL_NUM = livre.COL_NUM; +---------------------------------+------------------------+-------------------------+ | COL_NOM | LIV_TITRE | LIV_SS_TITRE | +---------------------------------+------------------------+-------------------------+ | Ailleurs et Demain | Dune | | | Ailleurs et Demain | Dune | Le Messie de Dune | | Ailleurs et Demain | Dune | L'empereur Dieu de Dune | | Ailleurs et Demain | Dune | Les hérétiques de Dune | | Ailleurs et Demain | Dune | Les enfants de Dune | | Ailleurs et Demain | Dune, la génése | La Guerre des machines | | Ailleurs et Demain | Dune, la génése | Le Jihad Butl~rien | | Ailleurs et Demain | Dune, la génése | La Bataille de Corrin | | Ailleurs et Demain Classiques | L'Effet Lazare | | | Ailleurs et Demain Classiques | L'Homme de deux mondes | | | Antologie de la Science Fiction | NULL | NULL | | Special Suspens | NULL | NULL | +---------------------------------+------------------------+-------------------------+ 12 rows in set (0.00 sec) mysql> SELECT * FROM auteur; +---------+------------+------------+--------------------+ | AUT_NUM | AUT_NOM | AUT_PRENOM | AUT_DATE_NAISSANCE | +---------+------------+------------+--------------------+ | 1 | HERBERT | Brian | 1944-10-12 | | 2 | ANDERSON | Kevin | 1962-03-27 | | 3 | HERBERT | Frank | 1920-10-08 | | 4 | Stephenson | Neil | 1957-09-05 | +---------+------------+------------+--------------------+ 4 rows in set (0.00 sec) mysql> select AUT_NOM, AUT_PRENOM, LIV_TITRE ,LIV_SS_TITRE FROM livre -> RIGHT JOIN ecrit -> ON ecrit.ECR_NUM_LIVRE=livre.LIV_NUM -> RIGHT JOIN auteur -> ON ecrit.ECR_NUM_AUTEUR = auteur.AUT_NUM ; +------------+------------+------------------------+------------------------+ | AUT_NOM | AUT_PRENOM | LIV_TITRE | LIV_SS_TITRE | +------------+------------+------------------------+------------------------+ | HERBERT | Brian | Dune, la génése | La Guerre des machines | | HERBERT | Brian | Dune, la génése | Le Jihad Butlérien | | HERBERT | Brian | L'Homme de deux mondes | | | ANDERSON | Kevin | NULL | NULL | | HERBERT | Frank | L'Effet Lazare | | | HERBERT | Frank | L'Homme de deux mondes | | | Stephenson | Neil | NULL | NULL | +------------+------------+------------------------+------------------------+ 7 rows in set (0.00 sec) Pour des raisons de lisibilité des requêtes, il est préférable de n'utiliser que la syntaxe LEFT. Cette jointure est appelée jointure externe. Les jointures externes sont également utilisées pour permettre de détecter les lignes d'une table n'ayant pas de correspondance dans une autre : mysql> SELECT AUT_NOM, AUT_PRENOM FROM auteur -> LEFT JOIN ecrit -> ON ecrit.ECR_NUM_AUTEUR = auteur.AUT_NUM -> WHERE ecrit.ECR_NUM_LIVRE IS NULL; +------------+------------+ | AUT_NOM | AUT_PRENOM | +------------+------------+ | ANDERSON | Kevin | | Stephenson | Neil | +------------+------------+ 2 rows in set (0.00 sec) On utilise alors le fait qu'une colonne n'ayant pas de correspondance est affichée à NULL. Les sous-requêtes sont supportées depuis la version 4.1 de MySQL. Elles sont souvent nécessaires pour l'extraction de certaines informations depuis la base de données, mais ne devraient pas être systématiquement employées en lieu et place des jointures. Une sous-requête est une commande SELECT imbriquée dans une autre commande, une vue anonyme est une sous-requête placée dans une clause FROM. Un des emplois classiques des sous-requêtes est d'obtenir une valeur placée dans une clause de sélection ou de restrictions d'une requête SELECT. Ainsi rechercher l'auteur le plus jeune de la base reviendrait à : mysql> SELECT AUT_NOM, AUT_PRENOM FROM auteur -> WHERE TO_DAYS(AUT_DATE_NAISSANCE) = -> (SELECT MAX(TO_DAYS(AUT_DATE_NAISSANCE)) -> FROM auteur as TABLE_TMP); +----------+------------+ | AUT_NOM | AUT_PRENOM | +----------+------------+ | ANDERSON | Kevin | +----------+------------+ 1 row in set (0.00 sec) La sous requête est effectuée en premier, renvoyant une seule valeur, qui est intégré à la requête principale avant son exécution. ------------ TO DO : IN --------------- Dans le cas où la sous-requête renvoie plusieurs lignes, il est possible de tester la valeur d'un attribut de la requête (dans les filtres WHERE et HAVING) en employant les mots clef : ALL : la condition sera vérifié si la comparaison entre l'attribut et le résultat de la sous requête est vérifiée pour toutes les lignes de la sous-requête ANY : la condition sera vérifié si la comparaison entre l'attribut et le résultat de la sous requête est vérifiée pour au moins une ligne de la sous-requête mysql> SELECT AUT_NOM, AUT_PRENOM FROM auteur -> WHERE YEAR(AUT_DATE_NAISSANCE) >= ALL -> (SELECT AUT_DATE_NAISSANCE FROM auteur as TABLE_TMP); +----------+------------+ | AUT_NOM | AUT_PRENOM | +----------+------------+ | ANDERSON | Kevin | +----------+------------+ 1 row in set (0.00 sec) Les vues anonymes permettent de faire des sélections dans des tables temporaires qui sont utilisées dans la clause FROM. Ces tables doivent être nommées, MySQL devant les stocker en mémoire afin d'exécuter la requête principal. Ainsi, touver l'auteur dont on a le plus de livres peut se faire par la requête : mysql> SELECT AUT_NOM, AUT_PRENOM, COUNT(ECR_NUM_LIVRE) AS NB_LIVRES -> FROM auteur, ecrit -> WHERE auteur.AUT_NUM=ecrit.ECR_NUM_AUTEUR -> GROUP BY AUT_NOM, AUT_PRENOM -> HAVING NB_LIVRES = -> (SELECT MAX(NB) FROM ( -> SELECT COUNT(ECR_NUM_LIVRE) AS NB, ECR_NUM_AUTEUR -> FROM ecrit -> GROUP BY ECR_NUM_AUTEUR -> ) AS TABLE_TMP -> ); +---------+------------+-----------+ | AUT_NOM | AUT_PRENOM | NB_LIVRES | +---------+------------+-----------+ | HERBERT | Brian | 4 | +---------+------------+-----------+ 1 row in set (0.00 sec) Vous devez concevoir les requêtes permettant d'obtenir les informations suivantes (vous êtes libres d'afficher les colonnes de votre choix, tant que l'énoncé est respecté) : La liste des chambres de l'hôtel La liste des chambres de l'hôtel ne possédant pas de bains La liste des chambres de l'hôtel ne possédant pas de bain, et n'étant pas au RDC La liste des chambres de l'hôtel proposant au moins 4 places de couchage Le nombre de chambre par étage Le nombre de chambre proposant au moins 4 places de couchage par étage Le nombre de clientes enregistrées La liste des mails sur le domaine Wanadoo Modifier les adresses de manière à ajouter l'arondissement quand elles sont situées à Paris. Par exemple 75116 PARIS deviendra 75116 PARIS 16. La liste des clients "professionnels" La moyenne du prix d'une nuit sur tous les tarifs enregistrés Le chiffre d'affaire maximum si l'hôtel avait été loué au complet tous les jours de l'année 2006 La liste des clients avec leur titre en toute lettre La liste des factures associées aux clients avec leur titre en toute lettre La liste des factures associées aux clients avec leur titre en toute lettre La liste des emails en base avec les clients qui leur correspondent La liste de tous les clients avec éventuellement leurs mails La liste des clients dont on n'a pas de mails Le nombre moyen de chambres par étage La liste de toutes les factures et de leur montant total Les détails de la facture la plus chère Vous devez concevoir les requêtes permettant d'obtenir les informations suivantes (vous êtes libres d'afficher les colonnes de votre choix, tant que l'énoncé est respecté) : Liste des films et de leurs acteurs Liste des films par genre Liste de tous les films commençant par "S", de leur genre, de leur type de support et de leurs acteurs Liste des films disponibles dans au moins deux types de support Somme des durées des films par genre Genre contenant le maximum de films Liste des acteurs et des réalisateurs Durée moyenne d'un film de la vidéothèque Titre de film ayant le plus grand nombre de caractères Liste des films actuellement absents de la vidéothèque 1 Suehring Steve Thomson Laura Wiley Publishing 2 Jay Greenspan and Brad Bulger Greenspan Jay Bulger Brad M&T Books 3 4 MySQL AB