Vous êtes sur la page 1sur 38

Classes Préparatoires aux Grandes Ecoles (CPGE)

Cours de
Programmation
Avancée en
Python

Analyse
algorithmique

Base de
Données
Relationnelles

Enseignant-Chercheur en Informatique à l’INP-HB


Laboratoire de Recherche en Informatique et Télécommunication (LARIT)
DFR : Maths – Info
kpo.loua@inphb.ci / 00225 40 28 31 08

05 Septembre 2019

TS STIC 1
2018 - 2019
A Celui qui peut tout
Et qui me rend capable de tout,
Mon bien-aimé Père !
Classes Préparatoires
aux Grandes Ecoles
Approfondissement en Python 3

Table des matières


PARTIE 1 : NOTION DE BASE DE DONNEES ................................................................................................. 4
Chapitre 1 : Bases de données relationnelles (6H) ................................................................................ 6
1.1. Principes ................................................................................................................................. 6
1.1.2. Enjeux ................................................................................................................................. 6
1.2. L’architecture d’une base de données ................................................................................... 7
1.3. Le modèle relationnel............................................................................................................. 8
1.4. Dépendances fonctionnelles ................................................................................................ 11
1.5. Théorie de normalisation ..................................................................................................... 12
1.6. Algèbre relationnelle ............................................................................................................ 16
TD n°1 - Algèbre relation et les requêtes ----------------------------- (2H) ............................................. 23
Chapitre 2 : Le langage SQL (8H) .......................................................................................................... 26
2.1. Définition .............................................................................................................................. 26
TP n°1 – Environnement de l’outil MySQL -------------------------------(1H) .......................................... 36
TP n°2 – Manipulation de requêtes SQL, interface avec Python ------------- (1H) ............................. 36
PARTIE 2 : ALGORITHME AVANCE ..................................................................... Erreur ! Signet non défini.
Chapitre 3 : Complexité algorithmique (8H) ................................................. Erreur ! Signet non défini.
3.1. Introduction ................................................................................... Erreur ! Signet non défini.
3.2. Motivations ................................................................................... Erreur ! Signet non défini.
3.3. Complexité et notation O .............................................................. Erreur ! Signet non défini.
3.3.2. Notation de Landau ................................................................... Erreur ! Signet non défini.
3.4. Comment mesurer la complexité d'un algorithme ?..................... Erreur ! Signet non défini.
3.5. Différentes nuances de complexité ............................................... Erreur ! Signet non défini.
TDn°2 – Manipulation des ordres de grandeurs, performance d’un algorithme, calcul de
complexité ------------------------------------ (4H) ............................................ Erreur ! Signet non défini.
Chapitre 4 : Notion de pile (2H)..................................................................... Erreur ! Signet non défini.
4.1. Rappels et compléments sur les listes........................................... Erreur ! Signet non défini.
4.2. Manipulation des piles .................................................................. Erreur ! Signet non défini.
4.3. Création d’une pile ........................................................................ Erreur ! Signet non défini.
4.4. Applications ................................................................................... Erreur ! Signet non défini.
Chapitre 5 : Récursivité (8H).......................................................................... Erreur ! Signet non défini.
5.1. Introduction ................................................................................... Erreur ! Signet non défini.
5.2. Fonction récursive ......................................................................... Erreur ! Signet non défini.
5.3. Complexité d’un algorithme récursif............................................. Erreur ! Signet non défini.

1
Classes Préparatoires
aux Grandes Ecoles
Approfondissement en Python 3

TDn°3 – Manipulation des piles, notions de récursivité, complexité----------- (4H)...... Erreur ! Signet
non défini.
5.4. Résolution des récurrences ........................................................... Erreur ! Signet non défini.
TPn°3 – Simulation de piles ----------------------------------------- (2H) ............ Erreur ! Signet non défini.
Chapitre 6 : Algorithmes de tri (10H) ............................................................ Erreur ! Signet non défini.
6.1. Introduction ................................................................................... Erreur ! Signet non défini.
6.2. Algorithmes de tri par insertion .................................................... Erreur ! Signet non défini.
6.3. Algorithme de tri rapide ................................................................ Erreur ! Signet non défini.
6.4. Algorithme du Tri par fusion ......................................................... Erreur ! Signet non défini.
TDn°4 – Tri rapide, tri fusion, complexité de tris avancés ---------------- (4H) ........ Erreur ! Signet non
défini.
TPn°5 – Implémentation de Tris avancés : tri rapide, tri fusion ------------ (2H) .... Erreur ! Signet non
défini.

2
Classes Préparatoires
aux Grandes Ecoles
Approfondissement en Python 3

Objectifs
▪ Gérer des données de bases structurées ou non
▪ Approfondir les connaissances en langage de programmation évolué et moderne

3
Classes Préparatoires
aux Grandes Ecoles
Approfondissement en Python 3

PARTIE 1 : NOTION DE BASE DE


DONNEES

4
Classes Préparatoires
aux Grandes Ecoles
Approfondissement en Python 3

Savoir-faire :
▪ Comprendre et décrire les rôles des différents éléments d'une architecture trois
tiers
▪ Recourir aux concepts des bases de données relationnelles ;
▪ Traduire les questions posées dans un langage de requête en respectant sa syntaxe
▪ Prototyper et créer une base de données simple, à l’aide d’un outil interactif
▪ Consulter une base de données à travers des requêtes de type SQL ;

5
Classes Préparatoires
aux Grandes Ecoles
Approfondissement en Python 3

Chapitre 1 : Bases de données relationnelles (6H)

Durée : CM --------------------------------------------------------------------------------- (4H)

1.1. Principes

1.1.1. Définition

Il est difficile de donner une définition exacte de la notion de base de données. Une
définition très générale pourrait être :

Une Base de données est un ensemble organisé d'informations avec un objectif commun.

Peu importe le support utilisé pour rassembler et stocker les données (papier, fichiers,
etc.), dès lors que des données sont rassemblées et stockées d'une manière organisée dans
un but spécifique, on parle de base de données.

Plus précisément, on appelle base de données un ensemble structuré et organisé permettant


le stockage de grandes quantités d'informations afin d'en faciliter l'exploitation (ajout,
mise à jour, recherche de données). Bien entendu, dans le cadre de ce cours, nous nous
intéressons aux bases de données informatisées.

1.1.2. Enjeux

Les bases de données ont pris une place importante en informatique, et particulièrement
dans le domaine de la gestion. L'étude des bases de données a conduit au développement
de concepts, méthodes et algorithmes spécifiques, notamment pour gérer les données en
mémoire secondaire (i.e. disques durs). En effet, dès l'origine de la discipline, les
informaticiens ont observé que la taille de la RAM ne permettait pas de charger l'ensemble
d'une base de données en mémoire. Cette hypothèse est toujours vérifiée, car le volume
des données ne cesse de s'accroître sous la poussée des nouvelles technologies du WEB.

Ainsi, les bases de données de demain devront être capables de gérer plusieurs dizaines de
Téra-Octets de données, géographiquement distribuées à l'échelle d'Internet, par
plusieurs dizaines de milliers d'utilisateurs dans un contexte d'exploitation changeant (on
ne sait pas très bien maîtriser ou prédire les débits de communication entre sites) voire
sur des nœuds volatiles. En physique des hautes énergies, on prédit qu'une seule expérience
produira de l'ordre du pétaoctet de données par an.
Comme il est peu probable de disposer d'une technologie de disque permettant de stocker
sur un unique disque cette quantité d'informations, les bases de données se sont orientées
vers des architectures distribuées ce qui permet, par exemple, d'exécuter potentiellement

