20 Query SQL yang Wajib Dikuasai Setiap Data Analyst

Jadi, Anda sudah bisa menulis beberapa query SQL dasar. Tapi, apakah Anda bisa "berbicara SQL" dengan lancar ketika atasan tiba-tiba meminta dashboard mendesak di tengah meeting penting?

Setelah bergelut dengan data, dari era kartu perforasi hingga cloud computing, saya telah menyaksikan bagaimana query SQL yang tepat bisa menyelamatkan karir, memenangkan proyek bernilai miliaran, dan bahkan menyelamatkan perusahaan dari keputusan bisnis yang fatal.

Artikel ini akan mengungkap 20 query SQL paling esensial yang telah saya gunakan berulang kali dalam berbagai situasi kritis - dari startup e-commerce lokal hingga bank multinasional. Mari kita mulai perjalanan ini.

💡 Mengapa SQL Tetap Relevan (Bahkan di Era AI)

SQL (Structured Query Language) adalah bahasa universal data. Tidak peduli apakah Anda sedang membersihkan dataset berantakan, menggabungkan tabel yang kompleks, atau menyusun insight untuk tim bisnis - SQL tetap menjadi keterampilan yang tidak tergantikan dalam analitik data.

Saya masih ingat jelas ketika 1 tahun lalu, seorang eksekutif muda bertanya kepada saya: "Dengan adanya tools AI sekarang, apakah SQL masih perlu dipelajari?" Saya tersenyum dan menunjukkan bagaimana bahkan tool AI terbaik masih mengandalkan SQL di balik layar untuk mengakses dan memproses data.

Menguasai query-query esensial akan menghemat waktu Anda, meningkatkan efisiensi, dan menjadikan Anda orang yang dicari ketika kekacauan data melanda organisasi.

🧰 20 Query SQL Esensial (dengan Kasus Penggunaan Nyata)

Mari kita uraikan dengan contoh berdasarkan database perusahaan e-commerce Indonesia.

1. SELECT Statement: Fondasi Segala Analisis

sql
SELECT * FROM customers;

Kasus Nyata: Saat diminta memberikan overview cepat tentang karakteristik pelanggan Tokopedia di rapat direksi, query sederhana ini menjadi langkah pertama yang krusial.

Actionable Insight: Gunakan SELECT dengan bijak untuk eksplorasi awal, tapi hindari SELECT * pada database produksi dengan jutaan baris. Selalu pilih kolom spesifik yang Anda butuhkan untuk mengoptimalkan performa.

sql
-- Lebih baik gunakan:
SELECT customer_id, name, email, registration_date 
FROM customers 
LIMIT 1000;

2. WHERE Clause: Penyaring Data yang Presisi

sql
SELECT * FROM orders WHERE status = 'Pending';

Pengalaman Nyata: Ketika sebuah unicorn e-commerce Indonesia mengalami lonjakan komplain pelanggan, query cepat dengan WHERE menunjukkan 1.200 pesanan dengan status 'Pending' selama lebih dari 48 jam - akar masalah yang langsung bisa ditindaklanjuti.

Actionable Insight: Buat "library" clause WHERE untuk situasi umum di bisnis Anda. Misalnya, untuk tim customer service:

sql
-- Untuk pelanggan VIP yang pesanannya tertunda
WHERE status = 'Pending' AND customer_tier = 'VIP' AND DATEDIFF(day, order_date, CURRENT_DATE) > 1

-- Untuk produk yang sering di retur
WHERE return_rate > 0.15 AND total_orders > 100

3. ORDER BY: Pahami Prioritas Data Anda

sql
SELECT * FROM products ORDER BY price DESC;

Kisah dari Lapangan: Saat mengevaluasi strategi harga marketplace fashion, ORDER BY mengungkap bahwa produk termahal menyumbang 40% margin keuntungan meski volume penjualannya hanya 5% - insight yang mengubah fokus pemasaran.

Trik Praktis: Kombinasikan ORDER BY dengan LIMIT untuk analisis cepat "top/bottom performers":

sql
-- 10 produk dengan conversion rate terendah
SELECT product_name, views, purchases, (purchases/NULLIF(views,0))*100 as conversion_rate
FROM product_performance
ORDER BY conversion_rate ASC
LIMIT 10;

4. LIMIT: Sahabat Performa dan Explorasi Data

sql
SELECT * FROM products LIMIT 10;

