Rencana kueri

Anda dapat menggunakan paket kueri untuk mendapatkan informasi tentang operasi individual yang diperlukan untuk menjalankan kueri. Sebelum Anda bekerja dengan paket kueri, sebaiknya Anda terlebih dahulu memahami cara Amazon Redshift menangani kueri pemrosesan dan membuat paket kueri. Untuk informasi selengkapnya, lihat Perencanaan kueri dan alur kerja eksekusi.

Untuk membuat rencana kueri, jalankan EXPLAIN perintah diikuti oleh teks kueri yang sebenarnya. Paket kueri memberi Anda informasi berikut:

• Operasi apa yang dilakukan mesin eksekusi, membaca hasil dari bawah ke atas.

• Jenis langkah apa yang dilakukan setiap operasi.

• Tabel dan kolom mana yang digunakan dalam setiap operasi.

• Berapa banyak data yang diproses dalam setiap operasi, dalam hal jumlah baris dan lebar data dalam byte.

• Biaya relatif operasi. Biaya adalah ukuran yang membandingkan waktu eksekusi relatif dari langkah-langkah dalam suatu rencana. Biaya tidak memberikan informasi yang tepat tentang waktu eksekusi aktual atau konsumsi memori, juga tidak memberikan perbandingan yang berarti antara rencana eksekusi. Itu memberi Anda indikasi operasi mana dalam kueri yang menghabiskan sumber daya paling banyak.

Perintah EXPLOW tidak benar-benar menjalankan kueri. Ini hanya menunjukkan paket yang dijalankan Amazon Redshift jika kueri dijalankan dalam kondisi operasi saat ini. Jika Anda mengubah skema atau data untuk tabel dan menjalankannya MENGANALISA lagi untuk memperbarui metadata statistik, rencana kueri mungkin berbeda.

Output rencana kueri oleh EXPLOW adalah tampilan eksekusi kueri tingkat tinggi yang disederhanakan. Itu tidak menggambarkan detail pemrosesan query paralel. Untuk melihat informasi terperinci, jalankan kueri itu sendiri, lalu dapatkan informasi ringkasan kueri dari tampilan SVL_QUERY_SUMMARY atau SVL_QUERY_REPORT. Untuk informasi selengkapnya tentang menggunakan tampilan ini, lihatMenganalisis ringkasan kueri.

Contoh berikut menunjukkan output EXPLOW untuk query GROUP BY sederhana pada tabel EVENT:

explain select eventname, count(*) from event group by eventname;

                            QUERY PLAN
-------------------------------------------------------------------
XN HashAggregate  (cost=131.97..133.41 rows=576 width=17)
  ->  XN Seq Scan on event  (cost=0.00..87.98 rows=8798 width=17)

EXPLORE mengembalikan metrik berikut untuk setiap operasi:

Biaya

Nilai relatif yang berguna untuk membandingkan operasi dalam suatu rencana. Biaya terdiri dari dua nilai desimal yang dipisahkan oleh dua periode, misalnya. cost=131.97..133.41 Nilai pertama, dalam hal ini 131,97, memberikan biaya relatif untuk mengembalikan baris pertama untuk operasi ini. Nilai kedua, dalam hal ini 133,41, memberikan biaya relatif untuk menyelesaikan operasi. Biaya dalam paket kueri bersifat kumulatif saat Anda membaca rencana, sehingga HashAggregate biaya dalam contoh ini (131,97.. 133,41) termasuk biaya Pemindaian Seq di bawahnya (0,00.87.98).

Baris

Perkiraan jumlah baris yang akan dikembalikan. Dalam contoh ini, pemindaian diharapkan mengembalikan 8798 baris. HashAggregate Operator sendiri diharapkan mengembalikan 576 baris (setelah nama peristiwa duplikat dibuang dari set hasil).

catatan

Perkiraan baris didasarkan pada statistik yang tersedia yang dihasilkan oleh perintah ANALYZE. Jika ANALYSIS belum dijalankan baru-baru ini, estimasi kurang dapat diandalkan.

Lebar

Perkiraan lebar baris rata-rata, dalam byte. Dalam contoh ini, baris rata-rata diharapkan menjadi 17 byte lebar.

JELASKAN operator

Bagian ini menjelaskan secara singkat operator yang paling sering Anda lihat di output EXPLOW. Untuk daftar lengkap operator, lihat EXPLAIN di bagian Perintah SQL.