6
Classes Préparatoires
aux Grandes Ecoles
Approfondissement en Python 3

plusieurs instructions d'entrée/sortie en même temps sur des disques différents et donc
de diviser le temps total d'exécution par un ordre de grandeur.

1.2. L’architecture d’une base de données

En règle générale, une application peut aisément se diviser en trois niveaux distincts : les
données, le traitement de ces données et leur affichage.

La couche de donnée regroupe le stockage et les mécanismes d’accès des données de façon
qu’elle soit utilisable par l’application au niveau traitement.
La couche de traitement concerne à la fois les tâches à réaliser par l’application sur les
données et les traitements nécessaires pour donner suite à une action de l’utilisateur.
Enfin, la couche de présentation qui permet l’interaction entre l’utilisateur et l’application.
Ces trois niveaux pouvant être imbriqués ou repartis, leur découpage et leur répartition
permettent de distinguer les architectures applicatives suivantes :
– L’architecture un tiers,
– L’architecture deux tiers,
– L’architecture trois tiers.

1.2.1. L’architecture client-serveur (deux tiers)

Dans une architecture deux tiers ou client-serveur de données, le poste client se contente
de déléguer la gestion des données à un service spécialisé. Ce type d’application permet de
tirer parti de la puissance des ordinateurs déployés en réseau pour fournir à l'utilisateur
une interface riche, tout en garantissant la cohérence des données, qui restent gérées de
façon centralisée.

1.2.2. Architecture trois tiers (trois couches)

L’architecture trois tiers applique les principes suivants :


– Les données sont toujours gérées de façon centralisée ;

7
Classes Préparatoires
aux Grandes Ecoles
Approfondissement en Python 3

– La présentation est toujours prise en charge par le poste client ;


– La logique applicative est prise en charge par un serveur intermédiaire.
Par conséquent, cette architecture appelée encore client-serveur de deuxième génération
ou client-serveur distribué, sépare l’application en trois niveaux de service distinct :

▪ Premier niveau (Couche présentation) : Elle correspond à la partie de l'application


visible et interactive avec les utilisateurs. On parle d'interface homme-machine. La
couche présentation relaie les requêtes de l'utilisateur à destination de la couche
métier, et en retour lui présente les informations renvoyées par les traitements de
cette couche.

▪ Deuxième niveau (Couche métier ou business) : Elle correspond à la partie


fonctionnelle de l'application, celle qui implémente la « logique », et qui décrit les
opérations que l'application opère sur les données en fonction des requêtes des
utilisateurs effectuées au travers de la couche présentation. Les différentes règles
de gestion et de contrôle du système sont mises en œuvre dans cette couche.

▪ Troisième niveau (Couche accès aux données) : Elle consiste en la partie gérant
l’accès aux données qui sont destinées à être conservées sur la durée, voire de
manière définitive.

1.3. Le modèle relationnel

Une base de données relationnelle est une base de données structurée suivant les principes
de l'algèbre relationnelle.

Le père des bases de données relationnelles est Edgar Frank Codd. Chercheur chez IBM à
la fin des années 1960, il étudiait alors de nouvelles méthodes pour gérer de grandes
quantités de données, car les modèles et les logiciels de l'époque ne le satisfaisaient pas.
Mathématicien de formation, il était persuadé qu'il pourrait utiliser des branches
spécifiques des mathématiques (la théorie des ensembles et la logique des prédicats du
premier ordre) pour résoudre des difficultés telles que la redondance des données,
l'intégrité des données ou l'indépendance de la structure de la base de données avec sa
mise en œuvre physique.

8
Classes Préparatoires
aux Grandes Ecoles
Approfondissement en Python 3

En 1970, il publia un article où il proposait de stocker des données hétérogènes dans des
tables, permettant d'établir des relations entre elles. De nos jours, ce modèle est
extrêmement répandu, mais en 1970, cette idée était considérée comme une curiosité
intellectuelle. On doutait que les tables puissent être jamais gérées de manière efficace
par un ordinateur.

Ce scepticisme n'a cependant pas empêché Codd de poursuivre ses recherches. Un premier
prototype de Système de gestion de bases de données relationnelles (SGBDR) a été
construit dans les laboratoires d'IBM. Depuis les années 80, cette technologie a mûri et a
été adoptée par l'industrie. En 1987, le langage SQL, qui étend l'algèbre relationnelle, a
été standardisé.
C'est dans ce type de modèle que se situe ce cours de base de données.

1.3.1. Exemple introductif : Gestion de bibliothèque

Le responsable de la bibliothèque des CPGE peut être tenté de gérer les emprunts par un
simple fichier sur un tableur, par exemple Excel. Les premières lignes de ce fichier peuvent
ressembler à ce qui suit :

On peut tout de suite relever les différentes difficultés avec cette organisation. Elles sont
les suivantes :
– l'orthographe des différents noms de famille peut manquer de cohérence;
– l'orthographe des différents titres des ouvrages peut manquer de cohérence : Mme ou
Madame Bovary ?
– la recopie des numéros de téléphone est fastidieuse et comporte des risques d'erreur ;
– même l'entrée de la date peut poser problème (les autres emprunts du même
emprunteur).
– personne différente portant le même nom
– mise à jour d’une donnée de l’emprunteur
– et si le fichier comportait des milliers de lignes !

9
Classes Préparatoires
aux Grandes Ecoles
Approfondissement en Python 3

La séparation d’objets reliés permet une avancée importante : Les modifications sont
maintenant plus simples à gérer.

Dans le modèle relationnel, les données sont organisées en tableaux à deux dimensions qui
s’appellent relations.

La table des Livres comporte une colonne identifiant le livre, puis une autre identifiant
l'auteur par son numéro, et de même pour le genre. Les titres ne sont pas répétés, ce qui
garantit la cohérence des données.

Table des emprunteurs : ici, la non-répétition des


abonnés de la bibliothèque permet de garantir la
cohérence des données La table des Emprunts permet de
trouver le numéro de l'emprunteur
et celui de l'ouvrage emprunté. La
date de rendu est éventuellement
NULL si l'ouvrage est encore
dehors.

10
Classes Préparatoires
aux Grandes Ecoles
Approfondissement en Python 3

1.3.2. Le système de gestion de base de données relationnelles

Les bases de données (BD) sont généralement gérées par un système appelle Système de
gestion de base de données relationnelles (SGBDR). C’est un système qui permet de gérer
une BD partagée par plusieurs utilisateurs simultanément

Le SGBD permet de :
Décrire les données indépendamment des applications (de manière intrinsèque) avec un
langage de définition des données DATA DEFINITION LANGUAGE (DDL)
Manipuler les données : interroger et mettre à jour les données sans préciser
d'algorithme d'accès. Dire QUOI sans dire COMMENT à l’aide d’un langage de requêtes
déclaratif.
Exemple : quels sont les noms des produits de prix inférieur à 100 F ?
On parle de langage de manipulation des données DATA MANIPULATION
LANGUAGE (DML)
Contrôler les données (intégrité) : vérification de contraintes d'intégrité
Exemple : personne dont le salaire compris entre 400F et 20000 F

1.4. Dépendances fonctionnelles

1.4.1. Définition 1

Soit R(U) une relation avec U l’ensemble de ses attributs.


