Apa yang dijelaskan PostgreSQL dengan tepat?

Output penjelasan MySQL cukup mudah. PostgreSQL sedikit lebih rumit. Saya juga belum bisa menemukan sumber yang bagus untuk menjelaskannya.

Dapatkah Anda menjelaskan apa yang sebenarnya dikatakan menjelaskan atau setidaknya mengarahkan saya ke sumber yang baik?

Menjelaskan_EXPLAIN.pdf juga dapat membantu.

Bagian yang selalu membingungkan saya adalah biaya awal vs biaya total. Saya Google ini setiap kali saya melupakannya, yang membawa saya kembali ke sini, yang tidak menjelaskan perbedaannya, itulah mengapa saya menulis jawaban ini. Inilah yang saya kumpulkan dari dokumentasi PostgresEXPLAIN , dijelaskan seperti yang saya pahami.

Berikut contoh dari aplikasi yang mengelola forum:

EXPLAIN SELECT * FROM post LIMIT 50;

Limit  (cost=0.00..3.39 rows=50 width=422)
  ->  Seq Scan on post  (cost=0.00..15629.12 rows=230412 width=422)

Berikut penjelasan grafis dari PgAdmin:

(Saat Anda menggunakan PgAdmin, Anda dapat mengarahkan mouse ke komponen untuk membaca detail biaya.)

Biaya direpresentasikan sebagai tupel, misalnya biaya dari LIMITadalah cost=0.00..3.39dan biaya berurutan scanning postadalah cost=0.00..15629.12. Angka pertama pada tupel adalah biaya awal dan angka kedua adalah biaya total . Karena saya menggunakan EXPLAINdan tidak EXPLAIN ANALYZE, biaya ini hanyalah perkiraan, bukan ukuran sebenarnya.

• Biaya awal adalah konsep yang rumit. Ini tidak hanya mewakili jumlah waktu sebelum komponen itu dimulai . Ini mewakili jumlah waktu antara saat komponen mulai mengeksekusi (membaca dalam data) dan saat komponen mengeluarkan baris pertamanya .
• Biaya total adalah seluruh waktu eksekusi komponen, dari saat mulai membaca data hingga selesai menulis keluarannya.

Sebagai komplikasi, biaya setiap node "induk" mencakup biaya node turunannya. Dalam representasi teks, pohon diwakili oleh lekukan, misalnya LIMITsimpul induk dan Seq Scananaknya. Dalam representasi PgAdmin, panah menunjuk dari anak ke orang tua - arah aliran data - yang mungkin berlawanan dengan intuisi jika Anda terbiasa dengan teori grafik.

Dokumentasi mengatakan bahwa biaya sudah termasuk semua node turunan, tetapi perhatikan bahwa total biaya induk 3.39jauh lebih kecil daripada total biaya turunannya 15629.12. Total biaya tidak termasuk karena komponen seperti LIMITtidak perlu memproses seluruh inputnya. Lihat EXPLAIN SELECT * FROM tenk1 WHERE unique1 < 100 AND unique2 > 9000 LIMIT 2;contohnya di dokumentasi PostgresEXPLAIN .

Dalam contoh di atas, waktu startup adalah nol untuk kedua komponen, karena tidak ada komponen yang perlu melakukan pemrosesan apa pun sebelum mulai menulis baris: pemindaian berurutan membaca baris pertama tabel dan memancarkannya. The LIMITmembaca baris pertama dan kemudian memancarkan itu.

Kapan sebuah komponen perlu melakukan banyak pemrosesan sebelum dapat mulai mengeluarkan baris apa pun? Ada banyak kemungkinan alasannya, tetapi mari kita lihat satu contoh yang jelas. Berikut kueri yang sama dari sebelumnya tetapi sekarang berisi ORDER BYklausa:

EXPLAIN SELECT * FROM post ORDER BY body LIMIT 50;

Limit  (cost=23283.24..23283.37 rows=50 width=422)
  ->  Sort  (cost=23283.24..23859.27 rows=230412 width=422)
        Sort Key: body
        ->  Seq Scan on post  (cost=0.00..15629.12 rows=230412 width=422)

Dan secara grafis:

Sekali lagi, pemindaian sekuensial pada posttidak memiliki biaya permulaan: ia segera mulai mengeluarkan baris. Tetapi pengurutan memiliki biaya awal yang signifikan 23283.24karena harus mengurutkan seluruh tabel sebelum dapat menghasilkan bahkan satu baris . Total biaya pengurutan 23859.27hanya sedikit lebih tinggi daripada biaya permulaan, yang mencerminkan fakta bahwa setelah seluruh kumpulan data telah diurutkan, data yang diurutkan dapat dikeluarkan dengan sangat cepat.

Perhatikan bahwa waktu startup LIMIT 23283.24persis sama dengan waktu startup semacam itu. Ini bukan karena LIMITwaktu startup sendiri tinggi. Ini sebenarnya tidak memiliki waktu startup dengan sendirinya, tetapi EXPLAINmengumpulkan semua biaya turunan untuk setiap orang tua, sehingga LIMITwaktu startup mencakup jumlah waktu startup dari turunannya.

Rollup biaya ini dapat mempersulit pemahaman biaya eksekusi setiap komponen. Misalnya, LIMITwaktu startup kami nol, tapi itu tidak jelas pada pandangan pertama. Untuk alasan ini, beberapa orang lain menautkan ke menjelaskan.depesz.com , alat yang dibuat oleh Hubert Lubaczewski (alias depesz) yang membantu memahami EXPLAINdengan - antara lain - mengurangi biaya anak dari biaya orang tua. Dia menyebutkan beberapa kerumitan lain dalam postingan blog singkat tentang alatnya.

