Guide des tables temporaires SQL

Une table temporaire est une table qui ne dure que le temps de ta session de base de données. Tu la remplis de lignes, tu l’interroges comme n’importe quelle autre table, et la base de données la supprime pour toi quand tu te déconnectes. Les exemples fonctionnent avec PostgreSQL, MySQL, SQLite et SQL Server.

Comment utiliser les tables temporaires SQL

Crée une table temporaire comme une table normale, avec le mot-clé TEMPORARY. Le plus souvent, tu la remplis directement à partir d’une requête :

CREATE TEMPORARY TABLE table_name AS
SELECT ...;

SQL Server fait exception : un # au début du nom rend une table temporaire, et SELECT ... INTO la crée et la remplit.

-- Input: orders
-- id | customer | total | status
-- ---+----------+-------+---------
-- 1  | Maria    | 120   | paid
-- 2  | Tom      | 35    | refunded
-- 3  | Priya    | 89    | paid

CREATE TEMPORARY TABLE paid_orders AS
SELECT id, customer, total FROM orders WHERE status = 'paid';
-- SQL Server: SELECT id, customer, total INTO #paid_orders FROM orders WHERE status = 'paid';

SELECT * FROM paid_orders;  -- #paid_orders in SQL Server

-- Output:
-- id | customer | total
-- ---+----------+------
-- 1  | Maria    | 120
-- 3  | Priya    | 89

Tu peux aussi définir les colonnes d’abord et insérer les lignes ensuite, comme avec une table permanente :

CREATE TEMPORARY TABLE temp_students (  -- SQL Server: CREATE TABLE #temp_students (
  student_id INT PRIMARY KEY,
  first_name VARCHAR(50),
  last_name VARCHAR(50),
  age INT
);

INSERT INTO temp_students (student_id, first_name, last_name, age)
VALUES (1, 'John', 'Doe', 20);

SELECT * FROM temp_students;

-- Output:
-- student_id | first_name | last_name | age
-- -----------+------------+-----------+----
-- 1          | John       | Doe       | 20

Règles à connaître

• Seule ta session peut la voir. Les autres connexions ne peuvent pas la lire, et la base de données la supprime à la fin de ta session. Si ton application utilise un pool de connexions, crée la table temporaire et interroge-la sur la même connexion.
• Elle masque une table permanente du même nom. Dès que tu crées une table temporaire appelée orders, toutes les requêtes sur orders lisent la table temporaire jusqu’à ce que tu la supprimes, alors choisis des noms qui ne peuvent pas entrer en conflit. Le préfixe # de SQL Server évite ce problème.
• La créer deux fois échoue. Lance le même script deux fois dans une session et le CREATE échoue, car la table existe déjà. Supprime-la d’abord :

DROP TABLE IF EXISTS paid_orders;
-- In MySQL, DROP TEMPORARY TABLE IF EXISTS can never drop a permanent table by mistake

• MySQL ne peut pas lire une table temporaire deux fois dans une même requête. Une auto-jointure, ou une sous-requête sur la même table temporaire, échoue avec ERROR 1137 (HY000): Can't reopen table. Fais-en une deuxième copie si besoin.

Syntaxe alternative

• CREATE TEMP TABLE est une forme plus courte acceptée par PostgreSQL et SQLite. Pas par MySQL.
• Les tables temporaires globales de SQL Server commencent par deux dièses, ##paid_orders. Toutes les sessions peuvent la lire, et SQL Server la supprime quand la session qui l’a créée se termine.
• Une CTE fait le même travail quand une seule requête a besoin des lignes. Rien n’est stocké, donc rien à supprimer :

-- Input: the orders table above

WITH paid_orders AS (
  SELECT id, customer, total FROM orders WHERE status = 'paid'
)
SELECT * FROM paid_orders;

-- Output:
-- id | customer | total
-- ---+----------+------
-- 1  | Maria    | 120
-- 3  | Priya    | 89

Quand utiliser une table temporaire ?

Utilise une table temporaire quand tu veux garder un résultat pour plus d’une requête, mais pas au-delà de ta session.

Réutiliser les mêmes lignes dans plusieurs requêtes

Quand plusieurs rapports partent des mêmes lignes filtrées, comme les commandes du mois ou les projets actifs, enregistre-les une fois et interroge la table temporaire au lieu de répéter le filtre à chaque fois.

Stocker des totaux à filtrer ou réutiliser

Agrège une seule fois avec GROUP BY et garde les totaux dans une table temporaire. Tu peux ensuite les filtrer, les classer ou les comparer à leur propre moyenne sans tout recalculer.

Découper une requête complexe en étapes

Une requête avec plusieurs niveaux de sous-requêtes est difficile à lire et à déboguer. Construis chaque étape dans une table temporaire, vérifie ses lignes, puis joins-la à tes tables permanentes à l’étape suivante.

Tester des modifications sur une copie

Avant de lancer un UPDATE ou un DELETE sur des données réelles, copie la table dans une table temporaire et lance-le dessus. Tu vois ce qui change, et l’original reste intact.

Exemples concrets de tables temporaires SQL

Dans SQL Server, crée chacune de ces tables temporaires avec SELECT ... INTO #name au lieu de CREATE TEMPORARY TABLE.

Deux rapports sur les commandes d’un mois

