Guía de tablas temporales en SQL

12 de julio de 2025 Por Matthew Rathbone

Una tabla temporal es una tabla que solo dura lo que dura tu sesión de base de datos. La llenas con filas, la consultas como cualquier otra tabla y la base de datos la elimina por ti cuando te desconectas. Los ejemplos funcionan en PostgreSQL, MySQL, SQLite y SQL Server.

Cómo usar tablas temporales en SQL

Crea una tabla temporal como una tabla normal, con la palabra clave TEMPORARY. Lo más común es llenarla directamente desde una consulta:

CREATE TEMPORARY TABLE table_name AS
SELECT ...;

SQL Server es la excepción: un # al inicio del nombre hace que la tabla sea temporal, y SELECT ... INTO la crea y la llena.

-- 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

También puedes definir primero las columnas e insertar filas después, igual que con una tabla 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

Reglas que debes conocer

Solo tu sesión puede verla. Otras conexiones no pueden leerla, y la base de datos la elimina cuando termina tu sesión. Si tu aplicación usa un pool de conexiones, crea la tabla temporal y consúltala en la misma conexión.
Oculta una tabla permanente con el mismo nombre. En cuanto creas una tabla temporal llamada orders, toda consulta sobre orders lee la tabla temporal hasta que la elimines, así que elige nombres que no choquen. El prefijo # de SQL Server evita esto.
Crearla dos veces falla. Si ejecutas el mismo script dos veces en una sesión, el CREATE falla porque la tabla ya existe. Elimínala primero:

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

MySQL no puede leer una tabla temporal dos veces en una consulta. Un self-join, o una subconsulta sobre la misma tabla temporal, falla con ERROR 1137 (HY000): Can't reopen table. Haz una segunda copia si la necesitas.

Sintaxis alternativa

CREATE TEMP TABLE es una forma más corta que aceptan PostgreSQL y SQLite. MySQL no.
Las tablas temporales globales de SQL Server empiezan con dos almohadillas, ##paid_orders. Cualquier sesión puede leerlas, y SQL Server las elimina cuando termina la sesión que las creó.
Una CTE hace lo mismo cuando solo una consulta necesita las filas. No se guarda nada, así que no hay nada que eliminar:

-- 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

¿Cuándo conviene usar una tabla temporal?

Usa una tabla temporal cuando quieras que un resultado se conserve para más de una consulta, pero no más allá de tu sesión.

Reutiliza las mismas filas en varias consultas

Cuando varios reportes parten de las mismas filas filtradas, como los pedidos de este mes o los proyectos activos, guárdalas una vez y consulta la tabla temporal en lugar de repetir el filtro cada vez.

Guarda totales que quieras filtrar o reutilizar

Agrega una sola vez con GROUP BY y guarda los totales en una tabla temporal. Después puedes filtrarlos, ordenarlos o compararlos con su propio promedio sin recalcular.

Divide una consulta compleja en pasos

Una consulta con varias capas de subconsultas es difícil de leer y depurar. Construye cada paso como una tabla temporal, revisa sus filas y luego únela a tus tablas permanentes en el siguiente paso.

Prueba cambios en una copia

Antes de ejecutar un UPDATE o un DELETE sobre datos reales, copia la tabla a una tabla temporal y ejecútalo ahí. Puedes ver qué cambia y el original queda intacto.

Ejemplos reales de tablas temporales en SQL

En SQL Server, crea cada una de estas tablas temporales con SELECT ... INTO #name en lugar de CREATE TEMPORARY TABLE.

Haz dos reportes de los pedidos de un mes

Filtra los pedidos de octubre en una tabla temporal una sola vez y luego ejecuta sobre ella todos los reportes que quieras:

-- 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

Encuentra clientes que gastan más que el promedio

Guarda el total de cada cliente y luego compara los totales con su propio promedio:

-- 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

Este no funciona en MySQL, que no puede leer customer_totals dos veces en una consulta (Can't reopen table). Calcula primero el promedio en una consulta aparte.

Encuentra clientes que no han pedido últimamente

Calcula el pedido más reciente de cada cliente en un paso y luego únelo a la lista de clientes. En tablas grandes, un índice en la tabla temporal acelera el join:

-- 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

Revisa qué eliminaría un DELETE

¿Vas a limpiar pedidos cancelados antiguos? Ejecuta primero el DELETE en una copia y revisa lo que queda:

-- 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

Más lecturas sobre tablas temporales en SQL

En este blog:

Guía de CTE vs subconsultas en SQL: cuándo una CTE resuelve el problema sin una tabla temporal
Guía de CREATE TABLE en SQL: tipos de columna y restricciones, que comparten las tablas temporales
Guía de JOIN en SQL con diagramas: cómo unir tablas temporales con tablas permanentes
Guía de GROUP BY en SQL: las agregaciones que seguido guardarás en una tabla temporal
Optimiza tempdb para un mejor rendimiento de SQL Server: donde SQL Server guarda sus tablas temporales
Cómo trabajar de forma segura en una base de datos de producción: más formas de probar un cambio antes de hacerlo

Documentación oficial:

Beekeeper Studio es un cliente de bases de datos gratuito y de código abierto

La mejor herramienta de consultas y edición de SQL que he usado. Tiene todo lo que necesito para administrar mi base de datos. - ⭐⭐⭐⭐⭐ Mit

Beekeeper Studio es rápido, intuitivo y fácil de usar. Es compatible con muchísimas bases de datos y funciona de maravilla en Windows, Mac y Linux.

Descargar gratis

Lo que dicen los usuarios de Beekeeper Studio

★★★★★

"Beekeeper Studio reemplazó por completo mi antiguo flujo de trabajo con SQL. Es rápido, intuitivo y hace que trabajar con bases de datos vuelva a ser un placer."

— Alex K., desarrollador de bases de datos

★★★★★

"He probado muchas GUI de bases de datos, pero Beekeeper logra el equilibrio perfecto entre funciones y simplicidad. Simplemente funciona."

— Sarah M., ingeniera Full Stack

¿Listo para mejorar tu flujo de trabajo con SQL?

Descarga gratis

Ver todas las ediciones →