Bergabung secara eksplisit vs implisit SQL

Apakah ada perbedaan efisiensi dalam gabungan eksplisit eksplisit dan implisit? Sebagai contoh:

SELECT * FROM
table a INNER JOIN table b
ON a.id = b.id;

vs.

SELECT a.*, b.*
FROM table a, table b
WHERE a.id = b.id;

Dari segi kinerja, keduanya persis sama (setidaknya dalam SQL Server).

PS: Perlu diketahui bahwa IMPLICIT OUTER JOINsintaks sudah ditinggalkan sejak SQL Server 2005. ( IMPLICIT INNER JOINSintaks yang digunakan dalam pertanyaan masih didukung)

Penghentian "Gaya Lama" GABUNG Sintaks: Hanya Hal Sebagian

Secara pribadi saya lebih suka sintaks bergabung karena lebih jelas bahwa tabel bergabung dan bagaimana mereka bergabung. Coba bandingkan kueri SQL yang lebih besar di mana Anda memilih dari 8 tabel yang berbeda dan Anda memiliki banyak pemfilteran di mana. Dengan menggunakan sintaks bergabung Anda memisahkan bagian-bagian di mana tabel bergabung, ke bagian di mana Anda memfilter baris.

Pada MySQL 5.1.51, kedua kueri memiliki rencana eksekusi yang identik:

mysql> explain select * from table1 a inner join table2 b on a.pid = b.pid;
+----+-------------+-------+------+---------------+------+---------+--------------+------+-------+
| id | select_type | table | type | possible_keys | key  | key_len | ref          | rows | Extra |
+----+-------------+-------+------+---------------+------+---------+--------------+------+-------+
|  1 | SIMPLE      | b     | ALL  | PRIMARY       | NULL | NULL    | NULL         |  986 |       |
|  1 | SIMPLE      | a     | ref  | pid           | pid  | 4       | schema.b.pid |   70 |       |
+----+-------------+-------+------+---------------+------+---------+--------------+------+-------+
2 rows in set (0.02 sec)

mysql> explain select * from table1 a, table2 b where a.pid = b.pid;
+----+-------------+-------+------+---------------+------+---------+--------------+------+-------+
| id | select_type | table | type | possible_keys | key  | key_len | ref          | rows | Extra |
+----+-------------+-------+------+---------------+------+---------+--------------+------+-------+
|  1 | SIMPLE      | b     | ALL  | PRIMARY       | NULL | NULL    | NULL         |  986 |       |
|  1 | SIMPLE      | a     | ref  | pid           | pid  | 4       | schema.b.pid |   70 |       |
+----+-------------+-------+------+---------------+------+---------+--------------+------+-------+
2 rows in set (0.00 sec)

table1memiliki 166208 baris; table2memiliki sekitar 1000 baris.

Ini adalah kasus yang sangat sederhana; itu tidak berarti membuktikan bahwa optimizer kueri tidak akan bingung dan menghasilkan rencana yang berbeda dalam kasus yang lebih rumit.

Sintaks kedua memiliki kemungkinan gabungan silang yang tidak diinginkan: Anda bisa menambahkan tabel ke bagian FROM tanpa klausa WHERE yang sesuai. Ini dianggap berbahaya.

Jawaban pertama yang Anda berikan menggunakan apa yang dikenal sebagai ANSI bergabung dengan sintaks, yang lain valid dan akan bekerja di semua basis data relasional.

Saya setuju dengan grom bahwa Anda harus menggunakan sintaks bergabung ANSI. Seperti yang mereka katakan, alasan utamanya adalah kejelasan. Alih-alih memiliki klausa di mana dengan banyak predikat, beberapa di antaranya bergabung dengan tabel dan yang lain membatasi baris yang dikembalikan dengan sintaks gabungan ANSI, Anda membuatnya dengan jelas menyilaukan kondisi mana yang digunakan untuk bergabung dengan tabel Anda dan yang digunakan untuk membatasi hasil.

Dari segi kinerja, keduanya persis sama (setidaknya dalam SQL Server) tetapi perlu diketahui bahwa mereka mencela sintaks gabung ini dan tidak didukung oleh sql server2005 di luar kotak.

