Aller au contenu
Encyclopédie informatique Édition 2026

Le modèle relationnel

Partie 3 sur 4

Niveau de lecture :

5Les opérations dérivées

À partir des cinq opérations de base, on définit d’autres opérations, très utiles mais non indispensables, car chacune peut s’écrire avec les opérations de base. On les appelle dérivées. Elles existent pour écrire plus court et pour que le système les reconnaisse et les accélère.

5.1L’intersection

L’intersection de R1 et R2, notée R1 ∩ R2, contient les tuples qui sont à la fois dans R1 et dans R2 (même schéma exigé). Voici la formule qui la ramène aux opérations de base : R1 ∩ R2 = R1 − (R1 − R2). On vérifie : R1 − R2 est ce qui est dans R1 sans être dans R2 ; si on l’ôte de R1, il reste ce qui est dans R1 et dans R2. Usage : « les clients qui ont commandé en 2025 et en 2026 ».

5.2La jointure

La jointure est de loin l’opération dérivée la plus importante : c’est elle qui permet de recoller les informations rangées dans des tables séparées, grâce aux clés. Elle se définit en trois temps : on fait le produit cartésien des deux tables, puis on ne garde (restriction) que les couples de lignes qui vérifient une condition, enfin on peut projeter pour enlever des colonnes inutiles. La figure 3 montre le cas courant : relier chaque commande à son client.

LA JOINTURE : RECOLLER DEUX TABLES GRÂCE À LA CLÉ ÉTRANGÈRE client id nom 1 Ada 2 Alan commande id client_id total 10 1 42 € 11 1 15 € 12 2 30 € clé principale : id clé étrangère : client_id renvoie à client.id résultat de la jointure nom id total Ada 10 42 € Ada 11 15 € Alan 12 30 € On associe chaque commande au client dont l’id est égal à son client_id : c’est une jointure sur égalité (équi-jointure). Définition formelle : un produit cartésien des deux tables, puis une restriction (id = client_id), puis une projection. Une commande ne peut pas viser un client inexistant : c’est la contrainte d’intégrité référentielle.
Figure 3. La jointure recolle deux tables grâce à la clé étrangère.

Selon la condition, on distingue plusieurs variantes :

  • La thêta-jointure (notée θ-jointure, thêta étant une lettre grecque utilisée pour désigner « une condition quelconque ») garde les couples de lignes du produit cartésien qui satisfont une condition faite de comparaisons : égal (=), différent (≠), plus petit (<), plus grand (>), plus petit ou égal (≤), plus grand ou égal (≥). On range parfois un symbole de négation parmi les « comparateurs » ; ce n’en est pas un, c’est un connecteur logique, qui se combine avec les comparaisons. On note R1 ⋈θ R2.
  • L’équi-jointure est une thêta-jointure dont la condition est une égalité entre deux colonnes, par exemple client.id = commande.client_id. C’est la jointure de la figure 3, et de très loin la plus fréquente.
  • La jointure naturelle est une équi-jointure sur les colonnes qui portent le même nom dans les deux tables, suivie d’une projection qui n’en garde qu’un exemplaire. Elle se note R1 ⋈ R2. Elle est pratique quand les noms ont été choisis avec soin (la clé étrangère porte le même nom que la clé qu’elle vise), et dangereuse sinon : deux colonnes qui s’appellent date par coïncidence seront jointes sans qu’on l’ait voulu.

Un défaut de la jointure ordinaire : les lignes sans correspondance disparaissent. Un client sans commande ne figure pas dans le résultat de la figure 3. Pour les conserver, on utilise la jointure externe (outer join), qui garde toutes les lignes d’une table (ou des deux) et remplit par NULL les colonnes de l’autre quand il n’y a pas de correspondance. On ne parle souvent que des jointures dites internes ; c’est pourtant l’outil qu’on utilise pour répondre à « tous les clients, avec le total de leurs commandes, y compris ceux qui n’ont rien acheté ». Voir le langage SQL pour l’écriture.

Une dernière variante, la semi-jointure, garde les lignes de la première table pour lesquelles il existe une ligne correspondante dans la seconde, sans ajouter de colonnes de la seconde : « les clients qui ont au moins une commande ».

5.3Le quotient (la division)

Le quotient ou division de R1 par R2, noté R1 ÷ R2 (div(R1, R2) en notation texte), répond aux questions de la forme « pour tous les… ». On le définit ainsi : la table des tuples qui, « concaténés à chaque tuple de l’une des tables, fournissent des tuples appartenant à l’autre ». Un exemple parle mieux :

  • R1 contient des couples (étudiant, cours suivi) ;
  • R2 contient la liste des cours obligatoires : {algèbre, réseaux, bases de données} ;
  • R1 ÷ R2 donne les étudiants qui suivent tous les cours obligatoires : ceux dont l’ensemble des cours contient les trois.

