Retour à tous les guides
Conception de bases de données··5 min de lecture

Normalisation des bases de données : 1NF, 2NF et 3NF avec des exemples

Apprenez la normalisation de bases de données de la 1NF à la 3NF avec des exemples SQL pratiques. Comprenez pourquoi cela compte et quand la dénormalisation a du sens.

Normalisation de base de données de 1NF à 3NF, en divisant les lignes de commande en produits, commandes et clients
Dans ce guide
  1. Qu'est-ce que la normalisation de base de données ?
  2. Pourquoi normaliser ?
  3. Première forme normale (1NF)
  4. Deuxième forme normale (2NF)
  5. Troisième forme normale (3NF)
  6. Un exemple normalisé complet
  7. Quand dénormaliser
  8. Références et lecture complémentaire

Les exemples SQL utilisent PostgreSQL à moins qu'un autre dialecte ne soit nommé. Les extraits courts supposent que leurs tables référencées existent déjà. Validez le DDL dans votre base de données cible avant de l'appliquer.

Qu'est-ce que la normalisation de base de données ?

Normalisation de base de données est le processus d'organisation d'une base de données relationnelle pour réduire la redondance des données et améliorer l'intégrité des données. Introduite par Edgar F. Codd dans les années 1970, la normalisation consiste à diviser de grandes tables en tables plus petites et associées et à définir des relations entre elles.

L'objectif est de représenter les dépendances de manière cohérente et de réduire les duplications évitables. Les instantanés historiques, tels qu'un prix de vente, peuvent appartenir à une table différente car ils représentent des faits différents.

Pourquoi normaliser ?

  • Éliminer la redondance — Évitez de stocker les mêmes données à plusieurs endroits.
  • Prévenir les anomalies de mise à jour — Les modifications de données ne doivent être effectuées qu'à un seul endroit.
  • Prévenir les anomalies d'insertion — Vous pouvez ajouter de nouvelles données sans nécessiter de données sans rapport.
  • Prévenir les anomalies de suppression — La suppression d'un enregistrement ne supprime pas accidentellement des données sans rapport.
  • Prendre en charge des requêtes maintenables — Des dépendances claires facilitent le raisonnement sur les requêtes. Les performances dépendent des modes d'accès, des index et des jointures ; la normalisation seule ne rend pas une requête plus rapide.

Première forme normale (1NF)

Une table est en 1NF quand :

  • Chaque colonne ne contient que des valeurs atomiques (indivisibles)
  • Chaque colonne contient des valeurs d'un seul type
  • Les lignes se distinguent par une clé candidate ; déclarez une clé primaire pour imposer un identifiant choisi en SQL
  • Il n'y a pas de groupes répétitifs ni de tableaux

Avant la 1NF (En violation)

-- BAD: phone_numbers contains multiple values
| id | name  | phone_numbers          |
|----|-------|------------------------|
| 1  | Alice | 555-0100, 555-0101     |
| 2  | Bob   | 555-0200               |

Après la 1NF

CREATE TABLE contacts (
  id SERIAL PRIMARY KEY,
  name VARCHAR(100) NOT NULL
);

CREATE TABLE phone_numbers (
  id SERIAL PRIMARY KEY,
  contact_id INTEGER REFERENCES contacts(id),
  phone VARCHAR(20) NOT NULL
);

-- Each phone number is in its own row
-- | id | contact_id | phone    |
-- |----|-----------|----------|
-- | 1  | 1         | 555-0100 |
-- | 2  | 1         | 555-0101 |
-- | 3  | 2         | 555-0200 |

Deuxième forme normale (2NF)

Une table est en 2NF quand :

  • Il est déjà en 1NF
  • Chaque attribut non premier dépend de chaque l'ensemble du clé candidate, sans dépendance sur une partie seulement d'une clé

Une clé candidate est un ensemble minimal d'attributs qui identifie de manière unique une ligne. Les attributs apparaissant dans n'importe quelle clé candidate sont des attributs premiers. Les dépendances partielles importent lorsqu'une clé candidate contient plusieurs colonnes ; les clés candidates incluent des identifiants uniques alternatifs, et pas seulement la clé primaire choisie. Si une colonne non clé dépend uniquement d'une partie de la clé, elle doit être déplacée vers une table séparée.

Avant la 2NF (En violation)

-- BAD: course_name depends only on course_id, not the full key
-- PK: (student_id, course_id)
| student_id | course_id | course_name | grade |
|-----------|-----------|-------------|-------|
| 1         | 101       | Math        | A     |
| 1         | 102       | Physics     | B     |
| 2         | 101       | Math        | C     |

