Gabungan SQL adalah tempat Anda menjalankan kueri yang menggabungkan beberapa tabel.
Tutorial gabungan SQL ini menyajikan contoh dasar gabungan SQL, serta pengenalan berbagai jenis gabungan.
Jenis Gabung SQL
Standar ANSI SQL menetapkan lima jenis gabungan, seperti yang tercantum dalam tabel berikut.
| Jenis Gabung | Deskripsi |
|---|---|
 INNER JOIN | Mengembalikan baris ketika setidaknya ada satu baris di kedua tabel yang cocok dengan kondisi join. |
 LEFT OUTER JOIN atau LEFT JOIN | Mengembalikan baris yang memiliki data di tabel kiri (kiri dari JOIN kata kunci), meskipun tidak ada baris yang cocok di tabel kanan. |
 RIGHT OUTER JOIN atau RIGHT JOIN | Mengembalikan baris yang memiliki data di tabel kanan (kanan JOIN kata kunci), meskipun tidak ada baris yang cocok di tabel kiri. |
 FULL OUTER JOIN atau FULL JOIN | Mengembalikan semua baris, selama ada data yang cocok di salah satu tabel. |
CROSS JOIN | Mengembalikan baris yang menggabungkan setiap baris dari tabel pertama dengan setiap baris dari tabel kedua. |
Ada juga istilah lain untuk berbagai operasi gabungan, seperti berikut:
| Gabung | Deskripsi |
|---|---|
| Gabung sendiri | Saat sebuah tabel bergabung dengan dirinya sendiri. |
| Gabungan alami | Gabungan implisit berdasarkan kolom umum dalam dua tabel yang digabungkan. |
| Bersama-sama | Gabungan yang hanya berisi perbandingan kesetaraan dalam predikat gabungan. |
SQL Bergabung dengan Sintaks
Gabungan dalam dapat ditentukan baik dalam FROM atau WHERE klausa. Gabungan luar dan Gabungan silang dapat ditentukan di FROM klausa saja.
Untuk membuat SQL, gabung di FROM klausa, lakukan sesuatu seperti ini:
SELECT *
FROM Table1 < JoinType > Table2 [ ON ( JoinCondition ) ]
Dimana JoinType menentukan jenis gabungan apa yang dilakukan, dan JoinCondition mendefinisikan predikat yang akan dievaluasi untuk setiap pasangan baris yang digabungkan.
Untuk menentukan bergabung di WHERE klausa, lakukan sesuatu seperti ini:
SELECT *
FROM Table1, Table2 [ WHERE ( JoinCondition ) ]
Sekali lagi, JoinCondition mendefinisikan predikat yang akan dievaluasi untuk setiap pasangan baris yang digabungkan.
Juga, semua yang diapit dalam tanda kurung siku ([] ) adalah opsional.
Tabel Contoh untuk Contoh dalam Tutorial ini
Sebagian besar contoh dalam tutorial ini melakukan penggabungan terhadap dua tabel berikut.
PetTypes tabel:
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 1 | Bird | | 2 | Cat | | 3 | Dog | | 4 | Rabbit | +-------------+-----------+ (4 rows affected)
Pets tabel:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 2 | 3 | 3 | Fetch | 2019-08-16 | | 3 | 2 | 2 | Scratch | 2018-10-01 | | 4 | 3 | 3 | Wag | 2020-03-15 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | | 7 | 3 | 2 | Bark | NULL | | 8 | 2 | 4 | Meow | NULL | +---------+-------------+-----------+-----------+------------+ (8 rows affected)
Gabungan Batin
SQL INNER JOIN mengembalikan baris ketika setidaknya ada satu baris di kedua tabel yang cocok dengan kondisi gabungan.
SELECT
Pets.PetName,
PetTypes.PetType
FROM Pets
INNER JOIN PetTypes
ON Pets.PetTypeId = PetTypes.PetTypeId;Hasil:
-----------+-----------+ | PetName | PetType | |-----------+-----------| | Fluffy | Cat | | Fetch | Dog | | Scratch | Cat | | Wag | Dog | | Tweet | Bird | | Fluffy | Dog | | Bark | Dog | | Meow | Cat | +-----------+-----------+ (8 rows affected)
Untuk menentukan gabungan dalam di FROM klausa, kami menggunakan INNER JOIN . Kami juga menggunakan ON kata kunci untuk menentukan predikat yang akan dievaluasi untuk setiap pasangan baris yang digabungkan.
Terlepas dari jenis gabungan, kami memenuhi syarat nama kolom kami dengan nama tabel. Alasan kami melakukan ini adalah untuk menghindari ambiguitas mengenai nama kolom di antara tabel. Kedua tabel dapat memiliki kolom dengan nama yang sama (seperti dalam contoh kami), dan dalam kasus seperti itu, DBMS tidak akan tahu kolom mana yang Anda maksud. Mengawali nama kolom dengan nama tabelnya memastikan bahwa Anda mereferensikan kolom yang benar, dan mencegah kesalahan apa pun yang dapat diakibatkan oleh ambiguitas tentang kolom mana yang Anda maksud.
Dalam contoh ini, kedua tabel memiliki PetTypeId kolom. Pets.PetTypeId kolom adalah kunci asing untuk PetTypes.PetTypeId kolom, yang merupakan kunci utama untuk tabel itu.
Dalam contoh ini, kita dapat melihat bahwa semua hewan peliharaan dikembalikan, tetapi tidak semua jenis hewan peliharaan dikembalikan. Tidak ada kelinci di Pets tabel, dan Rabbits jenis hewan peliharaan tidak dikembalikan.
Alasan Rabbits jenis tidak dikembalikan karena INNER JOIN hanya mengembalikan baris ketika setidaknya ada satu baris di kedua tabel yang cocok dengan kondisi gabungan. Dalam hal ini, Rabbits hanya dalam satu tabel (PetTypes tabel).
Perhatikan bahwa jenis gabungan adalah opsional. Oleh karena itu, sebagian besar (jika tidak semua) DBMS memungkinkan Anda untuk menghilangkan INNER kata kunci. Ketika Anda menghilangkan ini (yaitu hanya menentukan JOIN ), diasumsikan sebagai gabungan dalam.
Oleh karena itu, kita dapat menulis ulang contoh di atas menjadi ini:
SELECT
Pets.PetName,
PetTypes.PetType
FROM Pets
JOIN PetTypes
ON Pets.PetTypeId = PetTypes.PetTypeId;
Juga, seperti pernyataan SQL lainnya, FROM klausa dapat berada di satu baris utuh jika Anda mau:
SELECT
Pets.PetName,
PetTypes.PetType
FROM Pets JOIN PetTypes ON Pets.PetTypeId = PetTypes.PetTypeId;Alias
Ini adalah praktik umum untuk menggunakan alias tabel saat melakukan gabungan SQL. Alias membantu membuat kode lebih ringkas, dan lebih mudah dibaca.
Oleh karena itu, kita dapat mengubah contoh sebelumnya menjadi ini:
SELECT
p.PetName,
pt.PetType
FROM Pets p INNER JOIN PetTypes pt
ON p.PetTypeId = pt.PetTypeId;Hasil:
-----------+-----------+ | PetName | PetType | |-----------+-----------| | Fluffy | Cat | | Fetch | Dog | | Scratch | Cat | | Wag | Dog | | Tweet | Bird | | Fluffy | Dog | | Bark | Dog | | Meow | Cat | +-----------+-----------+ (8 rows affected)
Equi-Gabung
Gabung di atas juga dapat disebut sebagai gabungan yang seimbang . Equi-join adalah join yang hanya berisi perbandingan kesetaraan dalam predikat join.
Cara lain penulisan join di atas adalah seperti ini:
SELECT
p.PetName,
pt.PetType
FROM
Pets p,
PetTypes pt
WHERE p.PetTypeId = pt.PetTypeId;Hasil:
+-----------+-----------+ | PetName | PetType | |-----------+-----------| | Fluffy | Cat | | Fetch | Dog | | Scratch | Cat | | Wag | Dog | | Tweet | Bird | | Fluffy | Dog | | Bark | Dog | | Meow | Cat | +-----------+-----------+
Ini adalah contoh menentukan gabungan dalam di WHERE ayat. Kami hanya menyediakan daftar tabel yang dipisahkan koma, dan kemudian WHERE kondisi. Jika kami menghilangkan WHERE kondisi, kami akan berakhir dengan CROSS JOIN .
Banyak pemula menemukan sintaks di atas jauh lebih mudah dipahami daripada INNER JOIN sintaksis. Jangan ragu untuk menggunakan sintaks ini jika Anda mau, namun, ketahuilah bahwa sebagian besar profesional SQL lebih suka menggunakan INNER JOIN sintaks dari contoh sebelumnya.
Lihat SQL Inner Join untuk contoh lainnya, termasuk inner join yang menggabungkan 3 tabel.
Gabung Yang Tepat
Juga dikenal sebagai RIGHT OUTER JOIN , RIGHT JOIN mengembalikan baris yang memiliki data di tabel kanan (kanan JOIN kata kunci), meskipun tidak ada baris yang cocok di tabel kiri.
SELECT
p.PetName,
pt.PetType
FROM Pets p
RIGHT JOIN PetTypes pt
ON p.PetTypeId = pt.PetTypeId;Hasil:
+-----------+-----------+ | PetName | PetType | |-----------+-----------| | Tweet | Bird | | Fluffy | Cat | | Scratch | Cat | | Meow | Cat | | Fetch | Dog | | Wag | Dog | | Fluffy | Dog | | Bark | Dog | | NULL | Rabbit | +-----------+-----------+ (9 rows affected)
Dalam hal ini, kami mendapat PetType tambahan nilai – Rabbits – meskipun tidak ada hewan peliharaan di Pets tabel jenis itu. Ini menghasilkan NULL nilai dalam PetName kolom melawan Rabbits .
Lihat SQL Right Join untuk contoh lainnya, termasuk right join yang menggabungkan 3 tabel.
Kiri Bergabung
Juga dikenal sebagai LEFT OUTER JOIN , SQL LEFT JOIN mengembalikan baris yang memiliki data di tabel kiri (kiri JOIN kata kunci), meskipun tidak ada baris yang cocok di tabel kanan.
Ini kebalikan dari RIGHT JOIN .
Jika kita mengubah contoh sebelumnya menggunakan gabungan kiri, kita mendapatkan hasil sebagai berikut.
SELECT
p.PetName,
pt.PetType
FROM Pets p
LEFT JOIN PetTypes pt
ON p.PetTypeId = pt.PetTypeId;Hasil:
+-----------+-----------+ | PetName | PetType | |-----------+-----------| | Fluffy | Cat | | Fetch | Dog | | Scratch | Cat | | Wag | Dog | | Tweet | Bird | | Fluffy | Dog | | Bark | Dog | | Meow | Cat | +-----------+-----------+ (8 rows affected)
Dalam kasus khusus ini, hasil kami sama dengan gabungan dalam.
Namun, jika kita menukar urutan tabel di FROM klausa, kita akan mendapatkan hasil yang mirip dengan join kanan pada contoh sebelumnya.
SELECT
p.PetName,
pt.PetType
FROM PetTypes pt
LEFT JOIN Pets p
ON p.PetTypeId = pt.PetTypeId;Hasil:
+-----------+-----------+ | PetName | PetType | |-----------+-----------| | Tweet | Bird | | Fluffy | Cat | | Scratch | Cat | | Meow | Cat | | Fetch | Dog | | Wag | Dog | | Fluffy | Dog | | Bark | Dog | | NULL | Rabbit | +-----------+-----------+ (9 rows affected)
Jadi Anda dapat melihat bahwa perbedaan yang dihasilkan antara gabungan kiri dan kanan hanya bergantung pada cara Anda mengurutkan kolom di FROM klausa.
Lihat SQL Left Join untuk contoh lainnya, termasuk left join yang menggabungkan 3 tabel.
Gabung Penuh
SQL FULL JOIN (atau FULL OUTER JOIN ) mengembalikan semua baris, selama ada data yang cocok di salah satu tabel.
Dengan kata lain, ini seperti menggabungkan kiri dan kanan dalam satu gabungan.
Ini contoh full join.
SELECT
p.PetName,
pt.PetType
FROM Pets p
FULL JOIN PetTypes pt
ON p.PetTypeId = pt.PetTypeId;Hasil:
+-----------+-----------+ | PetName | PetType | |-----------+-----------| | Fluffy | Cat | | Fetch | Dog | | Scratch | Cat | | Wag | Dog | | Tweet | Bird | | Fluffy | Dog | | Bark | Dog | | Meow | Cat | | NULL | Rabbit | +-----------+-----------+ (9 rows affected)
Ini mengembalikan hasil yang sama yang kita dapatkan dengan gabungan kanan, tetapi akan mengembalikan hasil yang berbeda jika ada baris di tabel kiri yang tidak memiliki nilai yang sesuai di tabel kanan.
Mari kita bertukar nama tabel dan menjalankannya lagi.
SELECT
p.PetName,
pt.PetType
FROM PetTypes pt
FULL JOIN Pets p
ON p.PetTypeId = pt.PetTypeId;Hasil:
+-----------+-----------+ | PetName | PetType | |-----------+-----------| | Tweet | Bird | | Fluffy | Cat | | Scratch | Cat | | Meow | Cat | | Fetch | Dog | | Wag | Dog | | Fluffy | Dog | | Bark | Dog | | NULL | Rabbit | +-----------+-----------+ (9 rows affected)
Hasil yang sama.
Lihat SQL Full Join untuk contoh lainnya, termasuk full join yang menggabungkan 3 tabel.
Salib Bergabung
SQL CROSS JOIN mengembalikan baris yang menggabungkan setiap baris dari tabel pertama dengan setiap baris dari tabel kedua.
Dengan kata lain, ini mengembalikan produk Cartesian dari baris dari tabel di gabungan.
SELECT
p.PetName,
pt.PetType
FROM Pets p
CROSS JOIN PetTypes pt;Hasil:
+-----------+-----------+ | PetName | PetType | |-----------+-----------| | Fluffy | Bird | | Fetch | Bird | | Scratch | Bird | | Wag | Bird | | Tweet | Bird | | Fluffy | Bird | | Bark | Bird | | Meow | Bird | | Fluffy | Cat | | Fetch | Cat | | Scratch | Cat | | Wag | Cat | | Tweet | Cat | | Fluffy | Cat | | Bark | Cat | | Meow | Cat | | Fluffy | Dog | | Fetch | Dog | | Scratch | Dog | | Wag | Dog | | Tweet | Dog | | Fluffy | Dog | | Bark | Dog | | Meow | Dog | | Fluffy | Rabbit | | Fetch | Rabbit | | Scratch | Rabbit | | Wag | Rabbit | | Tweet | Rabbit | | Fluffy | Rabbit | | Bark | Rabbit | | Meow | Rabbit | +-----------+-----------+ (32 rows affected)
Seperti yang mungkin Anda bayangkan, ini bisa sangat berbahaya jika Anda menjalankannya pada tabel yang salah.
Ini sama dengan melakukan ini:
SELECT
p.PetName,
pt.PetType
FROM Pets p, PetTypes pt;
Anda dapat menambahkan WHERE klausa ke gabungan silang, yang akan mengubahnya menjadi gabungan dalam.
Seperti ini:
SELECT
p.PetName,
pt.PetType
FROM Pets p
CROSS JOIN PetTypes pt
WHERE p.PetTypeId = pt.PetTypeId;Hasil:
+-----------+-----------+ | PetName | PetType | |-----------+-----------| | Fluffy | Cat | | Fetch | Dog | | Scratch | Cat | | Wag | Dog | | Tweet | Bird | | Fluffy | Dog | | Bark | Dog | | Meow | Cat | +-----------+-----------+ (8 rows affected)
Lihat SQL Cross Join untuk contoh lainnya.
Gabungan Alami
SQL NATURAL JOIN adalah jenis equi-join dimana predikat join muncul secara implisit dengan membandingkan semua kolom pada kedua tabel yang memiliki nama kolom yang sama pada tabel join.
Kumpulan hasil hanya berisi satu kolom untuk setiap pasangan kolom dengan nama yang sama. Jika tidak ditemukan kolom dengan nama yang sama, hasilnya adalah gabungan silang.
SELECT
Pets.PetName,
PetTypes.PetType
FROM Pets NATURAL JOIN PetTypes;Hasil:
petname | pettype ---------+--------- Fluffy | Cat Fetch | Dog Scratch | Cat Wag | Dog Tweet | Bird Fluffy | Dog Bark | Dog Meow | Cat (8 rows)
Sebenarnya, gabungan alami sebenarnya bukan tipe gabungan, seperti yang dipertimbangkan oleh standar ANSI. Ini adalah kata kunci yang dapat Anda masukkan secara opsional untuk membuat gabungan menjadi gabungan alami.
Oleh karena itu, kita dapat mengubah contoh di atas menjadi NATURAL INNER JOIN jika kita ingin:
SELECT
Pets.PetName,
PetTypes.PetType
FROM Pets NATURAL INNER JOIN PetTypes;
Seperti disebutkan sebelumnya, gabungan dalam adalah jenis gabungan default, jadi jika Anda menghilangkan jenis gabungan (misalnya, INNER , LEFT , RIGHT , dll), maka diperlakukan sebagai gabungan dalam.
Jika pemformatan hasil ini terlihat berbeda dari hasil sebelumnya, itu karena saya harus melompat ke PostgreSQL untuk menjalankan kueri ini. Saya menjalankan contoh sebelumnya di SQL Server, tetapi SQL Server tidak mendukung penggabungan alami.
Lihat SQL Natural Join untuk contoh lainnya, termasuk natural join yang menggabungkan 3 tabel.
Sendiri Bergabung
SQL SELF JOIN bergabung dengan tabel untuk dirinya sendiri.
Contoh klasik dari self join ada di tabel Employee. Dalam tabel seperti itu, satu karyawan mungkin melapor ke karyawan lain. Oleh karena itu, Anda dapat menggunakan self join untuk bergabung dengan tabel pada kolom ID karyawan dan kolom ID manajer.
Misalkan kita memiliki tabel berikut:
+--------------+-------------+------------+-------------+ | EmployeeId | FirstName | LastName | ReportsTo | |--------------+-------------+------------+-------------| | 1 | Homer | Connery | NULL | | 2 | Bart | Pitt | 1 | | 3 | Maggie | Griffin | 1 | | 4 | Peter | Farnsworth | 2 | | 5 | Marge | Morrison | NULL | | 6 | Lisa | Batch | 5 | | 7 | Dave | Zuckerberg | 6 | | 8 | Vlad | Cook | 7 | +--------------+-------------+------------+-------------+
Kita bisa melakukan self join di tabel ini untuk mengembalikan semua karyawan dan manajernya.
SELECT
CONCAT(e1.FirstName, ' ', e1.LastName) AS Employee,
CONCAT(e2.FirstName, ' ', e2.LastName) AS Manager
FROM Employees e1
LEFT JOIN Employees e2
ON e1.ReportsTo = e2.EmployeeId;Hasil:
+------------------+-----------------+ | Employee | Manager | |------------------+-----------------| | Homer Connery | | | Bart Pitt | Homer Connery | | Maggie Griffin | Homer Connery | | Peter Farnsworth | Bart Pitt | | Marge Morrison | | | Lisa Batch | Marge Morrison | | Dave Zuckerberg | Lisa Batch | | Vlad Cook | Dave Zuckerberg | +------------------+-----------------+
Lihat SQL Self Join untuk contoh lainnya.