Kisah Nyata: Seorang junior analyst hampir membuat server database down ketika menjalankan query tanpa LIMIT pada tabel dengan 50 juta baris. Sejak itu, LIMIT menjadi wajib dalam standar query eksplorasi di perusahaan.

Insight Berharga: Selalu mulai dengan LIMIT saat bekerja dengan data baru. Gunakan pola "start small, scale gradually" - mulai dengan LIMIT 10, lalu 100, 1000, dst sesuai kebutuhan.

5. COUNT(): Pahami Volume Dengan Singkat

sql
SELECT COUNT(*) FROM orders WHERE status = 'Cancelled';

Pengalaman Pribadi: Saat menganalisis penyebab churn untuk aplikasi financial technology, kami menemukan lonjakan 300% pada COUNT order yang dibatalkan setelah peluncuran UI baru - indikasi masalah UX yang bisa segera diperbaiki.

Trik Analitis: Kombinasikan COUNT dengan pembagian waktu untuk memahami tren:

sql
-- Analisis pembatalan pesanan per jam
SELECT HOUR(created_at) as hour_of_day, 
       COUNT(*) as cancelled_orders
FROM orders 
WHERE status = 'Cancelled' 
  AND DATE(created_at) = CURRENT_DATE - INTERVAL 1 DAY
GROUP BY HOUR(created_at)
ORDER BY hour_of_day;

6. GROUP BY: Temukan Pola Tersembunyi

sql
SELECT region, COUNT(*) FROM customers GROUP BY region;

Kasus Nyata: Analisis distribusi pelanggan bank digital menggunakan GROUP BY mengungkap bahwa 78% pengguna aktif terkonsentrasi di 5 kota besar, tapi 65% pertumbuhan baru justru datang dari kota tier-2 - mengubah strategi ekspansi pasar.

Actionable Insight: Gunakan GROUP BY untuk "slicing" data dari berbagai dimensi:

sql
-- Analisis multi-dimensi dengan GROUP BY
SELECT 
    payment_method,
    device_type,
    COUNT(*) as transaction_count,
    SUM(amount) as total_revenue
FROM transactions
WHERE created_at >= CURRENT_DATE - INTERVAL 30 DAY
GROUP BY payment_method, device_type
ORDER BY total_revenue DESC;

7. SUM(): Kuantifikasi Nilai Bisnis

sql
SELECT SUM(amount) FROM sales WHERE year = 2024;

Pengalaman Menarik: Ketika menyajikan laporan tahunan untuk retail fashion, SUM() sederhana mengungkap bahwa nilai transaksi dari program loyalitas menyumbang 62% total pendapatan - jauh lebih tinggi dari perkiraan manajemen sebesar 30%.

Trik Analisis: Gunakan SUM() dengan conditional logic untuk perbandingan periode:

sql
-- Analisis komparatif pendapatan YoY
SELECT 
    SUM(CASE WHEN YEAR(transaction_date) = 2025 THEN amount ELSE 0 END) as revenue_2025,
    SUM(CASE WHEN YEAR(transaction_date) = 2024 THEN amount ELSE 0 END) as revenue_2024,
    (SUM(CASE WHEN YEAR(transaction_date) = 2025 THEN amount ELSE 0 END) - 
     SUM(CASE WHEN YEAR(transaction_date) = 2024 THEN amount ELSE 0 END)) / 
     NULLIF(SUM(CASE WHEN YEAR(transaction_date) = 2024 THEN amount ELSE 0 END), 0) * 100 as growth_percent
FROM sales;

8. AVG(): Jalan Pintas Memahami Tengah Data

sql
SELECT AVG(price) FROM products;

Kasus Implementasi: Saat membantu marketplace elektronik menetapkan strategi pricing, AVG() mengungkap bahwa harga rata-rata produk best-seller 22% lebih rendah dari keseluruhan katalog - insight yang mengubah pendekatan bundling produk.

Insight Penting: AVG() bisa menyesatkan jika distribusi data tidak normal. Selalu kombinasikan dengan PERCENTILE_CONT() untuk gambaran lengkap:

sql
-- Analisis distribusi harga lebih komprehensif
SELECT 
    AVG(price) as mean_price,
    PERCENTILE_CONT(0.5) WITHIN GROUP (ORDER BY price) as median_price,
    PERCENTILE_CONT(0.25) WITHIN GROUP (ORDER BY price) as percentile_25,
    PERCENTILE_CONT(0.75) WITHIN GROUP (ORDER BY price) as percentile_75