Operator pemindaian berurutan

Operator pemindaian sekuensial (Seq Scan) menunjukkan pemindaian tabel. Seq Scan memindai setiap kolom dalam tabel secara berurutan dari awal hingga akhir dan mengevaluasi kendala kueri (dalam klausa WHERE) untuk setiap baris.

Bergabunglah dengan operator

Amazon Redshift memilih operator gabungan berdasarkan desain fisik tabel yang digabungkan, lokasi data yang diperlukan untuk bergabung, dan persyaratan spesifik kueri itu sendiri.

• Loop Bersarang

  Gabungan yang paling tidak optimal, loop bersarang digunakan terutama untuk cross-join (produk Cartesian) dan beberapa kesenjangan bergabung.

• Hash Bergabung dan Hash

  Biasanya lebih cepat daripada gabungan loop bersarang, gabungan hash dan hash digunakan untuk gabungan dalam dan gabungan luar kiri dan kanan. Operator ini digunakan saat menggabungkan tabel di mana kolom gabungan bukan kunci distribusi dan kunci pengurutan. Operator hash membuat tabel hash untuk tabel bagian dalam di join; operator bergabung hash membaca tabel luar, hash kolom bergabung, dan menemukan kecocokan di tabel hash bagian dalam.

• Gabung Bergabung

  Biasanya gabungan tercepat, gabungan gabungan digunakan untuk sambungan dalam dan gabungan luar. Gabungan gabungan tidak digunakan untuk bergabung penuh. Operator ini digunakan saat menggabungkan tabel di mana kolom gabungan adalah kunci distribusi dan kunci pengurutan, dan ketika kurang dari 20 persen tabel penggabungan tidak disortir. Ia membaca dua tabel yang diurutkan secara berurutan dan menemukan baris yang cocok. Untuk melihat persentase baris yang tidak disortir, kueri tabel SVV_TABLE_INFO sistem.

• Bergabung Spasial

  Biasanya gabungan cepat berdasarkan kedekatan data spasial, digunakan untuk GEOMETRY dan tipe GEOGRAPHY data.

Operator agregat

Paket kueri menggunakan operator berikut dalam kueri yang melibatkan fungsi agregat dan operasi GROUP BY.

• Agregat

  Operator untuk fungsi agregat skalar seperti AVG dan SUM.

• HashAggregate

  Operator untuk fungsi agregat dikelompokkan yang tidak disortir.

• GroupAggregate

  Operator untuk fungsi agregat dikelompokkan yang diurutkan.

Mengurutkan operator

Paket kueri menggunakan operator berikut ketika kueri harus mengurutkan atau menggabungkan kumpulan hasil.

• Urutkan

  Mengevaluasi klausa ORDER BY dan operasi pengurutan lainnya, seperti jenis yang diperlukan oleh kueri dan gabungan UNION, kueri SELECT DISTINCT, dan fungsi jendela.

• Gabungkan

  Menghasilkan hasil akhir yang diurutkan menurut hasil diurutkan antara yang berasal dari operasi paralel.

UNION, INTERSECT, dan KECUALI operator

Paket kueri menggunakan operator berikut untuk kueri yang melibatkan operasi set dengan UNION, INTERSECT, dan EXCEPT.

• Subkueri

  Digunakan untuk menjalankan query UNION.

• Hash Intersect Berbeda

  Digunakan untuk menjalankan query INTERSECT.

• SetOp Kecuali

  Digunakan untuk menjalankan kueri KECUALI (atau MINUS).

Operator lainnya

Operator berikut juga sering muncul dalam output EXPLOW untuk kueri rutin.

• Unik

  Menghapus duplikat untuk kueri SELECT DISTINCT dan kueri UNION.

• Batasi

  Memproses klausa LIMIT.

• Jendela

  Menjalankan fungsi jendela.

• Hasil

  Menjalankan fungsi skalar yang tidak melibatkan akses tabel apa pun.

• Subrencana

  Digunakan untuk subquery tertentu.

• Jaringan

  Mengirim hasil antara ke node pemimpin untuk diproses lebih lanjut.

• Terwujud

  Menyimpan baris untuk input ke gabungan loop bersarang dan beberapa gabungan gabungan.

Bergabung dalam EXPLOW

