[[{"login":"devoir"}],[{"quiz":1369}]]
- Détails
- Écrit par : Richard GAUTHIER
- Clics : 893
[[{"visu":false,"text":"Afin de vérifier vos acquis, répondez aux questions suivantes."}],[{"text":"
"},{"radio":[{"label":"","sol":true},{"label":"Entre 3 et 6","sol":false},{"label":"Plus de 6
","sol":false}]}],[{"text":""},{"radio":[{"label":"","sol":false},{"label":"Dans les options du thème","sol":true}]}],[{"text":""},{"radio":[{"label":"
"},{"radio":[{"label":"","sol":false},{"label":"","sol":true},{"label":""},{"radio":[{"label":"","sol":false},{"label":"","sol":true},{"label":"
"},{"chekbox":[{"label":"
","sol":false}]}],[{"text":"
","sol":true}]}],[{"text":"
Quel est l'intérêt de définir une charte graphique avant de se lancer dans le design d'un site ?
Attention, plusieurs réponses sont possibles.
"},{"chekbox":[{"label":"Garantir la cohérence du design
","sol":true},{"label":"Définir la structure des pages
","sol":false},{"label":"Définir l'ambiance graphique du site
","sol":true},{"label":"Définir l’expérience utilisateur
","sol":false},{"label":"Valider la direction graphique avec le client","sol":true}]}],[{"text":"Combien de polices de caractères différentes est-il recommandé de trouver sur une page ?
Entre 1 et 3
","sol":false}]}],[{"text":"
Où est-il préférable de paramétrer les tailles, couleurs et polices de caractères utilisées ?
Dans l’onglet Style des modules Elementor
Combien d'occurrences de titre de premier niveau (H1) est-il recommandé d'avoir sur une page ?
"},{"radio":[{"label":"1 seule
","sol":true},{"label":"2 à 3
"},{"label":"Plus de 3","sol":false}]}],[{"text":"Je souhaite insérer une image en arrière-plan d’une section Elementor. Comment le paramétrer ?
"},{"radio":[{"label":"Avec le module Image d'Elementor
","sol":false},{"label":"Dans les options de style de la section
","sol":true}]}],[{"text":"Toujours dans cette même section, je souhaite ajouter de la marge interne pour donner plus d’espace à mon image. Sur quel paramètre dois-je jouer ?
Le padding
","sol":true},{"label":"Le margin
","sol":false}]}],[{"text":"Toujours dans cette section, je souhaite maintenant créer un bouton faisant scroller vers la section suivante de ma page. Quelles solutions s’offrent à moi ?
"},{"radio":[{"label":"Ajouter une classe “section1” à la section et mettre “.section1” dans le champ Lien de mon bouton
","sol":false},{"label":"Ajouter un ID “section1” et mettre “#section1” dans le champ Lien de mon bouton
","sol":true}]}],[{"text":"Je souhaite maintenant ajouter mes témoignages clients dans la page Elementor. L’extension n’a pas généré de module “Témoignages” dans Elementor ; est-il tout de même possible d’insérer mes témoignages dans Elementor ?
"},{"radio":[{"label":"Oui
","sol":true},{"label":"Non
","sol":false}]}],[{"text":"Le design de mes témoignages clients ne convient pas à mon client, et il me demande de le personnaliser. Quelles solutions s’offrent à moi ?
Attention, plusieurs réponses sont possibles.
"},{"chekbox":[{"label":"Modifier le code du plugin
","sol":false},{"label":"Modifier le fichier styles.css du thème
","sol":false},{"label":"Modifier le fichier styles.css du thème enfant
","sol":true},{"label":"Ajouter des règles CSS dans Apparence >> Personnaliser >> CSS personnalisé
","sol":true}]}],[{"text":"Mon client Le Caviste Bordelais souhaite une section présentant un carrousel de témoignages clients facilement administrable. J’ai trouvé une extension qui répond à ce besoin. Où chercher les paramètres de cette extension une fois celle-ci installée ?
"},{"radio":[{"label":"Dans le customizer
","sol":false},{"label":"Dans une rubrique dédiée du dashboard WordPress
","sol":true},{"label":"Dans la rubrique Extensions du dashboard WordPress","sol":false}]}],[{"text":"Qu'est-ce que la page d'accueil d'un site WordPress affiche par défaut ?
Le contenu de la page nommée \"Accueil\"
Les derniers articles publiés
Aucune de ces réponses
","sol":false}]}],[{"text":"Vous travaillez pour un client qui vous a demandé de créer son site web intitulé Le Caviste Bordelais. Sur quelle URL vous rendez-vous pour vous connecter au dashboard WordPress ?
"},{"radio":[{"label":"http://www.monsite.com/connection
","sol":false},{"label":"http://www.monsite.com/wp-admin
","sol":false},{"label":"http://www.monsite.com/wp-login.php
","sol":true}]}],[{"text":"Quelle différence entre une page et un article est vraie ?
"},{"radio":[{"label":"Les pages sont plus importantes que les articles.
","sol":false},{"label":"Les articles disparaissent après un certain temps, contrairement aux pages.
"},{"label":"La date de publication d'un article est importante, contrairement à celle d'une page.
","sol":true}]}],[{"text":"Quelle est la différence entre une catégorie et un tag ?
"},{"radio":[{"label":"Les catégories apparaissent dans le menu, pas les tags.
","sol":false},{"label":"On ne peut attribuer qu'une seule catégorie par article, alors que l'on peut attribuer plusieurs tags.
","sol":false},{"label":"Les catégories ont une hiérarchie (catégorie, sous-catégorie...), à la différence des tags.
","sol":true},{"label":"Les catégories permettent d'organiser les articles, pas les tags.
","sol":false}]}],[{"text":"Je viens de créer une nouvelle page pour Le Caviste Bordelais. J’aimerais à présent la définir comme page d’accueil. Où dois-je me rendre pour effectuer cette configuration ?
Réglages >> Général
Réglages >> Lecture
Réglages >> Écriture
","sol":false}]}],[{"text":"J’ai créé plusieurs pages pour le site Le Caviste Bordelais et souhaite maintenant construire un menu pour en faciliter l’accès. Où dois-je me rendre pour faire cela ?
Attention, plusieurs réponses sont possibles.
Réglages >> Menus
","sol":false},{"label":"Apparence >> Menus
","sol":true},{"label":"Apparence >> Personnaliser >> Menus
","sol":true},{"label":"Articles >> Catégories
","sol":false}]}],[{"text":"Pourquoi est-il si important de bien définir le titre du site dans \"Réglages >> Général\" ?
Attention, plusieurs réponses sont possibles.
"},{"chekbox":[{"label":"C'est le titre qui va apparaître sur la page d'accueil.
","sol":false},{"label":"C'est le titre qui va apparaître dans les résultats de recherche Google.
","sol":true},{"label":"C'est un paramètre important pour le référencement naturel du site.
","sol":true},{"label":"Cela permet de savoir de quel site il s'agit.
","sol":false}]}],[{"text":"Les paramètres de personnalisation proposés dans le customizer (\"Apparence >> Personnaliser\") dépendent principalement :
"},{"radio":[{"label":"du thème utilisé
","sol":true},{"label":"des plugins (extensions) utilisés
","sol":false},{"label":"des contenus créés sur le site
","sol":false}]}],[{"text":"À quoi sert l'onglet \"Options d'écran\" dans le dashboard WordPress ?
Attention, plusieurs réponses sont possibles.
"},{"chekbox":[{"label":"À personnaliser l'apparence du dashboard WordPress.
","sol":false},{"label":"À choisir quels champs faire apparaître dans les pages du dashboard WordPress.
","sol":true},{"label":"À définir des paramètres comme le nombre de contenus listés dans les pages d'administration.","sol":true}]}],[{"text":"Le Caviste Bordelais vient de valider mon devis pour la création de son nouveau site web. Sur quoi vais-je commencer à travailler ?
Attention, plusieurs réponses sont possibles.
"},{"chekbox":[{"label":"Le design des pages
","sol":false},{"label":"Le choix du thème et des plugins
","sol":false},{"label":"La définition des objectifs du site
","sol":true},{"label":"La définition de la stratégie SEO et des mots-clés cibles
","sol":true}]}],[{"text":"À quoi sert un wireframe ?
"},{"radio":[{"label":"À définir l'arborescence des pages du site.
","sol":false},{"label":"À définir le design d'une page.
","sol":false},{"label":"À définir la structure d'une page.
","sol":true}]}],[{"text":"Quelle est la principale fonction du thème ?
"},{"radio":[{"label":"Ajouter des fonctionnalités au site.
","sol":false},{"label":"Définir l'apparence du site.
","sol":true},{"label":"Personnaliser le contenu des pages.","sol":false}]}],[{"text":"
Quels avantages apporte un page builder ?
Attention, plusieurs réponses sont possibles.
"},{"chekbox":[{"label":"La création de pages aux structures complexes est simplifiée.
","sol":true},{"label":"De nombreux composants clés en main peuvent facilement être ajoutés au contenu des pages.
","sol":true},{"label":"Le référencement naturel est amélioré.
","sol":false},{"label":"Le site charge plus rapidement.","sol":false}]}],[{"text":"Quels sont les principaux critères de choix d'un thème WordPress ?
Attention, plusieurs réponses sont possibles.
"},{"chekbox":[{"label":"Un prix économique
","sol":false},{"label":"Une dernière mise à jour récente
","sol":true},{"label":"Un page builder intégré
","sol":false},{"label":"De bonnes notes et commentaires utilisateurs
","sol":true},{"label":"La prise en charge des plugins importants (e-commerce, LMS...) que l'on prévoit d'utiliser
","sol":true},{"label":"Un grand nombre d’options et de fonctionnalités","sol":false}]}],[{"text":"Cochez la ou les propositions exactes ci-dessous :
Attention, plusieurs réponses sont possibles.
"},{"chekbox":[{"label":"Un addon est un bout de code à ajouter à un thème
","sol":false},{"label":"Un addon est une extension obligatoire pour compléter un thème
","sol":false},{"label":"Un addon est une extension payante
","sol":false},{"label":"Un addon est une extension permettant d’ajouter des fonctionnalités à un thème
","sol":true},{"label":"Un addon est une extension permettant d’ajouter des fonctionnalités à une autre extension
","sol":true}]}],[{"text":"Les thèmes payants sont de meilleure qualité que les thèmes gratuits.
"},{"radio":[{"label":"Vrai
","sol":false},{"label":"Faux","sol":true}]}],[{"text":"
Quelles sont les parties du site dont l'apparence va être définie quasi exclusivement par le thème ?
Attention, plusieurs réponses sont possibles.
"},{"chekbox":[{"label":"Le header (en-tête)
","sol":false},{"label":"La zone de contenu
","sol":false},{"label":"Le footer (pied de page)
","sol":true},{"label":"La sidebar
","sol":true}]}],[{"text":"Combien d'extensions est-il recommandé d'installer sur son site ?
"},{"radio":[{"label":"1 à 3
","sol":false},{"label":"4 à 8
","sol":false},{"label":"8 à 10
","sol":false},{"label":"Il faut éviter d'installer trop d'extensions
","sol":true}]}],[{"text":"Quelle est la signification de l'acronyme RSS?"},{"radio":[{"label":"Really Simple Syndication
","sol":true},{"label":"Ready Simple Sun","sol":false},{"label":"Racing Sigle Speed
","sol":false},{"label":"Racing Single Sport","sol":false}]}],[{"text":"Quelles sont les manières de faire de la veille technologique?"},{"chekbox":[{"label":"Le flux RSS","sol":true},{"label":"Google Alerte
","sol":true},{"label":"newsletter
","sol":true},{"label":"le magasine Voici","sol":false},{"label":"Blogs Spécialisés","sol":true},{"label":"Scraping","sol":true},{"label":"Des magasines spécialisés","sol":true}]}]]
- Détails
- Écrit par : Richard GAUTHIER
- Clics : 1758
[[{"title":"SQL : Requêtes SQL et mises à jour","posi":0},{"text":"
"},{"text":""}],[{"text":"
","title":"Sélection de données"},{"edit":"
"}],[{"text":"
"}],[{"text":"
","title":"Clause WHERE"},{"edit":"
"}],[{"text":"
","title":" Clause SELECT"},{"edit":"
"}],[{"text":"
","title":"Tri et suppression des doublons"},{"edit":"
"}],[{"text":"
","title":"Jointure"},{"edit":"
"}],[{"text":"
","title":"Nouvelle » syntaxe SQL pour les jointures"},{"edit":"
"}],[{"text":"
","title":"Modification des données"},{"edit":"
"}],[{"text":"
","title":"Suppression de lignes"},{"edit":"
"}],[{"text":"
"}],[{"text":"
","title":"Copie de table"},{"edit":"
"}],[{"text":"
","title":"Requêtes imbriquées"},{"edit":"
"}],[{"text":"
","title":"Requêtes de groupe"},{"edit":"
"}],[{"text":"
"},{"solution":""}],[{"text":"
","title":"Exercice"},{"edit":"
"},{"solution":""},{"solution":"
"},{"solution":"
"},{"solution":"
"},{"solution":"
"},{"solution":"
"},{"solution":"
"},{"solution":"
"}],[{"text":"
","title":"Exercice"},{"edit":"
"},{"solution":"
"}],[{"text":"
","title":"Exercice"},{"edit":"
"},{"solution":"
"}],[{"text":"
"},{"solution":"1.
2.
","title":"Exercice"},{"edit":"
"},{"solution":"
Nous avons vu dans la séquence précédente comment créer des tables et les remplir.
Nous avons maintenant une base de données, c’est-à-dire un ensemble de tables, contenant des données cohérentes vis à vis de nos contraintes d’intégrité.
Nous allons maintenant voir deux autres utilisations d’un SGBD :
- la sélection de données ;
- la mise à jour des données.
La sélection va consister en l’écriture de requêtes SQL permettant de trouver toutes les données de la base vérifiant un certain critère. Le premier rôle du programmeur de bases de données va donc être celui qui consiste à traduire des questions que l’on se pose sur les données du langage naturel au langage
SQL, afin que le SGBD puisse y répondre.
Reprenons la bascs de données de la médiathèque municipale.
Quelles questions peut-on poser à la base de données? Il semble naturel que le SGBD puisse répondre aux questions suivantes, nécessaire au bon fonctionnement
de la médiathèque.
- Étant donné un code barre, quels sont les livres empruntés par l’utilisateur correspondant?
- Étant donné un ISBN. le livre correspondant est-il emprunté?
- Quels sont les utilisateurs en retard, c'est-à-dire ceux dont la date de retour est inférieure à une date donnée ?
- Quels sont tous les livres écrits par Voltaire qui ne sont pas empruntés?
- Quel est le nombre total de livres empruntés?
Une autre fonction importante du SGBD est la mise à jour des données.
Elle peut consister en une modification d’une ligne existante (par exemple, pour changer l'adresse d’un utilisateur ayant déménagé, sans modifier son
code barre, son nom où son e-mail) ou une suppression (par exemple lorsqu'un utilisateur rend un livre, il faut supprimer la ligne correspondante dans la table emprunt).
Pour les exemples plus parlants, nous utilisons dans la suite le SGBD libre PostgreSQL, avec une base de données de médiathèque fic-
tive. Les fichiers permettant de créer cette base sont disponibles librement
sur le site https://www.nsi-terminale.fr/. Ils utilisent la syntaxe SQL
standard et sont donc compatibles avec n'importe quel SGBD relationnel
respectant la norme SQL (et ont été testés avec un certain nombre d’entre
eux, libres et propriétaires).
Commençons par une requête simple. On considère la table livre, créée par l’ordre suivant :
CREATE TABLE livre (titre VARCHAR(300) NOT NULL,
editeur VARCHAR(90) NOT NULL,
annee INT NOT NULL,
isbn CHAR(14) PRIMARY KEY);
Où les entités suivantes sont insérées :
INSERT INTO livre VALUES ('Les Aventures de Huckleberry Finn', 'Flammarion', '2020', '978-2081509511');
INSERT INTO livre VALUES ('Fondation et Empire', 'Editions Denoël', '1999', '978-2207249123');
INSERT INTO livre VALUES ('Akira', 'Glénat', '2000', '978-2723428262');
INSERT INTO livre VALUES ('Les Robots', 'Editions Milan', '2017', '978-2745989857');
INSERT INTO livre VALUES ('Astérix chez les Pictes', 'Editions Albert René', '2013', '978-2864972662');
INSERT INTO livre VALUES ('Les Monades urbaines', 'Robert Laffont', '2016', '978-2221197691');
INSERT INTO livre VALUES ('Les Voyages de Gulliver', 'Primento', '2015', '978-2335008586');
INSERT INTO livre VALUES ('Lolita', 'Penguin UK', '2012', '978-0141391601');
INSERT INTO livre VALUES ('La Nuit des temps', 'Presses de la Cité', '2014', '978-2258116429');
INSERT INTO livre VALUES ('Ravage', 'Editions Gallimard', '2014', '978-2072534911');
INSERT INTO livre VALUES ('Les Lauriers de César', 'Educa Books', '2008', '978-2012101500');
INSERT INTO livre VALUES ('Niourk', 'French Pulp éditions', '2018', '979-1025100639');
INSERT INTO livre VALUES ('Le Meilleur des mondes', 'Plon', '2013', '978-2259221702');
INSERT INTO livre VALUES ('Berlin Alexanderplatz', 'Editions Gallimard', '1933', '978-2070219292');
INSERT INTO livre VALUES ('Fahrenheit 451', 'Simon and Schuster', '2011', '978-1439142677');
INSERT INTO livre VALUES ('La Mort d''Ivan Ilitch', 'Flammarion', '2015', '978-2081364509');
INSERT INTO livre VALUES ('Croisière sans escale', 'Editions Denoël', '1990', '978-2207500293');
INSERT INTO livre VALUES ('Le Vieil Homme et la Mer', 'Editions Gallimard', '2018', '978-2072762093');
INSERT INTO livre VALUES ('Mrs Dalloway', 'Flammarion', '2015', '978-2081358881');
INSERT INTO livre VALUES ('L''Idiot', 'Les Editions de Londres', '2019', '978-1911572909');
INSERT INTO livre VALUES ('Le Carnet d''or', 'Le Livre de poche', '1980', '978-2253025320');
INSERT INTO livre VALUES ('Les Grandes Espérances', 'BoD - Books on Demand', '2019', '978-2322185801');
INSERT INTO livre VALUES ('Astérix et Cléopâtre', 'Dargaud', '1999', '978-2012100060');
INSERT INTO livre VALUES ('Madame Bovary', 'UPblisher', '2016', '978-2759902293');
INSERT INTO livre VALUES ('Les Frères Karamazov', 'Les éditions Pulsio', '2016', '978-2371131118');
INSERT INTO livre VALUES ('Moby Dick', 'Campfire Graphic Novels', '2010', '978-8190732673');
INSERT INTO livre VALUES ('Demain les chiens', 'J''ai Lu', '2015', '978-2290112168');
INSERT INTO livre VALUES ('Le Tour de Gaule d''Astérix', 'Educa Books', '2007', '978-2012101685');
INSERT INTO livre VALUES ('1984', 'Houghton Mifflin Harcourt', '1983', '978-0547249643');
INSERT INTO livre VALUES ('Don Quichotte', 'Les éditions Pulsio', '2016', '978-2371130418');
INSERT INTO livre VALUES ('Le Château de Lord Valentin', 'Robert Laffont', '2017', '978-2221216361');
INSERT INTO livre VALUES ('Le Père Goriot', 'Primento', '2012', '978-2806231697');
INSERT INTO livre VALUES ('Le Procès', 'Flammarion', '2014', '978-2081351981');
INSERT INTO livre VALUES ('L''Homme qui rétrécit', 'Editions Gallimard', '2017', '978-2072457340');
INSERT INTO livre VALUES ('Chroniques martiennes', 'Editions Gallimard', '2016', '978-2072455162');
INSERT INTO livre VALUES ('Le Roi Lear', 'Éditions Actes Sud', '2015', '978-2330052768');
INSERT INTO livre VALUES ('Le Cadeau de César', 'Educa Books', '2005', '978-2012101531');
INSERT INTO livre VALUES ('La Planète des singes', 'Julliard', '2011', '978-2260019183');
INSERT INTO livre VALUES ('Orgueil et Préjugés', 'Fleurus', '2015', '978-2215130475');
INSERT INTO livre VALUES ('Une maison de poupée', 'Éditions Actes Sud', '2016', '978-2330068349');
INSERT INTO livre VALUES ('Vermilion Sands', 'Carroll & Graf Pub', '1988', '978-0881844221');
INSERT INTO livre VALUES ('La Grande Traversée', 'Seuil Jeunesse', '2014', '979-1023500448');
INSERT INTO livre VALUES ('L''Étranger', 'Editions Gallimard', '2012', '978-2072376429');
INSERT INTO livre VALUES ('L''Île des morts', 'POL Editeur', '2010', '978-2846825573');
INSERT INTO livre VALUES ('Par-delà le mur du sommeil', 'République des Lettres', '2018', '978-2824904269');
INSERT INTO livre VALUES ('Le Papyrus de César', 'Editions Albert René', '2015', '978-2864972716');
INSERT INTO livre VALUES ('La Main de Zeï', 'Bragelonne Classic', '2016', '978-2820511034');
INSERT INTO livre VALUES ('Beloved', 'Christian Bourgois', '2015', '978-2267028133');
INSERT INTO livre VALUES ('La Conscience de Zeno', 'République des Lettres', '2015', '978-2824902371');
INSERT INTO livre VALUES ('Delirium Circus', 'Bragelonne', '2013', '978-2820508935');
INSERT INTO livre VALUES ('Médée', 'Hatier', '2013', '978-2218972324');
INSERT INTO livre VALUES ('Nostromo', 'Oxford University Press', '2009', '978-0199555918');
INSERT INTO livre VALUES ('Au carrefour des étoiles', 'J''ai Lu', '1997', '978-2277118473');
INSERT INTO livre VALUES ('Le Vagabond', 'BnF collection ebooks', '2016', '978-2346014453');
INSERT INTO livre VALUES ('Les Buddenbrook', 'LGF/Le Livre de Poche', '1993', '978-2253063193');
INSERT INTO livre VALUES ('Les Métamorphoses', 'Le Livre de Poche', '2011', '978-2253158677');
INSERT INTO livre VALUES ('Jack Barron et l''Éternité', 'J''ai Lu', '2016', '978-2290105504');
INSERT INTO livre VALUES ('Hacker''s Delight', 'Addison-Wesley Professional', '2003', '978-0201914658');
INSERT INTO livre VALUES ('Astérix et les Normands', 'Dargaud', '2005', '978-2012101418');
INSERT INTO livre VALUES ('Le Temps incertain', 'Robert Laffont', '2011', '978-2221119709');
INSERT INTO livre VALUES ('Astérix en Corse', 'Dargaud', '2005', '978-2012101524');
INSERT INTO livre VALUES ('Les Fils de la Médina', 'Arles [France] : Actes sud', '2003', '978-2742744824');
INSERT INTO livre VALUES ('Le Grand secret', 'Presses de la Cité', '2014', '978-2258116405');
INSERT INTO livre VALUES ('Le Devin', 'Educa Books', '2010', '978-2012101517');
INSERT INTO livre VALUES ('Le Noir Dessein', 'Livre de poche', '1998', '978-2253062820');
INSERT INTO livre VALUES ('Astérix légionnaire', 'Educa Books', '2011', '978-2012101784');
INSERT INTO livre VALUES ('Romancero gitano', 'Greenbooks editore', '2020', '978-8832957402');
INSERT INTO livre VALUES ('The Practice of Programming', 'Addison-Wesley Professional', '1999', '978-0201615869');
INSERT INTO livre VALUES ('Crime et Châtiment', 'Editions Humanis', '2012', '979-1021900486');
INSERT INTO livre VALUES ('La Promenade au phare', 'LGF/Le Livre de Poche', '1983', '978-2253031536');
INSERT INTO livre VALUES ('L''Homme sans qualités', 'Contemporary French Fiction', '2011', '978-2757803691');
INSERT INTO livre VALUES ('Le Bruit et la Fureur', 'Gallimard Education', '1972', '978-2070361625');
INSERT INTO livre VALUES ('Les Plus qu''humains', 'adsaa', '1999', '000-0000000162');
INSERT INTO livre VALUES ('La Main gauche de la nuit', 'Robert Laffont', '2012', '978-2221128121');
INSERT INTO livre VALUES ('Mémoires d''Hadrien', 'Gallimard Education', '1974', '978-2070369218');
INSERT INTO livre VALUES ('Contes de l''absurde', 'Presses Pocket', '1978', '978-2266006095');
INSERT INTO livre VALUES ('Astérix et la Transitalique', 'Editions Albert René', '2017', '978-2864973270');
INSERT INTO livre VALUES ('L''Odyssée d''Astérix', 'Educa Books', '2008', '978-2864972051');
INSERT INTO livre VALUES ('Les Singes du temps', 'Robert Laffont', '2011', '978-2221119693');
INSERT INTO livre VALUES ('Les Contes de Canterbury', 'Gallimard Education', '2000', '978-2070406340');
INSERT INTO livre VALUES ('Sécheresse', 'La Cheminante', '2014', '978-2371270060');
INSERT INTO livre VALUES ('The Art of Computer Programming', 'Addison-Wesley Professional', '1997', '978-0321635747');
INSERT INTO livre VALUES ('L''Aveuglement', 'Contemporary French Fiction', '2000', '978-2020403436');
INSERT INTO livre VALUES ('Le Berceau du chat', 'Contemporary French Fiction', '2010', '978-2757820919');
INSERT INTO livre VALUES ('Anna Karénine', 'Bibliothèque russe et slave', '2018', '978-2371240087');
INSERT INTO livre VALUES ('La Montagne magique', 'Fayard', '2016', '978-2213703848');
INSERT INTO livre VALUES ('Le Domaine des dieux', 'French & European Publications', '1992', '978-0785909903');
INSERT INTO livre VALUES ('Cent ans de solitude', 'Contemporary French Fiction', '1995', '978-2020238113');
INSERT INTO livre VALUES ('Gargantua et Pantagruel', 'Livre de Poche Jeunesse', '2009', '978-2013230827');
INSERT INTO livre VALUES ('Contes', 'J''ai Lu', '2015', '978-2290117965');
INSERT INTO livre VALUES ('Guerre et Paix', 'Archipoche', '2016', '978-2352879183');
INSERT INTO livre VALUES ('Énéide', 'Belles Lettres', '1993', '978-2251013039');
INSERT INTO livre VALUES ('Seconde Fondation', 'adsaa', '1979', '000-0000000097');
INSERT INTO livre VALUES ('Les Jeux de l''esprit', 'FeniXX', '1971', '978-2402281775');
INSERT INTO livre VALUES ('Middlemarch', 'Wordsworth Editions', '1994', '978-1853262371');
INSERT INTO livre VALUES ('Œdipe roi', 'J''ai Lu', '2013', '978-2290080207');
INSERT INTO livre VALUES ('L''Amour aux temps du choléra', 'Grasset', '2009', '978-2246819554');
INSERT INTO livre VALUES ('Fictions', 'Gallimard Education', '1974', '978-2070366149');
INSERT INTO livre VALUES ('Astérix chez les Bretons', 'Dargaud', '2002', '978-2012100084');
INSERT INTO livre VALUES ('Le Château', 'Points', '2011', '978-2757827413');
INSERT INTO livre VALUES ('Le Voyageur imprudent', 'Editions Gallimard', '2014', '978-2072535031');
INSERT INTO livre VALUES ('Je suis une légende', 'Editions Gallimard', '2013', '978-2072457388');
INSERT INTO livre VALUES ('Le Maître du Haut Château', 'J''ai Lu', '2017', '978-2290157268');
INSERT INTO livre VALUES ('Les Âmes mortes', 'Bibliothèque russe et slave', '2018', '978-2371240001');
INSERT INTO livre VALUES ('Le Tambour', 'Contemporary French Fiction', '1997', '978-2020314305');
INSERT INTO livre VALUES ('Polymath', 'iMinds Pty Ltd', '2014', '978-1921746864');
INSERT INTO livre VALUES ('Seigneur de lumière', 'Editions Gallimard', '2014', '978-2072487958');
INSERT INTO livre VALUES ('Ulysse', 'Nathan', '2012', '978-2092532195');
INSERT INTO livre VALUES ('Pedro Páramo', 'New York : Grove Press', '1959', '000-0000000069');
INSERT INTO livre VALUES ('Ubik', 'Houghton Mifflin Harcourt', '2012', '978-0547728247');
INSERT INTO livre VALUES ('Algorithms', 'Addison-Wesley Professional', '2011', '978-0132762564');
INSERT INTO livre VALUES ('Fifi Brindacier', 'Hachette Romans', '2013', '978-2011179043');
INSERT INTO livre VALUES ('Le monde s''effondre', 'Editions Présence Africaine', '1972', '978-2708701915');
INSERT INTO livre VALUES ('La Naissance des dieux', 'Glénat BD', '2017', '978-2331035531');
INSERT INTO livre VALUES ('Hamlet', 'Primento', '2012', '978-2806240187');
INSERT INTO livre VALUES ('Les Enfants de minuit', 'Gallimard Education', '2010', '978-2070402632');
INSERT INTO livre VALUES ('Dune', 'Penguin', '2003', '978-1101658055');
INSERT INTO livre VALUES ('La Couleur tombée du ciel', 'Tiers Livre Éditeur', '2014', '978-2814510012');
INSERT INTO livre VALUES ('L''Éducation sentimentale', 'FeniXX', '1990', '978-2402282697');
INSERT INTO livre VALUES ('Obélix et Compagnie', 'Educa Books', '2008', '978-2012101555');
INSERT INTO livre VALUES ('Le Journal d''un fou', 'Bibebook', '2013', '978-2824709420');
INSERT INTO livre VALUES ('Les Hauts de Hurlevent', 'Le Livre de Poche', '2012', '978-2253174561');
INSERT INTO livre VALUES ('La Plaie', 'FeniXX', '1967', '978-2402255462');
INSERT INTO livre VALUES ('Astérix chez les Belges', 'Dargaud', '1979', '978-2012101562');
INSERT INTO livre VALUES ('Le Rouge et le Noir', 'Les Éditions de l''Ebook malin', '1971', '978-2367881171');
INSERT INTO livre VALUES ('À la recherche du temps perdu', 'Books LLC, Wiki Series', '2010', '978-1153611725');
INSERT INTO livre VALUES ('La storia', 'Editions Gallimard', '2004', '978-2070315017');
INSERT INTO livre VALUES ('L''Homme total', 'Presses Universitaires de France - PUF', '2011', '978-2130592150');
Rentrez les expressions ci-dessus dans votre base de donnée dans l'onglet SQL de phpmyadmin.
Mettre le résultat ici de la requête sql.
Maintenant que la table livre est mise en place, on souhaite trouver les titres de tous les livres publiés après 1990 dans la base de données de la médiathèque.
Une telle requête peut s’écrire en SQL :
SELECT titre FROM livre WHERE annee >= 1990;
Sélectionner la base de donnée dans phpmyadmin et exécuter la requête SQL. Mettre le résultat ci-dessous et conclure.
Dans cette requête, la partie « FROM livre » indique la table sur laquelle porte la requête.
La partie « WHERE ... » indique que l’on ne sélectionne
que les lignes de la table Livre pour lesquelles la valeur de l’attribut annee est plus grande que 1990.
Enfin, la partie SELECT titre indique qu'on ne veut renvoyer que les valeurs de l’attribut titre des lignes trouvées. On remarque que le résultat d'une requête «SELECT ... » est une table, ici possédant une unique colonne titre.
","title":"Requête sur une table"},{"edit":"Mettre le résultat ici (code et figure).
L'expression se trouvant dans la partie WHERE doit être une expression booléenne.
Elle peut être construite à partir d'opérateurs de comparaison (<, <=, >, >=, = et <>), d'opérateurs arithmétiques (+, -, *, /, %), de constantes, de noms d’attributs, d'opérateurs logiques (AND, OR et NOT) et d'opérateurs spéciaux tels que l'opérateur de comparaison de textes LIKE.
Par exemple, si l’on souhaite afficher les titres de tous les livres publiés par Dargaud entre 1970 et 1980, on pourra écrire :
SELECT titre FROM livre WHERE annee >= 1970
AND annee <= 1980
AND editeur = 'Dargaud';
Tester la requête et mettre le résultat ci-dessous.
Si l’utilisation de l'égalité « = » est appropriée ici, on pourrait vouloir faire une requête approchée.
Par exemple, trouver les titres des livres qui contiennent le mot « Astérix » dans le titre.
Une telle requête s’écrira
SELECT titre FROM livre WHERE titre LIKE '%Astérix%';
Tester la requête et mettre le résultat ci-dessous.
La chaîne de caractères « '%Astérix%' » est un motif. L'opération s LIKE m s’évalue à vrai si et seulement si la chaîne de caractères s correspond au motif m.
Dans un motif, le symbole « % » est un joker et peut être substitué par n'importe quelle chaîne.
Le symbole «_» quant à lui représente n'importe quel caractère.
Ainsi, le motif « '%Astérix%' » correspond à n'importe quelle chaîne dans laquelle les caractères Astérix sont précédés ou suivis de caractères quelconques.
Mettre le résultat ici (code et figure).
La clause SELECT peut prendre trois formes ;
La première est celle où l’on liste explicitement les
attributs que l’on désire renvoyer. Si on veut renvoyer les titres et l’'ISBN des livres publiés après 1990, on écrira ceci :
SELECT titre, isbn FROM livre WHERE annee >= 1990;
Tester la requête dans phpmyadmin et mettre le résultat ci-dessous et conclure.
Le résultat est de nouveau une table, mais cette fois avec les colonnes (ou attributs) titre et isbn.
Il est possible de renommer les colonnes au moyen du mot clé AS.
SELECT titre AS le_titre, isbn AS nom ,serie
FROM livre
WHERE annee >= 1990;
Tester la requête dans phpmyadmin et mettre le résultat ci-dessous et conclure.
Ainsi, si la clause WHERE d’une requête permet de restreindre les lignes de la table que l’on renvoie (en ne gardant que celle vérifiant la condition), la clause SELECT permet de restreindre la liste des colonnes.
La seconde forme de la clause SELECT est celle que l’on utilise lorsqu'on veut conserver toutes les colonnes. En effet, il serait fastidieux de récrire toutes les colonnes d’une table. On peut utiliser à cette fin le symbole « * » qui signifie « toutes les colonnes de la table ».
SELECT * FROM livre WHERE annee >= 1990;
Tester la requête dans phpmyadmin et mettre le résultat ci-dessous et conclure.
La troisième utilisation de la clause SELECT est celle permettant d'appeler des fonctions d’agrégation. Ces dernières permettent d'appliquer une fonction à l’ensemble des valeurs d’une colonne et de renvoyer le résultat comme une table ayant une seule case (une ligne et une colonne).
Nous présentons quelques unes de ces fonctions :
- COUNT qui permet d'obtenir le nombre de résultats,
- AVG (pour l’anglais average) qui permet de calculer la moyenne d'une colonne,
- SUM qui permet d’en faire la somme,
- MIN et MAX qui permettent de trouver respectivement le minimum et maximum d’une colonne.
Si on souhaite savoir combien de livres contiennent la chaîne « Astérix » dans leur titre (plutôt que de renvoyer ces titres), on écrira la requête suivante :
SELECT COUNT(titre) AS total
FROM livre
WHERE titre LIKE '%Astérix%';
Tester la requête dans phpmyadmin et mettre le résultat ci-dessous et conclure.
Notons que nous avons choisi de renommer la colonne. En effet, le résultat n'étant pas directement une colonne d’une table existante, les SGBD choisissent un nom arbitraire, souvent peu parlant.
La fonction « COUNT » ne faisant que compter la taille de la colonne, elle peut s’appliquer à n'importe quel nom de colonne et même au symbole « * ». Il est donc courant d'écrire une requête de la forme
SELECT COUNT(*) AS total
FROM livre
WHERE titre LIKE '%Astérix%';
qui donnera le même résultat que précédemment.
Les fonctions AVG et SUM ne peuvent s'appliquer qu’à des colonnes dont le domaine est un nombre
On peut écrire par exemple
SELECT SUM(annee) AS somme FROM livre;
SELECT AVG(annee) AS moyenne FROM livre;
Tester les 2 requêtes dans phpmyadmin et mettre le résultat ci-dessous et conclure.
Ici, en l’absence de clause WHERE, toutes les lignes sont sélectionnées. La somme et la moyenne des années sont calculées et renvoyées comme une
table.
Enfin, les fonctions MIN() et MAX() peuvent s'appliquer sur n'importe quelle colonne et ls comparaison pour son type sera utilisée pour déterminer le plus petit ou le plus grand élément.
SELECT MIN(annee) AS inf FROM livre;
SELECT MAX(annee}) AS sup FROM livre;
Tester les 2 requêtes dans phpmyadmin et mettre le résultat ci-dessous et conclure.
Mettre le résultat ici.
Comme nous avons pu l'observer lors de nos premières requêtes, les résultats sont affichés par le SGBD dans un ordre a priori quelconque. La situation est même plus complexe. En effet, en fonction de certains paramètres, le SGBD peut choisir entre différentes
façons de calculer la requête.
L'ordre peut donc être modifié entre deux exécutions de la même requête. Si l’on désire obtenir les résultats dans un ordre particulier, on peut utiliser la clause ORDER BY en fin de requête.
SELECT titre FROM livre
WHERE annee >= 1990
ORDER BY titre ASC;
Tester la requête dans phpmyadmin et mettre le résultat ci-dessous et conclure.
Ici, on demande au SGBD de trier les résultats par titre croissants (ASC pour l’anglais ascending).
Si on souhaite trier par valeurs décroissantes il suffit d'utiliser le mot clé DESC (pour l'anglais descending) à la place de ASC.
Supposons maintenant que l’on souhaite connaître toutes les années dans lesquelles un livre à été publié.
Nous envoyons la requête suivante :
SELECT annee FROM livre;
Tester la requête dans phpmyadmin et mettre le résultat ci-dessous et conclure.
Vous constatez que toutes les années, mais la même année peut apparaître plusieurs fois. Si on souhaite retirer les doublons d’un résultat, le mot clé DISTINCT
peut être ajouté à la clause SELECT.
SELECT DISTINCT annee FROM livre;
Tester la requête dans phpmyadmin et mettre le résultat ci-dessous et conclure.
Attention cependant, chaque ligne entière de résultat est considérée lors de la comparaison.
SELECT DISTINCT annee, isbn FROM livre;
Tester la requête dans phpmyadmin et mettre le résultat ci-dessous et conclure.
C’est pourquoi, la requête ci-dessus continuera d'afficher plusieurs fois la même année. En effet, comme l’isbn est unique pour chaque ligne, tous les couples annee, isbn de la table sont différents deux à deux (ils diffèrent par leur isbn même s'ils ont la même
année). Le mot clé DISTINCT n'aura donc ici aucun effet.
Mettre le résultat ici (code et figure).
Les requêtes que nous avons vues nous permettent assez facilement de déterminer les livres qui ont été empruntés. Ces derniers sont simplement ceux dont l'ISBN est présent dans la table emprunt.
SELECT * FROM emprunt;
Tester la requête dans phpmyadmin et mettre le résultat ci-dessous et conclure.
Cette réponse n’est cependant pas très satisfaisante. En effet, il serait plus naturel de pouvoir afficher les titres de ces livres plutôt que leur ISBN. Le problème est que les titres des livres sont présents uniquement dans la table livre.
L'opération de jointure de deux tables apporte une réponse à ce problème. Elle a déjà été étudiée en première dans le cadre du traitement de données en tables.
Étant données deux tables A et B, la jointure consiste à créer toutes combinaisons de lignes de A et de B
ayant un attribut de même valeur. Ici, on souhaiterait obtenir une « grande table » dont les colonnes sont celles de la table emprunt et celle de la table livre, en réunissant les lignes ayant ie même isbn.
Cela peut être fait au moyen de la directive JOIN.
SELECT * FROM emprunt
JOIN livre ON emprunt.isbn = livre.isbn;
Tester la requête dans phpmyadmin et mettre le résultat ci-dessous et conclure.
Cette requête crée la jointure des deux tables.
Comme on peut le voir, toutes les colonnes des deux tables ont été recopiées dans la sortie.
Chaque ligne est le résultat de la fusion de deux lignes ayant le même ISBN. Le choix de ces lignes est donné
par la condition de jointure indiquée par le mot clé ON.
La condition indique au SGBD dans quel cas deux lignes doivent être fusionnées.
Ici, on joint les lignes pour lesquelles les ISBN sont égaux.
On écri donc l'expression booléenne
« emprunt.isbn = livre.isbn ».
La notation portant le même nom.
La jointure peut être combinée avec les clauses SELECT et WHERE.
Par exemple, si on souhaite afficher uniquement les titres et les dates des livres empruntés qui sont à rendre avant le 1er février 2020, on peut écrire la requête suivante :
SELECT livre.titre, emprunt.retour
FROM emprunt
JOIN livre ON emprunt.isbn = livre.isbn
WHERE emprunt retour < '2020-02-01';
Tester la requête dans phpmyadmin et mettre le résultat ci-dessous et conclure.
Même s’il n’y a pas d’ambiguïté ici, une bonne pratique consiste à préfixer les noms d’attributs par leur table dès que l’on utilise plus d’une table dans la requête. On n’est évidemment pas limité à une seule jointure.
Si on souhaite afficher les noms et prénoms des utilisateurs ayant emprunté ces livres, il suffit de joindre la table usager, en rajoutant une nouvelle clause JOIN ON, cette fois sur le code_barre de l'usager.
SELECT usager.nom, usager.prenom, livre.titre, emprunt.retour
FROM emprunt
JOIN livre ON emprunt.isbn = livre.isbn
JOIN usager ON usager.code_barre = emprunt.code_barre
WHERE emprunt.retour <'2020-02-01';
Tester la requête dans phpmyadmin et mettre le résultat ci-dessous et conclure.
La requête ci-dessus fonctionne parfaitement mais est un peu fastidieuse à écrire. Il est possible de créer dans une requête un alias pour un nom de table au moyen du mot clé AS, comme pour le renommage de colonne.
La requête peut donc être réécrite de la manière suivante :
SELECT u.nom, u.prenom, l.titre, e.retour
FROM emprunt AS e
JOIN livre AS l ON e.isbn = l.isbn
JOIN usager AS u ON u.code_barre = e.code_barre
WHERE e.retour < '2020-02-01';
Tester la requête dans phpmyadmin et mettre le résultat ci-dessous et conclure.
La jointure est une opération fondamentale des bases de données relationnelles. En effet, comme nous l'avons vu, la modélisation relationnelle des données impose parfois un découpage des données.
Les relations entre ces dernières sont maintenues par des contraintes, notamment les contraintes de référence.
La jointure permet de reconstituer ce lien, en construisant « à la volée » de grandes tables contenant toutes les informations liées.
Mettre le résultat ici (code et figure).
Considérons la requête
SELECT livre.titre, emprunt.retour
FROM emprunt
JOIN livre ON emprunt.isbn = livre.isbn
WHERE emprunt.retour < '2020-02-01';
Puisque l’on peut mettre des conditions arbitraires dans la clause WHERE, une manière alternative d'écrire la requête est la suivante :
SELECT livre.titre, emprunt.retour
FROM emprunt, livre
WHERE emprunt.isbn = livre.isbn
AND emprunt.retour < '2020-02-01';
Pour n'importe quel SGBD, ces deux requêtes sont équivalentes, tant du point de vue du résultat que des performances.
La seconde version est « l’ancienne » syntaxe SQL, utilisée avant l'introduction du mot clé JOIN dans la version du standard de 1992. La bonne pratique consiste à privilégier l’utilisation du mot clé JOIN. En effet, il rend plus lisible les grandes requêtes en séparant clairement prédicats de jointure et filtres
sur les données. Il permet aussi de communiquer clairement l'intention d'effectuer une jointure. Enfin, lors d’une utilisation avancée, il permet de changer la méthode de jointure (QUTER JOIN, LEFT OUTER JOIN, RIGHT OUTER JOIN, etc.) tout en conservant la même syntaxe.
Mettre le résultat ici (code et figure).
Les données stockées dans un SGBD ne sont a priori pas figées et peuvent être modifiées au cours du temps. Nous allons montrer deux types de modifications pouvant être faites sur les tables :
- la suppression d’un ensemble de lignes et
- la mise à jour de certains attributs d’un ensemble de lignes.
L'ordre DELETE FROM t WHERE c permet de supprimer de la table t toutes les lignes vérifiant la condition c.
Dans l'exemple de notre médiathèque, supposons que l'utilisateur Sébastien Petit, dont le code_barre est '934701281931582', ait rendu ses livres. Il faut supprimer de la table emprunt toutes les lignes pour lesquelles le code barre vaut '934701281931582', ce qui donne l’ordre suivant :
DELETE FROM emprunt WHERE code_barre = '934701281931582' ;
Après exécution de cet ordre, la recherche dans la table emprunt ne donne plus de résultats :
SELECT COUNT(*) AS total
FROM emprunt
WHERE code_barre = '934701281631582';
Attention, au même titre qu’une requête SELECT sans clause WHERE sélectionne toutes les lignes, un ordre DELETE sans clause WHERE efface toutes les lignes de la table. Il ne faut pas confondre « DELETE FROM » et « DROP TABLE + ». La première opération vide une table de son contenu, mais ne supprime pas la table.
Il est donc possible d’y ajouter de nouveau des données au moyen de l'instruction INSERT.
La seconde opération détruit la table (et ses données). La table ne peut donc plus être référencée.
Comme nous l'avons dit précédemment, les contraintes sont vérifiées à chaque mise à jour.
Essayons de supprimer le livre Hacker's delight de la
table livre, sachant que l’'ISBN de ce dernier est '978-0201914658'.
DELETE FROM livre WHERE isbn = '978-0201914658' ;
Ici, le SGBD nous indique que supprimer ce livre (et donc supprimer sa clé primaire de la table livre) violerait la contrainte de clé étrangère dans la table auteur_de.
Comme pour la destruction d’une table, il faut donc
supprimer en premier les lignes dont les attributs sont déclarés comme clés étrangères avant de supprimer celles contenant les clés primaires correspondantes.
Du point de vue de leur exécution, les ordres de modification de table sont soit entièrement exécutés, soit entièrement annulés.
Considérons la requête suivante :
DELETE FROM usager WHERE cp = '75001' OR cp = '75002' ;
qui efface de la table usager toutes les personnes dont le code postal est 75001 ou 75002. Si aucune de ces personnes n'apparaît dans la table emprunt, alors les suppressions peuvent être effectuées sans erreur.
Supposons maintenant que certaines de ces personnes ont emprunté un livre. Même si la SGDB rencontre en premier des personnes sans emprunt et les supprime, il lèvera une erreur dès qu’il rencontrera un usager référencé dans la table emprunt.
Dans ce cas, foutes les modifications déjà faites seront annulées et la table se trouvera dans l'état qu’elle avait avant la tentative d’exécution.
Les exécutions sont donc de type « tout où rien ».
Mettre le résultat ici (code et figure).
Le second type de modification est la mise à jour. Elle consiste à remplacer certains attributs d'un ensemble de lignes par de nouvelles valeurs.
La syntaxe est la suivante :
UPDATE t SET a1 = e1, ..., SET an = en WHERE c
Cette dernière signifie « sélectionne dans la table t toutes les lignes vérifiant la condition c et pour chacune de ces lignes, remplace la valeur courante de
l'attribut a par la valeur de l'expression e ».
Par exemple, si l'utilisateur Sébastien Petit souhaite mettre à jour son adresse email, on écrit ceci :
UPDATE utilisateur SET email = Cette adresse e-mail est protégée contre les robots spammeurs. Vous devez activer le JavaScript pour la visualiser. '
WHERE code_barre = '934701281931582';
Les expressions de mise à jour peuvent mentionner des noms d’attributs.
Ces derniers sont alors remplacés par la valeur courante (avant mise à jour) de ces attributs.
Supposons par exemple que la médiathèque soit fermée au mois d'avril. On souhaite que tous les emprunts dont la date de rendu était en avril soient prolongés de 30 jours.
UPDATE emprunt SET retour = retour + 30
WHERE retour >= '2020-04-01';
Dans la mise à jour précédente, la clause « SET retour = retour + 30 » est similaire à la modification d’une variable dans un langage de programmation comme Python, c’est-à-dire prendre la valeur courante de retour, y ajouter 30 et écrire la nouvelle valeur dans retour.
","title":"Mise à jour"},{"edit":"Mettre le résultat ici (code et figure).
Toute modification (création de table, suppression de table, mise à jour, suppression de ligne, insertion de ligne) qui ne viole pas de contrainte est définitive.
En cas de suppression ou de mise à jour, les anciennes données sont perdues. Il faut donc être particulièrement vigilant lors de la conception d’un programme effectuant des mises à jour dans une base de données.
Les bonnes pratiques recommandent l'utilisation de plusieurs « copies » de la base de données.
Une copie de test, utilisée pour le développement et une copie de « production » utilisée pour faire fonctionner le logiciel, une fois que ce dernier à été testé rigoureusement. La base de production doit par ailleurs être sauvegardée fréquemment pour éviter les risques liés à de mauvaises manipulations ou à des défaillances logicielles ou matérielles.
Comme nous l'avons vu, l’ordre « SELECT ... FROM » renvoie une table comme résultat. Il est possible de nommer cette dernière grâce au mot-clé INTO :
SELECT * INTO usager_paris FROM usager WHERE cp LIKE '75%';
Cet ordre crée une nouvelle table nommée usager_paris contenant le résultat de la requête.
Cette dernière a le même schéma que la table usager
car toutes les colonnes ont été copiées. En revanche, elle ne contiendra que les lignes pour lesquelles le code postal commence par 75.
La table usager_paris est ensuite utilisable comme n'importe quelle autre table. La clause WHERE permet de choisir les lignes à conserver. Par exemple,
SELECT * INTO usager2 FROM usager;
crée une copie conforme de usager alors que
SELECT * INTO usager3 FROM usager WHERE 1 = 0;
crée une table vide ayant le même schéma que usager (car la condition « 1 = 0») est toujours fausse.
Attention cependant, l'opération SELECT ... INTO ne copie pas les contraintes. Ainsi, dans la table usager3 ci-dessus, la colonne code_barre, bien qu’elle existe, n'est pas déclarée en tant que clé primaire. L'opération
SELECT INTO servira donc plutôt à sauvegarder un résultat temporaire de requête plutôt que créer une véritable copie.
Créer une copie conforme d’une table peut se faire en utilisant deux variations sur des opérations que nous connaissons bien.
La première est l'opération CREATE, utilsée comme ceci :
CREATE TABLE usager3 (LIKE usager INCLUDING ALL);
Cette syntaxe indique de créer la table usager3 comme une table de même schéma que usager, en incluant les contraintes (clés primaires, étrangères, CHECK, NOT NULL, ...).
L’inconvénient est que la table usager3 est vide. On peut cependant la remplir en utilisant une variation de l'order INSERT :
INSERT INTO usager3 (SELECT * FROM usager);
Ici, on dit d’insérer dans usager3 toutes les lignes renvoyées par la requête mise entre parenthèses. Cette dernière peut être arbitraire, mais doit renvoyer des lignes du même schéma que celles attendues pour la table usager3, en particulier on aurait pu utiliser une clause WHERE.
Mettre le résultat ici (code et figure).
L'opération « SELECT ... INTO » permet de sauver le résultat d’une requête sous un certain nom de table. Il est donc possible d'effectuer sur ce résultat une nouvelle requête.
Cependant, cette opération va occuper de l’espace de stockage. Il ne faudra donc pas oublier de supprimer la table ainsi créée. Il est possible de créer une table de manière temporaire et d'exécuter une requête sur cette table en imbriquant la première requête dans la clause « FROM » de la seconde ou dans une clause « JOIN ... ON »:
SELECT * FROM (SELECT * FROM livre
WHERE annee >= 1990) AS tmp
WHERE tmp.annee <= 2000;
La requête ci-dessus calcule d’abord une table intermédiaire nommée tmp qui liste les livres publiés après 1990. Suite à quoi, la table tmp est refiltrée pour
ne garder que les livres pour lesquels l’année est inférieure à 2000.
Attention, il ne s’agit ici que d’une explication de « haut niveau ». En pratique, n'importe quel SGBD moderne évaluera cette deux requêtes imbriquées comme la requête équivalente :
SELECT * FROM livre
WHERE annee >= 1990
AND annee <= 2000;
Une autre manière d’imbriquer les requêtes consiste à utiliser une sous-requête dans la clause WHERE. En effet, le langage SQL identifie les valeurs scalaires et les tables à une seule « case » telles que celles renvoyées par les fonctions d’agrégation.
Par exemple, si on souhaite afficher les titres des livres dont l’année est la plus ancienne dans la base, on pourra écrire :
SELECT titre FROM livre
WHERE annee = (SELECT MIN(annee)
FROM livre);
Ici, la sous-requête calcule l’année minimum de la table livre (1933 dans notre base), puis affiche tous les titres de livres dont l’année vaut 1933.
Attention, la sous-requête ne doit pas nécessairement comporter une fonction d’agrégation. Il suffit qu'elle renvoie une table contenant une seule valeur
.
Ainsi, si nous voulons afficher les titres des livres publiés la même année que Moby Dick (sans connaître cette année), nous pouvons écrire :
SELECT titre FROM livre
WHERE annee =
(SELECT annee
FROM livre
WHERE titre = ’Moby Dick’);
Mais attention, si la sous-requête renvoie plusieurs résultats, le SGBD renverra une erreur :
# SELECT titre FROM livre WHERE annee =
(SELECT annee FROM livre WHERE titre LIKE ?{Astérix#’);
ERROR: more than one row returned by a subquery
used as an expression
Un opérateur utilisant la puissance des requêtes imbriquées est l'opérateur IN. L'expression e IN (g) renvoie vrai si et seulement si la valeur résultant de l'évaluation de e est l’une des lignes renvoyées par la requête g. Ainsi, pour exprimer la requête « afficher les titres des livres qui ont été publiés la même année qu'un livre dont le titre contient Astérix », on pourra écrire :
SELECT titre FROM livres
WHERE annee IN
(SELECT annee FROM livres
WHERE titre LIKE '%Astérix/');
Mettre le résultat ici (code et figure).
. Les requêtes de groupe sont explicitement hors
programme. Leur compréhension peut cependant aider lors de la création d'exercices, en particulier pour déterminer si la requête demandée est réalisable dans le fragment de SQL du programme de terminale.
Ces requêtes s'expriment au moyen de l'opérateur GROUP BY (éventuellement. accompagné de l'opérateur HAVING). Intuitivement, ces requêtes
permettent, de répondre à la question « donner le f de x pour chaque g distinct de la table t » où f est une fonction d’agrégation, x un attribut de la table et g un autre attribut appelé clé de groupe.
Cette requête s’écrira alors
SELECT g, f(x) FROM t GROUP BY g
Par exemple, si on souhaite connaître le nombre (f) de Livres (t) publiés pour chaque année (g) de la base, on écrira :
SELECT annee, COUNT(*) FROM livre GROUP BY annee;
Mettre le résultat ici (code et figure).
Avant de commencer les exercices, vous devez réaliser les étapes suivantes pour mettre à jour votre base sur :
http://217.182.207.90/phpmyadmin/
Etape 1 : Exporter votre base de données.
Etape 2 : Effacer toutes les tables de la base.
Etape 3 : Importer la base mediathèque.
A partir de cette base donner et tester le code SQL de chacune des requêtes ci-dessous.
Les mots en police fixe donnent une indication sur les attributs et les tables à utiliser dans la requête.
1. Tous les titres de livre.
2. Tous les noms d'usager.
3. Tous les noms d'usager en retirant les doublons.
4. Les titres des livres publiés avant 1980.
5. Les titres des livres dont le titre contient la lettre « À ».
6. Les isbn des livres à rendre pour le 01/01/2020.
7. Les noms d'auteurs triés par ordre alphabétique.
8. Les noms d'usagers vivant dans le 12ème ou 13ème arrondissement de Paris (codes postaux 75012 et 75013).
9. Les noms et adresses des usagers n’habitant pas dans une rue. (la chaîne « Rue » ne doit pas apparaître dans l’adresse).
10. Les années et titres des livres publiés lors d’une année bissextile.
On rappelle que ce sont les années divisibles par 4, mais pas celles divisibles par 100 sauf si elles sont divisibles par 400.
","title":"Exercice : requêtes simples, sans jointure ni imbrication"},{"edit":"Mettre le résultat ici (code et figure).
***** 9 et 10 pb sol
En utilisant cette base, donner et tester le code SQL
de chacune des requêtes ci-dessous.
1. Le titre des livres empruntés.
2. Le titre des livres empruntés à rendre avant le 31/03/2020.
3. Le nom et prenom de l’auteur du livre 1984”
4. Le nom et le prenom des usagers ayant emprunté des livres, sans doublons (ie. si un usager à emprunté plusieurs livres, il ne doit apparaître qu'une fois dans le résultat).
5. Même requête que précédemment, avec les noms triés par ordre alphabétique.
6. Les titre des livres publiés strictement avant Dune”.
7. Les noms et prenoms des auteurs des livres trouvés à la question précédente,
8. Comme la question précédente, en retirant les doublons.
9. Le nombre de résultats trouvés à la question précédente.
Mettre le résultat ici (code et figure).
1.
SELECT titre FROM livre;
"},{"solution":"2.SELECT nom FROM usager;
3.
SELECT DISTINCT nom FROM usager;
"},{"solution":"4.
SELECT titre FROM livre WHERE annee <= 1980;
SELECT titre FROM livre WHERE annee <= 1980;
5.
SELECT titre FROM livre WHERE titre LIKE ’#A4’;
6.
SELECT isbn FROM emprunt WHERE retour = '2020-01-01';
SELECT isbn FROM emprunt WHERE retour = '2020-01-01';
7.
SELECT nom FROM auteur ORDER BY nom ASC;
SELECT nom FROM auteur ORDER BY nom ASC;
8.
SELECT nom FROM usager WHERE cp = '75012' OR cp = '75013';
SELECT nom FROM usager WHERE cp = '75012' OR cp = '75013';
9.
SELECT nom, adresse FROM usager
SELECT nom, adresse FROM usager
WHERE NOT (adresse LIKE ’%Rue%');
10.
SELECT annee, titre FROM livre WHERE annee % 4 = 0
AND (annee % 100 <> 0 OR annee % 400 = 0);
Dans ce dernier cas, on fera attention à l’utilisation des parenthèses, l’opérateur AND étant prioritaire sur le OR (comme en Python).
A l'aide de la base de données de la médiathèque, formuler simplement en francais les requêtes SQL suivantes.
1. SELECT * FROM livre WHERE titre LIKE '%Robot%';
2. SELECT nom, prenom FROM usager WHERE ville = 'Guingamp’;
3. SELECT u.nom, u.prenom
FROM usager AS u
JOIN emprunt AS e ON u.code_barre = e.code_barre
WHERE retour < '2020-04-02';
4. SELECT l.titre
FROM livre AS l
WHERE l.isbn IN (SELECT isbn FROM livres
WHERE annee > 1990);
5. Réécrire la requête 4 de façon à utiliser une seule clause SELECT.
Mettre le résultat ici (code et figure).
1. Renvoie tous les livres dont le titre contient « Robot ».
2. Renvoie le nom et le prénom des usagers habitant Guingamp.
3. Renvoie le nom et prénom des usagers devant rendre un livre avant le 2 avril 2020.
4. Renvoie les titres des livres publiés après 1990.
Cette dernière requête peut s’écrire :
SELECT l.titre
FROM livre AS l
WHERE l.annee > 1990;
En utilisant la base de données de la médiathèque, calculer tous les auteurs ayant collaboré sur un ouvrage et les renvoyer sous la forme (n1,p1,n2, p2, t) où les ni sont les noms des auteurs, pi leur prénoms et t le titre du livre sur lequel ils ont collaboré.
Si trois auteurs ont collaboré sur le même livre, on souhaite avoir trois lignes de résultats (auteur1/auteur2, auteur2/auteur3 et auteur1/auteur3) et non pas
les trois sur la même ligne.
Pour ne pas afficher deux fois le même couple, on demande en plus que n1 < n2.
Mettre le résultat ici (code et figure).
SELECT a1.nom, a1.prenom, a2.nom, a2.prenom, l.titre
FROM livre AS l
JOIN auteur_de AS ad1 ON l.isbn = ad1.isbn
JOIN auteur_de AS ad2 ON l.isbn = ad2.isbn
JOIN auteur AS a1 ON ad1.a_id = a1.a_id
JOIN auteur AS a2 ON ad2.a_id = a2.a_id
WHERE a1.nom < a2.nom;
Le cœur de cette requête est une jointure entre deux copies de la table auteur_de (nommée ad1 et ad2), sur le même isbn, celui que l’on utilise pour la jointure avec la table livre. La jointure entre ad1 et ad2 sur le
même isbn place sur la même ligne deux a_id de deux auteurs qui ont le même isbn. Il suffit alors de joindre avec les tables contenant les données.
On considère les trois tables décrites à la figure ci-dessous. Pour chacune des requêtes SQL ci-dessous, caleuler son résultat (à la main).
1. SELECT * FROM x WHERE b > 3;
2. SELECT DISTINCT e FROM z
WHERE e > 10 AND e < 50;
3. SELECT * FROM y WHERE c % 2 = 0 ORDER BY d ASC;
4. SELECT x.a , x.b FROM x
JOIN z ON z.a = x.a
WHERE z.e < 9;
5. SELECT DISTINCT x.b , y.d FROM x
JOIN z ON z.a = x.a
CREATE TABLE x (a INT PRIMARY KEY, b INT, CHECK (b >= 0));
CREATE TABLE y (c INT PRIMARY KEY, d INT, CHECK (d <= 30));
CREATE TABLE z (a INT REFERENCES X(a),
c INT REFERENCES Y(c), e INT, UNIQUE (a,c));
| x: | y: | z: | ||||||
| a | b | c | d | a | c | e | ||
| 1 | 1 | 9 | 9 | 1 | 11 | 30 | ||
| 2 | 2 | 10 | 10 | 2 | 14 | 9 | ||
| 2 | 2 | 11 | 9 | 5 | 15 | 1 | ||
| 4 | 2 | 12 | 20 | 7 | 17 | 3 | ||
| 5 | 1 | 13 | 30 | 1 | 10 | 50 | ||
| 6 | 9 | 14 | 9 | 2 | 9 | 8 | ||
| 7 | 1 | 15 | 1 | 2 | 15 | 15 | ||
| 16 | 10 | 3 | 17 | 19 | ||||
| 17 | 10 | 4 | 16 | 12 | ||||
| 5 | 10 | 20 | ||||||
| 2 | 11 | 30 | ||||||
| 7 | 14 | 9 | ||||||
| 7 | 9 | 12 |
Mettre le résultat ici (code et figure).
| a | b |
| 6 | 9 |
| e |
| 12 15 19 20 30 |
3.
| c | d |
| 14 10 16 12 | 9 10 10 20 |
4.
| a | b |
| 5 7 2 | 1 1 2 |
5.
| b | d |
| 1 1 2 1 2 2 | 1 10 10 9 1 9 |
On considère les trois tables ci-dessous ;
| x: | y: | z: | ||||||
| a | b | c | d | a | c | e | ||
| 1 | 1 | 9 | 9 | 1 | 11 | 30 | ||
| 2 | 2 | 10 | 10 | 2 | 14 | 9 | ||
| 2 | 2 | 11 | 9 | 5 | 15 | 1 | ||
| 4 | 2 | 12 | 20 | 7 | 17 | 3 | ||
| 5 | 1 | 13 | 30 | 1 | 10 | 50 | ||
| 6 | 9 | 14 | 9 | 2 | 9 | 8 | ||
| 7 | 1 | 15 | 1 | 2 | 15 | 15 | ||
| 16 | 10 | 3 | 17 | 19 | ||||
| 17 | 10 | 4 | 16 | 12 | ||||
| 5 | 10 | 20 | ||||||
| 2 | 11 | 30 | ||||||
| 7 | 14 | 9 | ||||||
| 7 | 9 | 12 |
CREATE TABLE x (a INT PRIMARY KEY, b INT, CHECK (b >= 0));
CREATE TABLE y (c INT PRIMARY KEY, d INT, CHECK (d <= 30));
CREATE TABLE z (a INT REFERENCES X(a),
c INT REFERENCES Y(c), e INT, UNIQUE (a,c));
Pour chaeune des modifications ci-dessous, indiquer si elle réussit ou si elle échoue. Si elle réussit, indiquer comment la table est modifiée. Si elle échoue, expliqner
pourquoi.
Les questions sont indépendantes les unes des autres.
1, UPDATE x SET b = b +a;
2. UPDATE x SET b = b - 2;
3. INSERT INTO z VALUES (1, 17, 1);
4. INSERT INTO z VALUES (1, 18, 1};
5. INSERT INTO z VALUES (1, 10, 1);
6. DELETE FROM y WHERE c >= 12 AND c <= 13;
7. DELETE FROM y WHERE c >= 12 AND c <= 14;
8. INSERT INTO y VALUES (40, 20);
9. INSERT INTO y VALUES (20, 40);
10. DELETE FROM z
WHERE a % 2 = 0 OR c % 2 = 0 0R e % 2 = 0;
Mettre le résultat ici (code et figure).
1. Succès. La table x devient :
| a | b |
| 1 2 3 4 5 6 7 | 2 4 5 6 6 15 8 |
2. Échec. La ligne (1,1) deviendrait (1,-1) après mise à jour, ce qui viole la contrainte « CHECK (b >= 0) ».
3. Succès. La ligne (1,17,1) est ajoutée à la table z.
4. Échec. La valeur 18 n’est pas une clé primaire dans la table y.
5. Échec. Une ligne (1,10,50) est déjà présente dans la table.
6. Succès. La table y devient :
| c | d |
| 9 10 11 14 15 16 17 | 9 10 9 9 1 10 10 |
7. Échec. La table z contient des entrées avec 11 ou 14. Les clés primaires correspondantes dans y ne peuvent pas être supprimées.
8. Succès. La ligne (40,20) est ajoutée à la table y.
9. Échec. La valeur 40 viole la contrainte « CHECK a <= 30 »
10. Succès. La table z devient :
| a | c | e |
| 5 7 3 | 15 17 17 | 1 3 19 |
- Détails
- Écrit par : Richard GAUTHIER
- Clics : 1020
[[{"title":"SQL - Bases de données relationnelles","posi":0},{"text":"
"},{"text":""}],[{"text":"
![](\"https://sciencesappliquees.com/images/nsi/sql1.png\")
![](\"https://sciencesappliquees.com/images/nsi/sql2.png\")
![](\"https://sciencesappliquees.com/images/nsi/sql3.png\")
","title":"SQL : un langage de définition de données"},{"edit":"
"}],[{"text":"
","title":" "},{"edit":"
"}],[{"text":"
","title":" Vocabulaire"},{"edit":"
"}],[{"text":"
","title":"Types de données en SQL"},{"edit":"
"}],[{"text":"
","title":""},{"edit":"
"}],[{"text":"
"}],[{"text":"
","title":""},{"edit":"
"}],[{"text":"
","title":""},{"edit":"
"}],[{"text":"
","title":"Spécification des contraintes d'intégrité"},{"edit":"
"}],[{"text":"
"}],[{"text":"
"}],[{"text":"
","title":""},{"edit":"
"}],[{"text":"
","title":"Suppression de tables"},{"edit":"
"}],[{"text":"
","title":"Insertion dans une table"},{"edit":"
"}],[{"text":"
"},{"solution":"
"}],[{"text":"
"},{"solution":""}],[{"text":"
","title":"Exercice"},{"edit":"
"},{"solution":"
"}],[{"text":"
","title":"Exercice"},{"edit":"
"},{"solution":"
"}],[{"text":"
"},{"solution":"
"}],[{"text":"
"},{"solution":"
"}],[{"text":"
"},{"solution":"
"}]]
Le modèle relationnel introduit à la séquence précédente est un modèle mathématique permettant de raisonner sur des données tabulées. Il est mis en œuvre par un logiciel particulier, le Système de Gestion
de Bases de Données (SGBD en abrégé).
Un SGBD relationnel est un SGBD utilisant le modèle relationnel pour la représentation des données!. L'écrasante majorité des SGBD relationnels utilisent le langage SQL (Séructured Query Language, langage de requête structuré). Ce dernier permet d'envoyer
des ordres au SGDB.
Les ordres peuvent être de deux natures. Les mises à
jour permettent la création de relations, l’ajout d’entité dans ces dernières, leur modification et leur suppression.
Les requêtes permettent de récupérer les données répondant à des critères particuliers.
Directement inspiré du modèle relationnel introduit par E. Codd, le langage SQL permet la définition de relations ou tables dans une base de données relationnelle. Ce langage est standardisé par PISO sous la référence ISO/IEC 9075.
La dernière version du standard date de 2016.
Le langage SQL permet de créer des tables en spécifiant leur nom, leurs attributs, les types de ces derniers et les contraintes associées à la table.
Vous allez utiliserer comme SGBD pour travailler avec le langage SQL :
MariaDB avec l'application phpmyadmin
Pour cela, il faut aller sur le serveur privé (Vps) à l'adresse suivante:
et tapez les paramètres données par votre professeur.
Vous sélectionnez la base de donnée et cliquez sur l'onglet SQL pour exécuter vos expressions SQL.
Maintenant vous allez créer les tables correspondant à la modélisation finale de la médiathèque obtenue à la fin de la séquence précédente.
On saisit les ordres suivants :
CREATE TABLE usager (nom VARCHAR(90) NOT NULL, prenom VARCHAR(90) NOT NULL,
adresse VARCHAR(300) NOT NULL, cp VARCHAR(5) NOT NULL,
ville VARCHAR(60) NOT NULL,
email VARCHAR(60) NOT NULL,
code_barre CHAR(15) PRIMARY KEY);
CREATE TABLE livre (titre VARCHAR(300) NOT NULL,
editeur VARCHAR(90) NOT NULL,
annee INT NOT NULL,
isbn CHAR(14) PRIMARY KEY);
CREATE TABLE auteur (a_id INT PRIMARY KEY,
nom VARCHAR(90) NOT NULL,
prenom VARCHAR(90) NOT NULL);
CREATE TABLE auteur_de (a_id INT REFERENCES Auteur(a_id),
isbn CHAR(14)
REFERENCES Livre(isbn),
PRIMARY KEY (a_id, isbn));
CREATE TABLE emprunt (code_barre CHAR(15)
REFERENCES Usager(code_barre),
isbn CHAR(14) PRIMARY KEY
REFERENCES Livre(isbn),
retour DATE NOT NULL);
Vous devez obtenir ceci :
Vous voyez que l’interaction avec un SGBD se fait par l'envoi d’une suite d'ordres SQL.
Un ordre peut s'étendre sur plusieurs lignes.
Les blancs et l’indentation ne sont pas significatifs mais améliorent la lisibilité dans certains cas.
Un ordre se termine par un « ; ».
Les cinq ordres donnés ci-dessus créent les cinq
tables composant notre base de données.
Une première remarque de syntaxe est que SQL est insensible à la casse. On aurait ainsi pu écrire « create
table livre ... » ou encore « CReATE TablE liVrE ... ». Nous faisons le choix d'utiliser des capitales pour les mots clés du langage SQL (CREATE, TABLE, PRIMARY, etc.) et des minuscules pour les noms d’attributs (a_id,
prenom, etc.) et de tables.
Ces derniers ne pouvant pas contenir d’espace,
nous utilisons le caractère « _» comme séparateur de mots.
Enfin, nous utilisons la convention, généralement considérée comme une bonne pratique, d'utiliser des noms de tables au singulier.
Une autre remarque de syntaxe est que le langage SQL peut sembler « verbeux », à l'inverse d’un langage
de programmation comme Python.
Les ordres ressemblent à du langage naturel (en anglais). La notation est aussi semblable aux schémas du modèle relationnel.
Mettre le résultat ici.
La syntaxe générale d'un ordre CREATE TABLE est la suivante :
CREATE TABLE nom_table (att1 dom1 contri1? ,
.......... ,
attn domn contrin? ,
contr_glob1,
......... ,
contr_globn ) ;
On donne, à la suite des mots clés CREATE TABLE, un nom de table, suivi de la liste des définitions d’attributs entre parenthèses et séparées par des virgules.
Une définition d’attribut consiste en un nom d'attribut, un type d’attribut (ou domaine) qui sont tous les deux obligatoires et optionnellement des contraintes sur cet attribut, Si des contraintes portent sur plusieurs attributs à la fois (par exemple pour spécifier que plusieurs attributs forment une clé primaire) on peut placer ces contraintes en fin de liste, avant la parenthèse fermante.
Attention : Le système lèvera une erreur si la table existe déjà.
Strictement parlant, une relation du modèle relationnel et une table SQL ne sont pas des concepts équivalents. En particulier, une table peut contenir des doublons. En effet, il n'est pas obligatoire de spécifier une clé primaire lors de la création d’une table SQL. Sans clé primaire, une table peut contenir plusieurs copies du même n-uplet, sans que cela pose problème, chose qui n’est a priori pas autorisé pour les ensembles du modèle relationnel (car ce sont des ensembles).
Nous ignorerons ces différences dans le cadre du programme de terminale et utiliserons les termes «tables» et «relations» indistinctement.
De façon analogue, en SQL les attributs d’une relation sont appelées des colonnes et les entités des lignes.
Mettre le résultat ici.
Les domaines abstraits du modèle relationnel correspondent à des types de données du langage SQL.
Nous avons comme type :
Types numériques.
| nom du type | exact ou approché | description |
| SMALLINT | exact | entier 16 bits signé |
| INTEGER | exact | entier 32 bits signé |
| INT | exact | alias pour INTEGER |
| BIGINT | exact | entier 64 bits signé |
| DECIMAL(t, f) | exact | décimal signé de t chiffres dont f après la virgule |
| REAL | approché | flottant 32 bits |
| DOUBLE PRECISION | approché | flottant 64 bits |
Le standard SQL définit plusieurs types numériques.
Ces derniers sont soit des types numériques exacts, soit des types numériques approchés.
La table ci-dessous détaille les différents types numériques. La plupart de ces types représentent fidèlement les entiers où flottants «machine» manipulables directement par le processeur. Une exception notable est le type DECIMAL(E, f) qui permet de représenter de manière exacte un nombre à virgule d'une taille donnée. Ce type est particulièremnent important, car il permet par exemple de représenter des sommes d'argent sans erreurs d'arrondis. Ainsi, le type
DECIMAL(5,2) permet de stocker des valeurs décimales de 5 chiffres, dont deux après la virgule, soit des valeurs entre -999, 99 et 999,99. Une utilisation de ce type permettra de réaliser une contrainte de domaine
sur un attribut numérique. Le standard ne supporte que les nombres en base 10, sans autoriser des notations hexadécimales ou octales comme dans les
autres langages.
Mettre le résultat ici (code et figure).
Types textes
| nom du type | description |
| CHAR(n) | Chaîne d’exactement n caractères. Les caractères manquant sont complétés par des espaces. |
| TEXT Chaîne de taille quelconque. | Chaîne d’au plus n caractères. |
| TEXT | Chaîne de taille quelconque. |
Le standard SQL définit plusieurs types permettant de stocker des chaînes de caractères. Malheureusement, ces derniers sont supportés
de manière inégale dans les divers SGBD. On se limitera aux plus communs.
Le type CHAR(n) permet de définir des chaînes de caractères de taille exactement n. La taille maximale acceptée pour n dépend des différents systèmes, mais ils supportent tous au moins 8000 caractères. La taille minimale est 1. Ce type est approprié lorsque l’on veut stocker des exactement 14 caractères, de la forme *XXX-XXXXXXXXXX’ (trois chiffres, un tiret, dix chiffres). Attention, si l’on stocke une chaîne de taille inférieure à n, cette dernière est complétée par la droite avec des espaces. Ainsi, la chaîne \"hello’ stockée dans une colonne de type CHAR(10) sera convertie en ’hello_____' (où le caractère « _ » représente un espace).
Le type VARCHAR(n) permet quant à lui de définir des chaînes de taille au plus n. La valeur de n suit les mêmes règles que pour le type CHAR.
Enfin, le type TEXT permet de stocker des chaînes de caractères de taille variable, sans fixer de taille maximale à priori. En pratique, il est équivalent à VARCHAR(n) pour la plus grande valeur de n supportée par le système. Les chaînes de caractères littérales sont délimitées par des guillemets simples « ' ».
Le caractère guillemet peut être échappé en le doublant,
Par exemple, la chaîne « c'est moi » s’écrira ’c' 'est moi'.
Les autres caractères n’ont pas besoin
d'être échappés. Une chaîne peut en particulier contenir un retour chariot (et donc être écrite sur plusieurs lignes).
Type booléen
Le type BOULEAN est inégalement supporté par les différents systèmes, qu’ils soient commerciaux ou libres. Cela est dû au fait que le standard SQL laisse ce type comme optionnel.
Les SGBD sont donc libres de ne pas le proposer. Une alternative possible est d'utiliser CHAR(1) et de se
servir de deux caractères distincts (par exemple 'T et 'F') pour représenter des booléens.
Une autre alternative est d'utiliser un type numérique exact et de considérer la valeur 0 comme fausse et les autres valeurs comme vraies.
","title":""},{"edit":"Mettre le résultat ici (code et figure).
Type des dates, durées et instants
| nom du type | description |
| DATE | une date au format 'AAAA-MM-JJ' |
| TIME | une heure au format ’hh:mm:ss' |
| TIMESTAMP | un instant (date et heure) au format 'AAAA-MM-JJ hh:mm:ss’ |
À première vue anodine, la gestion des dates et du temps est un problème excessivement complexe, source de nombreux bugs. Le standard SQL propose donc de nombreux types temporels permettant de représenter des dates, des heures et des durées.
Quelques types sont donnés dans la table ci-dessus. Les valeurs de ces types s’écrivent comme de simples chaînes de caractères. Une fonctionnalité intéressante est la possibilité d'utiliser l'addition pour ajouter des jours à une valeur de type DATE.
Si d est une expression de type DATE, alors d + 10 représente la date + 10 jours après d. Cette opération produit une valeur de type DATE et donc prend correctement en compte les changements de mois, année et les années bissextiles.
Nous ne détaillons pas plus ces types de données très
complexes (qui savent par exemple prendre en compte les fuseaux horaires).
Mettre le résultat ici (code et figure).
Valeur NULL
Une valeur notée NULL existe en SQL. Elle représente une absence de valeur et peut donc être utilisée à la place de n’importe quelle autre valeur, quel que soit le type attendu.
Son utilisation est similaire à la constante None du langage Python, mais son comportement est complexe et peut être source d’erreurs.
Il est déconseillé de l’utiliser dans le cadre d’une initiation aux bases de données. En particulier, SQL interdit l’utilisation de NULL comme valeur pour une clé primaire. En revanche, elle est autorisée pour les clés étrangères. La valeur NULL permet donc de violer la contrainte de référence.
La seule chose que l’on fera donc avec des attributs potentiellement NULL est de les tester au moyen des expression
- e IS NULL
- ou e IS NOT NULL.
Attention cependant, le test e = NULL ne produit pas le résultat booléen comme s’y attendrait mais renvoie toujours NULL quelle que soit la valeur de e .
Mettre le résultat ici (code et figure).
Les contraintes d’intégrité jouant un rôle fondamental dans le modèle relationnel, il est naturel de pouvoir les spécifier en SQL.
Nous montrons ici comment définir les quatre types de contraintes d’intégrité étudiés au précédent :
Clé primaire. Les mots clés PRIMARY KEY permettent d'indiquer qu'un attribut est une clé primaire.
Voici un exemple :
CREATE TABLE personne (id INT PRIMARY KEY,
nom VARCHAR(99),
prenom VARCHAR (99));
Si l’on souhaite utiliser plusieurs attributs comme clé primaire, on peut spécifier la contrainte après les attributs :
CREATE TABLE point (x INT,
y INT,
couleur VARCHAR(30),
PRIMARY KEY (x. y)):
Mettre le résultat ici (code et figure).
Clé étrangère. Un attribut peut être qualifié de clé étrangère en utilisant le mot clé REFERENCES suivi de la table où se trouve la clé primaire et de son nom.
CREATE TABLE employe (emp INT REFERENCES personne(id),
dept VARCHAR (90),
suph INT REFERENCES personne(id));
La table employe associe un employé (attribut emp}, qui est une personne, à son département dans l’entreprise (ressources humaines, support informatique, comptabilité, etc.) et à son supérieur hiérarchique (attribut suph), qui est aussi une personne. Ce lien est matérialisé par le fait que emp et suph sont des clés étrangères. Il est à noter que la plupart des SGBD ne supportent pas l’utilisation de clés étrangères composites.
L'utilité des clés primaires composites se trouve donc amoindrie en pratique.
","title":""},{"edit":"Mettre le résultat ici (code et figure).
Unicité, non nullité.
Il peut être intéressant de spécifier qu'un groupe d’attributs est unique, sans pour autant en faire une clé primaire. Cette information permet au SGBD plus de vérifications sur les données (cohérence
des données) et parfois de traiter ces dernières de façon plus efficace.
Cela peut être spécifié au moyen du mot clé UNIQUE.
Une autre bonne pratique consiste à déclarer qu’un attribut ne peut pas être NULL. Cette valeur spéciale ne pourra donc jamais être utilisée pour remplir des valeurs de la colonne correspondante.
Cela peut être fait au moyen du mot clé NOT NULL.
Notons que PRIMARY KEY implique obligatoirement NOT NULL.
En reprenant l'exemple des utilisateurs de la bibliothèque, on pourrait raffiner notre définition de table de la manière suivante :
CREATE TABLE usager (nom VARCHAR(90) NOT NULL,
prenom VARCHAR(90) NOT NULL,
adresse VARCHAR(300) NOT NULL,
cp VARCHAR(S5) NOT NULL,
ville VARCHAR(60) NOT NULL,
email VARCHAR(60) NOT NULL UNIQUE,
code_barre CHAR(15) PRIMARY KEY);
On spécifie de cette façon qu'aucun des attributs n’est optionnel et de plus que email doit être UNIQUE dans la table (même s’il n’est pas une clé primaire).
","title":""},{"edit":"Mettre le résultat ici (code et figure).
Contraintes utilisateur.
Il est possible de spécifier des contraintes arbitraires sur les attributs d’une même ligne au moyen du mot clé CHECK, suivi d'une formule booléenne. Cette contrainte est placée obligatoirement en fn de déclaration avant la parenthèse fermante (et non pas au niveau d’un attribut).
Nous donnons ici quelques exemples et reviendrons dessus dans la séquence suivante sur la syntaxe des expressions.NETS
CREATE TABLE produit (id INT PRIMARY KEY,
nom VARCHAR(100) NOT NULL,
quantite INT NOT NULL,
prix DECIMAL(10,2) NOT NULL,
CHECK (quantite >= 0 AND prix >= 0));
Nous définissons ici une table des produits vendus dans un magasin. Ces derniers ont un identifiant (qui est la clé primaire), un nom, une quantité et un prix.
Ceux-ci ne peuvent jamais être négatifs (ce qui n’est pas exprimable uniquement au moyen des types INT ou DECIMAL). On ajoute donc une contrainte CHECK.
Mettre le résultat ici (code et figure).
Une fois qu’une table est créée, il n'est pas possible d'en créer une autre avec le même nom. Si on souhaite recréer la table, par exemple avec un schéma différent, il faut d'abord supprimer celle portant le même nom.
C’est le but de l'instruction DROP TABLE :
DROP TABLE auteur_de;
Cette dernière supprime la table et donc toutes les données qui y sont stockées.
Un point important est qu'il n'est pas possible de supprimer une table si elle sert de référence pour une clé étrangère d’une autre table, car cela violerait une contrainte de référence :
# DROP TABLE usager;
ERROR: cannot drop table utilisateurs because other objects
depend on it
DETAIL: constraint emprunt code barre_fkey on table
emprunt depends on table usager
Nos reproduisons ci-dessus une interaction avec le SGBD PostgreSQL, mais tous les autres systèmes relationnels auront un comportement semblable.
Le système indique que la table usager est mentionnée par une contrainte (ici celle de la table emprunt). Le système refuse donc de supprimer la table et renvoie une erreur.
Il convient alors de supprimer les tables dans le bon ordre, c'est-à-dire d'abord les tables contenant les clés étrangères, avant les tables contenant les clés primaires référencées.
DROP TABLE emprunt;
DROP TABLE auteur_de;
DROP TABLE auteur;
DROP TABLE livre;
Certains SGBD permettent de spécifier que la suppression d’une table doit détruire automatiquement toutes les tables qui dépendent d’elle. Cette fonctionnalité est commode mais dangereuse et de toute façon inégalement supportée. Il est donc conseillé de spécifier explicitement les commandes de
suppression, dans l’ordre adéquat.
Le standard SQL en pratique. Bien que très volumineux {le standard ISO/IEC 9075 qui définit la norme SQL se décompose en 14 parties distinctes et fait plus de 5000 pages). Le standard SQL comporte beaucoup de parties optionnelles. En pratique, même si la plupart des SGBD commerciaux et libres en implémentent une partie, leur support est inégal.
Il n’est donc pas rare de devoir écrire du code SQL « propriétaire », c'est-à-dire utilisant des extensions propres à SGBD particulier, dès que l’on souhaite faire des traitements un tant soit peu complexes. Cette
pratique nuit malheureusement à la portabilité.
Mettre le résultat ici (code et figure).
Nous pouvons enfin aborder l'insertion de nouvelles valeurs dans une table.
Cette action s'effectue au moyen de l’ordre INSERT INTO
INSERT INTO auteur VALUES (97, 'Ritchie','Dennis');
On spécifie le nom de la table (ici auteur) suivi d'une suite de n-uplets, chacun entre parenthèses.
Chaque n-uplet représente une nouvelle ligne de
la table. Les valeurs des attributs sont supposés être dans le même ordre que lors du « CREATE TABLE ». Si on souhaite les passer dans un ordre différent, on peut spécifier l’ordre des attributs avant le mot clé VALUES
INSERT INTO auteur (prenom, a_id, nom)
VALUES (’Jean-Jacques’, 200, ’Rousseau’);
Un point important est que les contraintes d’intégrités sont vérifiées au moment de l'insertion.
Une instruction INSERT violant ces contraintes conduira donc à une erreur et les données correspondantes ne seront pas ajoutées à la table.
# INSERT INTO auteur (97, ’Dumas’, ’Alexandre”’);
ERROR: duplicate key value violates unique constraint
“auteur _pkey\"
TDETATT Vaner Pa SANLÉOTN Smandiu nvicte
Ici, on essaye d’ajouter un auteur avec la même clé primaire qu’un auteur
déjà existant.
# INSERT INTO produit VALUES (1, ’ordinateur’, 10, -200);
ERROR: new row for relation \"produit\" violates check
coustraint \"produit _check\"
DETAIL: Failing row contains (1, ordinateur, 10, -200.00).
Ici, l'insertion viole la contrainte CHECK de la table produit définie plus haut.
Mettre le résultat ici (code et figure).
Regrouper ensemble les termes synonymes : colonne, entité, domaine, attribut, ligne, schéma, base de données, type, column, row.
","title":"Exercice"},{"edit":"Mettre le résultat ici (code et figure).
(colonne, attribut, column), (ligne, entité, row),
(domaine, type), (schéma), (base de données).
Nous avons le modéliser l'annuaire de la manière suivante :
Annuaire(nom String, prénom String, tel String)
Les contraintes sur le modèle sont les suivantes :
- le numéro de téléphone est unique;
- le numéro de téléphone est une clé primaire.
- les attributs nom et le prenom ne peuvent pas être vides.
Donner un ordre SQL permettant de créer la table correspondante,
avec un maximum de contrainte d'intégrité.
","title":"Exercice"},{"edit":"Mettre le résultat ici (code et figure).
CREATE TABLE annuaire( nom VARCHAR(100) NOT NULL,
prenom VARCHAR(100) NOT NULL,
tel VARCHAR(20) PRIMARY KEY);
Nous avons le modèle relationnel suivant :
Eleve(nom String, prénom String, num String)
Matiere(intitule String, m_id INT)
Note(num String, m_id INT, note Float)
Contrainte : attribut note compris entre 0 et 20.
Donner les ordres SQL permettant de créer les tables correspondantes, avec un maximum de contrainte d'intégrité.
Donner les ordres SQL permettant de supprimer ces tables une fois qu’elles existent.
Mettre le résultat ici (code et figure).
CREATE TABLE eleve (nom VARCHAR(100) NOT NULL,
prenom VARCHAR(100) NOT NULL,
num VARCHAR(20) PRIMARY KEY);
CREATE TABLE matiere ( intitule VARCHAR(100) NOT NULL,
m_id INT PRIMARY KEY);
CREATE TABLE note ( num VARCHAR(20) REFERENCES eleve(num),
m_id INT REFERENCES matiere(m_id),
note DECIMAL(4,2) NOT NULL,
PRIMARY KEY (num, m_id),
CHECK (note >= O AND note <= 20));
DROP TABLE note;
DROP TABLE matiere;
DROP TABLE eleve;
Pour chacune des séquences d'ordres SQL suivantes, dire quelle instruction provoque une erreur.
On suppose que la base de données ne contient aucune table au début de chaque séquence,
1. DROP TABLE client;
CREATE TABLE client (cid INT PRIMARY KEY,
nom VARCHAR (100),
prenom VARCHAR (100),
points _fidelite INT NOT NULL,
CHECK (points_fidelite >= 0));
2. CREATE TABLE client (cid INT PRIMARY KEY,
nom VARCHAR (100),
prenom VARCHAR(100),
points_fidelite INT NOT NULL,
CHECK(points_fidelite >= 0));
CREATE TABLE commande (cid INT REFERENCES client (cid),
pid INT REFERENCES produit (pid),
date DATE NOT NULL) ;
CREATE TABLE produit (pid INT PRIMARY KEY,
nom VARCHAR (100),
prix DECIMAL(10,2));
3.
CREATE TABLE client (cid INT PRIMARY KEY,
nom VARCHAR(100),
prenom VARCHAR(100),
points _fidelite INT NOT NULL,
CHECK (points_fidelite >= 0));
CREATE TABLE produit (pid INT PRIMARY KEY,
nom VARCHAR (100),
prix DECIMAL(10,2));
CREATE TABLE commande (cid INT REFERENCES client(cid),
nomp VARCHAR(100)
REFERENCES produit (nom),
date DATE NOT NULL) ;
4.
CREATE TABLE client (cid INT PRIMARY KEY,
nom VARCHAR (100),
prenom VARCHAR(100),
points_fidelite INT NOT NULL,
CHECK (points _fidelite >= 0));
CREATE TABLE produit (pid INT PRIMARY KEY,
nom VARCHAR (100),
prix DECIMAL(10,2));
CREATE TABLE commande (cid INT REFERENCES client(cid),
pid INT REFERENCES produit (pid),
date DATE NOT NULL);
INSERT INTO commande VALUES (0, 0, 2020-03-02);
Mettre le résultat ici (code et figure).
1. L'ordre DROP échoue car la table client n'existe pas.
2. L'ordre CREATE TABLE commande ... échoue car la table produits n'existe pas encore.
3. L'ordre CREATE TABLE commande ... échoue car la table nomp ne référence pas une clé primaire.
4. L'ordre INSERT échoue, les valeurs 0 et O ne font pas référence à des clés primaires.
On considère les deux tables suivantes :
CREATE TABLE joueur (jid INT PRIMARY KEY,
nom VARCHAR(100) NOT NULL);
CREATE TABLE partie (j1 INT REFERENCES joueur(jid),
j2 INT REFERENCES joueur(jid),
score1 INT NOT NULL,
score2 INT NOT NULL,
CHECK ((j1 <> j2));
Ces tables stockent des résultats de parties entre des joueurs. Lister toutes les contraintes d’intégrité et pour chacune donner des ordres SQL violant ces contraintes.
","title":"Exercice"},{"edit":"Mettre le résultat ici (code et figure).
On donne la liste des contraintes et à chaque fois
une suite d’ordres incompatibles avec celle-ci.
1. jid est une clé primaire (contrainte d’entité)
INSERT INTO joueur VALUES (1, 'TOTO’);
INSERT INTO joueur VALUES (1, 'TOTO’);
2. nom doit être non NULL (contrainte de domaine)
INSERT INTO joueur VALUES (1, NULL);
Requêtes similaires pour score1 et score2.
3. j1 et j2 sont des clé étrangère (contraintes de référence)
INSERT INTO partie VALUES (42, 43, 10, 10);
(on suppose qu'aucun jid n’a la valeur 42 ou 43)
4. j1et j2 doivent avoir des valeurs distinctes (car une personne ne peut pas jouer contre elle-même, contrainte utilisateur).
INSERT INTO joueur VALUES (1, ’Toto”);
INSERT INTO partie VALUES (1, 1, 10, 10);
5. Toutes les contraintes de domaine peuvent être violées en insérant une valeur d’un type différent de celui attendu.
Nous avons créé les tables suivantes ;
CREATE TABLE joueur (jid INT PRIMARY KEY,
nom VARCHAR(100) NOT NULL);
CREATE TABLE partie (j1 INT REFERENCES joueur(jid),
j2 INT REFERENCES joueur(jid),
score1 INT NOT NULL,
score2 INT NOT NULL,
CHECK ((j1 <> j2));
Modifier les ordres de création des tables en prenant en compte les modifications suivantes :
- La table partie contient en plus une colonne jour non nulle, indiquant la date à laquelle la partie à eu lieu.
- Les scores ne peuvent pas être négatifs.
- Deux joueurs ne peuvent pas jouer plusieurs fois le même jour.
","title":"Exercice"},{"edit":"Mettre le résultat ici (code et figure).
La table joueur est inchangée. On modifie la table partie.
CREATE TABLE partie (j1 INT REFERENCES joueur(jid),
j2 INT REFERENCES joueur(jid),
score1 INT NOT NULL,
score2 INT NOT NULL,
jour DATE NOT NULL,
UNIQUE (ji, j2, jour),
CHECK ((j1 < j2) AND
(score1 >= 0) AND
(score2 >= 0)));
En particulier, pour interdire de saisir pour le même jour une partie entre les joueurs 1 et 2 et une autre entre les joueurs 2 et 1, on force le jid du premier joueur à être strictement inférieur. La contrainte UNIQUE permet
ensuite de s'assurer que un triplet (j1, j2, jour) n’apparaît qu’une seule fois.
Écrire un programme Python qui lit un fichier CSV infos.csv au format suivant :
- les champs sont séparés par des « ; »
- le fichier contient 4 colonnes nom, prenom, annee naissance, taille, représentant le nom, prénom, l'année de naissance et la taille (en cm) de personnes.
Le programme doit écrire sur sa sortie standard un script SQL (i.e. un ensemble d'ordres) qui crée une table permettant de stocker ces informations ainsi qu'un identifiant unique (entier) servant de clé primaire et remplit la table avec les données du fichier CSV.
","title":"Exercice"},{"edit":"Mettre le résultat ici (code et figure).
import csv
print (\"\"\"CREATE TABLE personne
(pid INT PRIMARY KEY,
nom VARCHAR (100),
prenom VARCHAR (100),
annee_naiss INT,
taille INT,
CHECK (taille >= O AND annee_naissance >= 0));\"\"\")
def q(s):
return s.replace(\"'\", \"''\")
with open (\"infos.csv\") as f:
pid = 0
for l in csv.DictReader(f, delimiter=\";\"):
print (\"\"\"INSERT INTO personne
VALUES (%d, '%s', '%s', %d, %d);\"\"\" % \\
(pid, q(l[\"nom\"]), q(l[\"prenom\"]), \\
int(l[\"annee_naissance\"]), int(l[\"taille\"])))
pid = pid +1
La fonction auxiliaire q prend en argument une chaîne de caractères et échappe le caractère \" s’il est présent en le doublant ''(règle d'échappement pour les chaînes SQL).
SOLUTIONSSELECT titre FROM livre;
- Détails
- Écrit par : Richard GAUTHIER
- Clics : 1200
[[{"title":"SQL - Modèle relationnel","posi":0},{"text":"
"},{"text":""}],[{"text":"
"}],[{"text":"
","title":"Modèle de données, structure de données"},{"edit":"
"}],[{"text":"
","title":"Modélisation relationnelle des données"},{"edit":"
"}],[{"text":"
","title":""},{"edit":"
"}],[{"text":"
","title":"Contraintes d'intégrité"},{"edit":"
"}],[{"text":"
"}],[{"text":"
","title":"Contrainte d'entité"},{"edit":"
"}],[{"text":"
","title":"Contrainte de référence."},{"edit":"
"}],[{"text":"
","title":"Contraintes utilisateurs"},{"edit":"
"}],[{"text":"
"}],[{"text":"
"},{"solution":"
"}],[{"text":"
"},{"solution":"
"}],[{"text":"
","title":"Exercice"},{"edit":"
"},{"solution":"
"}],[{"text":"
","title":"Exercice"},{"edit":"
"},{"solution":"
"}],[{"text":"
"},{"solution":"
"}],[{"text":"Proposer une modélisation pour un réseau de bus.
"},{"solution":"
","title":"Exercice"},{"edit":"
"},{"solution":"
"}],[{"text":"Source : http://tecfaetu.unige.ch/staf/staf-h/tassini/staf2x/Heidi/last_bd.htm"},{"edit":" "}]]
Considérons une activité : l'emprunt d’un livre dans une médiathèque municipale.
Alice trouve le livre qu’elle souhaite emprunter et approche d’une borne d'emprunt automatique. Elle scanne le code barre de sa carte de bibliothèque et des informations la concernant apparaissent :
« Alice, aucun livre en cours de prêt ».
Elle peut ensuite scanner le code barre apposé sur le livre. Les informations sont alors mises à jour pour afficher la liste des livres empruntés :
« La Programmation en pratique, B. Kernighan et R. Pike, Ed. Vuibert, 2017, ISBN 978-2711786701 ».
Sur la borne d’à côté, Basile vient rendre ses livres. Il scanne lui aussi sa carte et les informations le concernant apparaissent à l'écran :
« Basile, un livre en cours de prêt ».
Basile peut alors scanner le code barre du livre qu’il rapporte et ce dernier est supprimé de la liste.
Cette simple activité nous permet d'illustrer les caractéristiques d’un système d’information, c’est-à-dire d'un système technique (ici informatique) et humain permettant de gérer de l'information.
Que pouvons-nous dire sur le système informatique sous-jacent ?
En premier lieu, il contient une description d’objets (les livres), de personnes physiques (les usagers) et des
processus (l'emprunt et la restitution de livres).
Le système ne contient cependant qu’une «approximation» de la réalité :
En effet, il ne retient pour Alice et Basile que leur nom et prénom, éventuellement leur date d’inscription et
les livres en cours d'emprunt ;
Nous pourrions rajouter d’autres informations telle que :
- leur taille,
- la couleur de leurs yeux
- ou leur plat préféré ne sont pas connus du système.
De même pour les livres : seuls le titre, les auteurs, l'éditeur et l'ISBN (le numéro de série international unique attribué à chaque ouvrage publié) sont mémorisés. Le système ne retient donc que ce qui est nécessaire au bon fonctionnement des processus dont il facilite le déroulement : l'emprunt et le rendu de livres. Une telle « approximation » de la réalité s'appelle une modélisation.
Avant de préciser la façon de modéliser les données, finissons de passer en revue les différentes caractéristiques du système d’information de
la bibliothèque. Outre le stockage des données de chaque objet considéré (livres, usagers, emprunts, etc.), ce dernier doit garantir l'absence d’erreur.
Par exemple, si Basile repose son livre en rayon sans passer par une borne et qu’Alice tente de l’emprunter, le système doit détecter le problème et signaler que Basile a toujours le livre en sa possession.
De manière symétrique, si Alice rend un livre, alors le système doit effectivement garantir que quelqu'un d’autre peut l’emprunter.
Il y a un autre aspect que nous n'avons pas évoqué :
les documentalistes doivent pouvoir ajouter de nouveaux livres dans le système ou en retirer, par exemple quand ces derniers ont été perdus
ou sont en trop mauvais état.
Cependant, tout un chacun ne doit pas pouvoir modifier la liste des livres du système. Ce dernier doit donc permettre différents niveaux d'accès aux données. Enfin, on souhaite que quelle que soit la borne utilisée, la procédure soit la même.
Les données doivent donc être les mêmes. Il semble donc raisonnable de penser que ces données sont
stockées dans un même endroit et que les bornes ne sont que des clients permettant de consulter et modifier ces données de manière contrôlée.
Ces caractéristiques, et bien d’autres, sont celles d’un système de gestion de base de données. Ce dernier est le composant logiciel principal autour duquel est construit le système d’information.
Nous reviendrons sur ces aspects tout au long des séquences suivantes.
De manière générale, un modèle de données est une représentation (mathématique ou informatique) de concepts que l’on souhaite étudier.
Les intérêts d’une telle modélisation sont nombreux.
Un modèle permet d’énoncer des propriétés de ces données en termes logiques.
Il permet aussi de programmer des processus réels complexes (par exemple, emprunter un livre) sous
forme d’opérations élémentaires sur les données.
L'un des modèles de données les plus populaires est le modèle relationnel.
Ce dernier a été défini en 1970 par l’informaticien Américain Edgar F. Codd (1923-2003), alors qu’il était employé par IBM.
Dans ce modèle, un objet modélisé (on parle d’entité) est représenté par un n-uplet de valeurs scalaires et les collections d'objets par des ensembles de n-uplets.
Par exemple, le livre emprunté par Alice peut être représenté par le quintuplet suivant :
(’La Programmation en pratique’, ’B. Kernighan et R. Pike’, 'Vuibert’, 2017, '978-2711786701')
Dans ce dernier, quatre composantes sont des chaînes de caractères (le titre, les auteurs, le nom de l’éditeur et l’ISBN) et une composante est un entier
(l'année d'édition).
L'ensemble des livres de la bibliothèque peut alors être
représenté par un ensemble Livre de tels n-uplets :
Livre = {
(’La Programmation en pratique’,?B. Kernighan et R. Pike?, ’Vuibert’,2017,978-2711786701?), ('NSI 1ère : 30 leçons et exercices’, ?T. Balabonski, J.-C. Filliâtre, S. Conchon et K. Nguyen’, Ellipses”, 2019, °978-2340033641°), (’Zadig et autres contes’,’Voltaire’,’Folio’, 1992, °978-2070384815°), .....
}
On appelle un tel ensemble une relation. Une autre relation est l’ensemble Emprunt des livres actuellement empruntés :
Emprunt = {
(’La Programmation en pratique”, ’Alice’,01/04/2020), (Le Bouclier Arverne”, ’Charlie’,15/05/2020), (’Le Guide du routard galactique”, ’Charlie’,08/04/2020),...
Chaque relation se conforme à un schéma. Ce dernier est une description qui indique pour chaque composante des n-uplets de la relation leur nom et
leur domaine.
On appelle une telle composante un attribut. Par exemple, les éléments de la relation Livre possèdent cinq attributs :
- titre : le titre du livre, une chaîne de caractères;
- auteur : le ou les auteurs du livre, une chaîne de caractères;
- éditeur : l’éditeur du livre, une chaîne de caractères
- année : l’année de publication du livre, un entier naturel;
- isbn : l'identifiant unique du livre, une chaîne de caractères.
Une manière plus compacte de noter un schéma pour une relation est la suivante :
Livre(titre String, auteur String, éditeur String, année Int, isbn String)
Une base de données est un ensemble de relations.
Par exemple, la base de données de la médiathèque peut être composée de trois relations :
Livre, Emprunt et Usager.
Cette dernière, que nous n'avons pas encore décrite, recense toutes les personnes inscrites à la médiathèque.
Elle pourrait avoir le schéma suivant :
Usager(nom String, prénom String, code_barre String)
Dans une telle relation, on stocke les noms et prénoms des personnes ainsi que la suite de caractères que représente le code barre de leur carte.
En effet, cette information est nécessaire pour retrouver la personne à partir de son code barre imprimé sur sa carte.
Par extension, on appelle schéma d’une base
de données l’ensemble des schémas des relations constituant la base.
","title":"Le modèle relationnel"},{"edit":"Mettre le résultat ici (code et figure).
Modèle de données, structure de données.
Ces deux concepts présents en informatique se placent à différents niveau d’abstraction. Le modèle de données indique quelles caractéristiques d’une entités réelle on souhaite manipuler dans un programme.
Il indique aussi les relations des entités entre elles.
Par exemple, une personne peut emprunter plusieurs livres, mais un livre ne peut être emprunté que par au plus une personne.
Une structure de données indique la manière dont on va organiser les données en machine (dans un langage de programmation). Pour un même modèle de données (par exemple, un ensemble de noms) on peut choisir
plusieurs structures de données différentes (un tableau, une liste chaînée, un arbre binaire, . .….).
Mettre le résultat ici (code et figure).
Principes généraux
La théorie et la pratique des bases de données relationnelles est un domaine de recherche toujours actif, mais qui s’est fortement développé et complexifié depuis ses balbutiements dans les années 1970.
Nous ne proposons pas d'étudier ici cette théorie, qui irait bien au-delà du programme de terminale et demande des connaissances en mathématiques et en logique, notamment en théorie des ensembles.
Nous allons cependant essayer de donner les grands principes sous-jacents en les illustrant par des exemples.
Le fil conducteur de cette section sera l'exemple de la médiathèque que nous allons raffiner au fur et à mesure. La modélisation des données se décompose en plusieurs étapes :
1. déterminer les entités (objets, actions, personnes, etc.) que l’on sou-
********
2. modéliser les ensembles d’entités comme des relations en donnant leur schéma, en s’attachant en particulier à choisir le bon domaine pour chaque attribut ;
3. définir les contraintes de la base de données, c’est-à-dire l’ensemble des propriétés logiques que nos données doivent vérifier à tout moment.
D'autres modèles. Il existe d’autres modèles que le modèle relationnel. En effet, ce dernier est parfois trop « rigide » pour représenter certains types de données. Ainsi, pour représenter des documents ayant une structure complexe (chapitres, sections, sous-sections, titres, texte libre, mise en gras ou en italique, tables, images, etc.) le modèle relationnel basé sur des ensembles de n-uplets est peu adapté.
On pourra faire appel dans ce cas à des modèles dits semi-structurés.
Un autre modèle de données est le modèle de graphe. Par exemple, si l’on souhaite représenter un réseau
social (une personne peut avoir des amis qui eux-mêmes peuvent avoir des amis, etc.) et effectuer dessus des traitements comme : « trouver tous les amis de mes amis qui ont les même centres d’intérêts que moi » alors le modèle relationnel est là encore peu adapté.
Faire cohabiter ces différents modèles dans un même système d’information permet d’effectuer des traitements riches, mais complexifie énormément la conception du système.
Mettre le résultat ici (code et figure).
Une contrainte d’intégrité est une propriété logique, préservée à tout instant par la base de données et qui garantit la cohérence des données.
En d’autres termes, une contrainte d'intégrité est un invariant de la base de données.
On distingue quatre grandes catégories de contraintes d’intégrité jouant des rôles complémentaires.
Considérons en premier lieu la relation des usagers, que l’on va rendre un peu plus réaliste.
Normalement, lorsqu'une personne s'inscrit dans une médiathèque, elle donne non seulement son nom et
son prénom, mais aussi son adresse.
Cette dernière peut servir à déterminer son tarif d'abonnement (par exemple, les gens qui habitent dans la ville de la médiathèque ont un tarif préférentiel) ou à envoyer des courriers de relance.
De nos jours, il est aussi commun de stocker une adresse e-mail. Lors de l'inscription, la personne obtiendra une carte avec un code barre et ce dernier doit donc également être associé à l'usager.
Chacune des propriétés que l'on souhaite renseigner pour un usager correspondant à un attribut pour la relation Usager
.
Il peut être compliqué de décider si une propriété complexe (par exemple l'adresse) doit être séparée en plusieurs attributs.
Ce découpage est important car il va influencer la façon dont on va interroger les données stockées.
Nous proposons la modélisation suivante :
Usager(nom String, prénom String, adresse String, cp String, ville String, email String, code_ barre String)
On peut s'étonner ici que les attributs soient tous représentés par des chaînes de caractères.
Le code postal (attribut cp) et le code barre (attribut
code_barre) sont a priori des suites de chiffres.
On pourrait donc vouloir les représenter par des entiers.
Le problème est que ces suites de chiffres peuvent commencer par le chiffre 0, non significatif pour les entiers. Ainsi, le code postal de la ville d’'Oyonnax est 01100. Le stocker comme un entier reviendrait à stocker l’entier 1100, ce qui peut être problématique par la suite.
Dans un premier temps, nous allons nous abstraire lors de la modélisation des aspects techniques propres aux systèmes de gestion de bases de données et au langage SQL.
Nous proposons donc d’utiliser des domaines génériques, inspirés des types de données des langages de programmation :
- String représente les chaînes de caractères
- Int représente les entiers signés (qu’on suppose de taille arbitraire, comme l es entiers de Python)
- Boolean représente les valeurs booléennes True et False
- Float représente les nombres flottants.
- Date représente des dates (jour/mois/année)
- Time représente des instants (heure : minute : seconde)
Le choix des domaines est particulièrement important, car il doit répondre à deux impératifs :
- permettre de représenter exactement et sans perte d’information toutes les valeurs possibles pour un attribut ;
- limiter autant que possible la saisie de valeurs illégales ou mal formées
Les contraintes de domaines sont toutes les propriétés que le domaine d’un attribut va permettre de garantir.
Par exemple, si l’on souhaite représenter un choix binaire (abonné/non abonné, présent/absent, etc.) le domaine Boolean ne contenant que deux valeurs permet de garantir la contrainte que l’attribut ne peut pas avoir de troisième valeur.
De même, si l’on souhaite stocker l’âge d'une personne, le domaine Int est plus approprié que String, ce dernier permettant de représenter des valeurs qui ne sont clairement pas des âges (par exemple 'Toto').
En revanche, l'utilisation seule du domaine Int ne permet pas de garantir l’absence de données incohérentes dans la base. Ainsi, des valeurs telles que -10 ou 45000 sont des entiers valides mais è priori pas des ages raisonnable pour des personne.
","title":"Contrainte de domaine"},{"edit":"La contrainte d’entité permet de s’assurer que chaque
élément d’une relation est unique et identifie une entité de manière non ambiguë.
Considérons une relation Usager où l’on n'aurait stocké que les noms et prénoms des personnes.
Il est relativement courant que deux personnes portent le même nom de famille et le même prénom, surtout dans des villes assez peuplées.
Si ces deux personnes s'inscrivent toutes les deux à la médiathèque, la relation Usager contiendra deux couples identiques, ce qui poserait problème.
Pour éviter cette situation, il faut s'assurer, lors de la modélisation, que pour chaque entité d’une relation, un attribut ou en ensemble d’attributs permet d'identifier cette entité de manière unique.
La relation Usager définie à la section précédente respecte bien cette contrainte. En effet, le code barre est unique (car la carte associée est donnée à la personne au moment où elle s'inscrit et on peut supposer que le système ne réutilise pas un numéro déjà attribué).
On appelle un tel ensemble d’attributs la clé
primaire de la relation.
On indique cela en les soulignant dans le schéma :
Usager(nom String, prénom String, adresse String, cp String, ville String, email String, code_barre String)
Notons que les attributs pouvant jouer le rôle de clé primaire peuvent ne pas être uniques. Dans notre cas, on pourrait imaginer que l’adresse email puisse aussi jouer le rôle de clé primaire. Ou encore, la combinaison du nom, du prénom, de l’adresse, du code postal (attribut cp) et de la ville ensembles jouent le rôle de clé primaire.
Mais attention, le choix de la clé primaire est important, car le système garantira son unicité (pour préserver la contrainte d’entité). En fonction des choix, certains cas d’utilisation seront impossibles.
Par exemple, si l’on choisit l’adresse email, alors il ne sera pas possible pour un parent de renseigner son adresse e-mail dans le compte de ses enfants l’adresse devant être unique pour chaque entité de la relation.
De même, si on choisit la combinaison des noms, prénoms, adresses, code postal et ville, il faut s’assurer que l’adresse est suffisamment précise pour distinguer deux personnes homonymes qui habiteraient le même immeuble de la même ville.
Dans le cadre de la relation Livre, on peut redonner le schéma initial en utilisant l'ISBN comme clé primaire :
Livre(titre String, auteur String, éditeur String, année Int, isbn String)
Encore une fois, cette modélisation est raisonnable.
Utiliser uniquement le titre ou le couple titre et auteurs comme clé primaire aurait posé problème si la bibliothèque avait en stock le même livre dans deux versions différentes (par exemple en livre de poche et en grand format illustré).
L’isbn lui-même peut ne pas être suffisant si la médiathèque dispose de plusieurs copies du même ouvrage. Il faudrait alors distinguer ces différentes copies dans la base de données, par exemple en ajoutant un identifiant unique sur chaque exemplaire pour servir de clé (par exemple un code barre unique ajouté par la médiathèque).
Mettre le résultat ici (code et figure).
Les clés primaires ne permettent pas seulement
de distinguer les entités de manière unique.
Elles permettent aussi de servir de référence dans une autre relation.
Intéressons nous maintenant à la relation Emprunt. L'exemple que l’on a donné en introduction est naïf, car
il stocke dans cette table le prénom de l'utilisateur, le titre du livre et la date de rendu.
On pourra plutôt définir la relation Emprunt avec le schéma suivant :
Emprunt(code_barre ; String, isbn : String, retour : Date)
Ici, code_barre et isbn sont des clés étrangères.
Cela signifie que la valeur de l’attribut code _barre dans la relation Emprunt doit être l’une des valeurs existantes pour cet attribut dans la relation Usager.
De même, isbn doit correspondre à un isbn existant dans la relation Livre. Cette contrainte permet de garantir que la relation Emprunt ne mentionne que des livres et des usagers connus de la base de données.
Elle permet d'éviter de rajouter des valeurs fictives ne correspondant à aucun utilisateur ou à aucun livre.
De manière plus importante, elle empêche aussi de supprimer des entités des relations Livre et Usager. En particulier, si la relation Emprunt contient l’entité
(\"123456789\", \"978-2340033641\", 07/03/2020),
alors retirer l’utilisateur dont le code barre est \"23456789\" de la relation Usager est une violation de la contrainte de référence, car la valeur \"123456789\" ne
serait plus celle d’une clé primaire dans la relation Usager (et d'un point de vue pratique, cela permet de s'assurer qu'avant de désinscrire une personne, cette dernière a rendu tous ses livres).
Une autre remarque que l’on peut faire sur le schéma Emprunt est que l’isbn est déclaré comme clé primaire de la relation. Cela implique qu’un même livre ne peut apparaître dans deux entités distinctes. Là encore, on
voit que la contrainte nous permet de garantir la cohérence des données :
il n’est pas possible qu’un même livre soit emprunté par deux usagers en même temps.
Une dernière observation importante sur l’utilisation des clés étrangères est qu'elle permet de créer des associations multiples entre entités de différentes relations.
Ici, on peut associer au même utilisateur plusieurs livres
en cours d'emprunt. En effet, code_barre n'étant qu’une clé étrangère, il n’a pas à être unique dans la relation Emprunt :
un même utilisateur a le droit d’emprunter plusieurs livres. En d’autres termes, nous pouvons par ce moyen associer à un utilisateur une liste de livres.
Nous pouvons utiliser cette technique pour pallier un défaut de conception de la relation Livre.
En effet, dans cette dernière, nous avons représenté les auteurs du livre comme un chaîne de caractères dans laquelle est écrite la liste des auteurs.
Bien que cette modélisation fonctionne, elle ne permet pas d'exprimer certaines contraintes sur les données, par exemple qu’un même auteur n’apparaît pas deux fois pour le même livre.
En effet. les chaînes de caractères étant arbitraires, on peut y saisir n'importe quoi. L'utilisation de clés étrangères va nous permettre de remédier à ce problème. On simplifie dans un premier temps le schéma de la relation Livre pour ne plus mentionner les auteurs :
Livre(titre : String, éditeur : String, année : Int, isbn : String)
On peut ensuite créer une nouvelle relation, Auteurs ayant le schéma suivant :
Auteur(a_id : Int, nom : String, prénom : String)
Ici, l’attribut a_id est un identifiant d’auteur unique, associé à l’auteur lorsque l'employé de la médiathèque rajoute un nouvel auteur dans la base.
La relation Auteur pourrait par exemple être la suivante :
{ (0, ’Goscinny”,’René’), (10, ’Kernighan’,’Brian’),
(2, ’Conchon’,’Sylvain’), (42, ’Filliâtre’, Jean-Christophe’), (4, ’Pike’,’Rob”’), (19, ’Balabonski”,’Thibaut’), (23, ’Uderzo”,’Albert’), (77, Nguyen’, ’Kim’), ... }
La seule contrainte sur les identifiants est qu’ils doivent être uniques.
Il n’y a en particulier aucune notion d'ordre. Munis des relations Livre et Auteur, nous pouvons associer des auteurs à des livres au moyen de la relation Auteur_ de :
Auteur_de(a_id : Int, isbn : String)
Cette relation associe des auteurs à des livres. Les attributs a_id et isbn sont des clés étrangères faisant référence aux relations Auteur et Livre respectivement.
Le couple de ces deux attributs forment la clé primaire de la table Auteur_de. Cela empêche qu’un même auteur et un même livre apparaissent deux fois dans la relation et donc qu’un même auteur soit mentionné deux fois pour le même ouvrage.
En revanche, rien n'empêche qu’un même auteur apparaisse plusieurs fois pour des ouvrages différents, ou que différents auteurs apparaissent pour le même ouvrage.
Attention cependant, si un isbn n'apparaît pas dans cette relation, c’est que le livre correspondant n’a pas
d'auteur. Les contraintes de clé primaires et étrangères ne permettent pas d'empêcher ce cas de figure.
Nous terminons ce tour d’horizon des contraintes
d’intégrité par les contraintes utilisateurs (parfois appelées contraintes métier).
Ces dernières sont toutes les contraintes d’une relation qu’on ne peut exprimer par les trois précédentes. Un exemple de contrainte utilisateur est qu’un âge de personne doit être positif et inférieur à 200. Pour notre médiathèque, une autre contrainte utilisateur pourrait être que la chaîne de caractères représentant l'e-mail contienne un et un seul caractère « @ ».
Ces contraintes, liées à l’utilisation que l’on veut faire de la base de données,sont importantes mais difficilement exprimables dans la syntaxe très simple
des schémas.
On veillera donc à en faire une description précise en français.
Nous verrons dans la séquence suivant que les systèmes de gestion de bases de données proposent une syntaxe pour écrire certaines de ces contraintes.
Le modèle relationnel est un modèle dans lequel
les données sont représentées par des ensembles de n-uplets appelés des relations.
Un élément d’une relation est appelé une entité. Il représente généralement un objet, une action, une personne du monde réel.
Chaque entité possède des propriétés appelées des attributs.
On spécifie une relation en donnant son schéma, c’est-à-dire son nom, la liste de ses attributs avec leur domaine, c’est-à-dire l’ensemble des valeurs que peuvent prendre un attribut.
Une base de données est un ensemble de relations et le schéma d’une base est l’ensemble des schémas des
relations qui la compose.
La cohérence des données au sein d’une base est assurée par des contraintes d’intégrité.
Ces dernières sont des invariants, c’est-à-dire des propriétés logiques que les données doivent vérifier à tout instant.
On distingue parmi ces contraintes :
Les contraintes d’entité qui garantissent que chaque entité d’une relation est unique.
Une clé primaire est un ensemble d’attributs qui identifie chaque entité de la relation de manière unique et garantit la contrainte d’entité.
Les contraintes de référence qui créent des associations entre deux relations. Elle permettent de garantir qu’une entité d’une relation B mentionne une entité existante dans une relation A.
Une clé étrangère est un ensemble d’attributs d’une table qui sont une clé primaire dans une autre table.
Les contraintes de domaines qui restreignent les valeurs d’un attribut à celles du domaine et évitent que l’on puisse donner à un attribut une valeur illégale.
Les contraintes utilisateurs qui restreignent encore plus les valeurs d’un ou de plusieurs attributs et sont guidées par la nature des données que l’on souhaite stocker dans la base.
Toutes ces contraintes doivent être utilisées pour assurer la qualité des données :
elles permettent de s'assurer que les données sont « conformes » aux entités du monde réel qu’elles représentent.
","title":" Conclusion"},{"edit":"Mettre le résultat ici.
On souhaite modéliser un annuaire téléphonique simple dans lequel chaque personne (identifiée par son nom et son prénom) est associée
à son numéro de téléphone.
Proposer une modélisation relationnelle de cet
annuaire.
","title":"Exercice"},{"edit":"Mettre le résultat ici (code et figure).
De façon très simple, on peut modéliser l'annuaire
de la manière suivante :
Annuaire(nom String, prénom String, tel String)
On n’oubliera pas de préciser que le numéro, par définition unique, est une clé primaire. Son domaine peut être String afin d’éviter les problèmes de 0 en première position ou de permettre de saisir des caractères non numériques
comme +.
Donner la modélisation relationnelle d’un bulletin scolaire.
Cette dernière doit permettre de mentionner :
- des élèves, possédants un numéro d'étudiant alphanumérique unique;
- un ensemble de matières fixées, mais qui ne sont pas données;
- au plus une note sur 20, par matière et par élève.
On prendra soin de préciser toutes les contraintes utilisateurs qui ne peuvent êtres inscrites dans les schémas des relations.
","title":"Exercice"},{"edit":"Mettre le résultat ici (code et figure).
La modélisation consiste en trois relations
Eleve(nom String, prénom String, num String)
Matiere(intitule String, m_ind INT)
Note(num String, m_id INT, note Float)
On n’a pas moyen de forcer que la valeur de la note soit comprise entre 0 et
20. On à fait le choix de donner un indentifiant numérique à la matière.
On considère la solution donnée pour l'exercice précédent sur l'annuaire.
Dire si chacun des ensembles est une relation valide pour le schéma Annuaire.
Annuaire(nom : String, prénom : String, tel :String)
1. { }
2. {('Titi', 'Toto', '0123456789' )}
3. {( 'Titi', 'Toto’, '0123456789'), (’Doe”, 'John’, '0123466789’ )}
4.{('Titi','Toto', '0123456789'), ('Titi', 'Toto', '987654343210' )}
5. {('Titi', 'Toto', '0123466789'), (’Doe’,’John’)}
6. {('Titi',’Toto’, 42)}
Mettre le résultat ici (code et figure).
1. Oui, la relation vide est un ensemble valide
2. Oui, la relation ne contient qu’un triplet bien formé
3. Non, les deux triplets ont la même valeur pour l’attribut tel qui est une clé primaire.
4. Oui, les deux clés primaires des deux entités sont différentes.
5. Non, l’ensemble contient un couple, qui n’est pas une entité bien formée pour le schéma Annuaire
6. Non, l’ensemble contient un triplet dont la clé primaire est un nombre et non pas une chaîne
On considère la solution donnée pour l'exercice sur les bulletins scolaires. Dire si chacun des ensembles est une relation valide pour le schéma de la base de données du bulletin de notes,
1 - Eleve={}
- Matiere = {}
- Note={}
2. - Eleve= {(’Titi’,’Toto',’AB56789'), }
- Matiere = {('NSI’,0), (’Sport',1)}
- Note = {(’AB56789',1,17)}
3 - Eleve= {('Titi','Toto','AB56789'),}
- Matiere = {('NS1',0)}
- Note = {('AB56789',1,17)}
4. - Eleve= {('Titi','Toto','AB56789'), }
- Matiere = {('NSI',0),}
- Note = {('AB56789',0, 17), ('AB56789',0, 18)}
5. - Eleve= {('Titi','Toto','AB56789'),}
- Matiere = {('NSI',0),('Sport',1)}
- Note = {('AB56789',0, 17), ('AB56789',1,17)}
Mettre le résultat ici (code et figure).
1. Oui, les relation vides sont des ensembles valides
2. Oui, les données sont cohérentes
3. Non, l'identifiant 1 n’est pas une clé primaire dans Matiere
4. Non, il y a deux triplets avec la même clé primaire composite ('AB56789',0) dans Note
5. Oui, la note n'étant pas à la clé primaire de Note on peut avoir deux
entités avec la même note.
Modéliser des informations sur les départements français.
Pour chaque département on veut pouvoir stocker son nom, son code, son chef-lieu et la liste de tous les départements voisins.
Attention, les codes de département sont tous des nombres, sauf la Corse du Sud et la Haute Corse
qui ont les codes 2A et 2B respectivement,
Les départements d'Outre-Mer ont un code sur trois chiffres (de 971 à 976).
Proposer une contrainte utilisateur permettant d'éviter la redondance d'information dans la liste des
voisins.
","title":"Exercice"},{"edit":"Mettre le résultat ici (code et figure).
On pourra utiliser la modélisation suivante :
Departement(nom String, chef_lieu String, code String)
Voisin(dep1 String, dep2 String)
La relation Voisin stocke les couples (d1 , d2) des code de deux départements :
si d1 est voisin de d2.
Pour éviter de stocker aussi (d2, d1), on peut rajouter
la contrainte que le code de d1 est plus petit que celui de d2 (au sens de la comparaison des chaînes de caractères).
Par exemple on stockera (91,92) pour indiquer que l'Essonne et les Hauts-de-Seine sont voisins, mais pas
(92,91).
Cette dernière doit être suffisamment riche pour permettre de générer, pour chaque arrêt de bus du réseau, une fiche horaire avec tous les horaires de passage de toutes les lignes de bus qui desservent l'arrêt.
Indication : ici, plus qu'une simple traduction du français vers le modèle relationnel, on essayera de déterminer dans un premier temps quelles informations sont pertinentes et comment les représenter. On pourra ensuite procéder à la modélisation sous forme de relations.
","title":"Exercice"},{"edit":"Mettre le résultat ici (code et figure).
Considérons dans un premier temps les informations
pertinentes :
- Le réseau est constitué d’arrêts de bus. Un arrêt peut être représenté par ses coordonnées GPS (latitude et longitude, deux nombres à virgule), son nom et un identifiant unique.
- Une ligne de bus est représenté par un numéro unique et un nom (le nom est juste une chaîne de caractères permettant d'identifier la ligne simplement, comme ’Centre-Ville - Aéroport”)
- Les horaires de passage. Pour chaque ligne et chaque arrêt desservi par cette ligne, on stocke la liste des horaires de passage, ainsi qu’une indication sur le jour de validité de l’horaire. Un horaire peut être valide en semaine, le samedi ou le dimanche/jour férié.
Une fois faite cette analyse, on peut proposer la modélisation en trois relations
Arret(lat Float, lon Float, nom String, a_id Int)
Ligne(num Int, nom String)
Horaire(num Int, a_id Int, heure Time, jour String)
On remarque qu’un horaire de passage est identifié de manière unique par a_id Int, heure et jour.
"}],[{"text":"On considère deux relations R(a Int,b Int,c Int) et
S(a Int,e Int) où l’attribut a de S est une clé étrangère faisant référence à a de R. Dire si les affirmations suivantes sont vraies ou fausses, en justifiant.
1. Les a de R sont tous deux à deux distincts.
2. Les b de R sont tous deux à deux distincts.
3. Les a de S sont tous deux à deux distincts.
4. Les e de S sont tous deux à deux distincts.
5. S peut être vide alors que R est non vide.
6. R peut être vide alors que S est non vide
Mettre le résultat ici (code et figure).
1. Vrai. L’attribut a étant une clé primaire, tous les a sont distincts dans R.
2. Faux. L’attribut b n'intervient pas dans la clé. Ses valeurs peuvent se répéter, par exemple l’ensemble {(1,2, 3), (2,2,3)} est une instance valide du schéma R.
3. Faux. L’attribut a de S, considéré seul, est une clé étrangère. La seule contrainte est qu’il doit avoir la même valeur que la valeur d’un a de R.
4. Faux. L'attribut e seul n’a pas de contrainte. Il participe à la clé primaire de $, il faut donc que les couples (a,e) soient deux à deux distinct.
5. Vrai. Si S est vide, elle respecte bien la propriété que chaque valeur de a de S (il n’y en à pas) référence une valeur de a dans R.
6. Faux. Si S est non vide, c’est qu’elle contient au moins une entité. L’attribut a pour cet entité doit forcément référencer un a existant dans R qui ne peut donc pas être vide.
- Détails
- Écrit par : Richard GAUTHIER
- Clics : 1074