La division est la seule opération qui exprime directement le « pour tout ». Elle se ramène aux opérations de base, mais la formule est lourde : on construit tous les couples (étudiant, cours obligatoire) possibles par un produit cartésien, on en retire ceux qui existent réellement par une différence, et on soustrait les étudiants obtenus à la liste de tous les étudiants. Résultat : on retrouve ceux à qui il ne manque aucun cours. En SQL, on l’écrit plutôt par une double négation (« il n’existe aucun cours obligatoire que l’étudiant ne suive pas »), ou en comptant (partie 6).

Pour s’exercer

Exercice 6 : normaliser une table

La table inscription(etudiant_id, nom_etudiant, cours_id, intitule_cours, note) a pour clé (etudiant_id, cours_id). Quelles anomalies cette table provoque-t-elle ? Proposez un schéma en troisième forme normale.

Voir la réponse

Le nom de l’étudiant ne dépend que de etudiant_id, l’intitulé du cours que de cours_id : ce sont des dépendances sur une partie de la clé, donc la table n’est pas en deuxième forme normale. Conséquences : le nom est recopié autant de fois que l’étudiant suit de cours (anomalie de modification) ; on ne peut pas créer un cours sans étudiant inscrit (anomalie d’insertion) ; supprimer la dernière inscription d’un cours fait perdre son intitulé (anomalie de suppression). Schéma corrigé : etudiant(etudiant_id, nom_etudiant), cours(cours_id, intitule_cours), inscription(etudiant_id, cours_id, note) avec deux clés étrangères.

Exercice 7 : la division

La table suit(etudiant, cours) contient : (Ada, algèbre), (Ada, réseaux), (Ada, bases), (Alan, algèbre), (Alan, réseaux), (Grace, algèbre), (Grace, réseaux), (Grace, bases), (Grace, sport). La table obligatoire(cours) contient : algèbre, réseaux, bases. Quel est le résultat de suit ÷ obligatoire ? Comment le retrouver en comptant ?

Voir la réponse

Le résultat est {Ada, Grace} : ce sont les étudiants qui suivent tous les cours obligatoires. Alan en manque un (bases). Grace suit un cours en plus (sport), ce qui n’empêche pas d’être dans le résultat : la division demande de contenir l’ensemble, non d’être égal à lui. Avec un comptage : on garde, pour chaque étudiant, les lignes dont le cours est obligatoire, on compte par étudiant, et l’on retient ceux dont le compte vaut 3, le nombre de cours obligatoires : Ada (3), Alan (2), Grace (3).

6Les opérations de calcul

Reste une famille à traiter à part : les opérateurs de calcul. Il faut les distinguer : ils ne sont pas dérivés, c’est-à-dire qu’on ne peut pas les exprimer à l’aide des cinq opérations de base. Pourquoi ? Les cinq opérations de base ne font que sélectionner et recombiner des valeurs existantes ; aucune ne fabrique une valeur nouvelle, comme une somme. C’est pourquoi les chercheurs ont ajouté plus tard des opérateurs d’agrégation à l’algèbre : un agrégat résume plusieurs lignes en une valeur.

  • La somme additionne les valeurs d’un attribut numérique. On la note Somme(R, X) (ou Sum en anglais) : on y précise éventuellement des attributs de regroupement.
  • Le comptage (Compte, Count en anglais) compte les lignes.
  • On y ajoute la moyenne, le minimum et le maximum.

Le mécanisme de regroupement est le point délicat, et on le décrit souvent de façon confuse. Voici la version claire. On choisit une ou plusieurs colonnes de regroupement, par exemple client_id. On découpe la table en paquets : toutes les lignes ayant la même valeur dans ces colonnes forment un paquet. On calcule ensuite l’agrégat sur chaque paquet : la somme des totaux de chaque client, par exemple. Le résultat contient une ligne par paquet. Sans colonne de regroupement, la table entière forme un seul paquet : on obtient une seule valeur, la somme de la colonne (ou le nombre de lignes).

Sur la table « commande » de la figure 3, le regroupement par client_id avec la somme du total donne : client 1 → 57 (42 + 15), client 2 → 30. Un comptage par client donne 2 pour le client 1 et 1 pour le client 2. Et l’on retrouve la division de la partie 5 : « les étudiants qui suivent tous les cours obligatoires » équivaut à « les étudiants pour lesquels le nombre de cours obligatoires suivis est égal au nombre de cours obligatoires ».