Pengoptimal kueri menggunakan jenis gabungan yang berbeda untuk mengambil data tabel, tergantung pada struktur kueri dan tabel yang mendasarinya. Output EXPLORE mereferensikan tipe gabungan, tabel yang digunakan, dan cara data tabel didistribusikan di seluruh cluster untuk menjelaskan bagaimana kueri diproses.

Contoh tipe gabungan

Contoh berikut menunjukkan berbagai jenis gabungan yang dapat digunakan oleh pengoptimal kueri. Jenis gabungan yang digunakan dalam rencana kueri tergantung pada desain fisik tabel yang terlibat.

Contoh: Hash bergabung dengan dua tabel

Kueri berikut bergabung dengan EVENT dan CATEGORY pada kolom CATID. CATID adalah kunci distribusi dan sortir untuk CATEGORY tetapi tidak untuk EVENT. Gabungan hash dilakukan dengan EVENT sebagai tabel luar dan CATEGORY sebagai tabel bagian dalam. Karena CATEGORY adalah tabel yang lebih kecil, perencana menyiarkan salinannya ke node komputasi selama pemrosesan kueri dengan menggunakan DS_BCAST_INNER. Biaya bergabung dalam contoh ini menyumbang sebagian besar biaya kumulatif paket.

explain select * from category, event where category.catid=event.catid;

                               QUERY PLAN
-------------------------------------------------------------------------
 XN Hash Join DS_BCAST_INNER  (cost=0.14..6600286.07 rows=8798 width=84)
   Hash Cond: ("outer".catid = "inner".catid)
   ->  XN Seq Scan on event  (cost=0.00..87.98 rows=8798 width=35)
   ->  XN Hash  (cost=0.11..0.11 rows=11 width=49)
         ->  XN Seq Scan on category  (cost=0.00..0.11 rows=11 width=49)

catatan

Indentasi selaras untuk operator dalam output EXPLOW terkadang menunjukkan bahwa operasi tersebut tidak bergantung satu sama lain dan dapat dimulai secara paralel. Dalam contoh sebelumnya, meskipun pemindaian pada tabel EVENT dan operasi hash selaras, pemindaian EVENT harus menunggu sampai operasi hash selesai sepenuhnya.

Contoh: Gabung bergabung dengan dua tabel

Kueri berikut juga menggunakan SELECT *, tetapi bergabung dengan SALES dan LISTING pada kolom LISTID, di mana LISTID telah ditetapkan sebagai distribusi dan kunci pengurutan untuk kedua tabel. Gabungan gabungan dipilih, dan tidak diperlukan redistribusi data untuk join (DS_DIST_NONE).

explain select * from sales, listing where sales.listid = listing.listid;
QUERY PLAN
-----------------------------------------------------------------------------
XN Merge Join DS_DIST_NONE  (cost=0.00..6285.93 rows=172456 width=97)
  Merge Cond: ("outer".listid = "inner".listid)
  ->  XN Seq Scan on listing  (cost=0.00..1924.97 rows=192497 width=44)
  ->  XN Seq Scan on sales  (cost=0.00..1724.56 rows=172456 width=53)

Contoh berikut menunjukkan berbagai jenis gabungan dalam query yang sama. Seperti pada contoh sebelumnya, SALES dan LISTING digabungkan, tetapi tabel ketiga, EVENT, harus hash bergabung dengan hasil gabungan gabungan. Sekali lagi, bergabung hash menimbulkan biaya siaran.

explain select * from sales, listing, event
where sales.listid = listing.listid and sales.eventid = event.eventid;
                                  QUERY PLAN
----------------------------------------------------------------------------
XN Hash Join DS_BCAST_INNER  (cost=109.98..3871130276.17 rows=172456 width=132)
  Hash Cond: ("outer".eventid = "inner".eventid)
  ->  XN Merge Join DS_DIST_NONE  (cost=0.00..6285.93 rows=172456 width=97)
        Merge Cond: ("outer".listid = "inner".listid)
        ->  XN Seq Scan on listing  (cost=0.00..1924.97 rows=192497 width=44)
        ->  XN Seq Scan on sales  (cost=0.00..1724.56 rows=172456 width=53)
  ->  XN Hash  (cost=87.98..87.98 rows=8798 width=35)
        ->  XN Seq Scan on event  (cost=0.00..87.98 rows=8798 width=35)

Contoh: Gabung, agregat, dan urutkan