Filtre une fois les commandes d’octobre dans une table temporaire, puis lance dessus autant de rapports que tu veux :

-- Input: orders
-- id | customer | order_date | total
-- ---+----------+------------+------
-- 1  | Maria    | 2026-09-28 | 120
-- 2  | Tom      | 2026-10-02 | 35
-- 3  | Maria    | 2026-10-05 | 60
-- 4  | Priya    | 2026-10-09 | 89

CREATE TEMPORARY TABLE october_orders AS
SELECT id, customer, total
FROM orders
WHERE order_date >= '2026-10-01' AND order_date < '2026-11-01';

SELECT COUNT(*) AS order_count, SUM(total) AS revenue
FROM october_orders;

-- Output:
-- order_count | revenue
-- ------------+--------
-- 3           | 184

SELECT customer, SUM(total) AS spent
FROM october_orders
GROUP BY customer
ORDER BY spent DESC;

-- Output:
-- customer | spent
-- ---------+------
-- Priya    | 89
-- Maria    | 60
-- Tom      | 35

Trouver les clients qui dépensent plus que la moyenne

Stocke le total de chaque client, puis compare les totaux à leur propre moyenne :

-- Input: orders
-- id | customer | total
-- ---+----------+------
-- 1  | Maria    | 120
-- 2  | Tom      | 35
-- 3  | Maria    | 60
-- 4  | Priya    | 89
-- 5  | Priya    | 70

CREATE TEMPORARY TABLE customer_totals AS
SELECT customer, SUM(total) AS spent
FROM orders
GROUP BY customer;

SELECT customer, spent
FROM customer_totals
WHERE spent > (SELECT AVG(spent) FROM customer_totals)
ORDER BY spent DESC;

-- Output:
-- customer | spent
-- ---------+------
-- Maria    | 180
-- Priya    | 159

Celle-ci ne fonctionne pas dans MySQL, qui ne peut pas lire customer_totals deux fois dans une même requête (Can't reopen table). Calcule d’abord la moyenne dans une requête séparée.

Trouver les clients qui n’ont pas commandé récemment

Calcule la dernière commande de chaque client en une étape, puis joins-la à la liste des clients. Sur de grosses tables, un index sur la table temporaire accélère la jointure :

-- Input: customers
-- id | name
-- ---+------
-- 1  | Maria
-- 2  | Tom
-- 3  | Priya

-- Input: orders
-- id | customer_id | order_date
-- ---+-------------+-----------
-- 1  | 1           | 2026-09-30
-- 2  | 2           | 2026-05-14
-- 3  | 1           | 2026-04-02

-- Step 1: each customer's latest order
CREATE TEMPORARY TABLE last_orders AS
SELECT customer_id, MAX(order_date) AS last_order
FROM orders
GROUP BY customer_id;

-- Step 2: on big tables, index the column you'll join on
CREATE INDEX idx_last_orders ON last_orders (customer_id);

-- Step 3: customers with no order since July 1
SELECT c.name, l.last_order
FROM customers c
LEFT JOIN last_orders l ON l.customer_id = c.id
WHERE l.last_order IS NULL OR l.last_order < '2026-07-01'
ORDER BY c.name;

-- Output:
-- name  | last_order
-- ------+-----------
-- Priya | NULL
-- Tom   | 2026-05-14

Vérifier ce qu’un DELETE supprimerait

Tu fais le ménage dans les vieilles commandes annulées ? Lance d’abord le DELETE sur une copie et regarde ce qui reste :

-- Input: orders
-- id | customer | status    | order_date
-- ---+----------+-----------+-----------
-- 1  | Maria    | cancelled | 2025-11-03
-- 2  | Tom      | shipped   | 2025-12-19
-- 3  | Priya    | cancelled | 2026-02-11
-- 4  | Maria    | shipped   | 2026-03-02

CREATE TEMPORARY TABLE orders_copy AS
SELECT * FROM orders;

DELETE FROM orders_copy
WHERE status = 'cancelled' AND order_date < '2026-01-01';

SELECT * FROM orders_copy;

-- Output:
-- id | customer | status    | order_date
-- ---+----------+-----------+-----------
-- 2  | Tom      | shipped   | 2025-12-19
-- 3  | Priya    | cancelled | 2026-02-11
-- 4  | Maria    | shipped   | 2026-03-02

-- The real table still has every row
SELECT COUNT(*) AS order_count FROM orders;
-- Output: 4

Pour aller plus loin sur les tables temporaires SQL

Sur ce blog :

• Guide CTE vs sous-requête SQL : quand une CTE fait le travail sans table temporaire
• Guide SQL CREATE TABLE : types de colonnes et contraintes, communs aux tables temporaires
• Guide des JOIN SQL en diagrammes : joindre des tables temporaires à des tables permanentes
• Guide SQL GROUP BY : les agrégats que tu stockeras souvent dans une table temporaire
• Optimiser tempdb pour de meilleures performances SQL Server : là où SQL Server garde ses tables temporaires
• Travailler en toute sécurité sur une base de production : d’autres façons de tester une modification avant de l’appliquer

Documentation officielle :

• PostgreSQL : CREATE TABLE (TEMPORARY)
• MySQL : instruction CREATE TEMPORARY TABLE
• SQLite : CREATE TABLE
• SQL Server : CREATE TABLE, tables temporaires