FROM products
WHERE category = 'Smartphones';

9. MIN() dan MAX(): Pahami Rentang Data

sql
SELECT MIN(price), MAX(price) FROM products;

Pengalaman Nyata: Analisis harga untuk sebuah platform properti mengungkap bahwa rentang harga (MAX-MIN) di Jakarta Selatan 4x lebih lebar dari area lain - menunjukkan perlunya segmentasi mikro dalam strategi marketing.

Trik Praktis: Gunakan MIN/MAX untuk quality control data dan deteksi anomali:

sql
-- Deteksi potensi error data input
SELECT 
    category,
    MIN(price) as min_price,
    MAX(price) as max_price,
    MAX(price)/NULLIF(MIN(price),0) as price_ratio
FROM products
GROUP BY category
HAVING MAX(price)/NULLIF(MIN(price),0) > 100; -- Cek kategori dengan rasio harga ekstrem

10. DISTINCT: Memahami Keragaman Data

sql
SELECT DISTINCT country FROM customers;

Kasus Menarik: Analisis DISTINCT pada data pengiriman e-commerce menunjukkan bahwa meski memiliki pelanggan dari 34 provinsi, 90% volumeF pengiriman terkonsentrasi di 12 kota - mengubah strategi fulfillment center.

Implementasi Cerdas: Gunakan COUNT(DISTINCT) untuk analisis kardinalitas dan keunikan:

sql
-- Analisis keragaman produk per kategori
SELECT 
    category,
    COUNT(*) as total_products,
    COUNT(DISTINCT brand) as unique_brands,
    COUNT(DISTINCT brand) * 100.0 / COUNT(*) as brand_diversity_index
FROM products
GROUP BY category
ORDER BY brand_diversity_index DESC;

11. IN Operator: Filter Multi-Nilai dengan Elegan

sql
SELECT * FROM employees WHERE department IN ('Sales', 'Marketing');

Pengalaman Nyata: Analisis performa karyawan lintas departemen terkait menggunakan IN operator membantu mengidentifikasi sinergi antara tim sales dan support - tim dengan overlap tugas terbanyak namun sering beroperasi dalam silo.

Implementasi Strategis: Gunakan IN dengan subquery untuk filter dinamis:

sql
-- Temukan produk yang dibeli oleh pelanggan high-value
SELECT product_id, product_name
FROM products
WHERE product_id IN (
    SELECT DISTINCT product_id
    FROM orders
    WHERE customer_id IN (
        SELECT customer_id
        FROM customers
        WHERE lifetime_value > 10000000
    )
);

12. BETWEEN Operator: Filter Rentang dengan Presisi

sql
SELECT * FROM orders WHERE order_date BETWEEN '2024-01-01' AND '2024-12-31';

Kasus Implementasi: Analisis seasonal trend bank digital menggunakan BETWEEN menunjukkan bahwa periode Ramadhan hingga Lebaran memiliki lonjakan transaksi 250% dibanding periode normal - insight untuk kapasitas server dan tim support.

Trik Analitis: Gunakan BETWEEN untuk time-slicing granular:

sql
-- Analisis performa jam sibuk
SELECT 
    HOUR(created_at) as hour_of_day,
    COUNT(*) as transaction_count,
    SUM(amount) as total_amount
FROM transactions
WHERE 
    created_at BETWEEN '2025-04-01 00:00:00' AND '2025-04-30 23:59:59'
    AND DAYOFWEEK(created_at) BETWEEN 2 AND 6 -- Hanya hari kerja
GROUP BY HOUR(created_at)
ORDER BY transaction_count DESC;

13. JOIN (INNER JOIN): Menghubungkan Titik-Titik Data

sql
SELECT o.order_id, c.name 
FROM orders o 
JOIN customers c ON o.customer_id = c.customer_id;

Kisah dari Lapangan: JOIN sederhana antara data transaksi dan keluhan customer marketplace mengungkap bahwa 78% keluhan datang dari first-time buyers - mengubah fokus onboarding untuk pelanggan baru.

Best Practice: Selalu alias tabel Anda (seperti 'o' untuk orders) dan kualifikasi kolom untuk menghindari ambiguitas. Untuk JOIN kompleks, tulis satu JOIN per baris untuk keterbacaan:

sql
-- JOIN multi-tabel yang mudah dibaca
SELECT 
    o.order_id,
    c.name as customer_name,
    p.name as product_name,
    s.name as seller_name
