\documentclass[a4paper,11pt]{article}

\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}
\usepackage[francais,bloc,completemulti]{automultiplechoice}
\usepackage[french]{babel}
\usepackage{amsmath, amssymb}

\title{Bases de données et SQL}
\date{Numérique et sciences informatiques}

\begin{document}

\noindent\textbf{Bases de données et SQL} \hfill \textit{Numérique et sciences informatiques}\\[0.4em]
Nom~: \dotfill\ Prénom~: \dotfill

\bigskip

\element{terminalebasesdedonnees}{
  \begin{question}{q01}
    Que désigne le sigle SGBD ?
    \begin{choices}
    \wrongchoice{Stockage Garanti des Bases Distribuées}
    \wrongchoice{Système de Génération Binaire de Données}
    \wrongchoice{Standard Général des Bibliothèques de Données}
    \correctchoice{Système de Gestion de Base de Données}
    \end{choices}
  \end{question}
}

\element{terminalebasesdedonnees}{
  \begin{question}{q02}
    Dans le modèle relationnel, comment appelle-t-on \textbf{une ligne}
d'une table ?
    \begin{choices}
    \wrongchoice{Un attribut}
    \correctchoice{Un n-uplet (ou enregistrement)}
    \wrongchoice{Une clé}
    \wrongchoice{Un domaine}
    \end{choices}
  \end{question}
}

\element{terminalebasesdedonnees}{
  \begin{question}{q03}
    Quelle est la propriété fondamentale d'une \textbf{clé primaire} ?
    \begin{choices}
    \correctchoice{Elle identifie de manière unique chaque ligne de la table}
    \wrongchoice{Elle doit être un nombre entier}
    \wrongchoice{Elle peut prendre la valeur \texttt{NULL}}
    \wrongchoice{Elle doit toujours être une seule colonne}
    \end{choices}
  \end{question}
}

