BASE DE DONNÉES
Chapitre 2 : Le langage SQL
Nous avons eu l'occasion d'étudier la structure d'une base de données
relationnelle, nous allons maintenant apprendre à réaliser des requêtes, c'est-à- dire que nous allons apprendre à créer une base de données, créer des
attributs, ajouter de données, modifier des données et enfin, nous allons surtout apprendre à interroger une base de données afin d'obtenir des informations.
Pour réaliser toutes ces requêtes, nous allons devoir apprendre un langage de requêtes : SQL (Structured Query Language). SQL est propre aux bases de données relationnelles, les autres types de bases de données utilisent d'autres langages pour effectuer des requêtes.
Pour créer une nouvelle base de données, nous allons utiliser un logiciel : DB Browser for SQLite.
SQLite est un système de gestion de base de données relationnelle très répandu.
Noter qu'il existe d'autres systèmes de gestion de base de données relationnelle comme MySQL ou PostgreSQL.
Dans tous les cas, le langage de requête utilisé est le SQL (même si parfois on peut noter quelques petites différences).
Ce qui sera vu ici avec SQLite pourra, à quelques petites modifications près, être utilisé avec, par exemple, MySQL.
Lancer le logiciel DB Browser for SQLite
Vous devriez obtenir l' affichage suivant
Création d'une BDD
Cliquez sur Nouvelle base de données. Après avoir choisi le dossier de
destination et un nom pour votre base de données (par exemple "essai_BDD"), vous devriez avoir la fenêtre suivante :
A ce stade, la base de donnée a été créée mais elle ne contient aucune relation (ou table)
Pour créer une table dans cette BDD, il faut compléter la fenêtre précédente.
Nous allons créer la table FILMS étudiée dans le chapitre précédent.
id titre id_realisateur ann_sortie note_sur_10
1 Alien, le huitième
passager 1 1979 10
2 Dune 2 1985 5
3 2001 : l'odyssée de
l'espace 3 1968 9
4 Blade Runner 1 1982 10
Schéma relationnel :
FILMS(id, titre, #id_realisateur, ann_sortie, note_sur_10)
Nom de la table (ou relation) Ajout d'un champ , c'est ce qui correspond à un attribut
Les attributs peuvent avoir des particularités comme être une clé primaire (CP) ou s'autoincrémenter (IA)
Dans le type vous avez alors
différents choix : INTEGER, TEXT, BLOB, REAL, NUMERIC. Sans
entrer dans le détail, INTEGER est à indiquer si votre colonne contiendra des nombres entiers, TEXT si elle contient des chaines de caractères, les autres ont moins d'importance.
Rq. Le type REAL permet de stocker des nombres décimaux (float). Le type NUMERIC et le type DECIMAL permettent de stocker des valeurs entières ou décimales avec précision à réserver pour des grands nombres). Le type BLOB permet de stocker des valeurs binaires. Il existe également le type DATE permettant de créer des dates mais le logiciel utilisé dans le cadre du cours ne le gère pas.
Ci-dessus se fabrique la requête SQLau fur et à mesure que vous remplissez la partie "Ajouter un champ"
Exercice 1 : Créer la table FILMS en renseignant correctement la fenêtre précédente.
Schéma relationnel :
FILMS(id, titre, #id_realisateur, ann_sortie, note_sur_10)
La relation a bien été créée mais elle ne possède actuellement aucune données.
Nous allons la remplir en entrant cette fois directement une requête SQL d'insertion
Voici la requête SQL correspondant à la création de la table FILMS CREATE TABLE "FILMS" (
"id" INTEGER PRIMARY KEY AUTOINCREMENT,
"titre" TEXT,
"id_realisateur" INTEGER,
"ann_sortie" INTEGER,
"note_sur_10" INTEGER );
Dans l'onglet "Exécuter le SQL", entrer la requête suivante
puis cliquer sur le petit triangle bleu (play) pour exécuter la requête : INSERT INTO FILMS (id,titre,id_realisateur,ann_sortie,note_sur_10) VALUES
(1,'Alien,le huitième passager',1,1979,10), (2,'Dune', 2,1985,5),
(3,"2001 : l'odyssée de l'espace",3,1968,9), (4,'Blade Runner',1,1982,7);
Message de succès si tout s'est bien passée.
La table FILMS contient bien les données souhaitées (onglet "Parcourir les données") :
Sélectionner des données
Nous allons apprendre à effectuer des requêtes d'interrogation sur la base de données que nous venons de créer.
Toutes les requêtes se feront dans la fenêtre SQL 1 de l'onglet "Exécuter le SQL"
Saisissez la requête suivante :
SELECT id, titre, id_realisateur, ann_sortie, note_sur_10 FROM FILMS;
Après avoir exécutée la requête, vous devriez voir s'afficher les données demandées
Comme vous pouvez le constater, notre requête SQL a permis d'afficher tous les FILMS. Nous avons ici 2 mots clés du langage SQL SELECT qui permet de sélectionner les attributs qui devront être "affichés" (je mets "affichés" entre guillemets, car le but d'une requête sql n'est pas forcément d'afficher les données) et FROM qui indique la table qui doit être utilisée.
Il est évidemment possible d'afficher seulement certains champs (voire un seul) : saisissez la requête sql suivante :
SELECT titre, ann_sortie FROM FILMS;
Vérifiez que vous obtenez bien uniquement les titres et les années de sorties des films
Exercice 2 : Ecrivez et tester une requête permettant d'obtenir uniquement les titres des films.
Pour l'instant nos requêtes affichent tous les films, il est possible d'utiliser la commande WHEREafin d'imposer une (ou des) condition(s) permettant de sélectionner uniquement certaines entrées (films).
La condition doit suivre le mot-clé WHERE : Saisissez et testez la requête sql suivante :
SELECT titre, ann_sortie FROM FILMS WHERE note_sur_10=10;
Exercice 3 : Écrivez et testez une requête permettant d'obtenir uniquement les films et leurs années de sortie réalisés par le réalisateur 1.
RQ : Si vous désirez sélectionner tous les champs, vous pouvez écrire : SELECT * FROM FILMS;
à la place de :
SELECT id, titre, id_realisateur, ann_sortie, note_sur_10FROM FILMS;
Il est possible de combiner les conditions à l'aide d'unOR ou d'un AND Saisissez et testez la requête sql suivante :
SELECT titre, ann_sortie FROM FILMS WHERE id_realisateur=1AND ann_sortie>1979;
Exercice 4 : Écrire une requête permettant d'obtenir les titres des films publiés après 1970 qui ont une note supérieure ou égale à 6.
Correction :
SELECT titre FROM FILMS WHERE ann_sortie> 1970AND note_sur_10>6;
Il est aussi possible de rajouter la clause SQL ORDER BY afin d'obtenir les résultats classés dans un ordre précis.
Saisissez et exécuter la requête suivante :
SELECT titre FROM FILMS ORDER BY ann_sortie;
Il est possible d'obtenir un classement en sens inverse à l'aide de la clause DESC Saisissez et exécuter la requête suivante :
SELECT titre FROM FILMS ORDER BY ann_sortie DESC;
Cette requête est également possible
SELECT titre FROM FILMS ORDER BY id_realisateur DESC,note_sur_10ASC;
Il est aussi possible de limiter le nombre de données retournée par une requête en rajoutant la clause SQL LIMIT suivie du nombre de ligne maximale que vous désirez
Saisissez et exécuter la requête suivante :
SELECT titre FROM FILMS ORDER BY ann_sortie LIMIT 1;
Cette requête vous donnera ainsi le film le plus ancien
Il est aussi possible d'effectuer des recherches de portions de caractères contenus dans un attribut en utilisant la clause SQL LIKE suivie de la chaine de caractère que vous recherchez. On utilise le symbole % pour compléter la partie de la chaine qui pourra varier d'une ligne à l'autre
Saisissez et exécuter la requête suivante :
SELECT titre FROM FILMS WHERE titre LIKE 'DU%';
Cette requête vous donnera ainsi le film contenant DU...
La requête suivante :
SELECT id_realisateur FROM FILMS;
retourne plusieurs fois le même id de réalisateur
En fait les réalisateurs qui ont fait plusieurs films dans cette table Il est possible d'éviter les doublons grâce à la clause DISTINCT Saisissez et exécutez la requête suivante :
SELECT DISTINCT id_realisateur FROM FILMS;
Exercice 5 : Ecrivez la requête permettant d'obtenir tous les films contenant la lettre 'u' dans leurs titres.
Correction
SELECT titre FROM FILMS WHERE titre LIKE '%u%';
Pour des raisons de commodité ou de clarté, il est possible de renommer les colonnes de la table de résultat obtenu après une requête, on utilise le mot clé AS (création d'un Alias)
Saisissez et exécutez la requête suivante :
SELECT note_sur_10AS note FROM FILMS;
CREATE TABLE "REALISATEURS" (
"id" INTEGER PRIMARY KEY AUTOINCREMENT,
"nom" TEXT,
"prenom" TEXT,
"ann_naissance" INTEGER );
Nous avons vu qu'une BDD peut contenir plusieurs relations (tables) Nous allons créer la tableau REALISATEURS à l'aide de la requête SQL suivante :
Exercice 6 : Ajoutez des données à la table REALISATEURS en créant la requête d'insertion nécessaire.
id nom prenom ann_naissance
1 Scott Ridley 1937
2 Lynch David 1946
3 Kubrick Stanley 1928
Les jointures de table
Correction :
INSERT INTO REALISATEURS
(id,nom,prenom,ann_naissance) VALUES (1,'Scott','Ridley',1937),
(2,'Lynch','David',1946),
(3,'Kubrick','Stanley',1928);
Pour illustrer l'importance des clés primaire et étrangère nous allons créer une clé étrangère sur la table FILMS. Cette clé doit lier les deux tables. Elle
s'applique à l'attribut id_realisateur et est liée à la clé primaire id de la table REALISATEURS
Schéma relationnel :
FILMS(id, titre, #id_realisateur, ann_sortie, note_sur_10) Schéma relationnel :
REALISATEURS(id, nom, prenom, ann_naissance)
Modifions dans le logiciel la table FILMS
Faites un clic droit sur la table FILMS
Agrandissez la fenêtre de modification (cf. ci-dessous) pour faire apparaitre la colonne Clé étrangère
Effectuez les modifications suivantes :
La table que nous voulons lier: REALISATEURS
L'attribut de la table REALISATEURS que nous utiliserons : id (Rappel : c'est une clé primaire dans la table REALISATEURS)
Entrer ensuite les informations suivantes : ON DELETE CASCADE ON UPDATE CASCADE
Vérifier que la clé étrangère est bien créée.
CREATE TABLE "FILMS" (
"id" INTEGER PRIMARY KEY AUTOINCREMENT,
"titre" TEXT,
"id_realisateur" INTEGER,
"ann_sortie" INTEGER,
"note_sur_10" INTEGER,
FOREIGN KEY("id_realisateur") REFERENCES "REALISATEURS"("id") ON DELETE CASCADE
ON UPDATE CASCADE );
On voit à la fin de la requête SQL la création de la clé étrangère (FOREIGN KEY), elle est bien crée sur l'attribut
"id_realisateur" et créé le lien (REFERENCES) sur la table REALISATEURS attribut id.
Nous avons spécifié une
contrainte de suppression et de mise à jour sur la clé étrangère avec ON DELETE CASCADE et ON UPDATE CASCADE.
Cela veut dire que si nous supprimons des entrées dans la table
REALISATEURS, les lignes en référence dans la table FILMS seront, elles aussi, supprimées. (en d'autres termes, si on supprime des réalisateurs de la table REALISATEUR, leurs films seront supprimés de la table FILMS).
De même, si on modifie l'id d'un réalisateur de la table REALISATEUR, la
modification aura également lieu dans la table FILMS. L'attribut l'id_realisateur sera modifié.
INSERT INTO FILMS (id,titre,id_realisateur,ann_sortie,note_sur_10) VALUES (5,"The Island",45,2005,8);
Dans le chapitre précédent, nous avons vu l'intérêt de la création des clés étrangères.
Vous voyez avec l'exemple précédent, l'intérêt pour la gestion de la BDD en cas de suppression ou de mise à jour.
Essayons maintenant une requête d'insertion avec une donnée fausse.
Dans cette requête l'id_realisateur45 ne correspond à aucun réalisateur de la table REALISATEURS.
Essayez d'exécuter cette requête dans l'onglet Exécuter le SQL du logiciel.
Vous devriez avoir un message d'erreur du type : Result: FOREIGN KEY constraint failed
indiquant une insertion impossible à cause d'une contrainte sur la clé étrangère.
Voilà un autre intérêt des clé étrangères.
Nous avons 2 tables, grâce aux jointures nous allons pouvoir associer ces 2 tables dans une même requête.
En général, les jointures consistent à associer des lignes de 2 tables. Elles permettent d'établir un lien entre 2 tables.
SELECT * FROM FILMS,REALISATEURS
WHERE FILMS.id_realisateur = REALISATEURS.id;
Observez le résultat obtenu
Jointure de tables
La requête précédente peut également s'écrire de la manière suivante : SELECT * FROM FILMS INNER JOIN REALISATEURS ON
FILMS.id_realisateur = REALISATEURS.id
La sélection s'effectue sur plusieurs table :
SELECT .... FROM TABLE1,TABLE2 WHERE condition
Elle est associée à une condition qui spécifie le lien qui existe entre ces deux tables.
Vous l'aurez remarquez, c'est en fait la relation clé primaire/ clé étrangère qui est spécifiée.
Le FROM FILMS,REALISATEURS permet de créer une jointure entre les tables FILMS et REALISATEURS (donc en fait, si vous avez bien regardé le résultat, de "rassembler" les tables FILMS et REALISATEURS).
Le WHERE FILMS.id_realisateur = REALISATEURS.id signifie qu'une ligne quelconque A de la table FILMS devra être fusionnée avec la ligne B de la table REALISATEURS à condition que l'attribut id_realisateur de la ligne A soit égal à l'attribut id de la ligne B
Par exemple, la ligne 1 (id=1) de la table FILMS (que l'on nommera dans la suite ligne A) sera fusionnée avec la ligne 1 (id=1) de la table REALISATEURS (que l'on nommera dans la suite B) car l'attribut id_ realisateur de la ligne A est égal à 1 et l'attribut id de la ligne B est aussi égal à 1.
Par exemple, la ligne 1 (id=1) de la table FILMS (que l'on nommera dans la suite ligne A) ne sera pas fusionnée avec la ligne 2 (id=2) de la table REALISATEURS (que l'on nommera dans la suite B) car l'attribut id_ realisateur de la ligne A est égal à 1 et l'attribut id de la ligne B est égal à 2.
id titre id_realisateur ann_sortie note_sur_10 1 Alien, le huitième
passager 1 1979 10
2 Dune 2 1985 5
3 2001 : l'odyssée de
l'espace 3 1968 9
4 Blade Runner 1 1982 10
id nom prenom ann_naissance
1 Scott Ridley 1937
2 Lynch David 1946
3 Kubrick Stanley 1928
Essayez cette nouvelle requête:
SELECT * FROM REALISATEURS,FILMS WHERE FILMS.id_realisateur = REALISATEURS.id;
Observez le résultat obtenu
Comme vous pouvez le constater, le résultat est différent, cette fois-ci ce sont les lignes de la table FILMS qui viennent se greffer sur la table REALISATEURS.
Avec cette requête : SELECT * FROM FILMS,REALISATEURS WHERE
FILMS.id_realisateur = REALISATEURS.id; nous obtenions le résultat ci-dessous
Dans le cas d'une jointure, il est tout à fait possible de sélectionner certains attributs et pas d'autres.
Testez les requêtes suivantes :
SELECT nom,prenom,titre FROM REALISATEURS ,FILMS WHERE FILMS.id_realisateur = REALISATEURS.id;
SELECT titre,nom,prenom FROM FILMS ,REALISATEURS WHERE FILMS.id_realisateur = REALISATEURS.id;
Si un même nom d'attribut est présent dans les 2 tables (par exemple ici l'attribut id), il est nécessaire d'ajouter le nom de la table devant afin de pouvoir les distinguer (FILMS.id et REALISATEURS.id)
SELECT titre, FILMS.id,nom, prenom FROM FILMS,REALISATEURS WHERE FILMS.id_realisateur = REALISATEURS.id;
Il est possible d'utiliser la clause WHERE dans le cas d'une jointure en utilisant un AND :
SELECT titre,nom,prenom FROM FILMS INNER JOIN REALISATEURS ON FILMS.id_realisateur = REALISATEURS.id
WHERE ann_sortie>1980;
Enfin, pour terminer avec les jointures, vous devez savoir que nous avons abordé la jointure la plus simple (INNER JOIN). Il existe des jointures plus complexes (CROSS JOIN, LEFT JOIN, RIGHT JOIN), ces autres jointures ne seront pas abordées ici.
SELECT titre,nom,prenom FROM FILMS ,REALISATEURS WHERE FILMS.id_realisateur = REALISATEURS.id AND ann_sortie>1980;
Exercice 6 : Ecrivez la requête permettant d'obtenir le nom des films réalisés par Ridley Scott
Correction
SELECT titre FROM FILMS, REALISATEURS WHERE FILMS.id_realisateur
= REALISATEURS.id AND nom="Scott" AND prenom="Ridley";
Fonctions d'agrégation ou groupement de données
Pour illustrer cette partie, nous allons repartir d'une nouvelle base de donnée.
Ouvrez la base de donnée : livres_auteur_BDD.db
Les tableaux suivants présentent quelques fonctions utilisables dans les requêtes SQL.
Fonctions Rôle Exemple de requête
UPPER Convertir l'intégralité d'un attribut en majuscule SELECT UPPER(titre) FROM LIVRES;
LOWER Convertir l'intégralité d'un attribut en minuscule SELECT LOWER(titre) FROM LIVRES;
AS Permet de créer un Alias (champ virtuel) SELECT UPPER(titre) AS titre_maj FROM LIVRES;
LENGTH Compte le nombre de caractères SELECT LENGTH(titre) AS longueur_titre FROM LIVRES;
ROUND
Permet d'arrondir un nombre décimal (deux paramètres : le nom du champ à arrondir et le nombre de chiffres après la virgule )
SELECT ROUND(note, 2) AS note_arrondi FROM LIVRES;
Manipulation des données
Testez quelques requêtes et observez le résultat obtenu
Fonctions Rôle Exemple de requête AVG Calcule la valeur moyenne d'un attribut
contenant des nombres SELECT AVG(note) FROM LIVRES;
SUM Additionner les valeurs numériques d'un
attribut SELECT SUM(note) FROM LIVRES;
MAX Retourne la valeur maximale d'un attribut SELECT MAX(note) AS note_max FROM LIVRES;
MIN Retourne la valeur minimale d'un attribut SELECT MIN(note) FROM LIVRES;
COUNT Permet de compter le nombre d'entrées dans
un attribut SELECT COUNT(titre) FROM LIVRES;
Opérations d'agrégation des données
Le résultat d'un opérateur d'agrégation est une unique valeur.
Lorsqu'une requête combine des opérations de sélection et de calcul par agrégation, la sélection est toujours faites avant le calcul.
SELECT SUM(note) FROM LIVRES WHERE ann_publi>1960;
Un exemple avec COUNT:
SELECT COUNT(ann_publi) FROM LIVRES; compte toutes les entrées ann_publi SELECT COUNT(DISTINCT ann_publi) FROM LIVRES; compte toutes les entrées ann_publi distinctes entre elles
Rq. Un attribut peut avoir la valeur NULL, celle-ci correspond à l'absence de valeur dans la table.(ce n'est pas un 0 ou une chaine de caractères vides)
Pour tester si la valeur d'un attribut A est NULL, on ne doit pas écrire A=NULL mais A IS NULL (ou IS NOT NULL)
Nous voulons obtenir la moyenne des notes pour chaque auteur. Prenons la requête suivante :
SELECT AVG(note) AS note_moyenne, auteur FROM mesLivres;
Ça n'a pas de sens, car on va récupérer la note moyenne de tous les livres et l'attribut "auteur" à la fois, on va donc obtenir qu'une seule note moyenne pour tous les livres, mais pour plusieurs auteurs.
En quoi cette requête pose-t-elle un problème ?
Il existe une solution pour obtenir la moyenne des notes pour chaque auteur : le groupement de données.
Pour faire cela, on doit utiliser un nouveau mot-clé : GROUP BY. Cela signifie
« grouper par ».
SELECT AVG(note), auteur FROM LIVRES GROUP BY auteur;
La clause GROUP BY créée des regroupements sur des sous-tables générées par la sélection. Exemple :
SELECT COUNT(*),auteur FROM LIVRES GROUP BY auteur;
créé en fait des sous-tables dont les données sont regroupées pour chaque auteur
COUNT(*) nous indique pour chaque auteur (chaque sous-table) le nombre de lignes qui ont été regroupées
HAVING est un peu l'équivalent de WHERE, mais il agit sur les données une fois qu'elles ont été regroupées. C'est donc une façon de filtrer les données à la fin des opérations.
SELECT AVG(note), auteur FROM LIVRES GROUP BY auteur HAVING note>8;
RQ. il n'est pas possible de mettre dans le SELECT des attributs qui ne participe pas à la clause GROUP BY
La clause de sélection WHERE agit avant le regroupement, alors que HAVING agit après le regroupement
On peut effectuer des regroupements sur plusieurs colonnes en même temps.
SELECT COUNT(titre),ann_publi,auteur FROM LIVRES GROUP BY ann_publi,auteur;
SELECT COUNT(*) AS nbre,ann_publi FROM LIVRES GROUP BY ann_publi ORDER BY nbre DESC;
Exercice 7 : Ecrivez une requête permettant d'obtenir l’année (ou les années) ou il y a eu le plus de livre écrit
SELECT COUNT(*) AS nbre,ann_publi FROM LIVRES GROUP BY ann_publi ORDER BY nbre DESC LIMIT 1;
SELECT COUNT(titre) AS nbre, auteur FROM LIVRES GROUP BY auteur HAVING nbre>=2;
Exercice 8 : Ecrivez une requête permettant d'obtenir le nombre de livre écrit par chaque auteur si l’auteur en a écrit au moins 2.
En résumé
Une requête interrogative SQL générale :
SELECT (liste d’attributs (et fonctions d’agrégat)) FROM (liste de tables)
WHERE (condition (de lignes/de tuples)) GROUP BY (attributs de regroupement) HAVING (condition (de groupes))
ORDER BY (attributs de tri (chaque attribut suivi de DESC ou ASC)) Les clauses SELECT/FROM obligatoires.
Si il y a une clause HAVING alors il doit y avoir la clause GROUP BY.
"UPDATE" va permettre de modifier une ou des entrées. Nous utiliserons
"WHERE", comme dans le cas d'un "SELECT", pour spécifier les entrées à modifier.
Voici un exemple de modification : Ajoutez une entrée supplémentaire :
INSERT INTO LIVRES (id,titre,auteur,ann_publi,note) VALUES (17,'Hypérion','Simmons',1989,8);
UPDATE LIVRES SET note=7WHERE titre = 'Hypérion' Que va faire cette requête ?
Trouvez un moyen de vérifier votre hypothèse.
Exercice 9 : Écrivez une requête permettant d'attribuer la note de 10 à tous les livres écrits par Asimov publiés après 1950. Testez cette requête.
Mise à jour de données
Exercice 8 : Écrivez une requête permettant d'attribuer la note de 10à tous les livres écrits par Asimov publiés après 1950. Testez cette requête.
UPDATE LIVRES SET note=10WHERE auteur='Asimov' AND ann_publi >1950
"DELETE" est utilisée pour effectuer la suppression d'une (ou de plusieurs) entrée(s). Ici aussi c'est le "WHERE" qui permettra de sélectionner les
entrées à supprimer.
Que va faire cette requête ? Vérifiez votre réponse en l'exécutant et en faisant une requête "SELECT * FROM LIVRES".
DELETE FROM LIVRES WHERE titre='Hypérion'
Exercice 10 : Écrivez une requête permettant de supprimer les livres publiés avant 1945. Testez cette requête.
Veuillez trouver les requêtes SQL permettant d’effectuer chacune des demandes suivantes :
1. Obtenir la liste des 10villes les plus peuplées en 2012 (avec table VILLES_FRANCE)
2. Obtenir la liste des 50villes ayant la plus faible superficie (sur table VILLES_FRANCE)
3. Obtenir la liste des départements d’outre-mer, c’est-à-dire ceux dont le numéro de département commence par “97” (sur table DEPARTEMENT) 4. Obtenir le nom des 10 villes les plus peuplées en 2012, ainsi que le nom
du département associé (Réalisation d'une jointure et de order by, desc, limit)
5. Obtenir la liste du nom de chaque département, associé à son code et du nombre de commune au sein de ces départements, en triant afin d’obtenir en priorité les départements qui possèdent le plus de communes
(réalisation d'une jointure, et de count, group by, order by ,desc)
RQ. Les questions en italiques sont difficiles
6. Obtenir la liste des 10 plus grands départements, en termes de superficie (Réalisation d'une jointure, et de sum , group by, order by, desc, limit) 7. Compter le nombre de villes dont le nom commence par “Saint”
8. Obtenir la liste des villes qui ont un nom existant plusieurs fois, et trier afin d’obtenir en premier celles dont le nom est le plus souvent utilisé par
plusieurs communes (Utilisation d'un alias, group by et order by)
9. Obtenir en une seule requête SQL la liste des villes dont la superficie est supérieure à la superficie moyenne (requête imbriquée...)
10. Obtenir la liste des départements qui possèdent plus de 2 millions d’habitants (Utilisation de sum, d'un alias, group by, having, order by)
11. Remplacez les tirets par un espace vide, pour toutes les villes commençant par “SAINT-” (dans la colonne qui contient les noms en majuscule)
(Utilisation de REPLACE(attribut,'caractère à remplacer', 'caractère de remplacement')
Conclusion et perspectives
Une base de données peut être utilisée, par exemple, par un site d'e-commerce pour stocker les données relatives aux clients et aux commandes. Dans ce cas, nous avons un serveur web qui fournit aux clients les pages web dynamiques.
Comme cela vient d'être dit, d'un côté le serveur web fournit aux clients des pages web, d'un autre côté, ce même serveur peut interroger une base de données, par exemple pour savoir si tel ou tel article est en stock.
Il existe plusieurs langages de programmation utilisés côté serveur (java avec java server pages, ruby avec ruby on rails, javascript avec node.js ou encore python avec django...), Mais le plus populaire reste le php (en 2013plus de 244 millions de sites web l'utilisaient).
Un programme écrit en php peut donc d'un côté générer des pages web pour qu'elles soient envoyées vers le client et d'un autre côté interroger une (ou des) base(s) de données. Le serveur web peut utiliser les données récupérées dans la base de données pour générer la page web qui sera envoyée aux clients.
Reprise d'un projet existant : le formulaire en javascript et/ou php
Il faut dans un premier temps retrouver le formulaire de contact que vous aviez réalisé l'an dernier.
La page de traitement permettait de vérifier que le formulaire était correctement complété et affichait alors une page de remerciement.
Cette fois, en plus, il faut que les données transmises soit enregistrées dans une base de données après leurs vérifications.
Pour réaliser ce projet, il faut utiliser UwAmp comme serveur local, il faudra créer une base de données sur le serveur en utilisant phpMyAdmin (très ressemblant à DB Browser (SQLite)).
Créer une table et fabriquer les différents champ de votre unique table.
Il faudra ensuite écrire un script en php qui permet de se connecter à la base de donnée, puis d'insérer les données transmises