Saya pikir Anda memikirkan operator * = dan = * yang sudah usang vs. "outer join".

Saya baru saja menguji dua format yang diberikan, dan mereka bekerja dengan baik pada database SQL Server 2008. Dalam kasus saya, mereka menghasilkan rencana eksekusi yang sama, tetapi saya tidak dapat dengan yakin mengatakan bahwa ini akan selalu benar.

@ lomaxx: Hanya untuk memperjelas, saya cukup yakin bahwa kedua sintaks di atas didukung oleh SQL Serv 2005. Sintaks di bawah ini TIDAK didukung namun

select a.*, b.*  
from table a, table b  
where a.id *= b.id;

Secara khusus, gabungan luar (* =) tidak didukung.

Pada beberapa basis data (terutama Oracle) urutan gabungan dapat membuat perbedaan besar untuk kinerja permintaan (jika ada lebih dari dua tabel). Pada satu aplikasi, kami memiliki dua urutan perbedaan besar dalam beberapa kasus. Menggunakan sintaks gabungan dalam memberi Anda kendali atas ini - jika Anda menggunakan sintaks petunjuk yang benar.

Anda tidak menentukan database mana yang Anda gunakan, tetapi probabilitas menyarankan SQL Server atau MySQL di mana tidak ada perbedaan nyata.

Seperti yang dinyatakan Leigh Caldwell, pengoptimal kueri dapat menghasilkan rencana kueri yang berbeda berdasarkan apa yang secara fungsional tampak seperti pernyataan SQL yang sama. Untuk membaca lebih lanjut tentang ini, lihat dua posting blog berikut: -

Satu posting dari Tim Oracle Optimizer

Posting lain dari blog "Data Terstruktur"

Saya harap Anda menemukan ini menarik.

Dari segi kinerja, seharusnya tidak ada bedanya. Sintaks gabungan eksplisit tampaknya lebih bersih bagi saya karena secara jelas mendefinisikan hubungan antara tabel dalam klausa dari dan tidak mengacaukan klausa di mana.

Pada dasarnya, perbedaan antara keduanya adalah bahwa yang satu ditulis dengan cara yang lama, sementara yang lain ditulis dengan cara yang modern. Secara pribadi, saya lebih suka skrip modern menggunakan definisi dalam, kiri, luar, kanan karena mereka lebih jelas dan membuat kode lebih mudah dibaca.

Ketika berhadapan dengan inner joins, tidak ada perbedaan nyata dalam keterbacaan, namun, itu mungkin menjadi rumit ketika berhadapan dengan joins kiri dan kanan seperti pada metode yang lebih lama Anda akan mendapatkan sesuatu seperti ini:

SELECT * 
FROM table a, table b
WHERE a.id = b.id (+);

Di atas adalah cara lama bagaimana gabungan kiri ditulis sebagai lawan dari yang berikut:

SELECT * 
FROM table a 
LEFT JOIN table b ON a.id = b.id;

Seperti yang dapat Anda lihat secara visual, cara modern cara penulisan skrip membuat kueri lebih mudah dibaca. (Ngomong-ngomong, hal yang sama berlaku untuk gabungan kanan dan sedikit lebih rumit untuk gabungan luar).

Kembali ke pelat ketel, itu tidak membuat perbedaan ke kompiler SQL bagaimana kueri ditulis saat menangani mereka dengan cara yang sama. Saya telah melihat campuran keduanya di database Oracle yang telah membuat banyak orang menulis ke dalamnya, baik yang lebih tua maupun yang lebih muda. Sekali lagi, ini bermuara pada seberapa mudah dibaca skrip dan tim yang Anda kembangkan.

Dalam pengalaman saya, menggunakan sintaks cross-join-dengan-mana-klausa sering menghasilkan rencana eksekusi yang rusak otak, terutama jika Anda menggunakan produk Microsoft SQL. Cara SQL Server mencoba untuk memperkirakan jumlah baris tabel, misalnya, sangat mengerikan. Menggunakan sintaks gabungan dalam memberi Anda kontrol atas bagaimana kueri dieksekusi. Jadi dari sudut pandang praktis, mengingat sifat atavistik dari teknologi basis data saat ini, Anda harus mengikuti bagian dalam.