Panduan Temp Table SQL

12 Juli 2025 Oleh Matthew Rathbone

Temp table adalah tabel yang hanya bertahan selama sesi database Anda. Anda mengisinya dengan baris, melakukan query seperti tabel lain, dan database akan menghapusnya otomatis saat Anda memutus koneksi. Contoh-contoh di sini berlaku untuk PostgreSQL, MySQL, SQLite, dan SQL Server.

Cara menggunakan temp table SQL

Buat temp table seperti tabel biasa, dengan keyword TEMPORARY. Paling sering Anda mengisinya langsung dari sebuah query:

CREATE TEMPORARY TABLE table_name AS
SELECT ...;

SQL Server adalah pengecualian: tanda # di awal nama membuat tabel menjadi sementara, dan SELECT ... INTO membuat sekaligus mengisinya.

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

Anda juga bisa mendefinisikan kolom terlebih dahulu dan menambahkan baris belakangan, sama seperti tabel permanen:

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

Aturan yang perlu diketahui

Hanya sesi Anda yang bisa melihatnya. Koneksi lain tidak bisa membacanya, dan database menghapusnya saat sesi Anda berakhir. Jika aplikasi Anda memakai connection pool, buat temp table dan jalankan query-nya di koneksi yang sama.
Temp table menutupi tabel permanen dengan nama yang sama. Begitu Anda membuat temp table bernama orders, setiap query ke orders akan membaca temp table tersebut sampai Anda menghapusnya, jadi pilih nama yang tidak mungkin bentrok. Prefiks # di SQL Server menghindari masalah ini.
Membuatnya dua kali akan gagal. Jalankan skrip yang sama dua kali dalam satu sesi dan CREATE akan gagal karena tabelnya sudah ada. Hapus dulu:

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

MySQL tidak bisa membaca temp table dua kali dalam satu query. Self-join, atau subquery pada temp table yang sama, akan gagal dengan ERROR 1137 (HY000): Can't reopen table. Buat salinan kedua jika Anda membutuhkannya.

Sintaks alternatif

CREATE TEMP TABLE adalah bentuk singkat yang diterima PostgreSQL dan SQLite. MySQL tidak mendukungnya.
Global temp table SQL Server diawali dua tanda pagar, ##paid_orders. Semua sesi bisa membacanya, dan SQL Server menghapusnya saat sesi yang membuatnya berakhir.
CTE melakukan tugas yang sama jika hanya satu query yang membutuhkan barisnya. Tidak ada yang disimpan, jadi tidak ada yang perlu dihapus:

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

Kapan sebaiknya menggunakan temp table?

Gunakan temp table saat Anda ingin hasil query bertahan untuk lebih dari satu query, tapi tidak lebih lama dari sesi Anda.

Pakai ulang baris yang sama di beberapa query

Jika beberapa laporan berangkat dari baris hasil filter yang sama, misalnya pesanan bulan ini atau proyek yang aktif, simpan sekali saja lalu query temp table-nya alih-alih mengulang filter setiap kali.

Simpan total yang ingin difilter atau dipakai ulang

Lakukan agregasi sekali dengan GROUP BY dan simpan totalnya di temp table. Setelah itu Anda bisa memfilter, mengurutkan peringkat, atau membandingkannya dengan rata-ratanya sendiri tanpa menghitung ulang.

Pecah query kompleks menjadi beberapa langkah

Query dengan banyak lapisan subquery sulit dibaca dan di-debug. Bangun setiap langkah sebagai temp table, periksa barisnya, lalu join ke tabel permanen Anda di langkah berikutnya.

Uji perubahan pada salinan

Sebelum menjalankan UPDATE atau DELETE pada data asli, salin tabelnya ke temp table dan jalankan di sana. Anda bisa melihat apa yang berubah, dan tabel aslinya tetap utuh.

Contoh nyata temp table SQL

Di SQL Server, buat setiap temp table ini dengan SELECT ... INTO #name alih-alih CREATE TEMPORARY TABLE.

Buat dua laporan dari pesanan satu bulan

Filter pesanan bulan Oktober ke temp table sekali saja, lalu jalankan laporan sebanyak yang Anda mau:

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

Cari pelanggan yang belanja di atas rata-rata

Simpan total setiap pelanggan, lalu bandingkan total tersebut dengan rata-ratanya sendiri:

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

Contoh ini tidak bisa dijalankan di MySQL, yang tidak bisa membaca customer_totals dua kali dalam satu query (Can't reopen table). Hitung rata-ratanya dulu di query terpisah.

Cari pelanggan yang belakangan tidak memesan

Hitung pesanan terakhir setiap pelanggan dalam satu langkah, lalu join hasilnya ke daftar pelanggan. Pada tabel besar, index pada temp table akan mempercepat 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

Cek apa yang akan dihapus oleh DELETE

Mau membersihkan pesanan lama yang dibatalkan? Jalankan DELETE pada salinan dulu dan lihat apa yang tersisa:

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

Bacaan lanjutan tentang temp table SQL

Di blog ini:

Panduan SQL CTE vs Subquery: kapan CTE cukup tanpa temp table
Panduan SQL CREATE TABLE: tipe kolom dan constraint, yang juga berlaku untuk temp table
Panduan Diagram SQL JOIN: menggabungkan temp table dengan tabel permanen
Panduan SQL GROUP BY: agregat yang sering Anda simpan di temp table
Tuning tempdb untuk performa SQL Server yang lebih baik: tempat SQL Server menyimpan temp table-nya
Bekerja dengan Aman di Database Production: cara lain menguji perubahan sebelum menerapkannya

Dokumentasi resmi:

Beekeeper Studio Adalah GUI Database Gratis & Open Source

Tool query & editor SQL terbaik yang pernah saya pakai. Semua yang saya butuhkan untuk mengelola database ada di sini. - ⭐⭐⭐⭐⭐ Mit

Beekeeper Studio cepat, intuitif, dan mudah digunakan. Beekeeper mendukung banyak sekali database, dan berjalan mulus di Windows, Mac, dan Linux.

Download Gratis

Apa Kata Pengguna tentang Beekeeper Studio

★★★★★

"Beekeeper Studio benar-benar menggantikan alur kerja SQL lama saya. Cepat, intuitif, dan membuat pekerjaan database kembali menyenangkan."

— Alex K., Database Developer

★★★★★

"Saya sudah mencoba banyak GUI database, tapi Beekeeper punya keseimbangan sempurna antara fitur dan kesederhanaan. Langsung jalan."

— Sarah M., Full Stack Engineer

Siap Meningkatkan Alur Kerja SQL Anda?

Unduh Gratis

Lihat Semua Edisi →