Guia de tabelas temporárias em SQL

12 de julho de 2025 Por Matthew Rathbone

Uma tabela temporária é uma tabela que só dura enquanto sua sessão no banco de dados estiver aberta. Você a preenche com linhas, consulta como qualquer outra tabela, e o banco a remove para você quando você se desconecta. Os exemplos funcionam no PostgreSQL, MySQL, SQLite e SQL Server.

Como usar tabelas temporárias em SQL

Crie uma tabela temporária como uma tabela normal, com a palavra-chave TEMPORARY. Na maioria das vezes, você a preenche direto a partir de uma consulta:

CREATE TEMPORARY TABLE table_name AS
SELECT ...;

O SQL Server é a exceção: um # no início do nome torna a tabela temporária, e SELECT ... INTO a cria e preenche.

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

Você também pode definir as colunas primeiro e inserir as linhas depois, como em uma tabela 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

Regras importantes

Só a sua sessão consegue vê-la. Outras conexões não podem lê-la, e o banco a remove quando sua sessão termina. Se sua aplicação usa um pool de conexões, crie a tabela temporária e consulte-a na mesma conexão.
Ela esconde uma tabela permanente com o mesmo nome. Depois que você cria uma tabela temporária chamada orders, toda consulta em orders lê a tabela temporária até você removê-la, então escolha nomes que não possam conflitar. O prefixo # do SQL Server evita isso.
Criá-la duas vezes falha. Execute o mesmo script duas vezes na mesma sessão e o CREATE falha porque a tabela já existe. Remova-a antes:

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

O MySQL não consegue ler uma tabela temporária duas vezes na mesma consulta. Um self-join, ou uma subconsulta na mesma tabela temporária, falha com ERROR 1137 (HY000): Can't reopen table. Crie uma segunda cópia se precisar.

Sintaxe alternativa

CREATE TEMP TABLE é uma forma mais curta aceita pelo PostgreSQL e pelo SQLite. O MySQL não aceita.
Tabelas temporárias globais do SQL Server começam com dois sustenidos, ##paid_orders. Qualquer sessão pode lê-las, e o SQL Server as remove quando a sessão que as criou termina.
Uma CTE faz o mesmo trabalho quando só uma consulta precisa das linhas. Nada é armazenado, então não há nada para remover:

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

Quando usar uma tabela temporária?

Use uma tabela temporária quando quiser que um resultado fique disponível para mais de uma consulta, mas não por mais tempo que sua sessão.

Reutilize as mesmas linhas em várias consultas

Quando vários relatórios partem das mesmas linhas filtradas, como os pedidos deste mês ou os projetos ativos, salve-as uma vez e consulte a tabela temporária em vez de repetir o filtro toda vez.

Armazene totais que você quer filtrar ou reutilizar

Agregue uma vez com GROUP BY e guarde os totais em uma tabela temporária. Depois você pode filtrá-los, ranqueá-los ou compará-los com a própria média sem recalcular.

Divida uma consulta complexa em etapas

Uma consulta com várias camadas de subconsultas é difícil de ler e depurar. Monte cada etapa como uma tabela temporária, confira as linhas e depois faça o join com suas tabelas permanentes na etapa seguinte.

Teste alterações em uma cópia

Antes de executar um UPDATE ou DELETE em dados reais, copie a tabela para uma tabela temporária e execute lá. Você vê o que muda, e a original permanece intacta.

Exemplos reais de tabelas temporárias em SQL

No SQL Server, crie cada uma dessas tabelas temporárias com SELECT ... INTO #name em vez de CREATE TEMPORARY TABLE.

Dois relatórios sobre os pedidos de um mês

Filtre os pedidos de outubro para uma tabela temporária uma vez e depois execute quantos relatórios quiser sobre ela:

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

Encontre clientes que gastam acima da média

Armazene o total de cada cliente e depois compare os totais com a própria média:

-- 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 não roda no MySQL, que não consegue ler customer_totals duas vezes na mesma consulta (Can't reopen table). Calcule a média antes, em uma consulta separada.

Encontre clientes que não fazem pedidos há algum tempo

Calcule o pedido mais recente de cada cliente em uma etapa e depois faça o join com a lista de clientes. Em tabelas grandes, um índice na tabela temporária acelera o 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

Confira o que um DELETE removeria

Limpando pedidos cancelados antigos? Execute o DELETE em uma cópia primeiro e veja o que sobra:

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

Leitura complementar sobre tabelas temporárias em SQL

Neste blog:

Guia de CTE vs subconsulta em SQL: quando uma CTE resolve sem tabela temporária
Guia de SQL CREATE TABLE: tipos de coluna e restrições, que as tabelas temporárias também usam
Guia de SQL JOIN com diagramas: como fazer join de tabelas temporárias com permanentes
Guia de SQL GROUP BY: as agregações que você costuma guardar em uma tabela temporária
Ajustando o tempdb para melhorar o desempenho do SQL Server: onde o SQL Server guarda suas tabelas temporárias
Trabalhando com segurança em um banco de dados de produção: mais formas de testar uma alteração antes de aplicá-la

Documentação oficial:

Beekeeper Studio é um cliente de banco de dados gratuito e open source

A melhor ferramenta de consultas e edição de SQL que já usei. Tem tudo o que preciso para gerenciar meu banco de dados. - ⭐⭐⭐⭐⭐ Mit

O Beekeeper Studio é rápido, intuitivo e fácil de usar. Ele suporta vários bancos de dados e funciona muito bem no Windows, Mac e Linux.

Baixar grátis

O que os usuários dizem sobre o Beekeeper Studio

★★★★★

"O Beekeeper Studio substituiu completamente meu antigo fluxo de trabalho com SQL. É rápido, intuitivo e torna o trabalho com bancos de dados agradável de novo."

— Alex K., desenvolvedor de banco de dados

★★★★★

"Já testei muitas GUIs de banco de dados, mas o Beekeeper encontra o equilíbrio perfeito entre recursos e simplicidade. Simplesmente funciona."

— Sarah M., engenheira full stack

Pronto para melhorar seu fluxo de trabalho com SQL?

Baixar grátis

Ver todas as edições →