Terminale NSI / Thème 2 : Bases de données / Chapitre 2

Le langage SQL - Activité d'introduction

Dernière mise à jour le : 02/12/2025

Langage SQL - Activité d'introduction

Introduction

Dans cette activité, vous allez découvrir comment effectuer des requêtes sur une table d'une base de données, en utilisant le langage SQL (pour Structured Query Language).

Pour cela, nous allons travailler avec une table déjà étudiée l'année dernière en classe de Première, ce sera l'occasion de faire le lien avec ce qui a été vu l'an dernier.

Voici un extrait de la table utilisée l'année dernière :

prénom jour mois année sexe classe projet
Maïa 12 6 2008 F 1G3 apprendre à piloter une Formule 1
Baptiste 2 10 2008 G 1G3 ouvrir un restaurant
Batoul 4 6 2008 F 1G3 gagner au loto
Gwenola 22 9 2008 F 1G3 devenir quelqu’un de célèbre
Nathaël 13 2 2008 G 1G3 avoir une bonne note au prochain devoir
Adam 21 4 2008 G 1G3 manger des frites tous les jours à la cantine
Corentin 16 11 2008 G 1G3 marcher sur la lune
Alexis 31 10 2008 G 1G3 devenir Youtuber
Ethan 12 5 2008 G 1G3 aider les autres
Firmin 19 7 2008 G 1G3 devenir président
... ... ... ... ... ... ...

Cette dernière était stockée dans un fichier eleves.csv que l'on pouvait importer en Python pour mémoriser son contenu dans un tableau de dictionnaires eleves :

import csv

fichier = open('eleves.csv', 'r', encoding = 'UTF-8')  # ouverture du fichier
# Lecture de son contenu avec la méthode DictReader qui renvoie une valeur spéciale représentant le fichier CSV
table = csv.DictReader(fichier, delimiter=',')  # caractère de séparation : la virgule
eleves = [dict(ligne) for ligne in table]  # chaque élément est un dictionnaire
fichier.close()  # fermeture du fichier
>>> eleves 
[{'prénom': 'Maïa', 'jour': '12', 'mois': '6', 'année': '2008', 'sexe': 'F', 'classe': '1G3', 'projet': 'apprendre à piloter une Formule 1'}, 
 {'prénom': 'Baptiste', 'jour': '2', 'mois': '10', 'année': '2008', 'sexe': 'G', 'classe': '1G3', 'projet': 'ouvrir un restaurant'}, 
 {'prénom': 'Batoul', 'jour': '4', 'mois': '6', 'année': '2008', 'sexe': 'F', 'classe': '1G3', 'projet': 'gagner au loto'}, 
 {'prénom': 'Gwenola', 'jour': '22', 'mois': '9', 'année': '2008', 'sexe': 'F', 'classe': '1G3', 'projet': 'devenir quelqu’un de célèbre'}
 ...,
 {'prénom': 'Corentin', 'jour': '31', 'mois': '5', 'année': '2008', 'sexe': 'G', 'classe': '1G3', 'projet': 'dormir plus longtemps le matin'}]

Par défaut, toutes les valeurs sont mémorisées comme des chaînes de caractères, y compris le jour, le mois et l'année. On peut effectuer un prétraitement pour convertir en type int chaque valeur associée aux clés 'jour', 'mois' et 'annee' : 