Ini dijalankan dari yang paling menjorok ke yang paling tidak menjorok, dan saya percaya dari bawah rencana ke atas. (Jadi, jika ada dua bagian yang menjorok ke bawah, bagian yang berada jauh di bawah halaman dijalankan terlebih dahulu, lalu ketika bertemu yang lain dijalankan, maka aturan yang menggabungkannya dijalankan.)

Idenya adalah bahwa di setiap langkah ada 1 atau 2 dataset yang datang dan diproses oleh beberapa aturan. Jika hanya satu kumpulan data, operasi itu dilakukan untuk kumpulan data itu. (Misalnya memindai indeks untuk mencari tahu baris apa yang Anda inginkan, memfilter kumpulan data, atau mengurutkannya.) Jika dua, kedua kumpulan data adalah dua hal yang diindentasi lebih jauh, dan mereka digabungkan dengan aturan yang Anda lihat. Arti dari sebagian besar aturan dapat dengan mudah ditebak (terutama jika Anda telah membaca banyak rencana penjelasan sebelumnya), namun Anda dapat mencoba untuk memverifikasi item individual baik dengan melihat di dokumentasi atau (lebih mudah) dengan hanya memasukkan frasa ke dalam Google bersama dengan beberapa kata kunci seperti EXPLAIN.

Ini jelas bukan penjelasan lengkap, tetapi memberikan konteks yang cukup sehingga Anda biasanya dapat mengetahui apa pun yang Anda inginkan. Misalnya pertimbangkan rencana ini dari database yang sebenarnya:

explain analyze
select a.attributeid, a.attributevalue, b.productid
from orderitemattribute a, orderitem b
where a.orderid = b.orderid
and a.attributeid = 'display-album'
and b.productid = 'ModernBook';

------------------------------------------------------------------------------------------------------------------------------------------------------------

 Merge Join  (cost=125379.14..125775.12 rows=3311 width=29) (actual time=841.478..841.478 rows=0 loops=1)
   Merge Cond: (a.orderid = b.orderid)
   ->  Sort  (cost=109737.32..109881.89 rows=57828 width=23) (actual time=736.163..774.475 rows=16815 loops=1)
         Sort Key: a.orderid
         Sort Method:  quicksort  Memory: 1695kB
         ->  Bitmap Heap Scan on orderitemattribute a  (cost=1286.88..105163.27 rows=57828 width=23) (actual time=41.536..612.731 rows=16815 loops=1)
               Recheck Cond: ((attributeid)::text = 'display-album'::text)
               ->  Bitmap Index Scan on (cost=0.00..1272.43 rows=57828 width=0) (actual time=25.033..25.033 rows=16815 loops=1)
                     Index Cond: ((attributeid)::text = 'display-album'::text)
   ->  Sort  (cost=15641.81..15678.73 rows=14769 width=14) (actual time=14.471..16.898 rows=1109 loops=1)
         Sort Key: b.orderid
         Sort Method:  quicksort  Memory: 76kB
         ->  Bitmap Heap Scan on orderitem b  (cost=310.96..14619.03 rows=14769 width=14) (actual time=1.865..8.480 rows=1114 loops=1)
               Recheck Cond: ((productid)::text = 'ModernBook'::text)
               ->  Bitmap Index Scan on id_orderitem_productid  (cost=0.00..307.27 rows=14769 width=0) (actual time=1.431..1.431 rows=1114 loops=1)
                     Index Cond: ((productid)::text = 'ModernBook'::text)
 Total runtime: 842.134 ms
(17 rows)

Cobalah membacanya sendiri dan lihat apakah itu masuk akal.

Apa yang saya baca adalah bahwa database pertama-tama memindai id_orderitem_productidindeks, menggunakannya untuk menemukan baris yang diinginkannya orderitem, kemudian mengurutkan dataset tersebut menggunakan quicksort (jenis yang digunakan akan berubah jika data tidak sesuai dengan RAM), lalu sisihkan.

Selanjutnya, ia memindai orditematt_attributeid_idxuntuk menemukan baris yang diinginkannya orderitemattributedan kemudian mengurutkan set data itu menggunakan quicksort.

Kemudian mengambil dua kumpulan data dan menggabungkannya. (Penggabungan gabungan adalah semacam operasi "zipping" yang menjalankan dua kumpulan data yang diurutkan secara paralel, memancarkan baris yang digabungkan saat cocok.)

Seperti yang saya katakan, Anda mengerjakan bagian dalam rencana ke bagian luar, dari bawah ke atas.

Ada juga alat bantu online yang tersedia, Depesz , yang akan menyoroti di mana bagian mahal dari hasil analisis tersebut.

juga punya satu, berikut hasil yang sama , yang bagi saya membuatnya lebih jelas di mana masalahnya.

PgAdmin akan menunjukkan kepada Anda representasi grafis dari rencana penjelasan. Beralih bolak-balik di antara keduanya benar-benar dapat membantu Anda memahami apa arti representasi teks. Namun, jika Anda hanya ingin tahu apa yang akan dilakukan, Anda mungkin bisa selalu menggunakan GUI.

Dokumentasi resmi PostgreSQL memberikan penjelasan yang menarik dan menyeluruh tentang cara memahami output penjelasan.

Jika Anda menginstal pgadmin, ada tombol Jelaskan yang juga memberikan output teks menggambar diagram tentang apa yang terjadi, menunjukkan filter, menyortir, dan penggabungan sub-set yang menurut saya sangat berguna untuk melihat apa yang terjadi.