Soient X, Y ⸦ U, c’est-à-dire X et Y sont deux attributs ou ensemble d’attributs de R.
On dit qu’il existe une dépendance fonctionnelle entre X et Y (ou X détermine Y ou encore
Y est déterminé par X), noté X → Y si et seulement si :
Pour tout t1 et t2, deux tuples de R, si t1[X] = t2[X] alors t1[Y] = t2[Y]
Pour une DF X → Y , X est la source et Y est la cible.

Dans une relation, tout attribut est en DF avec la clef primaire. (Pourquoi ?)

1.4.2. Définition 2

Soit R(U) une relation et X ⸦ U


X est une clef possible ou candidate si et seulement si on a X → Y où Y = U – X (i.e le
complémentaire de X dans U).

La clef primaire d’une relation doit être choisie dans l’ensemble des clefs possibles de la
relation.
S’il n’y en a aucune, tous les attributs de la relation constituent sa clef. On parle alors de
relation « toute clef ».

11
Classes Préparatoires
aux Grandes Ecoles
Approfondissement en Python 3

Propriétés des DF
Soient X et Y ensembles d’attributs

Réflexivité : si Y ⸦ X alors X → Y ( et donc X X)


Augmentation : si X → Y et W ⸦ Z alors X,Z → Y,W
Transitivité : si X → Y et Y → Z alors X→Z
Pseudo-transitivité : si X → Y et Y,Z → W alors X,Z → W
Union : si X → Y et X → Z alors X → Y,Z
Décomposition ou projection : si X → Y,Z alors X → Y et X → Z

1.4.3. Définition 3 (Dépendance fonctionnelle totale)

Soit R(U) une relation et X,Y ⸦ U et X → Y


On a une DFT entre X et U, X → (DFT) Y si et seulement si pour tout X’ ⸦ X, X’ → Y n’est
pas vérifiée.

1.4.4. Définition 3 (Clef primaire)

Soit R(U) une relation et X ⸦ U et X est une clef de R.


On dit que X est une clef minimale de R si et seulement si pour tout X’ ⸦ X, X’ n’est pas une
clef de R.

1.5. Théorie de normalisation

La normalisation permet de garantir que le schéma relationnel est un bon schéma c’est-à-
dire de bonnes propriétés.
Exemple de mauvais schéma. Prenons la relation Enseignant suivante :

Enseignant Numéro Nom Catégorie Classe Salaire


1 Dupont Maitre de conférences 1 12 000
2 Martin Maitre de conférences 1 12 000
3 Smith Professeur 2 17 000
4 Dupont Assistant 1 10 000
5 Durant Assistant 1 10 000

On a en fait la contrainte suivante : tous enseignant de même catégorie et de même classe


gagnent le même salaire. C’est-à-dire :
Catégorie, Classe → Salaire
Il y a dans cette relation une redoncance de données. Ceci conduit à des anormalies de
stockage. (anormalies lors des opérations de mise à jour)
- Anormalie de modification :

12
Classes Préparatoires
aux Grandes Ecoles
Approfondissement en Python 3

S’il y a modication du salaire pour MC 1ier classe, on fait autant d’opérations de


modification qu’il y a d’enseignant de cette catégorie et de cette classe.
- Anomalie d’insertion :
Pour pouvoir stocker le salaire des MC 2ième classe, il faut qu’il y ait au moins un
enseignant dans cette catégorie et de cette classe.
- Anomalie de suppression :
Si l’unique professeur de 2ième classe part, on perd l’information sur le salaire des
professeurs de classe 2

L’objectif de la normalisation est de d’éliminer les anomalies de stockage c’est-à-dire


d’éliminer la redondance.

La normalisation consiste à éclater une relation en plusieurs. Elle comprend plusieurs


étapes : 1 FN, 2FN, 3FN et 3 BCNF

1.5.1. Première Forme Normale (1 FN)

Une relation est en 1 FN, si tous ses attributs sont atomiques (monovalués).
Exemple de relations non 1 FN

Question : Pourquoi ces deux relations ne sont pas en 1 FN ?

Solution 1 : créer autant d’attributs que le nombre maximum de valeurs de l’attribut


multivalué (stockage horizontal).

Exemple :

Solution 2 : créer une nouvelle relation comportant la clef de la relation initiale et


l’attribut multivalué puis éliminer l’attributs multivalué de la relation initiale (stockage
vertical).

Exemple :

13
Classes Préparatoires
aux Grandes Ecoles
Approfondissement en Python 3

Remarque : on vient de faire apparaître un couple clef primaire/ clef étrangère.

Inconvénients :
Solution 1 : stockage de valeurs nulles, impossibilité de stocker plus de valeur que prévu
Solution 2 : opération de jointure, lourdeur des auto-jointures

Avantages :
Solution 1 : tout est dans la même relation (pas de jointure)
Solution 2 : pas de valeur nulle, pas de limite au stockage

Préférer :
Solution 1 : quand le nombre de valeurs de l’attributs multivalué est constant ou que le
nombre maximum de valeur est faible (très peu de valeurs nulles).
Solution 2 : dans les autres cas.

1.5.2. Deuxième Forme Normale (2 FN)

Une relation est en 2 FN si et seulement si :


- Elle est en 1 FN
- Tout attribut n’appartenant pas à la clef primaire est en DF totale avec la clef
primaire.

Exemple de relation non 2 FN


Enseignant(Num, codeMatiere, Nom, VolumeHoraire) avec Num → Nom

Soit R(A,B,C,D) et F = {A, B → C ; A, B → D ;A → C}

Comment normaliser en 2 FN ?
- Isoler la DF partielle dans une nouvelle relation
- Eliminer l’attribut cible de la DF de la relation initiale

Enseignement(Num, code, VolumeHoraire)


Enseignant(Num, nom)

R1(A,B,D) et R2(A,C) en 2 FN

Remarque : un couple clef primaire/étrangère est apparu.

Une relation en 1 FN dont la clef est mono-attribut est forcément en 2 FN.

14
Classes Préparatoires
aux Grandes Ecoles
Approfondissement en Python 3

1.5.3. Troisième Forme Normale (3 FN)

Une relation est en 3 FN si et seulement si :


- Elle est en 2 FN
- Elle ne contient pas de DF transitive entre les attributs non-clef

Exemple :
Enseignant(Num, Nom, Categorie, Classe, Salaire) avec Categorie, Classe → Salaire

Soient R(A,B,C,D) et F = {A → B ; A → C ;A → D ; C → D}

Comment normaliser en 3 FN :
- Isoler la DF transitive dans la nouvelle relation
- Eliminer la cible de la DF de la relation initiale

Exemple :
Enseignement(Num, nom, Categorie, Classe)
Salaire(Categorie, Classe, Salaire)

R1(A,B,C) et R2(C,D)

Opération de mise à Jour :


- Modification : si le salaire d’un MC 1ière classe change, une seule modification
- Insertion : on peut stocker le salaire des MC 2ième classe sans avoir d’enregistrement
dans cette catégorie
- Suppression : si le professeur en classe 2 part, on conserve le salaire des
professeurs en classe 2.

1.5.4. Forme Normale Boyce et Codd (FNBC)

Une relation est en BCFN si et seulement si :


- Elle est en 2 FN
- Toute source de DF est une clef primaire minimale