En SQL, ces opérateurs sont les fonctions d’agrégation SUM, COUNT, AVG, MIN et MAX, associées aux clauses GROUP BY (regrouper) et HAVING (filtrer les paquets). Ils sont présentés en détail dans le langage SQL.

7De l’algèbre au langage SQL

L’algèbre relationnelle est une notation de mathématicien. Les systèmes de gestion de bases de données (les logiciels qui gèrent les bases, voir les SGBD) se pilotent par un langage d’ingénieur : SQL. SQL est déclaratif : on décrit le résultat voulu, comme en algèbre ; on ne décrit pas les étapes. La correspondance est étroite :

Tableau 1. Les opérations de l’algèbre et leur écriture en SQL.
AlgèbreSQL (écriture usuelle)
projection πSELECT colonnes … FROM table (avec DISTINCT pour éliminer les doublons)
restriction σ… WHERE condition
produit cartésien ×FROM t1 CROSS JOIN t2, ou FROM t1, t2 sans condition
jointure ⋈FROM t1 JOIN t2 ON condition
union ∪requête1 UNION requête2
différence −requête1 EXCEPT requête2 (nommé MINUS chez Oracle)
intersection ∩requête1 INTERSECT requête2
renommage ρ… AS nouveau_nom
agrégationSUM, COUNT, AVG, MIN, MAX avec GROUP BY
division ÷pas de mot dédié : double négation avec NOT EXISTS, ou comptage

Voici la requête de la figure 3 en SQL. Les mots en capitales sont les mots réservés du langage ; les autres sont les noms choisis pour les tables et colonnes :

SELECT client.nom, commande.id, commande.total
FROM commande
JOIN client ON client.id = commande.client_id;

7.1Là où SQL s’écarte de la théorie

SQL a été conçu chez IBM puis normalisé, avec des compromis par rapport au modèle de Codd, qui l’avait d’ailleurs critiqué. Trois écarts sont à connaître :

  • Les doublons. Une table SQL est un sac (« multi-ensemble ») et non un ensemble : elle peut contenir deux lignes identiques si aucune clé ne l’interdit. Les opérations SQL sur les sacs diffèrent légèrement de celles de l’algèbre : UNION élimine les doublons, mais UNION ALL les garde. Retenez : déclarez toujours une clé principale, sinon une table SQL n’est pas une relation au sens strict.
  • NULL. La logique à trois valeurs (partie 3) n’existe pas dans l’algèbre « pure », et elle réserve des surprises (une comparaison avec NULL n’est jamais vraie).
  • L’ordre des colonnes et des lignes. SQL garde un ordre des colonnes (celui de la déclaration) et peut trier les lignes (ORDER BY), ce que la relation ne prévoit pas.

7.2Le calcul relationnel et la récursivité

À côté de l’algèbre (qui décrit quelles opérations faire), Codd a défini le calcul relationnel, qui décrit quelles propriétés doivent vérifier les lignes du résultat, à la manière d’une formule de logique : « l’ensemble des x tels qu’il existe un y avec… ». Les deux approches ont le même pouvoir d’expression : c’est le théorème de Codd. SQL emprunte aux deux ; la partie WHERE est proche du calcul, la partie JOIN est proche de l’algèbre.

L’algèbre de base ne sait pas exprimer les parcours d’arbres (« tous les messages d’un fil de discussion, quel que soit le nombre de réponses imbriquées »). Les SGBD ont ajouté des extensions : la clause CONNECT BY d’Oracle (voir les SGBD) et, dans la norme SQL depuis 1999, les requêtes récursives (WITH RECURSIVE), qui répètent une requête jusqu’à ce qu’elle ne produise plus rien de nouveau.

7.3Ce que fait le système en coulisse

Quand vous écrivez une requête, le SGBD ne l’exécute pas telle quelle. L’optimiseur traduit la requête en une expression d’algèbre, puis la réécrit en une expression équivalente mais moins chère. Une règle célèbre : faire la restriction avant la jointure. Joindre un million de commandes à un million de clients puis ne garder que les clients de Tours est absurde ; il vaut mieux réduire d’abord les clients à ceux de Tours, puis joindre. L’optimiseur peut le faire parce que les opérations ont des propriétés mathématiques précises (σ commute avec ⋈ sous certaines conditions, et ainsi de suite). C’est l’un des grands bénéfices de la rigueur du modèle : les requêtes restent simples, et le système cherche le meilleur chemin, en s’aidant d’index (structures annexes de recherche rapide, voir les bases de données) et de statistiques sur les données.