NULL]]>NULL, sinon elle ne pourrait plus identifier une(eleve_id, cours_id) peutCommandes, l'attribut client_id référenceClients.]]>eleves ?]]>SELECT * en production et listerSELECT eleves]]>SELECT requiert au minimum la*) puis FROM pour la table.]]>GET ALL FROM eleves]]>GET n'existe pas en SQL. La commande deSELECT.]]>SELECT * FROM eleves]]>* est le joker qui désigne toutesFROM indique la table source.]]>READ eleves]]>READ n'est pas un mot-clé SQL. La lectureSELECT.]]>eleves, quelle requête utiliser ?]]>SELECT colonnes FROM table WHERE condition. LesAND, OR, NOT.]]>FILTER eleves WHERE age >= 18]]>FILTER n'est pas la syntaxe SQL standard.SELECT ... WHERE.]]>SELECT * FROM eleves CONDITION age >= 18]]>CONDITION n'existe pas en SQL. C'est WHERESELECT * FROM eleves WHERE age >= 18]]>WHERE introduit la condition deWHERE condition, où=, <, >, <=, >=, <>, LIKE, etc.).]]>SELECT * FROM eleves IF age >= 18]]>IF n'est pas un mot-clé SQL pour leWHERE.]]>ORDER BY nom, prenom.ORDER BY nom DESC. On peutORDER BY classe ASC, moyenne DESC.]]>SELECT * FROM eleves ARRANGE BY nom]]>ARRANGE BY n'est pas du SQL valide.]]>SELECT * FROM eleves ORDER BY nom]]>ORDER BY trie le résultat selon uneASC). Pour un ordre descendant, ajouterDESC.]]>SELECT * FROM eleves SORTED nom]]>SORTED n'existe pas en SQL.]]>SELECT * FROM eleves SORT BY nom]]>SORT BY n'est pas une syntaxe SQL. Le triORDER BY.]]>NOT NULL (valeurUNIQUE (pas de doublon), clé primaire,CHECK (condition arbitraire).]]>SELECT (lire),INSERT (créer), UPDATE (modifier), DELETE (supprimer).]]>INSERT INTO eleves VALUES ('Alice', 17)]]>INSERT INTO table VALUES (...) est laINSERT INTO eleves (nom, age) VALUES ('Alice', 17).]]>CREATE INTO eleves VALUES ('Alice', 17)]]>CREATE est utilisé pour créer une tableCREATE TABLE), pas pour insérer une ligne.]]>PUT INTO eleves VALUES ('Alice', 17)]]>PUT n'existe pas en SQL.]]>ADD INTO eleves VALUES ('Alice', 17)]]>ADD n'est pas la syntaxe SQL standard pourtelephones = "06 12 ; 06 34" mélange deuxUPDATE.]]>NULL ou par la contrainteNOT NULL.]]>commandes et clients encommandes.client_id à clients.id, quelleINNER JOIN (ne gardeLEFT JOIN (garde toutes lesRIGHT JOIN (symétrique),FULL JOIN (les deux côtés).]]>SELECT * FROM commandes JOIN clients ON commandes.client_id = clients.id]]>SELECT * FROM commandes, clients]]>SELECT * FROM commandes WITH clients]]>WITH introduit des sous-requêtes nomméesSELECT * FROM commandes UNION clients]]>UNION combine deux requêtes en empilantJOIN.]]>COUNT, SUM, AVG, MIN et MAX. EllesSELECT MOYENNE(age) FROM eleves]]>SELECT (age) FROM eleves AVERAGE]]>AVERAGE après le FROM n'existeSELECT.]]>SELECT MEAN(age) FROM eleves]]>AVG, pas MEAN.]]>SELECT AVG(age) FROM eleves]]>AVG (average) calcule la moyenneCOUNT, SUM, AVG, MIN, MAX.]]>SELECT … FROM … WHERE …ORDER BY …. Le mot-clé DESC après ORDER BYASC (par défaut)SELECT nom FROM eleves ORDER BY age DESC WHERE age >= 18]]>WHERE se place avant ORDER BY.]]>SELECT nom FROM eleves WHERE age >= 18 ORDER BY age DESC]]>WHERE filtre les lignesORDER BY age DESC les trie parSELECT nom FROM eleves WHERE age >= 18 ORDER BY age]]>DESC, le tri se faitSELECT nom FROM eleves WHERE age >= 18 SORT age DESC]]>SORT n'existe pas en SQLORDER BY.]]>WHERE sur lesUPDATE et DELETE. Sans elle, la modification s'appliqueMODIFY eleves SET note = note + 1 WHERE id = 42]]>MODIFY n'est pas un mot-clé SQL standard.]]>UPDATE eleves SET note = note + 1 WHERE id = 42]]>UPDATE met à jour des lignesSET indique les modificationsWHERE filtre les lignes affectées.]]>UPDATE eleves WHERE id = 42 SET note = note + 1]]>UPDATE table SET ... WHERE ....]]>CHANGE eleves SET note = note + 1 WHERE id = 42]]>CHANGE n'est pas un mot-clé SQL standard.]]>eleves (sans doublons), quelle requêteDISTINCT agit sur l'ensemble des colonnesSELECT DISTINCT nom, prenom FROM eleves ne renverraSELECT DISTINCT classe FROM eleves]]>DISTINCT élimine les doublons. SiSELECT classe DISTINCT FROM eleves]]>DISTINCT se place avant la liste desSELECT.]]>SELECT UNIQUE classe FROM eleves]]>UNIQUE est utilisé pour les contraintes auDISTINCT.]]>SELECT classe FROM eleves]]>DISTINCT, le résultat contiendra uneeleves avec autant de colonnes cours_1, cours_2, cours_3 qu'il y a de cours possibles]]>eleve et tous ses cours dans une même cellule]]>eleves(id, nom), cours(id, intitule) et inscriptions(eleve_id, cours_id) reliées par des clés étrangères]]>LIKE : % (zéro ou plus de caractères) et_ (un caractère exactement). Pour une rechercheILIKELIKE avec LOWER() (portable).]]>WHERE nom STARTS 'Du']]>STARTS n'est pas un mot-clé SQL standard.LIKE avec %.]]>WHERE nom LIKE 'Du%']]>LIKE permet la correspondance par% représente n'importe quelle'Du%'WHERE nom = 'Du']]>= teste l'égalité exacte. Cela neWHERE nom CONTAINS 'Du']]>CONTAINS est non standard (existant dansLIKE avec des jokers.]]>DELETE FROM eleves; ?]]>WHERE avec DELETE, sauf intentionWHERE obligatoire en modeeleves]]>DELETE sans clause WHERE vide laDROP TABLE eleves.]]>DROP TABLE qui supprime la structure.DELETE FROM ne touche que les lignes, pas le schéma.]]>WHERE)]]>WHERE, la requête s'applique àFOREIGN KEY. À la suppression d'un client,ON DELETE CASCADE (supprimer aussiON DELETE RESTRICT (interdire laid) est unique. Le nom peut être enclient_id qui n'existe pas dans la table clients]]>client_id doitclients. Sinon, on a une référence orpheline,NOT NULL,SELECT nom FROM eleves
WHERE moyenne > (SELECT AVG(moyenne) FROM eleves);>=, <, =, IN avec une sous-requête.> ne porte pas sur zéro maisAVG(moyenne) calcule effectivement lacommandes(id, client_id, nom_client, prenom_client, produit, prix)id est un choix raisonnable de clé primaireclient_id, pas de l'id de commande. Ilclientsclient_id dans commandes.]]>commandes.]]>INNER JOIN et LEFT JOIN ?]]>JOIN simple (équivalent de INNER JOIN)ON. LeLEFT JOIN étend ce comportement en conservantNULL côté droit.]]>INNER JOIN ne garde que les paires appariées ; LEFT JOIN garde toutes les lignes de la table de gauche, complétées par NULL à droite si aucune correspondance]]>LEFT JOIN. AvecINNER JOIN, les clients sans commande disparaissentLEFT JOIN ne fonctionne que sur des tables triées]]>LEFT JOIN.]]>INNER JOIN est plus rapide que LEFT JOIN]]>WHERE ou des jointures ?]]>eleves(id, nom, classe), quelle requête utiliser ?]]>SELECT colonne, AGREGATION(...) FROM
table GROUP BY colonne. Toutes les colonnes du SELECTGROUP BY. C'est la règle diteSELECT classe, COUNT(*)
FROM eleves;]]>GROUP BY, mélanger une colonne et uneclasse.]]>SELECT DISTINCT classe, COUNT(*)
FROM eleves;]]>DISTINCT élimine les doublons après calcul,GROUP BY.]]>SELECT classe, COUNT(eleves)
FROM eleves
GROUP BY classe;]]>COUNT(eleves) n'est pas valide :eleves est le nom de la table, pas une colonne.COUNT(*) ou uneCOUNT(id)).]]>SELECT classe, COUNT(*)
FROM eleves
GROUP BY classe;]]>GROUP BY regroupe les lignes parclasse. La fonction d'agrégationCOUNT(*) compte les lignes de chaque groupe. LeSELECT ... FROM ... WHERE ... GROUP BY ... HAVING ... ORDER BY.WHERE filtre les lignes individuelles avantHAVING filtre les groupes après agrégation.]]>SELECT classe
FROM eleves
GROUP BY classe
WHERE COUNT(*) >= 25;]]>WHERE doit toujours apparaîtreGROUP BY dans la syntaxe SQL. De plus,SELECT classe, COUNT(*)
FROM eleves
WHERE COUNT(*) >= 25
GROUP BY classe;]]>WHERE ne peut pas porter sur une fonctionHAVING.]]>SELECT classe, COUNT(*)
FROM eleves
HAVING classe COUNT(*) >= 25;]]>HAVING doitGROUP BY qui définit les groupes sur lesquelsHAVING.]]>SELECT classe, COUNT(*)
FROM eleves
GROUP BY classe
HAVING COUNT(*) >= 25;]]>HAVING filtre les groupes aprèsWHERE qui filtre lesCOUNT(*), il faut utiliser HAVING.]]>DROP TABLE eleves,DELETE FROM eleves et TRUNCATE TABLE eleves ?]]>DELETE FROM ... WHERE pourTRUNCATE pourDROP TABLE uniquement quand on veut effectivement seDROP.]]>TRUNCATE est légèrement moins répandu que lesDROP et DELETE sont identiques ; seulTRUNCATE est différent (il vide aussi lesDROP TABLE et DELETE FROM ne sontDROP et DELETE peut être catastrophique enDROP supprime tout, structureDROP TABLE supprime la table entière (structure etDELETE FROM (sans WHERE) supprimeTRUNCATE TABLEDELETE)]]>DROP est destructif sur le schéma : la tableDELETE est uneTRUNCATE est une opérationeleves suivante :
| id | nom | classe | moyenne |
|----|--------|--------|---------|
| 1 | Alice | 1A | 14.5 |
| 2 | Bob | 1B | 9.0 |
| 3 | Chloé | 1A | 16.0 |
| 4 | David | 1B | 13.0 |
| 5 | Émma | 1A | 11.5 |
Que renvoie la requête suivante ?
SELECT nom, moyenne
FROM eleves
WHERE classe = '1A' AND moyenne >= 12
ORDER BY moyenne DESC;WHERE pour neSELECT ; (3)ORDER BY si présent. CetteWHERE.1A avec une moyenne d'au moins('Alice', 14.5),('Chloé', 16.0), ('Émma', 11.5)]]>1A mais sa moyennemoyenne >= 12.('Chloé', 16.0) puis('Alice', 14.5)]]>WHERE classe = '1A' AND moyenne >= 121A avec1A mais sanom et moyenne. Étape 3,moyenne DESC : Chloé d'abord,('Chloé', 16.0)]]>1A). Elle doit donc apparaître dans leTable clients :
| id | nom |
|----|--------|
| 1 | Alice |
| 2 | Bob |
| 3 | Chloé |
Table commandes :
| id | client_id | produit |
|----|-----------|----------|
| 10 | 1 | Livre |
| 11 | 2 | Cahier |
| 12 | 1 | Stylo |
Combien de lignes renvoie la requête suivante ?
SELECT c.nom, cmd.produit
FROM clients c
JOIN commandes cmd ON c.id = cmd.client_id;LEFT JOIN. La ligneNULL dans lacmd.produit. Cela permet de'Livre' et avec 'Stylo'). LaJOIN,INNER JOIN) ne garde que les(client, commande) où la conditionc.id = cmd.client_id est vraie. Alice('Alice', 'Livre'), ('Bob', 'Cahier'),('Alice', 'Stylo').]]>ON c.id = cmd.client_id. AvecFROM clients, commandes (sans JOIN).]]>LEFT JOIN qui inclurait Chloé sansNULL côté commandes).]]>eleves(id, nom, classe, moyenne)1A, 1B, 1C), que renvoie laSELECT classe, AVG(moyenne) AS moy_classe
FROM eleves
GROUP BY classe
HAVING AVG(moyenne) > 12
ORDER BY moy_classe DESC;WHERE filtre lesHAVING filtre les groupes aprèsWHERE age >= 18 ... HAVING AVG(moyenne) > 12.]]>GROUP BY classeAVG(moyenne) calcule la moyenne de chaqueHAVING AVG(moyenne) > 12ORDER BY moy_classe DESC trieORDER BY]]>SELECT (ici moy_classe) au sein deORDER BY. La requête est valide.]]>AVGSUM (somme). Les deuxHAVING filtrerait certainesWHERE moyenne > 12 sans GROUP BY. Ici,AVG(moyenne)GROUP BY classe calcule laVIEW) en SQL est :]]>CREATE VIEW majeurs AS SELECT ... FROM
eleves WHERE age >= 18;. Ensuite,SELECT * FROM majeurs renvoie le résultatCREATE TABLE ... AS
SELECT ...). La vue, elle, ne contient paseleves(id_eleve, nom, prenom, id_classe#)
classes(id_classe, niveau, salle)
notes(id_eleve#, id_devoir#, note)
devoirs(id_devoir, matiere, date)Le # désigne une clé étrangère. Quelle
affirmation est correcte ?
#,notes esteleves n'a pas de lien avecclasses]]>id_classe# danseleves est précisément une cléclasses, ceid_eleve]]>id_eleve est la clé primaire deeleves, donc unique parid_eleve.]]>notes, ileleves]]>id_eleve# dansnotes impose que la valeur référence unnotes a une clé primaire(id_eleve, id_devoir), et seseleves etdevoirs]]>notes représente unenom_saisi reçue de l'utilisateur :
requete = "SELECT * FROM users WHERE nom = '" + nom_saisi + "';"Si l'utilisateur saisit
' OR '1'='1, que se passe-t-il ?
cursor.execute("... WHERE nom = ?", (nom_saisi,))).SELECT * FROM users WHERE nom = '' OR '1'='1';,'1'='1'OR lacursor.execute(req, (nom_saisi,))).]]>'1'='1' étant toujours vraie, toutescomptes suivante :
| id | titulaire | solde |
|----|-----------|-------|
| 1 | Alice | 1000 |
| 2 | Bob | 500 |
| 3 | Chloé | 2000 |
On exécute la requête suivante :
UPDATE comptes
SET solde = solde * 1.05
WHERE solde >= 1000;Quel est le contenu de la table après
exécution ?
UPDATE : (1) la clauseWHERE sélectionne les lignes affectées ; (2)SET indique comment modifier cesWHERE, toutes les lignesUPDATE ne supprime jamais deDELETE FROM comptes
WHERE solde < 1000;.]]>WHERE était absente. AvecWHERE solde >= 1000, seules les lignesWHERE solde >= 1000solde = solde * 1.05.WHERE est trop restrictive]]>solde >= 1000,