eleves = [
    {'prénom': e['prénom'],
     'jour': int(e['jour']),
     'mois': int(e['mois']),
     'année': int(e['année']),
     'sexe': e['sexe'],
     'classe': e['classe'],
     'projet': e['projet']} for e in eleves
]
>>> eleves
[{'prénom': 'Maïa', 'jour': 12, 'mois': 6, 'année': 2008, 'sexe': 'F', 'classe': '1G3', 'projet': 'apprendre à piloter une Formule 1'}, 
 {'prénom': 'Baptiste', 'jour': 2, 'mois': 10, 'année': 2008, 'sexe': 'G', 'classe': '1G3', 'projet': 'ouvrir un restaurant'}, 
 {'prénom': 'Batoul', 'jour': 4, 'mois': 6, 'année': 2008, 'sexe': 'F', 'classe': '1G3', 'projet': 'gagner au loto'}, 
 {'prénom': 'Gwenola', 'jour': 22, 'mois': 9, 'année': 2008, 'sexe': 'F', 'classe': '1G3', 'projet': 'devenir quelqu’un de célèbre'}  
 ..., 
 {'prénom': 'Corentin', 'jour': 31, 'mois': 5, 'année': 2008, 'sexe': 'G', 'classe': '1G3', 'projet': 'dormir plus longtemps le matin'}]

On a créé une base de données eleves.db qui ne contient que la relation Eleve suivante :

Eleve(
    id_eleve INT,
    prenom TEXT, 
    jour INT, 
    mois INT, 
    annee INT, 
    sexe TEXT, 
    classe TEXT, 
    projet TEXT
)

On a ajouté un attribut id_eleve, pourquoi selon vous ?

Remarque : Le fichier eleves.db que nous utiliserons est accessible dans l'archive de ce chapitre.

Utilisation d'un SGBD

Seul un logiciel de type SGBD (Système de Gestion de Bases de Données) peut manipuler les données présentes dans une base de données.