FROM 
    orders o
JOIN 
    customers c ON o.customer_id = c.id
JOIN 
    order_items oi ON o.id = oi.order_id
JOIN 
    products p ON oi.product_id = p.id
JOIN 
    sellers s ON p.seller_id = s.id
WHERE 
    o.status = 'Completed'
    AND o.created_at >= CURRENT_DATE - INTERVAL 30 DAY;

14. LEFT JOIN: Melihat Data Lengkap dari Perspektif "Kiri"

sql
SELECT e.name, d.department_name 
FROM employees e 
LEFT JOIN departments d ON e.dept_id = d.dept_id;

Pengalaman Nyata: LEFT JOIN antara data event tracking dan purchases di aplikasi fintech mengungkap bahwa 65% pengguna mencapai halaman checkout tapi tidak menyelesaikan pembayaran - mengarah pada redesign halaman pembayaran.

Actionable Insight: Gunakan LEFT JOIN untuk analisis "funnel drop-off":

sql
-- Analisis funnel konversi
SELECT 
    COUNT(DISTINCT u.user_id) as total_users,
    COUNT(DISTINCT v.user_id) as users_who_viewed_product,
    COUNT(DISTINCT c.user_id) as users_who_added_to_cart,
    COUNT(DISTINCT p.user_id) as users_who_purchased,
    ROUND(COUNT(DISTINCT v.user_id) * 100.0 / COUNT(DISTINCT u.user_id), 1) as view_rate,
    ROUND(COUNT(DISTINCT c.user_id) * 100.0 / COUNT(DISTINCT v.user_id), 1) as cart_rate,
    ROUND(COUNT(DISTINCT p.user_id) * 100.0 / COUNT(DISTINCT c.user_id), 1) as purchase_rate
FROM 
    users u
LEFT JOIN 
    product_views v ON u.user_id = v.user_id AND v.created_at >= CURRENT_DATE - INTERVAL 30 DAY
LEFT JOIN 
    cart_additions c ON u.user_id = c.user_id AND c.created_at >= CURRENT_DATE - INTERVAL 30 DAY
LEFT JOIN 
    purchases p ON u.user_id = p.user_id AND p.created_at >= CURRENT_DATE - INTERVAL 30 DAY
WHERE 
    u.created_at >= CURRENT_DATE - INTERVAL 30 DAY;

15. RIGHT JOIN: Perspektif "Kanan" yang Sering Terlupakan

sql
SELECT d.department_name, e.name 
FROM employees e 
RIGHT JOIN departments d ON e.dept_id = d.dept_id;

Kasus Menarik: RIGHT JOIN antara data produk dan penjualan marketplace mengidentifikasi "kategori hantu" - departemen yang ada di struktur tapi belum memiliki produk aktif, mengungkap peluang ekspansi yang terlewatkan.

Catatan Penting: RIGHT JOIN jarang digunakan karena bisa selalu direformulasi sebagai LEFT JOIN dengan mengubah urutan tabel. Namun, memahaminya penting untuk fleksibilitas analisis.

sql
-- Temukan kategori tanpa produk (bisa juga dengan LEFT JOIN)
SELECT 
    c.category_name,
    COUNT(p.id) as product_count
FROM 
    products p
RIGHT JOIN 
    categories c ON p.category_id = c.id
GROUP BY 
    c.category_name
HAVING 
    COUNT(p.id) = 0;

16. CASE Statement: Logika Kondisional yang Kuat

sql
SELECT name, 
CASE 
  WHEN salary > 100000 THEN 'High'
  WHEN salary BETWEEN 50000 AND 100000 THEN 'Medium'
  ELSE 'Low' 
END AS salary_band 
FROM employees;

Pengalaman Berharga: CASE statement untuk segmentasi pelanggan e-commerce mengungkap bahwa grup "Medium-Spender" dengan frekuensi tinggi memiliki LTV 3x lebih tinggi dari "High-Spender" dengan frekuensi rendah - mengubah strategi personalisasi.

Implementasi Canggih: Gunakan CASE untuk kalkulasi yang kompleks:

