0Pricing
SQL Academy · Pelajaran

Kinerja EXISTS vs JOIN

Pilih pola yang lebih cepat.

Kinerja EXISTS vs JOIN adalah pelajaran SQL Academy gratis di CoddyKit. Ini adalah pelajaran 4 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar SQL Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus SQL Academy mencakup 4 pelajaran total.

Mengapa Performa Penting di Sini

Ketika perlu memeriksa apakah baris terkait ada di tabel lain, SQL menyediakan beberapa alat: EXISTS, IN, dan JOIN. Masing-masing menghasilkan hasil yang benar, tetapi performanya bisa sangat berbeda, bergantung pada ukuran data, indeks, dan mesin basis data.

Dalam pelajaran ini, Anda akan mempelajari cara kerja setiap pendekatan dan kapan sebaiknya menggunakan masing-masing pendekatan.

Contoh Tabel

Sepanjang pelajaran ini, kita akan menggunakan dua tabel: customers dan orders. Seorang pelanggan dapat memiliki nol atau banyak pesanan. Ini adalah relasi satu-ke-banyak klasik yang cocok untuk menguji pola EXISTS vs JOIN.

CREATE TABLE customers (
  id   SERIAL PRIMARY KEY,
  name VARCHAR(100)
);

CREATE TABLE orders (
  id          SERIAL PRIMARY KEY,
  customer_id INT REFERENCES customers(id),
  total       NUMERIC(10,2)
);

INSERT INTO customers (name) VALUES
  ('Alice'), ('Bob'), ('Carol'), ('Dave');

INSERT INTO orders (customer_id, total) VALUES
  (1, 120.00), (1, 85.50), (3, 200.00);

Pendekatan JOIN

Pola yang umum adalah menggunakan INNER JOIN untuk menemukan pelanggan yang memiliki setidaknya satu pesanan. Cara ini berhasil, tetapi perhatikan masalahnya: jika seorang pelanggan memiliki lima pesanan, pelanggan tersebut muncul lima kali dalam kumpulan hasil sebelum DISTINCT menghapus duplikat.

Duplikasi tersebut menambah pekerjaan yang harus dilakukan basis data — basis data membangun hasil JOIN lengkap, lalu menghapus duplikat.

SELECT DISTINCT c.id, c.name
FROM customers c
INNER JOIN orders o ON o.customer_id = c.id;

Pendekatan EXISTS

EXISTS menjawab pertanyaan ya/tidak: apakah setidaknya satu baris yang cocok ada? Begitu mesin menemukan kecocokan pertama, mesin berhenti memindai — ini disebut evaluasi hubung singkat.

Tidak ada duplikat yang dihasilkan dan tidak perlu menggunakan DISTINCT, karena EXISTS sebenarnya tidak pernah mengembalikan baris bagian dalam.

SELECT c.id, c.name
FROM customers c
WHERE EXISTS (
  SELECT 1
  FROM orders o
  WHERE o.customer_id = c.id
);

Evaluasi Hubung Singkat Adalah Kuncinya

Evaluasi hubung singkat berarti subkueri berhenti segera setelah satu baris yang memenuhi syarat ditemukan. Apakah pelanggan memiliki 1 pesanan atau 10.000 pesanan, EXISTS hanya membaca sampai menemukan kecocokan pertama.

JOIN harus membaca semua baris yang cocok untuk membangun kumpulan hasil, bahkan ketika Anda hanya peduli pada keberadaan. Pada tabel lebar dengan banyak baris anak untuk setiap baris induk, perbedaan ini cepat terakumulasi.

-- EXISTS stops after finding row #1
SELECT c.name
FROM customers c
WHERE EXISTS (
  SELECT 1          -- 'SELECT 1' is conventional; the value does not matter
  FROM orders o
  WHERE o.customer_id = c.id
);

-- JOIN scans ALL matching order rows
SELECT DISTINCT c.name
FROM customers c
INNER JOIN orders o ON o.customer_id = c.id;

NOT EXISTS vs LEFT JOIN ... IS NULL

Untuk pemeriksaan sebaliknya — menemukan pelanggan yang tidak memiliki pesanan — Anda dapat menggunakan NOT EXISTS atau pola LEFT JOIN ... WHERE IS NULL. Keduanya umum digunakan, tetapi NOT EXISTS biasanya lebih mudah dibaca dan pengoptimal sering kali lebih menyukainya.

-- NOT EXISTS
SELECT c.id, c.name
FROM customers c
WHERE NOT EXISTS (
  SELECT 1
  FROM orders o
  WHERE o.customer_id = c.id
);

-- LEFT JOIN ... IS NULL (equivalent result)
SELECT c.id, c.name
FROM customers c
LEFT JOIN orders o ON o.customer_id = c.id
WHERE o.id IS NULL;

Peran Indeks

EXISTS dan JOIN sangat diuntungkan oleh indeks pada kolom kunci asing. Tanpa indeks pada orders.customer_id, setiap baris luar memicu pemindaian seluruh tabel orders.

Menambahkan indeks tersebut sering kali merupakan peningkatan performa terbesar — dampaknya lebih besar daripada memilih antara EXISTS dan JOIN.

-- Create an index on the foreign key
CREATE INDEX idx_orders_customer_id ON orders(customer_id);

-- Now both patterns use an index lookup instead of a full scan
EXPLAIN
SELECT c.name
FROM customers c
WHERE EXISTS (
  SELECT 1 FROM orders o
  WHERE o.customer_id = c.id
);