Kueri berikut menjalankan gabungan hash dari tabel SALES dan EVENT, diikuti oleh agregasi dan operasi pengurutan untuk memperhitungkan fungsi SUM yang dikelompokkan dan klausa ORDER BY. Operator pengurutan awal berjalan secara paralel pada node komputasi. Kemudian operator Jaringan mengirimkan hasilnya ke node pemimpin, di mana operator Merge menghasilkan hasil akhir yang diurutkan.

explain select eventname, sum(pricepaid) from sales, event 
where sales.eventid=event.eventid group by eventname
order by 2 desc;
                                           QUERY PLAN
---------------------------------------------------------------------------------
 XN Merge  (cost=1002815366604.92..1002815366606.36 rows=576 width=27)
  Merge Key: sum(sales.pricepaid)
  ->  XN Network  (cost=1002815366604.92..1002815366606.36 rows=576 width=27)
        Send to leader
        ->  XN Sort  (cost=1002815366604.92..1002815366606.36 rows=576 width=27)
              Sort Key: sum(sales.pricepaid)
              ->  XN HashAggregate  (cost=2815366577.07..2815366578.51 rows=576 width=27)
                    ->  XN Hash Join DS_BCAST_INNER  (cost=109.98..2815365714.80 rows=172456 width=27)
                          Hash Cond: ("outer".eventid = "inner".eventid)
                          ->  XN Seq Scan on sales  (cost=0.00..1724.56 rows=172456 width=14)
                          ->  XN Hash  (cost=87.98..87.98 rows=8798 width=21)
                                ->  XN Seq Scan on event  (cost=0.00..87.98 rows=8798 width=21)

Redistribusi data

Output EXPLOW untuk gabungan juga menentukan metode untuk bagaimana data dipindahkan di sekitar cluster untuk memfasilitasi penggabungan. Pergerakan data ini dapat berupa siaran atau redistribusi. Dalam siaran, nilai data dari satu sisi gabungan disalin dari setiap node komputasi ke setiap node komputasi lainnya, sehingga setiap node komputasi berakhir dengan salinan data yang lengkap. Dalam redistribusi, nilai data yang berpartisipasi dikirim dari irisan mereka saat ini ke irisan baru (mungkin pada node yang berbeda). Data biasanya didistribusikan ulang agar sesuai dengan kunci distribusi dari tabel lain yang berpartisipasi dalam gabungan jika kunci distribusi itu adalah salah satu kolom yang bergabung. Jika tidak satu pun dari tabel memiliki kunci distribusi pada salah satu kolom yang bergabung, baik kedua tabel didistribusikan atau tabel bagian dalam disiarkan ke setiap node.

Output EXPLORE juga mereferensikan tabel dalam dan luar. Tabel bagian dalam dipindai terlebih dahulu, dan muncul lebih dekat di bagian bawah rencana kueri. Meja bagian dalam adalah meja yang diperiksa untuk korek api. Biasanya disimpan dalam memori, biasanya tabel sumber untuk hashing, dan jika mungkin, adalah tabel yang lebih kecil dari keduanya yang bergabung. Tabel luar adalah sumber baris untuk dicocokkan dengan meja bagian dalam. Biasanya dibaca dari disk. Pengoptimal kueri memilih tabel bagian dalam dan luar berdasarkan statistik database dari proses terbaru dari perintah ANALYZE. Urutan tabel dalam klausa FROM dari kueri tidak menentukan tabel mana yang berada di dalam dan mana yang luar.

Gunakan atribut berikut dalam rencana kueri untuk mengidentifikasi bagaimana data dipindahkan untuk memfasilitasi kueri:

• DS_BCAST_INNER

  Salinan seluruh tabel bagian dalam disiarkan ke semua node komputasi.

• DS_DIST_ALL_NONE

  Tidak diperlukan redistribusi, karena tabel bagian dalam telah didistribusikan ke setiap node menggunakan DISTYLE ALL.

• DS_DIST_TIDAK ADA

  Tidak ada tabel yang didistribusikan kembali. Gabungan yang dikolokasikan dimungkinkan karena irisan yang sesuai digabungkan tanpa memindahkan data antar node.

• DS_DIST_INNER

  Meja bagian dalam didistribusikan kembali.

• DS_DIST_OUTER

  Tabel luar didistribusikan kembali.

• DS_DIST_ALL_INNER

  Seluruh tabel bagian dalam didistribusikan kembali ke satu irisan karena tabel luar menggunakan DISTSTYLE ALL.

• DS_DIST_KEDUANYA

  Kedua tabel didistribusikan kembali.