Remarques :
1. Si R est en BCFN alors elle est en 3 FN
Preuve : si R est en BCFN alors pour tout X tel que X → U, X est une clef minimale.
Supposons qu’il existe Y, Z U tel que Y → Z, mais dans ce cas Y est une clef minimale.
On ne peut donc jamais avoir de transitivité avec deux attributs non clef.
2. Si R est en 3 FN alors elle n’est pas forcément en BCFN
Preuve : cf. contre-exemple ci-dessous.

Soient R(A, B, C, D, E) et F={A → C ; A → D ; A → E ; E → B}

Comme E → B et que E n’est pas une clef minimale, cette relation n’est pas en BCFN.

15
Classes Préparatoires
aux Grandes Ecoles
Approfondissement en Python 3

Exemple de relation non BCFN


Soit la relation Adresse(Rue, LieuDit, BureauPostal, CodePostal)
- Quelles sont les DF existant dans cette relation ?
- En quelle forme normale est la relation ?

Comment normaliser en BCFN ?


- Isoler la DF problématique dans une nouvelle relation
- Eliminer la cible de la DF problématique et la remplacer par sa source dans la relation
initiale.

R2(A,E, C, D) et R2(E, B)

1.5.5. Théorème de décomposition de Casey-Delobel

A partir de la 2 FN, on normalise en appliquant le théorème suivant :

Théorème de décomposition
Soit R(X, Y, Z) une relation où X, Y et Z sont des ensembles d’attributs.
Soit X → Y une DF vérifiée dans R. Alors, il existe R1 et R2 deux relations telle que R1(X,Y)
et R2(X,Z) et R = Jointure(R1,R2 / R1.X = R2.X)
La décomposition de R dans les deux relations R1 et R2 est garantie sans perte
d’information.

1.6. Algèbre relationnelle

1.6.1. Définition

L’algèbre relationnelle est le langage de manipulation qu’utilise le SGBDR pour effectuer


des opérations sur les relations (tables).

Les requêtes SQL (Strutured Query Language) soumisent par l’utilisateur sont traduites
par le SGBD en opérations de l’algèbre relationnelle.

SQL Algèbre relationnelle

Utilisateur BD
SGBDR

L’algèbre relationnelle est un ensemble d’opérateurs qui prennent en entrée des relations
et qui produisent en sortie des relations.

16
Classes Préparatoires
aux Grandes Ecoles
Approfondissement en Python 3

Objectif : localiser des données dans la base qui répondent à un certain critère ou aux
besoins de l’utilisateur.

1.6.2. Terminaison structurelle

Les objets de base souvent référencés dans la modélisation relationnelle sont les domaines,
les relations, les attributs, les degrés et les tuples.

Domaine :
Le domaine représente un ensemble fini de valeur possible pour un attribut donné auquel
on définit aussi un ensemble d’opérateurs pouvant être appliqués aux valeurs du domaine.

Tuple
Grossièrement, un tuple est un enregistrement (une ligne) dans la base de données.
Plus formellement, un tuple est un élément atomique comportant un entête et un corps.
L'entête est un ensemble des noms d’attributs et de leurs domaines et le corps est un
ensemble de triplets <Nom du domaine, Nom d’attribut, Valeur>

Attribut :
Un attribut est simplement la valeur associée à un des triplets d’un tuple.

Clé candidate :
Une clé candidate est un ensemble des données (attribut) permettant d’indexer chaque
ligne d’une table donnée de manière différenciée. On utilise souvent une ou plusieurs clés
candidates comme clé primaire.

Une clé primaire :

17
Classes Préparatoires
aux Grandes Ecoles
Approfondissement en Python 3

Une clé primaire est une clé candidate qui identifie de manière unique un tuple. Elle est
généralement soulignée.

Une clé étrangère :