Membaca Keluaran EXPLAIN

Gunakan EXPLAIN (atau EXPLAIN ANALYZE untuk sekaligus menjalankan kueri) guna melihat cara basis data menjalankan kueri. Perhatikan petunjuk berikut:

  • Pemindaian Indeks — baik; indeks sedang digunakan.
  • Pemindaian Berurutan pada tabel besar — mungkin merupakan tanda bahaya; indeks mungkin membantu.
  • JOIN Hash / Loop Bersarang — algoritma JOIN yang dipilih; Loop Bersarang cocok dipasangkan dengan pemindaian indeks.
EXPLAIN ANALYZE
SELECT c.name
FROM customers c
INNER JOIN orders o ON o.customer_id = c.id
GROUP BY c.id, c.name
HAVING COUNT(o.id) > 0;

Saat JOIN Lebih Unggul

EXISTS unggul untuk pemeriksaan keberadaan murni. Namun, jika Anda juga memerlukan data dari tabel terkait — seperti total pesanan atau tanggal pesanan — Anda harus menggunakan JOIN. Tidak ada cara untuk mengembalikan kolom dari dalam subkueri EXISTS.

Pilih alat yang sesuai dengan pertanyaannya: EXISTS untuk "apakah ada?", JOIN untuk "berikan data dari kedua tabel".

-- Need order data? JOIN is the only option.
SELECT c.name, o.total, o.id AS order_id
FROM customers c
INNER JOIN orders o ON o.customer_id = c.id
ORDER BY c.name;

IN vs EXISTS pada Kumpulan Data Besar

IN (subquery) mengevaluasi seluruh subkueri terlebih dahulu, membuat daftar nilai di memori, lalu membandingkan setiap baris luar dengan daftar tersebut. Dengan jutaan baris, daftar ini dapat menghabiskan memori.

EXISTS dievaluasi baris demi baris dan berhenti lebih awal, sehingga tidak pernah mewujudkan seluruh kumpulan hasil bagian dalam. Pada pemeriksaan berkorelasi dalam jumlah besar, EXISTS hampir selalu lebih cepat daripada IN.

-- IN builds the full list first
SELECT name
FROM customers
WHERE id IN (
  SELECT customer_id FROM orders
);

-- EXISTS evaluates per-row and short-circuits
SELECT name
FROM customers c
WHERE EXISTS (
  SELECT 1 FROM orders o
  WHERE o.customer_id = c.id
);

Panduan Singkat Pengambilan Keputusan

Berikut referensi singkat untuk memilih pola yang tepat:

  • EXISTS — Anda hanya perlu mengetahui apakah terdapat kecocokan; tabel anak berukuran besar; gunakan NOT EXISTS untuk anti-gabung.
  • JOIN — Anda memerlukan kolom dari tabel terkait; gunakan untuk agregasi di kedua tabel.
  • IN — daftar nilai statis yang pendek (WHERE status IN ('active', 'pending')); hindari untuk subkueri berukuran besar.
  • Selalu buat indeks pada kolom kunci asing — hal ini lebih penting daripada pilihan sintaks.

Pemeriksaan Singkat

Pernyataan mana yang paling tepat menjelaskan mengapa EXISTS dapat lebih cepat daripada INNER JOIN + DISTINCT saat memeriksa keberadaan baris terkait?

Ringkasan Pelajaran

Dalam pelajaran ini, Anda mempelajari cara memilih antara EXISTS dan JOIN untuk SQL yang memperhatikan kinerja:

  • EXISTS berhenti lebih awal — pemindaian berhenti segera setelah kecocokan pertama ditemukan, sehingga duplikasi dapat dihindari tanpa memerlukan DISTINCT.
  • JOIN mengembalikan semua baris yang cocok — gunakan saat Anda memerlukan data dari tabel terkait, tetapi tambahkan DISTINCT atau GROUP BY jika Anda hanya memerlukan baris induk.
  • NOT EXISTS adalah pola anti-gabung yang jelas; LEFT JOIN ... IS NULL setara dengannya, tetapi lebih panjang.
  • Hindari IN dengan subkueri berukuran besar — IN mewujudkan seluruh hasil bagian dalam; EXISTS lebih hemat memori.
  • Buat indeks pada kunci asing — langkah tunggal ini sering memberikan peningkatan kinerja terbesar, apa pun sintaks yang Anda pilih.
  • Gunakan EXPLAIN / EXPLAIN ANALYZE untuk memverifikasi rencana eksekusi dan memastikan indeks digunakan.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Kinerja EXISTS vs JOIN” gratis?

Ya — teks lengkap “Kinerja EXISTS vs JOIN” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus SQL Academy, upgrade ke CoddyKit PRO. Kursus SQL Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Kinerja EXISTS vs JOIN”?

Pilih pola yang lebih cepat. Kamu berlatih SQL Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai SQL Academy?

Tidak diperlukan pengalaman sebelumnya. SQL Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 4 dari 4.

Berapa lama pelajaran “Kinerja EXISTS vs JOIN” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran SQL Academy ini?

Ya. Setiap pelajaran SQL Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Subkueri Berkorelasi
  2. EXISTS dan NOT EXISTS
  3. IN vs ANY vs ALL
  4. Kinerja EXISTS vs JOIN
← Kembali ke SQL Academy