Après la 2NF

CREATE TABLE students (
  id INTEGER PRIMARY KEY,
  name VARCHAR(100) NOT NULL
);

CREATE TABLE courses (
  id INTEGER PRIMARY KEY,
  name VARCHAR(100) NOT NULL
);

CREATE TABLE enrollments (
  student_id INTEGER REFERENCES students(id),
  course_id INTEGER REFERENCES courses(id),
  grade CHAR(2),
  PRIMARY KEY (student_id, course_id)
);

-- course_name now lives only in the courses table
-- grade depends on both student_id AND course_id

Troisième forme normale (3NF)

Une table est en 3NF quand :

  • Il est déjà en 2NF
  • Pour chaque dépendance fonctionnelle non triviale X → A, X est une surclé ou A appartient à une clé candidate. Dans les exemples ci-dessous, cela supprime les dépendances transitives entre les attributs non clés.

Avant la 3NF (En violation)

-- BAD: department_name depends on department_id, not on id
| id | name  | department_id | department_name |
|----|-------|---------------|-----------------|
| 1  | Alice | 10            | Engineering     |
| 2  | Bob   | 10            | Engineering     |
| 3  | Carol | 20            | Marketing       |

Après la 3NF

CREATE TABLE departments (
  id INTEGER PRIMARY KEY,
  name VARCHAR(100) NOT NULL
);

CREATE TABLE employees (
  id SERIAL PRIMARY KEY,
  name VARCHAR(100) NOT NULL,
  department_id INTEGER REFERENCES departments(id)
);

-- department_name is stored only in the departments table
-- employees references it via foreign key

Un exemple normalisé complet

Voici un schéma de commerce électronique qui sépare les produits, les clients, les adresses, les commandes et les lignes de commande. En supposant que chaque identifiant répertorié détermine les attributs restants, ces tables satisfont aux formes normales illustrées. Les prix de vente stockés sont des faits historiques et non des copies du prix actuel du produit.

CREATE TABLE categories (
  id SERIAL PRIMARY KEY,
  name VARCHAR(100) NOT NULL UNIQUE
);

CREATE TABLE products (
  id SERIAL PRIMARY KEY,
  name VARCHAR(200) NOT NULL,
  price NUMERIC(10, 2) NOT NULL CHECK (price >= 0),
  category_id INTEGER REFERENCES categories(id)
);

CREATE TABLE customers (
  id SERIAL PRIMARY KEY,
  email TEXT UNIQUE NOT NULL,
  full_name VARCHAR(150) NOT NULL
);

CREATE TABLE addresses (
  id SERIAL PRIMARY KEY,
  customer_id INTEGER REFERENCES customers(id),
  street VARCHAR(200) NOT NULL,
  city VARCHAR(100) NOT NULL,
  state VARCHAR(50),
  zip VARCHAR(20) NOT NULL
);

CREATE TABLE orders (
  id SERIAL PRIMARY KEY,
  customer_id INTEGER REFERENCES customers(id),
  shipping_address_id INTEGER REFERENCES addresses(id),
  status VARCHAR(20) DEFAULT 'pending',
  created_at TIMESTAMP DEFAULT now()
);

CREATE TABLE order_items (
  order_id INTEGER REFERENCES orders(id),
  product_id INTEGER REFERENCES products(id),
  quantity INTEGER NOT NULL CHECK (quantity > 0),
  unit_price NUMERIC(10, 2) NOT NULL,
  PRIMARY KEY (order_id, product_id)
);

Collez ceci dans Éditeur d'Erd Go pour voir l'ERD visuel avec toutes les relations cartographiées automatiquement.

Quand dénormaliser

Bien que la normalisation soit généralement une bonne pratique, il existe des cas où la dénormalisation améliore les performances :

  • Charges de travail lourdes en lecture — Si votre application lit beaucoup plus qu'elle n'écrit, stocker des données calculées ou en duplicata peut éviter des JOINs coûteux.
  • Rapports et analyses — Les tables dénormalisées ou les vues matérialisées sont souvent utilisées pour les tableaux de bord.
  • Mise en cache des Données chaudes — Stocker des valeurs agrégées fréquemment consultées directement dans une table.
  • Modèles d'accès de style NoSQL — Lorsque vos requêtes ont toujours besoin d'une combinaison spécifique de données.

La clé est de normalisez d'abord, puis dénormalisez intentionnellement là où les performances l'exigent, en documentant la raison pour laquelle le compromis a été fait.

Références et lecture complémentaire

Plus d'articles