Une clé étrangère est un attribut qui fait référence à une clé primaire d’une autre relation.
Elle est précédée d’un dièse (#).

Relation
Une relation (ou table) est un élément constitué d’un entête et d’un corps. L’entête est un
ensemble des noms d’attributs et de leurs domaines et le corps est un ensemble de tuples
ayant le même entête que la relation.

Soient : R : une relation ; Att1, Att2, … , Attn : des attributs ; D1, D2, … , Dn : les domaines
des attributs respectifs.

Alors on note R(Att1 : D1, Att2 : D2, … , Attn : Dn) la relation R ;

Ainsi la relation voiture sera notée Voiture(marque, couleur, plaque)


Par soucis de présentation nous retenons la notation suivante :
Voiture(plaque, couleur, marque)
– Voiture est le nom de la relation
– Plaque, couleur, marque sont les attributs de la relation
– Plaque est la clé primaire car le numéro de la plaque identifie de manière unique une
voiture.

Attention à ne pas confondre avec le concept de relation entre les tables.

1.6.3. Les opérations de l’algèbre relationnelle

L’algèbre relationnelle possède huit opérateurs : certains opérateurs sont ensemblistes


(selon la théorie des ensembles), d’autres sont relationnels (spécifiques à l’algèbre
relationnelle). On peut aussi classer les opérateurs selon qu’ils s’appliquent à une ou à
plusieurs relations (tables).

Opérations à un seul opérande : Opérations à deux opérandes :


– Sélection (opérateur relationnel) – Produit cartésien (opérateurs ensemblistes)
– Projection (opérateur relationnel) – Jointure (opérateur relationnel)
– Union (opérateurs ensemblistes)
– Intersection (opérateurs ensemblistes)
– Différence (opérateurs ensemblistes)
– Division (opérateur relationnel)

L'algèbre relationnelle est un langage d’interrogation des bases de données relationnelles.


Parfois, pour parvenir à extraire les données voulues, il faut effectuer plusieurs opérations.
Dans ce cas, le résultat de la première opération est utilisé dans la deuxième opération, et
le résultat de la deuxième opération peut être utilisé dans la troisième opération, …

18
Classes Préparatoires
aux Grandes Ecoles
Approfondissement en Python 3

1.6.4. Les opérateurs relationnels

Restriction (Sélection) σ
La sélection consiste à extraire d’une relation les occurrences (lignes) satisfaisant au(x)
critère(s) de sélection.
 Formalisme : R2 = SELECTION (R1/ C(Att)) où C(Att) est le critère de sélection sur
le(s) attribut(s) Att.
Critères de sélection :
▪ Opérateurs de comparaison : <, <=, =, >, >=, ? (Entre un champ ou attribut et une
valeur)
▪ Opérateurs logiques : ET, OU (entre deux comparaison)
▪ NON (pour renverser la comparaison)

Soit la table FILM qui permet de gérer une vidéothèque.

FILM(no-film, titre, duree, production, #code-categorie)

Requête : On aimerait avoir les films de durée supérieure à 115.

Réponse : R = σduree > 115(FILM) Ou


R = SELECTION (FILM/ duree > 115) (c’est mieux ainsi !)

Projection Π
La projection d'une relation consiste en la mise en place d'une nouvelle relation en ne
retenant que certaines colonnes (attributs) et en supprimant les occurrences en double.
 Formalisme : R2 = PROJECTION (R1/colonne 1, colonne 2, …)
R2 est la table résultat, R1 est la table utilisée par la projection. Pas de duplication des
occurrences.

On aimerait avoir les titres et productions de tous les films.


▪ Π titre, production (FILM)
▪ Ou Projection (FILM/ titre, production)

Division /
La division permet de trouver les occurrences d’une table qui sont associées à toutes les
occurrences d’une autre table (qui le plus souvent est le résultat d’une sélection).
 Formalisme : R = DIVISION (dividende, diviseur) ou R = dividende / diviseur

19
Classes Préparatoires
aux Grandes Ecoles
Approfondissement en Python 3

Attention au sens, chers Prépas !!!

DIVISION(PARTICIPER, EPREUVE)

Le nom des athlètes qui ont participé aux épreuves de 200 m et de 400 m et de 110 m H.

Jointure
La jointure consiste à créer une nouvelle table à partir de deux tables ayant un champ
commun (attribut) et vérifiant un critère de jointure.
 Formalisme :
R3 = JOINTURE(R1, R2/R1.attr_jointure op_comparaison R2.attr_jointure)

Cours Notes

nom_Cours Professeur coefficient Etudiant nom_Cours note


Gestion de projet Gnaba Carine 2 Kouadah Gestion de projet 12
Base de données KPO Loua 4 Bruken Base de données 14
Analyse Wakablet 2 Ichmed Analyse 12
Data mining Adingra 3 Toto Data mining 13

La jointure entre les deux tables Cours et Notes se fait à travers l’attribut Nom_cours
▪ JOINTURE(Cours, Notes/ Cours.nom_cours = Notes.nom_cours)

Cours.nom_Cours Professeur coefficient Etudiant Notes.nom_Cours note


Gestion de projet Gnaba Carine 2 Kouadah Gestion de projet 12
Base de données KPO Loua 4 Bruken Base de données 14
Analyse Wakablet 2 Ichmed Analyse 12
Data mining Adingra 3 Toto Data mining 13

1.6.5. Les opérateurs assemblâtes

Les opérateurs ensemblistes sont les mêmes qu’en mathématiques, dans la théorie des
ensembles. Vous avez certainement vu ce cours en MPSI.

20
Classes Préparatoires
aux Grandes Ecoles
Approfondissement en Python 3

Union (U)
L’union de deux tables est l'ensemble des occurrences qui appartiennent soit à la première
table, soit à la deuxième, soit aux deux tables. C’est la traduction du OU logique.
Remarque : pas de duplication des n-uplets.
Formalisme : Soient R1 et R2 deux relations. On a : R = R1 U R2 ou R = UNION (R1 , R2)

Intersection ( ∩ )
L'intersection de deux relations est l'ensemble des occurrences qui sont présentes dans
les deux relations. C’est la traduction du ET logique.
 Formalisme : R = R1 ∩ R2 ou R = INTERSECTION (R1, R2)

21
Classes Préparatoires
aux Grandes Ecoles
Approfondissement en Python 3

Différence –
La différence entre deux tables est l'ensemble des occurrences qui appartiennent à une
table sans appartenir à la seconde. Le but est d’obtenir l’ensemble des tuples d’une relation
qui ne figurent pas dans une autre. Attention, cette opération a un sens.
 Formalisme : R = R1 - R2 ou R = DIFFERENCE (R1, R2). Opération non commutative.

S-R

Noms des élèves qui ne portent pas


le nom d’un prof : Résu = Eleve2-Prof

Produit cartésien x
Le produit cartésien de deux tables consiste à combiner toutes les possibilités
d’associations d’occurrences des deux tables. Chaque ligne de R1 sera concaténée à chaque
ligne de R2.
 Formalisme : R = R1 x R2 ou R = PRODUIT (R1, R2)

Soit la base de données suivante :


Eleve(Num, Nom, Adresse, Age)
UV(Code, Nbh, Coord)

22
Classes Préparatoires
aux Grandes Ecoles
Approfondissement en Python 3

TD n°1 - Algèbre relation et les requêtes ----------------------------- (2H)

On considère la base de données BD AIRBASE suivante :

PILOTE (numpil : d_numpil, nompil: d_nompil, adr : d_ville, sal : d_sal)


AVION (numav : d_numav, nomav : d_nomav, cap : d_cap, loc : d_ville)
VOL (numvol : d_numvol, #numpil : d_numpil, #numav : d_numav, ville_dep : d_ville, ville_arr
: d_ville, h_dep : d_heure, h_arr : d_heure)

On pourra l’écrire plus simplement de la manière suivante :


PILOTE (numpil, nompil, adr, sal )
AVION (numav, nomav, cap, loc )
VOL (numvol, #numpil, #numav, ville_dep, ville_arr, h_dep, h_arr)

Convention : Les clés primaires sont soulignées et les clés étrangères sont précédées d’un
dièse (#).

TAF : Donner les réponses aux requêtes ci-dessous en algèbre relationnelle.

Exercice 1 : Expression des projections et sélections

Q1 : Donnez la liste des avions dont la capacité est supérieure à 350 passagers.
R1 = ……………………………………………………………………………………………………………………………………………………

Q2 : Quels sont les numéros et noms des avions localisés à Nice ?


R2.1 = ……………………………………………………………………………………………………………………………………………………
R2 = ……………………………………………………………………………………………………………………………………………………

Q3 : Quels sont les numéros des pilotes en service et les villes de départ de leurs vols ?
R3 = ……………………………………………………………………………………………………………………………………………………

Q4 : Donnez toutes les informations sur les pilotes de la compagnie.


R4 = ……………………………………………………………………………………………………………………………………………………

Q5 : Quel est le nom des pilotes domiciliés à Paris dont le salaire est supérieur à 15000 F
?
R5.1 = ……………………………………………………………………………………………………………………………………………………
R5.2 = ……………………………………………………………………………………………………………………………………………………
R5 = ……………………………………………………………………………………………………………………………………………………

Exercice 2 : Utilisation des opérateurs ensemblistes

Q6 : Quels sont les avions (numéro et nom) localisés à Nice ou dont la capacité est
inférieure à 350 passagers ?
R6.1 = ……………………………………………………………………………………………………………………………………………………
R6.2 = ……………………………………………………………………………………………………………………………………………………
R6 = ……………………………………………………………………………………...………………………………………………………………

23
Classes Préparatoires
aux Grandes Ecoles
Approfondissement en Python 3

Q7 : Liste des vols au départ de Nice allant à Paris après 18 heures ?


R7.1 = ……………………………………………………………………………………………………………………………………………………
R7.2 = ……………………………………………………………………………………………………………………………………………………
R7.3 = ……………………………………………………………………………………………………………………………………………………
R7.4 = ……………………………………………………………………………………………………………………………………………………
R7 = ……………………..………………………………………………………………………………………………………………………………

Q8 : Quels sont les numéros des pilotes qui ne sont pas en service ?
R8.1 = ……………………………………………………………………………………………………………………………………………………
R8.2 = ……………………………………………………………………………………………………………………………………………………
R8 = ………………..……………………………………………………………………………………………………………………………………

Q9 : Quels sont les vols (numéro, ville de départ) effectués par les pilotes de numéro 100
et 204 ?
R9.1 = ……………………………………………………………………………………………………………………………………………………
R9.2 = ……………………………………………………………………………………………………………………………………………………
R9.3 = ……………………………………………………………………………………………………………………………………………………
R9 = …………..…………………………………………………………………………………………………………………………………………

Exercice 3 : Expression des jointures

Q10 : Donnez le numéro des vols effectués au départ de Nice par des pilotes Niçois ?
R10.1 = ……………………………………………………………………………………………………………………………………………………
R10.2 = ……………………………………………………………………………………………………………………………………………………
R10 = …………………..…………………………………………………………………………………………………………………………………

Q11 : Quels sont les vols effectués par un avion qui n'est pas localisé à Nice ?
R11.1 = ……………………………………………………………………………………………………………………………………………………
R11.2 = ……………………………………………………………………………………………………………………………………………………
R11 = ………..……………………………………………………………………………………………………………………………………………

Q12 : Quels sont les pilotes (numéro et nom) assurant au moins un vol au départ de Nice
avec un avion de capacité supérieure à 300 places ?
R12.1 = ……………………………………………………………………………………………………………………………………………………
R12.2 = ……………………………………………………………………………………………………………………………………………………
R12.3 = ……………………………………………………………………………………………………………………………………………………
R12 = ………………….……………………………………………………………………………………………………………………………………

Q13 : Quels sont les noms des pilotes domiciliés à Paris assurant un vol au départ de Nice
avec un Airbus ?
R13.1 = ……………………………………………………………………………………………………………………………………………………
R13.2 = ……………………………………………………………………………………………………………………………………………………
R13.3 = ……………………………………………………………………………………………………………………………………………………
R13 = ……………………………………….………………………………………………………………………………………………………………

Q14 : Quels sont les numéros des vols effectués par un pilote Niçois au départ ou à
l'arrivée de Nice avec un avion localisé à Paris ?
R14.1 = ……………………………………………………………………………………………………………………………………………………
R14.2 = ……………………………………………………………………………………………………………………………………………………
R14.3 = ……………………………………………………………………………………………………………………………………………………
R14.4 = ……………………………………………………………………………………………………………………………………………………

24
Classes Préparatoires
aux Grandes Ecoles
Approfondissement en Python 3

R14.5 = ……………………………………………………………………………………………………………………………………………………
R14 = ……………………………………………………………………………………………………………………………………………………

Q15 : Quels sont les pilotes (numéro et nom) habitant dans la même ville que le pilote Dupont
?
Q16 : Quels sont les numéros des pilotes en service différents de celui de Durand ?
Q17 : Quelles sont les villes desservies à partir de la ville d'arrivée d'un vol au départ de
Paris ?
Q18 : Quels sont les appareils (leur numéro) localisés dans la même ville que l'avion numéro
100 ?

Exercice 4 : Divers

Q19 : Quels sont les numéros et noms des pilotes domiciliés dans la même ville que le pilote
Dupont et dont le salaire est supérieur à celui de Dupont ?
Q20 : Quels sont les numéros et noms des pilotes qui effectuent un vol au départ de leur
ville de résidence ?
Q21 : Y a-t-il des homonymes parmi les pilotes ? Si oui, donner leur numéro et nom.
Q22 : Quels sont les pilotes bordelais ne pilotant que des avions arrivant au moins une fois
à Bordeaux ?

25
Classes Préparatoires
aux Grandes Ecoles
Approfondissement en Python 3

Chapitre 2 : Le langage SQL (8H)

2.1. Définition

Le SQL (Structured Query Language, traduit en français par Langage de requêtes


structurées) est un langage permettant de communiquer avec une base de données. Ce
langage informatique est notamment très utilisé par les développeurs web pour
communiquer avec les données d’un site web. SQL.sh recense des cours de SQL et des
explications sur les principales commandes pour lire, insérer, modifier et supprimer des
données dans une base.

SQL est un langage de définition de données (LDD, ou en anglais DDL Data Definition
Language), un langage de manipulation de données (LMD, ou en anglais DML, Data
Manipulation Language), et un langage de contrôle de données (LCD, ou en anglais DCL, Data
Control Language), pour les bases de données relationnelles.

2.1.1. Les requêtes en SQL

La projection (SELECT………FROM)
L’utilisation la plus courante de SQL consiste à lire des données issues de la base de
données. Cela s’effectue grâce à la commande SELECT, qui retourne des enregistrements
dans un tableau de résultat. Cette commande peut sélectionner une ou plusieurs colonnes
d’une table.

Syntaxe :

SELECT nom_du_champ FROM nom_du_tableau ;

SQL AS (alias)
Dans le langage SQL il est possible d’utiliser des alias pour renommer temporairement une
colonne ou une table dans une requête. Cette astuce est particulièrement utile pour
faciliter la lecture des requêtes.

Alias sur une colonne Permet de renommer le nom d’une colonne dans les résultats d’une
requête SQL. C’est pratique pour avoir un nom facilement identifiable dans une application
qui doit ensuite exploiter les résultats d’une recherche

Syntaxe :

SELECT colonne1 AS c1, colonne2 FROM `table`

La selection (SELECT…….FROM…………..WHERE)

26
Classes Préparatoires
aux Grandes Ecoles
Approfondissement en Python 3

SQL WHERE La commande WHERE dans une requête SQL permet d’extraire les lignes
d’une base de données qui respectent une condition. Cela permet d’obtenir uniquement les
informations désirées.

Syntaxe : La commande WHERE s’utilise en complément à une requête utilisant SELECT.


La façon la plus simple de l’utiliser est la suivante :

SELECT nom_colonnes
FROM nom_table
WHERE condition ;

Opérateur Description

= Égale

Pas égale

!= Pas égale

> Supérieur à

< Inférieur à

>= Supérieur ou égale à

<= Inférieur ou égale à

IN Liste de plusieurs valeurs possibles

BETWEEN Valeur comprise dans un intervalle donnée (utile


pour les nombres ou dates)

LIKE Recherche en spécifiant le début, milieu ou fin


d'un mot.

IS NULL Valeur est nulle

IS NOT Valeur n'est pas nulle


NULL

SQL AND & OR


Une requête SQL peut être restreinte à l’aide de la condition WHERE. Les opérateurs
logiques AND et OR peuvent être utilisées au sein de la commande WHERE pour combiner
des conditions. Syntaxe d’utilisation des opérateurs AND et OR Les opérateurs sont à
ajoutés dans la condition WHERE. Ils peuvent être combinés à l’infini pour filtrer les

27
Classes Préparatoires
aux Grandes Ecoles
Approfondissement en Python 3

données comme souhaités. L’opérateur AND permet de s’assurer que la condition1 ET la


condition2 sont vrai :

SELECT nom_colonnes
FROM nom_table
WHERE condition1 AND condition2

L’opérateur OR vérifie quant à lui que la condition1 OU la condition2 est vrai :

SELECT nom_colonnes FROM nom_table


WHERE condition1 OR condition2

Ces opérateurs peuvent être combinés à l’infini et mélangés. L’exemple ci-dessous filtre les
résultats de la table « nom_table » si condition1 ET condition2 OU condition3 est vrai :

SELECT nom_colonnes FROM nom_table


WHERE condition1 AND (condition2 OR condition3)

Attention : il faut penser à utiliser des parenthèses lorsque c’est nécessaire. Cela permet
d’éviter les erreurs car et ça améliore la lecture d’une requête par un humain.

SQL IN
L’opérateur logique IN dans SQL s’utilise avec la commande WHERE pour vérifier si une
colonne est égale à une des valeurs comprises dans set de valeurs déterminés. C’est une
méthode simple pour vérifier si une colonne est égale à une valeur OU une autre valeur OU
une autre valeur et ainsi de suite, sans avoir à utiliser de multiple fois l’opérateur OR.
Syntaxe Pour chercher toutes les lignes où la colonne « nom_colonne » est égale à ‘valeur
1′ OU ‘valeur 2′ ou ‘valeur 3′, il est possible d’utiliser la syntaxe suivante :

SELECT nom_colonne
FROM table
WHERE nom_colonne IN ( valeur1, valeur2, valeur3, ... )

SQL BETWEEN
L’opérateur BETWEEN est utilisé dans une requête SQL pour sélectionner un intervalle de
données dans une requête utilisant WHERE. L’intervalle peut être constitué de chaînes de
caractères, de nombres ou de dates. L’exemple le plus concret consiste par exemple à
récupérer uniquement les enregistrements entre 2 dates définies.

Syntaxe L’utilisation de la commande BETWEEN s’effectue de la manière suivante :

SELECT *
FROM table
WHERE nom_colonne BETWEEN 'valeur1' AND 'valeur2'

28
Classes Préparatoires
aux Grandes Ecoles
Approfondissement en Python 3

SQL LIKE
L’opérateur LIKE est utilisé dans la clause WHERE des requêtes SQL. Ce mot-clé permet
d’effectuer une recherche sur un modèle particulier. Il est par exemple possible de
rechercher les enregistrements dont la valeur d’une colonne commence par telle ou telle
lettre. Les modèles de recherches sont multiples.
Syntaxe La syntaxe à utiliser pour utiliser l’opérateur LIKE est la suivante :

SELECT *
FROM table
WHERE colonne LIKE modele

Dans cet exemple le « modèle » n’a pas été défini, mais il ressemble très généralement à
l’un des exemples suivants : LIKE ‘%a’ : le caractère « % » est un caractère joker qui
remplace tous les autres caractères. Ainsi, ce modèle permet de rechercher toutes les
chaines de caractère qui se termine par un « a ».
o LIKE ‘a%’ : ce modèle permet de rechercher toutes les lignes de « colonne » qui
commence par un « a ».
o LIKE ‘%a%’ : ce modèle est utilisé pour rechercher tous les enregistrements qui
utilisent le caractère « a ».
o LIKE ‘pa%on’ : ce modèle permet de rechercher les chaines qui commence par « pa »
et qui se terminent par « on », comme « pantalon » ou « pardon ».
o LIKE ‘a_c’ : peu utilisé, le caractère « _ » (underscore) peut être remplacé par
n’importe quel caractère, mais un seul caractère uniquement (alors que le symbole
pourcentage « % » peut être remplacé par un nombre incalculable de caractères . Ainsi,
ce modèle permet de retourner les lignes « aac », « abc » ou même « azc ».

SQL IS NULL / IS NOT NULL


Dans le langage SQL, l’opérateur IS permet de filtrer les résultats qui contiennent la valeur
NULL. Cet opérateur est indispensable car la valeur NULL est une valeur inconnue et ne
peut par conséquent pas être filtrée par les opérateurs de comparaison (cf. égal, inférieur,
supérieur ou différent).

Syntaxe Pour filtrer les résultats où les champs d’une colonne sont à NULL il convient
d’utiliser la syntaxe suivante :

SELECT *
FROM `table`
WHERE nom_colonne IS NULL

A l’inverse, pour filtrer les résultats et obtenir uniquement les enregistrements qui ne sont
pas null, il convient d’utiliser la syntaxe suivante :

SELECT *
FROM `table`
WHERE nom_colonne IS NOT NULL

29
Classes Préparatoires
aux Grandes Ecoles
Approfondissement en Python 3

A savoir : l’opérateur IS retourne en réalité un booléen, c’est à dire une valeur TRUE si la
condition est vraie ou FALSE si la condition n’est pas respectée. Cet opérateur est souvent
utilisé avec la condition WHERE mais peut aussi trouver son utilité lorsqu’une sous-requête
est utilisée.

SQL GROUP BY
La commande GROUP BY est utilisée en SQL pour grouper plusieurs résultats et utiliser
une fonction de totaux sur un groupe de résultat. Sur une table qui contient toutes les
ventes d’un magasin, il est par exemple possible de lister, regrouper les ventes par clients
identiques et d’obtenir le coût total des achats pour chaque client.
Syntaxe d’utilisation de GROUP BY De façon générale, la commande GROUP BY s’utilise de
la façon suivante :

SELECT colonne1, fonction(colonne2)


FROM table
GROUP BY colonne1

A noter : cette commande doit toujours s’utiliser après la commande WHERE et avant la
commande HAVING.

Prenons en considération une table “achat” qui résume les ventes d’une boutique :

id client tarif date

1 Pierre 102 2012-10-23

2 Simon 47 2012-10-27

3 Marie 18 2012-11-05

4 Marie 20 2012-11-14

5 Pierre 160 2012-12-03

Ce tableau contient une colonne qui sert d’identifiant pour chaque ligne, une autre qui
contient le nom du client, le coût de la vente et la date d’achat.
Pour obtenir le coût total de chaque client en regroupant les commandes des mêmes clients,
il faut utiliser la requête suivante :

SELECT client, SUM(tarif)


FROM achat
GROUP BY client

30
Classes Préparatoires
aux Grandes Ecoles
Approfondissement en Python 3

La fonction SUM() permet d’additionner la valeur de


chaque tarif pour un même client SUM(tarif) client. Le résultat sera donc
le suivant :
Pierre 262

Simon 47

Marie 38

La manière simple de comprendre le GROUP BY c’est tout simplement d’assimiler qu’il va


éviter de présenter plusieurs fois les mêmes lignes. C’est une méthode pour éviter les
doublons.
Juste à titre informatif, voici ce qu’on obtient de la requête sans utiliser GROUP BY.
Requite :

SELECT client, SUM(tarif)


FROM achat

Résultat :

client SUM(tarif)

Pierre 262

Simon 47

Marie 38

Marie 38

Pierre 262

Utilisation d’autres fonctions de statistiques Il existe plusieurs fonctions qui peuvent être
utilisées pour manipuler plusieurs enregistrements, il s’agit des fonctions d’agrégations
statistiques, les principales sont les suivantes :
o AVG() pour calculer la moyenne d’un set de valeur. Permet de connaître le prix du
panier moyen pour de chaque client
o COUNT() pour compter le nombre de lignes concernées. Permet de savoir combien
d’achats a été effectué par chaque client
o MAX() pour récupérer la plus haute valeur. Pratique pour savoir l’achat le plus cher
o MIN() pour récupérer la plus petite valeur. Utile par exemple pour connaître la date
du premier achat d’un client
o SUM() pour calculer la somme de plusieurs lignes. Permet par exemple de connaître
le total de tous les achats d’un client Ces petites fonctions se révèlent rapidement
indispensable pour travailler sur des données.

31
Classes Préparatoires
aux Grandes Ecoles
Approfondissement en Python 3

SQL HAVING
La condition HAVING en SQL est presque similaire à WHERE à la seule différence que
HAVING permet de filtrer en utilisant des fonctions telles que SUM(), COUNT(), AVG(),
MIN() ou MAX().
Syntaxe L’utilisation de HAVING s’utilise de la manière suivante :

SELECT colonne1, SUM(colonne2)


FROM nom_table
GROUP BY colonne1
HAVING fonction(colonne2) operateur valeur

Cela permet donc de SÉLECTIONNER les colonnes DE la table « nom_table » en


GROUPANT les lignes qui ont des valeurs identiques sur la colonne « colonne1″ et que la
condition de HAVING soit respectée.

Important : HAVING est très souvent utilisé en même temps que GROUP BY bien que ce
ne soit pas obligatoire

Exemple
Pour utiliser un exemple concret, imaginons une table “achat” qui contient les achats de
différents clients avec le coût du panier pour chaque achat.

id client tarif date_achat

1 Pierre 102 2012-10-23

2 Simon 47 2012-10-27

3 Marie 18 2012-11-05

4 Marie 20 2012-11-14

5 Pierre 160 2012-12-03

Si dans cette table on souhaite récupérer la liste des clients qui ont commandé plus de 40€,
toute commandes confondues alors il est possible d’utiliser la requête suivante :

SELECT client, SUM(tarif)


FROM achat
GROUP BY client
HAVING SUM(tarif) > 40

32
Classes Préparatoires
aux Grandes Ecoles
Approfondissement en Python 3

Résultat :

client SUM(tarif)

Pierre 262

Simon 47

La cliente “Marie” a cumulé 38€ d’achat (un achat de 18€ et un autre de 20€) ce qui est
inférieur à la limite de 40€ imposée par HAVING. En conséquent cette ligne n’est pas
affichée dans le résultat.

SQL ORDER BY
La commande ORDER BY permet de trier les lignes dans un résultat d’une requête SQL. Il
est possible de trier les données sur une ou plusieurs colonnes, par ordre ascendant ou
descendant.

Syntaxe Une requête où l’on souhaite filtrer l’ordre des résultats utilise la commande
ORDER BY de la sorte :

SELECT colonne1, colonne2


FROM table
ORDER BY colonne1

Par défaut les résultats sont classés par ordre ascendant, toutefois il est possible
d’inverser l’ordre en utilisant le suffixe DESC après le nom de la colonne. Par ailleurs, il est
possible de trier sur plusieurs colonnes en les séparant par une virgule. Une requête plus
élaborée ressemblerait alors cela :

SELECT colonne1, colonne2, colonne3


FROM table
ORDER BY colonne1 DESC, colonne2 ASC

A noter : il n’est pas obligé d’utiliser le suffixe « ASC » sachant que les résultats sont
toujours classés par ordre ascendant par défaut. Toutefois, c’est plus pratique pour mieux
s’y retrouver, surtout si on a oublié l’ordre par défaut.

En utilisant deux méthodes de tri, il est possible de tri la première colonne puis de trier
une deuxième colonne selon le premier tri.
La requête serait alors la suivante :

SELECT *
FROM utilisateur
ORDER BY nom, date_inscription DESC

33
Classes Préparatoires
aux Grandes Ecoles
Approfondissement en Python 3

Une requête SELECT peut devenir assez longue. Juste à titre informatif, voici une requête
SELECT qui possède presque toutes les commandes possibles :

SELECT *
FROM table
WHERE condition
GROUP BY expression
HAVING condition
{ UNION | INTERSECT | EXCEPT }
ORDER BY expression

SQL UNION
La commande UNION de SQL permet de mettre bout-à-bout les résultats de plusieurs
requêtes utilisant elles-mêmes la commande SELECT. C’est donc une commande qui permet
de concaténer les résultats de 2 requêtes ou plus. Pour l’utiliser il est nécessaire que
chacune des requêtes à concaténer retournes le même nombre de colonnes, avec les mêmes
types de données et dans le même ordre.

A savoir : par défaut, les enregistrements exactement identiques ne seront pas répétés
dans les résultats. Pour effectuer une union dans laquelle même les lignes dupliquées sont
affichées il faut plutôt utiliser la commande UNION ALL.
Syntaxe La syntaxe pour unir les résultats de 2 tableaux sans afficher les doublons est la
suivante :

SELECT * FROM table1


UNION
SELECT * FROM table2

SQL INTERSECT
La commande SQL INTERSECT permet d’obtenir l’intersection des résultats de 2
requêtes. Cette commande permet donc de récupérer les enregistrements communs à 2
requêtes. Cela peut s’avérer utile lorsqu’il faut trouver s’il y a des données similaires sur 2
tables distinctes.

A savoir : pour l’utiliser convenablement il faut que les 2 requêtes retournent le même
nombre de colonnes, avec les mêmes types et dans le même ordre.
Syntaxe La syntaxe à adopter pour utiliser cette commande est la suivante :

SELECT * FROM table1


INTERSECT
SELECT * FROM table2

34
Classes Préparatoires
aux Grandes Ecoles
Approfondissement en Python 3

Dans cet exemple, il faut que les 2 tables soient similaires (mêmes colonnes, mêmes types
et même ordre). Le résultat correspondra aux enregistrements qui existent dans table1 et
dans table2.

SQL EXCEPT / MINUS


Dans le langage SQL la commande EXCEPT s’utilise entre 2 instructions pour récupérer les
enregistrements de la première instruction sans inclure les résultats de la seconde requête.
Si un même enregistrement devait être présent dans les résultats des 2 syntaxes, ils ne
seront pas présent dans le résultat final.

A savoir : cette commande s’appelle différemment selon les Systèmes de Gestion de Base
de Données (SGBD) :
o EXCEPT : PostgreSQL
o MINUS : MySQL et Oracle
Dès lors, il faut remplacer tout le reste de ce cours par MINUS pour les SGBD
correspondants.

Syntaxe La syntaxe d’une requête SQL est toute simple :

SELECT * FROM table1


EXCEPT
SELECT * FROM table2

Cette requête permet de lister les résultats du table 1 sans inclure les enregistrements de
la table 1 qui sont aussi dans la table 2.

Attention : les colonnes de la première requête doivent être similaires entre la première
et la deuxième requête (même nombre, même type et même ordre).

Jointure SQL
Les jointures en SQL permettent d’associer plusieurs tables dans une même requête. Cela
permet d’exploiter la puissance des bases de données relationnelles pour obtenir des
résultats qui combinent les données de plusieurs tables de manière efficace.

Types de jointures
Il y a plusieurs méthodes pour associer 2 tables ensemble. Voici la liste des différentes
techniques qui sont utilisées :
 INNER JOIN : jointure interne pour retourner les enregistrements quand la
condition est vraie dans les 2 tables. C’est l’une des jointures les plus communes.
 CROSS JOIN : jointure croisée permettant de faire le produit cartésien de 2
tables. En d’autres mots, permet de joindre chaque ligne d’une table avec chaque
ligne d’une seconde table. Attention, le nombre de résultats est en général très
élevé.

35
Classes Préparatoires
aux Grandes Ecoles
Approfondissement en Python 3

 LEFT JOIN (ou LEFT OUTER JOIN) : jointure externe pour retourner tous les
enregistrements de la table de gauche (LEFT = gauche) même si la condition n’est
pas vérifiée dans l’autre table.
 RIGHT JOIN (ou RIGHT OUTER JOIN) : jointure externe pour retourner tous
les enregistrements de la table de droite (RIGHT = droite) même si la condition
n’est pas vérifiée dans l’autre table.
 FULL JOIN (ou FULL OUTER JOIN) : jointure externe pour retourner les
résultats quand la condition est vraie dans au moins une des 2 tables.
 SELF JOIN : permet d’effectuer une jointure d’une table avec elle-même comme
si c’était une autre table.
 NATURAL JOIN : jointure naturelle entre 2 tables s’il y a au moins une colonne
qui porte le même nom entre les 2 tables SQL
 UNION JOIN : jointure d’union

Syntaxes :

Pour aller plus loin voir cours en ligne : https://sql.sh/cours

TP n°1 – Environnement de l’outil MySQL -------------------------------(1H)


TP n°2 – Manipulation de requêtes SQL, interface avec Python ------------- (1H)

36

Vous aimerez peut-être aussi