sql
-- Skoring RFM (Recency, Frequency, Monetary) pelanggan
SELECT 
    customer_id,
    -- Recency score (1-5)
    CASE 
        WHEN DATEDIFF(CURRENT_DATE, last_purchase_date) <= 30 THEN 5
        WHEN DATEDIFF(CURRENT_DATE, last_purchase_date) <= 60 THEN 4
        WHEN DATEDIFF(CURRENT_DATE, last_purchase_date) <= 90 THEN 3
        WHEN DATEDIFF(CURRENT_DATE, last_purchase_date) <= 180 THEN 2
        ELSE 1
    END as recency_score,
    -- Frequency score (1-5)
    CASE 
        WHEN purchase_count >= 20 THEN 5
        WHEN purchase_count >= 10 THEN 4
        WHEN purchase_count >= 5 THEN 3
        WHEN purchase_count >= 2 THEN 2
        ELSE 1
    END as frequency_score,
    -- Monetary score (1-5)
    CASE 
        WHEN total_spent >= 10000000 THEN 5
        WHEN total_spent >= 5000000 THEN 4
        WHEN total_spent >= 1000000 THEN 3
        WHEN total_spent >= 500000 THEN 2
        ELSE 1
    END as monetary_score
FROM 
    customer_metrics;

17. IS NULL: Detektif Data yang Hilang

sql
SELECT * FROM customers WHERE phone IS NULL;

Kasus Nyata: Analisis missing data dengan IS NULL pada bank digital mengungkap bahwa 40% pelanggan tanpa nomor telepon terverifikasi melakukan penipuan - mengarah pada aturan verifikasi yang lebih ketat.

Strategi Pembersihan Data: Gunakan IS NULL untuk audit kualitas data secara reguler:

sql
-- Audit kelengkapan data profile pelanggan
SELECT 
    COUNT(*) as total_users,
    SUM(CASE WHEN email IS NULL THEN 1 ELSE 0 END) as missing_email,
    SUM(CASE WHEN phone IS NULL THEN 1 ELSE 0 END) as missing_phone,
    SUM(CASE WHEN address IS NULL THEN 1 ELSE 0 END) as missing_address,
    SUM(CASE WHEN date_of_birth IS NULL THEN 1 ELSE 0 END) as missing_dob,
    ROUND(SUM(CASE WHEN email IS NULL THEN 1 ELSE 0 END) * 100.0 / COUNT(*), 1) as pct_missing_email,
    ROUND(SUM(CASE WHEN phone IS NULL THEN 1 ELSE 0 END) * 100.0 / COUNT(*), 1) as pct_missing_phone
FROM 
    users
WHERE 
    created_at >= CURRENT_DATE - INTERVAL 30 DAY;

18. UPDATE Statement: Perbaiki Data dengan Hati-hati

sql
UPDATE orders SET status = 'Shipped' WHERE order_id = 2023;

Pengalaman Berharga: UPDATE statement untuk memperbaiki kesalahan klasifikasi produk pada marketplace menyelamatkan kampanye marketing bernilai miliaran rupiah yang hampir menargetkan segmen pelanggan yang salah.

Best Practice Krusial: Selalu lakukan SELECT terlebih dahulu untuk verifikasi sebelum UPDATE, dan gunakan LIMIT jika memungkinkan:

sql
-- Verifikasi sebelum update
SELECT * FROM orders WHERE order_id = 2023;

-- Update dengan batas (untuk MySQL)
UPDATE orders SET status = 'Shipped' WHERE order_id = 2023 LIMIT 1;

19. DELETE Statement: Handle dengan Sangat Hati-hati

sql
DELETE FROM test_data WHERE created_at < '2022-01-01';

Kisah Peringatan: Seorang analyst junior tanpa sengaja menjalankan DELETE tanpa WHERE clause pada tabel produksi - menghapus 3 bulan data transaksi. Sejak itu, kami menerapkan aturan "SELECT sebelum DELETE" dan batasan akses DELETE.

Prosedur Aman:

sql
-- 1. Selalu mulai dengan SELECT
SELECT COUNT(*) FROM test_data WHERE created_at < '2022-01-01';

-- 2. Backup data jika memungkinkan
CREATE TABLE test_data_backup AS 
SELECT * FROM test_data WHERE created_at < '2022-01-01';

-- 3. Delete dengan hati-hati
DELETE FROM test_data WHERE created_at < '2022-01-01' LIMIT 1000;

20. Subquery: Kueri dalam Kueri

sql
SELECT name FROM customers 
WHERE id IN (SELECT customer_id FROM orders WHERE amount > 500);