Vous pouvez utiliser :

  • DB Browser for SQLite qui est installé sur vos ordinateurs :

    • (ce logiciel est téléchargeable à l'adresse : https://sqlitebrowser.org/)
    • Lancez le logiciel
    • Ouvrez le fichier eleves.db en le sélectionnant après avoir cliqué sur "Ouvrir une base de données"

  • sqliteonline accessible en ligne à l'adresse https://sqliteonline.com/.

Première requête SQL

Commençons par une requête permettant d’afficher tout le contenu de la table Eleve.

SELECT * FROM Eleve;

Analyse :

  • En SQL, chaque requête contient au moins les clauses SELECT et FROM et se termine par un point-virgule.
  • Le mot-clé SELECT demande au SGBD d’afficher ce que contient une table.
  • Après SELECT, il faut indiquer quels champs de la table, le SGBD doit récupérer dans celle-ci. Ici le caractère « * » indique qu’il faut récupérer tous les champs de la table.
  • Après le FROM (de l’anglais « de ») on indique la table dans laquelle on veut récupérer des informations (ici Eleve)
  • Bilan : cette requête se traduit par « prend tout ce qu’il y a dans la table Eleve, sous-entendu prend tous les champs de cette table.

Q1 : Écrivez cette requête dans le SGBD puis exécutez-la. Vous devriez voir apparaître la table Eleve complète comme ci-dessous.

id_eleve prenom jour mois annee sexe classe projet
1 Maïa 12 6 2008 F 1G3 apprendre à piloter une Formule 1
2 Baptiste 2 10 2008 G 1G3 ouvrir un restaurant
3 Batoul 4 6 2008 F 1G3 gagner au loto
4 Gwenola 22 9 2008 F 1G3 devenir quelqu’un de célèbre
5 Nathaël 13 2 2008 G 1G3 avoir une bonne note au prochain devoir
6 Adam 21 4 2008 G 1G3 manger des frites tous les jours à la cantine
7 Corentin 16 11 2008 G 1G3 marcher sur la lune
8 Alexis 31 10 2008 G 1G3 devenir Youtuber
9 Ethan 12 5 2008 G 1G3 aider les autres
10 Firmin 19 7 2008 G 1G3 devenir président
11 Abel 9 1 2008 G 1G3 devenir un joueur professionnel de billard
12 Sean 13 9 2008 G 1G3 jouer en NBA
13 Antoine 15 2 2008 G 1G3 gérer sa propre entreprise
14 Tim 20 2 2008 G 1G3 jouer dans le prochain James Bond
15 Anastasia 24 9 2006 F 1G3 monter le tapis rouge à Cannes
16 Nathanaël 29 10 2008 G 1G3 devenir champion du monde de bras de fer
17 Jules 4 6 2008 G 1G3 aller à Poudlard
18 Alexis 29 8 2008 G 1G3 avoir son émission de TV
19 Lého 24 10 2008 G 1G3 devenir une rockstar
20 Valentin 12 12 2008 G 1G3 créer un jeu vidéo
21 Hugo 23 7 2008 G 1G3 écrire un livre
22 Charlotte 30 4 2008 F 1G3 devenir astronaute
23 Ilyes 12 11 2008 G 1G3 inventer la machine à voyager dans le temps
24 Corentin 31 5 2008 G 1G3 dormir plus longtemps le matin

Sélection de colonnes en SQL

Rappel : en classe de Première, on a effectué des projections sur les colonnes de la table. L’instruction suivante permet de créer une table t contenant les attributs prenom et annee de la table eleves. On dit que l'on fait ainsi une projection sur ces deux colonnes.

>>> t = [{'prénom': e['prénom'], 'année': e['année']} for e in eleves]
>>> t
[{'prénom': 'Maïa', 'année': 2008},
 {'prénom': 'Baptiste', 'année': 2008},
 {'prénom': 'Batoul', 'année': 2008},
 {'prénom': 'Gwenola', 'année': 2008},
 {'prénom': 'Nathaël', 'année': 2008},
 {'prénom': 'Adam', 'année': 2008},
 {'prénom': 'Corentin', 'année': 2008},
 {'prénom': 'Alexis', 'année': 2008},
 {'prénom': 'Ethan', 'année': 2008},
 {'prénom': 'Firmin', 'année': 2008},
 {'prénom': 'Abel', 'année': 2008},
 {'prénom': 'Sean', 'année': 2008},
 {'prénom': 'Antoine', 'année': 2008},
 {'prénom': 'Tim', 'année': 2008},
 {'prénom': 'Anastasia', 'année': 2006},
 {'prénom': 'Nathanaël', 'année': 2008},
 {'prénom': 'Jules', 'année': 2008},
 {'prénom': 'Alexis', 'année': 2008},
 {'prénom': 'Lého', 'année': 2008},
 {'prénom': 'Valentin', 'année': 2008},
 {'prénom': 'Hugo', 'année': 2008},
 {'prénom': 'Charlotte', 'année': 2008},
 {'prénom': 'Ilyes', 'année': 2008},
 {'prénom': 'Corentin', 'année': 2008}]

En SQL, il est possible de sélectionner certaines colonnes de la table simplement en indiquant après le SELECT, les noms des attributs à conserver.

Par exemple, la requête

SELECT prenom, annee FROM Eleve;

permet de ne sélectionner que les attributs prenom et annee de la table Eleve (on fait une projection sur ces deux attributs). Elle produit le résultat :

prenom annee
Maïa 2008
Baptiste 2008
Batoul 2008
Gwenola 2008
Nathaël 2008
Adam 2008
Corentin 2008
Alexis 2008
Ethan 2008
Firmin 2008
Abel 2008
Sean 2008
Antoine 2008
Tim 2008
Anastasia 2006
Nathanaël 2008
Jules 2008
Alexis 2008
Lého 2008
Valentin 2008
Hugo 2008
Charlotte 2008
Ilyes 2008
Corentin 2008

Q2 : Écrivez et testez une requête SQL permettant de sélectionner uniquement les attributs prenom, sexe et projet.

Réponse :

Sélectionner de lignes en SQL

Rappel : en classe de Première, on a sélectionné des lignes de la table vérifiant une certaine condition. L’instruction suivante permettait de créer une table nes_en_septembre contenant les lignes des élèves nés en septembre.

>>> nes_en_septembre = [eleve for eleve in eleves if eleve['mois'] == 9] 
>>> nes_en_septembre
[{'prénom': 'Gwenola',
  'jour': 22,
  'mois': 9,
  'année': 2008,
  'sexe': 'F',
  'classe': '1G3',
  'projet': 'devenir quelqu’un de célèbre'},
 {'prénom': 'Sean',
  'jour': 13,
  'mois': 9,
  'année': 2008,
  'sexe': 'G',
  'classe': '1G3',
  'projet': 'jouer en NBA'},
 {'prénom': 'Anastasia',
  'jour': 24,
  'mois': 9,
  'année': 2006,
  'sexe': 'F',
  'classe': '1G3',
  'projet': 'monter le tapis rouge à Cannes'}]

En SQL, il est possible de préciser la condition de sélection en l’écrivant juste après le mot clé WHERE comme ci-dessous.

SELECT * FROM Eleve WHERE mois = 9;
id_eleve prenom jour mois annee sexe classe projet
4 Gwenola 22 9 2008 F 1G3 devenir quelqu’un de célèbre
12 Sean 13 9 2008 G 1G3 jouer en NBA
15 Anastasia 24 9 2006 F 1G3 monter le tapis rouge à Cannes

Q3 : Écrivez et testez une requête SQL permettant d’afficher les élèves issus de la classe 1G2.

Réponse :

Q4 : Écrivez et testez une requête SQL permettant d’afficher les garçons nés en juin 2008.

On peut utiliser les opérateurs AND ou OR pour combiner les conditions de sélection.

Réponse :

Sélectionner des lignes et des colonnes

Rappel : L’instruction suivante permettait de créer une table prenoms_projets_des_filles contenant les prénoms et les projets des filles de la classe.

>>> prenoms_projets_des_filles = [
    {'prénom': e['prénom'], 'projet': e['projet']} for e in eleves if e['sexe'] == 'F'
]
>>> prenoms_projets_des_filles
[{'prénom': 'Maïa', 'projet': 'apprendre à piloter une Formule 1'},
 {'prénom': 'Batoul', 'projet': 'gagner au loto'},
 {'prénom': 'Gwenola', 'projet': 'devenir quelqu’un de célèbre'},
 {'prénom': 'Anastasia', 'projet': 'monter le tapis rouge à Cannes'},
 {'prénom': 'Charlotte', 'projet': 'devenir astronaute'}]

En SQL, pour combiner les les sélections sur les lignes et les projections sur les colonnes, il suffit de préciser les attributs de projection après le SELECT et préciser la condition de sélection après le WHERE.

Par exemple, la requête

SELECT prenom, projet FROM Eleve WHERE sexe="F";

permet d'afficher une table contenant les prénoms et les projets des filles de la classe :

prenom projet
Maïa apprendre à piloter une Formule 1
Batoul gagner au loto
Gwenola devenir quelqu’un de célèbre
Anastasia monter le tapis rouge à Cannes
Charlotte devenir astronaute

Q5 : Écrivez et testez une requête SQL permettant d’afficher les prénoms (et uniquement les prénoms) des élèves nés en mai 2008.

Réponse :

Q6: Écrivez et testez une requête SQL permettant d’afficher les id, prénoms et projets des élèves nés les six derniers mois de l’année 2008.

Réponse :

Trier les résultats avec ORDER BY

La commande ORDER BY permet de trier les résultats d’une requête en précisant juste après sur quel attribut le tri doit se faire.

Par exemple, la requête

SELECT prenom, annee FROM Eleve ORDER BY prenom ASC;

permet de trier le résultat de la requête SELECT prenom, annee FROM Eleves selon les prénoms des élèves, ici selon l’ordre alphabétique grâce à ASC (« ascendant », du plus petit au plus grand).

Il suffirait de remplacer ASC par DESC (« descendant ») pour que le tri se fasse dans le sens inverse.

Q7 Écrivez et testez une requête SQL permettant d’afficher les prénoms et l’année de naissance des élèves, le résultat étant trié par ordre croissant d’année de naissance.

Réponse :

Q8 : Écrivez et testez une requête SQL permettant d’afficher, du plus jeune au moins jeune, les prénoms des élèves nés en septembre 2008.

On peut combiner les clauses WHERE et ORDER BY

Réponse :

Quelques fonctions de calculs

Il est possible d'utiliser des fonctions de calculs en SQL. En voici quelques unes.

Compter le nombre de tuples : COUNT(*)

Donnons tout de suite deux exemples.

La requête SQL suivante permet de compter le nombre d’élèves de Première NSI.

SELECT COUNT(*) AS nbEleves FROM Eleve;
nbEleves
24

La requête SQL suivante permet de compter le nombre de garçons de la classe.

SELECT COUNT(*) AS nbGarcons FROM Eleve WHERE sexe = "G";
nbGarcons
19

Analyse de la deuxième requête :

  • On sélectionne les tuples de la table Eleve correspondant à des garçons grâce à l’instruction FROM Eleves WHERE sexe="G"
  • L’instruction COUNT(*) permet de compter tous les tuples sélectionnés
  • L’ajout de AS nbGarcons permet de nommer le résultat. Cette astuce est optionnelle mais est particulièrement utile pour faciliter la lecture des requêtes.

Q9 : Écrivez une requête SQL permettant de compter le nombre d’élèves nés en 2008.

Réponse :

Q10 : Écrivez une requête SQL permettant de compter le nombre d’élèves nés en février.

Réponse :

Compter le nombre de valeurs distinctes d'un attribut

La requête 

SELECT annee FROM Eleve;

va afficher les années de naissance de chacun des 24 élèves (à savoir 2008, 2008, ..., 2008, 2006, 2008, ..., 2008).

L’utilisation d’un DISTINCT permet d’éviter les redondances dans les résultats affichées. Ainsi, l’instruction

SELECT DISTINCT annee FROM Eleve;

ne va afficher que les années de naissance distinctes des élèves (à savoir 2006, 2008). N’hésitez pas à tester ces deux requêtes.

Pour compter le nombre d’années de naissance distinctes des élèves de la classe, il suffit d’ajouter un COUNT comme suit :

SELECT COUNT(DISTINCT annee) AS nbAnneesDistinctes FROM Eleve;

Q11 : Écrivez une requête SQL permettant de compter le nombre de mois de naissances différents des élèves de la classe.

Réponse :

La fonction AVG()

La fonction d'agrégation AVG() (de l'anglais, average signifiant "moyenne") dans le langage SQL permet de calculer une valeur moyenne d'un ensemble de valeurs numériques.

Par exemple, la requête

SELECT AVG(annee) AS anneeMoyenne FROM Eleve;

permet de calculer l’année moyenne de naissance des élèves de la classe.

anneeMoyenne
2007.9166666666667

Q12 : Écrivez une requête SQL permettant de calculer l’âge moyen des élèves de la classe (en 2025). Ce résultat sera nommé ageMoyen.

Réponse :

Bilan

  • Pour interroger une base de données, on doit écrire des requêtes dans le langage SQL via un logiciel de type SGBD.
  • Nous avions ici une base de données formée d'une seule table, ce qui n'est pas souvent le cas. Ainsi, vous découvrirez d'autres fonctionnalités du langage SQL dans la suite de ce chapitre où nous travaillerons aussi sur des bases de données formées de plusieurs tables.


Germain BECKER, Sébastien Point, Lycée Mounier, ANGERS

Ressource éducative libre distribuée sous Licence Creative Commons Attribution - Pas d’Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International

Licence Creative Commons

Voir en ligne : info-mounier.fr/terminale_nsi/base_de_donnees/langage-sql-activite-intro.php