\element{terminalebasesdedonnees}{
  \begin{question}{q04}
    Que représente une \textbf{clé étrangère} dans une table ?
    \begin{choices}
    \correctchoice{Un attribut qui référence la clé primaire d'une autre table}
    \wrongchoice{Une clé qui ne peut pas être modifiée}
    \wrongchoice{Une clé importée d'un autre fichier}
    \wrongchoice{Un attribut crypté pour la sécurité}
    \end{choices}
  \end{question}
}

\element{terminalebasesdedonnees}{
  \begin{question}{q05}
    Quelle est la syntaxe SQL pour récupérer \textbf{toutes} les
colonnes de la table \texttt{eleves} ?
    \begin{choices}
    \wrongchoice{\texttt{SELECT eleves}}
    \wrongchoice{\texttt{GET ALL FROM eleves}}
    \correctchoice{\texttt{SELECT * FROM eleves}}
    \wrongchoice{\texttt{READ eleves}}
    \end{choices}
  \end{question}
}

\element{terminalebasesdedonnees}{
  \begin{question}{q06}
    Pour ne sélectionner que les élèves majeurs de la table
\texttt{eleves}, quelle requête utiliser ?
    \begin{choices}
    \wrongchoice{\texttt{FILTER eleves WHERE age >= 18}}
    \wrongchoice{\texttt{SELECT * FROM eleves CONDITION age >= 18}}
    \correctchoice{\texttt{SELECT * FROM eleves WHERE age >= 18}}
    \wrongchoice{\texttt{SELECT * FROM eleves IF age >= 18}}
    \end{choices}
  \end{question}
}

\element{terminalebasesdedonnees}{
  \begin{question}{q07}
    Pour afficher les élèves par ordre alphabétique de leur
nom, on utilise :
    \begin{choices}
    \wrongchoice{\texttt{SELECT * FROM eleves ARRANGE BY nom}}
    \correctchoice{\texttt{SELECT * FROM eleves ORDER BY nom}}
    \wrongchoice{\texttt{SELECT * FROM eleves SORTED nom}}
    \wrongchoice{\texttt{SELECT * FROM eleves SORT BY nom}}
    \end{choices}
  \end{question}
}

\element{terminalebasesdedonnees}{
  \begin{question}{q08}
    Qu'est-ce qu'une \textbf{contrainte d'intégrité} dans une base de
données relationnelle ?
    \begin{choices}
    \wrongchoice{Un mot de passe pour accéder à une table}
    \correctchoice{Une règle qui restreint les valeurs admissibles dans la base, vérifiée par le SGBD}
    \wrongchoice{Une copie de sauvegarde automatique}
    \wrongchoice{Un index pour accélérer les requêtes}
    \end{choices}
  \end{question}
}

\element{terminalebasesdedonnees}{
  \begin{question}{q09}
    Quelle commande SQL ajoute une ligne dans une table ?
    \begin{choices}
    \correctchoice{\texttt{INSERT INTO eleves VALUES ('Alice', 17)}}
    \wrongchoice{\texttt{CREATE INTO eleves VALUES ('Alice', 17)}}
    \wrongchoice{\texttt{PUT INTO eleves VALUES ('Alice', 17)}}
    \wrongchoice{\texttt{ADD INTO eleves VALUES ('Alice', 17)}}
    \end{choices}
  \end{question}
}

\element{terminalebasesdedonnees}{
  \begin{question}{q10}
    Dans une base relationnelle correctement conçue, on
attend que chaque attribut contienne une valeur
\textbf{atomique}. Que signifie cette propriété ?
    \begin{choices}
    \wrongchoice{La valeur doit être un entier}
    \correctchoice{La valeur n'est pas décomposable en plusieurs informations distinctes (par exemple, on ne stocke pas plusieurs numéros de téléphone dans une même cellule)}
    \wrongchoice{La valeur ne peut jamais être modifiée}
    \wrongchoice{La valeur ne peut pas être nulle}
    \end{choices}
  \end{question}
}

\element{terminalebasesdedonnees}{
  \begin{question}{q11}
    Pour combiner les tables \texttt{commandes} et \texttt{clients} en
reliant \texttt{commandes.client\_id} à \texttt{clients.id}, quelle
syntaxe utiliser ?
    \begin{choices}
    \correctchoice{\texttt{SELECT * FROM commandes JOIN clients ON commandes.client\_id = clients.id}}
    \wrongchoice{\texttt{SELECT * FROM commandes, clients}}
    \wrongchoice{\texttt{SELECT * FROM commandes WITH clients}}
    \wrongchoice{\texttt{SELECT * FROM commandes UNION clients}}
    \end{choices}
  \end{question}
}

\element{terminalebasesdedonnees}{
  \begin{question}{q12}
    Pour calculer la \textbf{moyenne des âges} des élèves, quelle
requête utiliser ?
    \begin{choices}
    \wrongchoice{\texttt{SELECT MOYENNE(age) FROM eleves}}
    \wrongchoice{\texttt{SELECT (age) FROM eleves AVERAGE}}
    \wrongchoice{\texttt{SELECT MEAN(age) FROM eleves}}
    \correctchoice{\texttt{SELECT AVG(age) FROM eleves}}
    \end{choices}
  \end{question}
}

\element{terminalebasesdedonnees}{
  \begin{question}{q13}
    Quelle requête renvoie les noms des élèves majeurs,
classés par âge \textbf{décroissant} ?
    \begin{choices}
    \wrongchoice{\texttt{SELECT nom FROM eleves ORDER BY age DESC WHERE age >= 18}}
    \correctchoice{\texttt{SELECT nom FROM eleves WHERE age >= 18 ORDER BY age DESC}}
    \wrongchoice{\texttt{SELECT nom FROM eleves WHERE age >= 18 ORDER BY age}}
    \wrongchoice{\texttt{SELECT nom FROM eleves WHERE age >= 18 SORT age DESC}}
    \end{choices}
  \end{question}
}

\element{terminalebasesdedonnees}{
  \begin{question}{q14}
    Pour augmenter de $1$ point la note de l'élève d'identifiant
$42$, quelle requête utiliser ?
    \begin{choices}
    \wrongchoice{\texttt{MODIFY eleves SET note = note + 1 WHERE id = 42}}
    \correctchoice{\texttt{UPDATE eleves SET note = note + 1 WHERE id = 42}}
    \wrongchoice{\texttt{UPDATE eleves WHERE id = 42 SET note = note + 1}}
    \wrongchoice{\texttt{CHANGE eleves SET note = note + 1 WHERE id = 42}}
    \end{choices}
  \end{question}
}

\element{terminalebasesdedonnees}{
  \begin{question}{q15}
    Pour obtenir la liste des \textbf{classes différentes} présentes
dans la table \texttt{eleves} (sans doublons), quelle requête
utiliser ?
    \begin{choices}
    \correctchoice{\texttt{SELECT DISTINCT classe FROM eleves}}
    \wrongchoice{\texttt{SELECT classe DISTINCT FROM eleves}}
    \wrongchoice{\texttt{SELECT UNIQUE classe FROM eleves}}
    \wrongchoice{\texttt{SELECT classe FROM eleves}}
    \end{choices}
  \end{question}
}

\element{terminalebasesdedonnees}{
  \begin{question}{q16}
    On souhaite représenter le fait qu'un élève peut
suivre \textbf{plusieurs cours} et qu'un cours peut
accueillir \textbf{plusieurs élèves}. Quel schéma
relationnel adopter ?
    \begin{choices}
    \wrongchoice{Deux tables avec une duplication des cours dans chaque ligne d'élève}
    \wrongchoice{Une seule table \texttt{eleves} avec autant de colonnes \texttt{cours\_1}, \texttt{cours\_2}, \texttt{cours\_3} qu'il y a de cours possibles}
    \wrongchoice{Une seule table contenant \texttt{eleve} et tous ses cours dans une même cellule}
    \correctchoice{Trois tables \texttt{eleves(id, nom)}, \texttt{cours(id, intitule)} et \texttt{inscriptions(eleve\_id, cours\_id)} reliées par des clés étrangères}
    \end{choices}
  \end{question}
}

\element{terminalebasesdedonnees}{
  \begin{question}{q17}
    Pour trouver tous les élèves dont le nom commence par "Du",
quelle requête utiliser ?
    \begin{choices}
    \wrongchoice{\texttt{WHERE nom STARTS 'Du'}}
    \correctchoice{\texttt{WHERE nom LIKE 'Du\%'}}
    \wrongchoice{\texttt{WHERE nom = 'Du'}}
    \wrongchoice{\texttt{WHERE nom CONTAINS 'Du'}}
    \end{choices}
  \end{question}
}

\element{terminalebasesdedonnees}{
  \begin{question}{q18}
    Que fait la requête \texttt{DELETE FROM eleves;} ?
    \begin{choices}
    \correctchoice{Elle supprime toutes les lignes de la table \texttt{eleves}}
    \wrongchoice{Elle supprime la table entière (structure et contenu)}
    \wrongchoice{Elle ne fait rien (manque de \texttt{WHERE})}
    \wrongchoice{Elle lève une erreur SQL}
    \end{choices}
  \end{question}
}

\element{terminalebasesdedonnees}{
  \begin{question}{q19}
    Lequel des éléments suivants n'est \textbf{pas} un
service rendu par un système de gestion de bases de
données ?
    \begin{choices}
    \wrongchoice{La gestion des accès concurrents par plusieurs utilisateurs ou programmes}
    \wrongchoice{La persistance des données (les données survivent à l'arrêt du programme)}
    \correctchoice{La compilation du code source d'un programme Python}
    \wrongchoice{La sécurisation des accès (authentification, droits par utilisateur)}
    \end{choices}
  \end{question}
}

\element{terminalebasesdedonnees}{
  \begin{question}{q20}
    Quelle situation viole l'\textbf{intégrité référentielle} ?
    \begin{choices}
    \wrongchoice{Avoir deux clients avec le même nom}
    \correctchoice{Insérer une commande avec un \texttt{client\_id} qui n'existe pas dans la table \texttt{clients}}
    \wrongchoice{Insérer une commande sans préciser la quantité}
    \wrongchoice{Trier les commandes par date}
    \end{choices}
  \end{question}
}

\element{terminalebasesdedonnees}{
  \begin{question}{q21}
    Que renvoie cette requête ?

\begin{lstlisting}
SELECT nom FROM eleves
WHERE moyenne > (SELECT AVG(moyenne) FROM eleves);
\end{lstlisting}
    \begin{choices}
    \wrongchoice{Les moyennes des élèves au-dessus de zéro}
    \wrongchoice{Une erreur (sous-requête non autorisée)}
    \wrongchoice{La moyenne des moyennes des élèves}
    \correctchoice{Les noms des élèves dont la moyenne est strictement supérieure à la moyenne de la classe}
    \end{choices}
  \end{question}
}

\element{terminalebasesdedonnees}{
  \begin{question}{q22}
    Une table \texttt{commandes(id, client\_id, nom\_client, prenom\_client, produit, prix)}
pose un problème classique de schéma. Lequel ?
    \begin{choices}
    \wrongchoice{La clé primaire est mal choisie}
    \correctchoice{Les informations du client (nom, prénom) sont dupliquées à chaque commande, ce qui crée des incohérences potentielles si les noms sont mal mis à jour}
    \wrongchoice{Le prix devrait être stocké séparément}
    \wrongchoice{La table contient trop de colonnes}
    \end{choices}
  \end{question}
}

\element{terminalebasesdedonnees}{
  \begin{question}{q23}
    Quelle est la différence entre \texttt{INNER JOIN} et \texttt{LEFT JOIN} ?
    \begin{choices}
    \correctchoice{\texttt{INNER JOIN} ne garde que les paires appariées ; \texttt{LEFT JOIN} garde toutes les lignes de la table de gauche, complétées par \texttt{NULL} à droite si aucune correspondance}
    \wrongchoice{Aucune, ce sont des synonymes}
    \wrongchoice{\texttt{LEFT JOIN} ne fonctionne que sur des tables triées}
    \wrongchoice{\texttt{INNER JOIN} est plus rapide que \texttt{LEFT JOIN}}
    \end{choices}
  \end{question}
}

\element{terminalebasesdedonnees}{
  \begin{question}{q24}
    Sans isolation des transactions, deux transactions
simultanées qui modifient le même compte bancaire peuvent
provoquer :
    \begin{choices}
    \correctchoice{Une perte de mise à jour : l'effet d'une transaction est annulé par l'autre, faisant disparaître un dépôt}
    \wrongchoice{Une erreur de syntaxe SQL}
    \wrongchoice{Une duplication automatique des données}
    \wrongchoice{Une accélération de l'exécution des deux transactions}
    \end{choices}
  \end{question}
}

\element{terminalebasesdedonnees}{
  \begin{question}{q25}
    Pourquoi crée-t-on des \textbf{index} sur les colonnes
fréquemment utilisées dans des \texttt{WHERE} ou des jointures ?
    \begin{choices}
    \correctchoice{Pour accélérer la recherche en évitant un parcours complet de la table}
    \wrongchoice{Pour économiser de l'espace de stockage}
    \wrongchoice{Pour rendre les données automatiquement triées}
    \wrongchoice{Pour chiffrer les données sensibles}
    \end{choices}
  \end{question}
}

\element{terminalebasesdedonnees}{
  \begin{question}{q26}
    Pour obtenir le \textbf{nombre d'élèves par classe} dans la
table \texttt{eleves(id, nom, classe)}, quelle requête utiliser ?
    \begin{choices}
    \wrongchoice{\begin{lstlisting}
SELECT classe, COUNT(*)
FROM eleves;
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
SELECT DISTINCT classe, COUNT(*)
FROM eleves;
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
SELECT classe, COUNT(eleves)
FROM eleves
GROUP BY classe;
\end{lstlisting}
}
    \correctchoice{\begin{lstlisting}
SELECT classe, COUNT(*)
FROM eleves
GROUP BY classe;
\end{lstlisting}
}
    \end{choices}
  \end{question}
}

\element{terminalebasesdedonnees}{
  \begin{question}{q27}
    Pour ne garder que les classes ayant \textbf{au moins
$25$ élèves}, on doit filtrer un résultat agrégé. Quelle
est la requête correcte ?
    \begin{choices}
    \wrongchoice{\begin{lstlisting}
SELECT classe
FROM eleves
GROUP BY classe
WHERE COUNT(*) >= 25;
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
SELECT classe, COUNT(*)
FROM eleves
WHERE COUNT(*) >= 25
GROUP BY classe;
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
SELECT classe, COUNT(*)
FROM eleves
HAVING classe COUNT(*) >= 25;
\end{lstlisting}
}
    \correctchoice{\begin{lstlisting}
SELECT classe, COUNT(*)
FROM eleves
GROUP BY classe
HAVING COUNT(*) >= 25;
\end{lstlisting}
}
    \end{choices}
  \end{question}
}

\element{terminalebasesdedonnees}{
  \begin{question}{q28}
    Les propriétés ACID des transactions garantissent leur
bon comportement dans un SGBD. Que désigne le « C » de
ACID ?
    \begin{choices}
    \wrongchoice{Compression}
    \wrongchoice{Confidentialité}
    \wrongchoice{Connexion}
    \correctchoice{Cohérence}
    \end{choices}
  \end{question}
}

\element{terminalebasesdedonnees}{
  \begin{question}{q29}
    Quelle est la différence entre \texttt{DROP TABLE eleves},
\texttt{DELETE FROM eleves} et \texttt{TRUNCATE TABLE eleves} ?
    \begin{choices}
    \wrongchoice{Aucune n'est valide en SQL standard
}
    \wrongchoice{\texttt{DROP} et \texttt{DELETE} sont identiques ; seul
\texttt{TRUNCATE} est différent (il vide aussi les
fichiers de log)
}
    \wrongchoice{Les trois commandes sont équivalentes
}
    \correctchoice{\texttt{DROP TABLE} supprime la table entière (structure et
contenu) ; \texttt{DELETE FROM} (sans \texttt{WHERE}) supprime
toutes les lignes mais conserve la structure (les
contraintes et les types restent) ; \texttt{TRUNCATE TABLE}
vide rapidement le contenu en conservant la
structure (souvent plus rapide que \texttt{DELETE})
}
    \end{choices}
  \end{question}
}

\element{terminalebasesdedonnees}{
  \begin{question}{q30}
    On considère la table \texttt{eleves} 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 ?

\begin{lstlisting}
SELECT nom, moyenne
FROM eleves
WHERE classe = '1A' AND moyenne >= 12
ORDER BY moyenne DESC;
\end{lstlisting}
    \begin{choices}
    \wrongchoice{Cinq lignes (toutes les lignes de la table)
}
    \wrongchoice{Trois lignes : \texttt{('Alice', 14.5)},
\texttt{('Chloé', 16.0)}, \texttt{('Émma', 11.5)}
}
    \correctchoice{Deux lignes : \texttt{('Chloé', 16.0)} puis
\texttt{('Alice', 14.5)}
}
    \wrongchoice{Une seule ligne : \texttt{('Chloé', 16.0)}
}
    \end{choices}
  \end{question}
}

\element{terminalebasesdedonnees}{
  \begin{question}{q31}
    On dispose des deux tables suivantes :

Table \texttt{clients} :

| id | nom    |
|----|--------|
| 1  | Alice  |
| 2  | Bob    |
| 3  | Chloé  |

Table \texttt{commandes} :

| id | client_id | produit  |
|----|-----------|----------|
| 10 | 1         | Livre    |
| 11 | 2         | Cahier   |
| 12 | 1         | Stylo    |

Combien de lignes renvoie la requête suivante ?

\begin{lstlisting}
SELECT c.nom, cmd.produit
FROM clients c
JOIN commandes cmd ON c.id = cmd.client_id;
\end{lstlisting}
    \begin{choices}
    \wrongchoice{2 lignes (une seule par client présent dans
les commandes)
}
    \correctchoice{3 lignes}
    \wrongchoice{9 lignes (le produit cartésien $3 \times 3$)}
    \wrongchoice{4 lignes}
    \end{choices}
  \end{question}
}

\element{terminalebasesdedonnees}{
  \begin{question}{q32}
    Avec la table \texttt{eleves(id, nom, classe, moyenne)}
contenant trente élèves répartis entre trois
classes (\texttt{1A}, \texttt{1B}, \texttt{1C}), que renvoie la
requête suivante ?

\begin{lstlisting}
SELECT classe, AVG(moyenne) AS moy_classe
FROM eleves
GROUP BY classe
HAVING AVG(moyenne) > 12
ORDER BY moy_classe DESC;
\end{lstlisting}
    \begin{choices}
    \correctchoice{La liste des classes dont la moyenne de
la classe est strictement supérieure à
$12$, avec leur moyenne, triée par
moyenne décroissante
}
    \wrongchoice{Une erreur SQL, car on ne peut pas mettre
un alias dans \texttt{ORDER BY}
}
    \wrongchoice{Toutes les classes, avec la somme des
moyennes des élèves
}
    \wrongchoice{La liste des élèves dont la moyenne
individuelle est supérieure à $12$
}
    \end{choices}
  \end{question}
}

\element{terminalebasesdedonnees}{
  \begin{question}{q33}
    Une \textbf{vue} (\texttt{VIEW}) en SQL est :
    \begin{choices}
    \correctchoice{Une requête nommée dont le résultat se
comporte comme une table virtuelle :
chaque interrogation de la vue
réexécute la requête sous-jacente sur les
données actuelles
}
    \wrongchoice{Une représentation graphique des relations
entre les tables
}
    \wrongchoice{Un type particulier d'index pour accélérer
les recherches
}
    \wrongchoice{Une copie figée des données à un instant
donné
}
    \end{choices}
  \end{question}
}

\element{terminalebasesdedonnees}{
  \begin{question}{q34}
    On considère le schéma relationnel suivant :

\begin{lstlisting}
eleves(id_eleve, nom, prenom, id_classe#)
classes(id_classe, niveau, salle)
notes(id_eleve#, id_devoir#, note)
devoirs(id_devoir, matiere, date)
\end{lstlisting}

Le \texttt{\#} désigne une clé étrangère. Quelle
affirmation est correcte ?
    \begin{choices}
    \wrongchoice{La table \texttt{eleves} n'a pas de lien avec
\texttt{classes}
}
    \wrongchoice{On peut avoir plusieurs élèves avec le
même \texttt{id\_eleve}
}
    \wrongchoice{Pour ajouter une note dans \texttt{notes}, il
n'est pas nécessaire que l'élève existe
dans \texttt{eleves}
}
    \correctchoice{La table \texttt{notes} a une clé primaire
composite \texttt{(id\_eleve, id\_devoir)}, et ses
deux composantes sont des clés étrangères
référençant respectivement \texttt{eleves} et
\texttt{devoirs}
}
    \end{choices}
  \end{question}
}

\element{terminalebasesdedonnees}{
  \begin{question}{q35}
    Un programme construit la requête SQL suivante
en concaténant directement la chaîne
\texttt{nom\_saisi} reçue de l'utilisateur :

\begin{lstlisting}
requete = "SELECT * FROM users WHERE nom = '" + nom_saisi + "';"
\end{lstlisting}

Si l'utilisateur saisit
\texttt{' OR '1'='1}, que se passe-t-il ?
    \begin{choices}
    \wrongchoice{Le SGBD détecte l'injection et rejette la
requête
}
    \wrongchoice{Python lève une exception au moment de la
concaténation
}
    \correctchoice{La requête devient
\texttt{SELECT * FROM users WHERE nom = '' OR '1'='1';},
ce qui sélectionne toutes les lignes
de la table : c'est une injection SQL
}
    \wrongchoice{La requête ne retourne aucune ligne
}
    \end{choices}
  \end{question}
}

\element{terminalebasesdedonnees}{
  \begin{question}{q36}
    On part de la table \texttt{comptes} suivante :

| id | titulaire | solde |
|----|-----------|-------|
| 1  | Alice     | 1000  |
| 2  | Bob       | 500   |
| 3  | Chloé     | 2000  |

On exécute la requête suivante :

\begin{lstlisting}
UPDATE comptes
SET solde = solde * 1.05
WHERE solde >= 1000;
\end{lstlisting}

Quel est le contenu de la table après
exécution ?
    \begin{choices}
    \wrongchoice{Bob est supprimé de la table
}
    \wrongchoice{Toutes les lignes voient leur solde
multiplié par $1{,}05$
}
    \correctchoice{Alice : $1050$, Bob : $500$ (inchangé),
Chloé : $2100$
}
    \wrongchoice{La table reste inchangée car la clause
\texttt{WHERE} est trop restrictive
}
    \end{choices}
  \end{question}
}


\onecopy{1}{
  \shufflegroup{terminalebasesdedonnees}
  \insertgroup{terminalebasesdedonnees}
}

\end{document}