Pengalaman Implementasi: Subquery untuk analisis cross-selling pada marketplace mengungkap pola pembelian tersembunyi - pelanggan yang membeli produk kategori A dalam 30 hari memiliki probabilitas 70% membeli produk kategori B, mengarah pada rekomendasi produk yang lebih akurat.

Trik Optimasi: Gunakan CTE (Common Table Expressions) untuk subquery kompleks agar lebih mudah dibaca dan di-debug:

sql
-- Pendekatan dengan subquery
SELECT 
    p.product_name,
    p.price,
    (SELECT AVG(price) FROM products WHERE category_id = p.category_id) as avg_category_price
FROM 
    products p
WHERE 
    p.price > (SELECT AVG(price) * 1.5 FROM products);

-- Pendekatan dengan CTE - lebih mudah dibaca
WITH category_avg AS (
    SELECT 
        category_id, 
        AVG(price) as avg_price
    FROM 
        products
    GROUP BY 
        category_id
),
overall_avg AS (
    SELECT AVG(price) * 1.5 as threshold_price FROM products
)
SELECT 
    p.product_name,
    p.price,
    c.avg_price as avg_category_price
FROM 
    products p
JOIN 
    category_avg c ON p.category_id = c.category_id
CROSS JOIN 
    overall_avg o
WHERE 
    p.price > o.threshold_price;

🎯 Final Thoughts

Mempelajari 20 query SQL ini tidak hanya akan membantu Anda melalui wawancara kerja dengan mulus - tetapi akan membuat pekerjaan sehari-hari Anda sebagai analis data lebih lancar, lebih cepat, dan lebih efisien.

Saya telah menyaksikan transformasi dari era kartu perforasi hingga era AI, namun satu hal tetap konstan: kemampuan untuk berbicara langsung dengan data melalui SQL tetap menjadi keterampilan fundamental yang membedakan analis biasa dari analis luar biasa.

Ingin meningkatkan level? Latih query-query ini di platform seperti:

• LeetCode
• Mode SQL
• StrataScratch
• HackerRank
• SQLZoo

Dan ingat, perjalanan ini bahwa SQL terbaik bukanlah yang paling rumit, melainkan yang paling jelas mengartikulasikan pertanyaan bisnis yang ingin Anda jawab.

Glosarium Data Analyst untuk Pemula

1. SQL (Structured Query Language)

Bahasa pemrograman khusus untuk mengakses dan memanipulasi database. Seperti "bahasa penghubung" antara Anda dan data Anda.

2. Query

Permintaan informasi spesifik dari database. Analoginya seperti pertanyaan yang Anda ajukan pada gudang data.

3. Database

Kumpulan terorganisir dari data yang terstruktur, biasanya disimpan dan diakses secara elektronik.

4. Table

Struktur data yang mengorganisir informasi dalam baris dan kolom, mirip seperti spreadsheet.

5. Primary Key

Kolom atau serangkaian kolom yang secara unik mengidentifikasi setiap baris dalam tabel. Seperti KTP untuk setiap baris data.

6. Foreign Key

Kolom yang membuat relasi dengan primary key di tabel lain, memungkinkan database menghubungkan informasi antar tabel.

7. JOIN

Operasi untuk menggabungkan baris dari dua atau lebih tabel berdasarkan kolom terkait. Seperti menjahit bagian-bagian data yang terpisah.

8. Aggregate Function

Fungsi yang melakukan perhitungan pada sekelompok nilai dan mengembalikan nilai tunggal, seperti SUM, AVG, COUNT.

9. GROUP BY

Klausa yang mengelompokkan baris yang memiliki nilai yang sama dalam kolom tertentu menjadi ringkasan.

10. WHERE

Klausa untuk memfilter baris berdasarkan kondisi tertentu, seperti menyaring butir beras dari sekam.

11. Subquery

Query yang bersarang di dalam query lain. Seperti pertanyaan di dalam pertanyaan.

12. CTE (Common Table Expression)

Ekspresi tabel sementara yang Anda bisa referensikan dalam query. Mempermudah pengorganisasian query kompleks.

13. Index

Struktur data yang meningkatkan kecepatan operasi pengambilan data pada database, mirip seperti indeks pada buku.

14. ETL (Extract, Transform, Load)

Proses mengambil data dari sumber, mengubahnya ke format yang diinginkan, dan memuat ke penyimpanan target.

15. Data Warehouse

Sistem penyimpanan data besar yang dirancang untuk analisis dan pelaporan, bukan untuk transaksi sehari-hari.