Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris. # SELECT Perintah SELECT mengembalikan baris dari tabel dan fungsi yang ditentukan pengguna. Perintah SELECT SQL, klausa, dan operator set berikut didukung di AWS Clean Rooms Spark SQL: **Topics** + [SELECT list](sql-function-select-list-spark.md) + [DENGAN klausa](WITH_clause.md) + [Klausa FROM](FROM_clause30.md) + [Klausa JOIN](join-clause.md) + [Klausa WHERE](WHERE_clause.md) + [Klausa VALUES](VALUES.md) + [Klausa GROUP BY](GROUP_BY_clause.md) + [Klausa HAVING](HAVING_clause.md) + [Tetapkan operator](UNION.md) + [Klausa ORDER BY](ORDER_BY_clause.md) + [Contoh subquery](Subquery_examples.md) + [Subquery berkorelasi](correlated_subqueries.md) Sintaks, argumen, dan beberapa contoh berasal dari [Apache Spark](https://spark.apache.org/docs/latest/api/sql/) SQL Reference. # SELECT list SELECT listNama-nama kolom, fungsi, dan ekspresi yang Anda ingin kueri untuk kembali. Daftar ini mewakili output kueri. ## Sintaks ``` SELECT [ DISTINCT ] | expression [ AS column_alias ] [, ...] ``` ## Parameter DISTINCT Opsi yang menghilangkan baris duplikat dari set hasil, berdasarkan nilai yang cocok dalam satu atau beberapa kolom. *expression* Ekspresi yang terbentuk dari satu atau lebih kolom yang ada di tabel yang direferensikan oleh kueri. Ekspresi dapat berisi fungsi SQL. Contoh: ``` coalesce(dimension, 'stringifnull') AS column_alias ``` AS column\$1alias Nama sementara untuk kolom yang digunakan dalam set hasil akhir. ASKata kunci adalah opsional. Contoh: ``` coalesce(dimension, 'stringifnull') AS dimensioncomplete ``` Jika Anda tidak menentukan alias untuk ekspresi yang bukan nama kolom sederhana, set hasil akan menerapkan nama default ke kolom tersebut. **catatan** Alias dikenali tepat setelah didefinisikan dalam daftar target. Anda tidak dapat menggunakan alias dalam ekspresi lain yang ditentukan setelahnya dalam daftar target yang sama. # DENGAN klausa Klausa WITH adalah klausa opsional yang mendahului daftar SELECT dalam kueri. *Klausa WITH mendefinisikan satu atau lebih common\$1table\$1expressions.* Setiap ekspresi tabel umum (CTE) mendefinisikan tabel sementara, yang mirip dengan definisi tampilan. Anda dapat mereferensikan tabel sementara ini di klausa FROM. Mereka hanya digunakan saat kueri milik mereka berjalan. Setiap CTE dalam klausa WITH menentukan nama tabel, daftar opsional nama kolom, dan ekspresi kueri yang mengevaluasi tabel (pernyataan SELECT). Dengan subquery klausa adalah cara yang efisien untuk mendefinisikan tabel yang dapat digunakan selama eksekusi query tunggal. Dalam semua kasus, hasil yang sama dapat dicapai dengan menggunakan subquery di bagian utama pernyataan SELECT, tetapi dengan subquery klausa mungkin lebih mudah untuk ditulis dan dibaca. Jika memungkinkan, subkueri klausa WITH yang direferensikan beberapa kali dioptimalkan sebagai subexpressions umum; yaitu, dimungkinkan untuk mengevaluasi subquery WITH sekali dan menggunakan kembali hasilnya. (Perhatikan bahwa subexpressions umum tidak terbatas pada yang didefinisikan dalam klausa WITH.) ## Sintaksis ``` [ WITH common_table_expression [, common_table_expression , ...] ] ``` dimana *common\$1table\$1expression* bisa non-rekursif. Berikut ini adalah bentuk non-rekursif: ``` CTE_table_name AS ( query ) ``` ## Parameter *common\$1table\$1expression* Mendefinisikan tabel sementara yang dapat Anda referensikan di [Klausa FROM](FROM_clause30.md) dan hanya digunakan selama eksekusi kueri yang dimilikinya. *CTE\$1TABLE\$1NAME* Nama unik untuk tabel sementara yang mendefinisikan hasil subquery klausa WITH. Anda tidak dapat menggunakan nama duplikat dalam satu klausa WITH. Setiap subquery harus diberi nama tabel yang dapat direferensikan di. [Klausa FROM](FROM_clause30.md) *query* Setiap kueri SELECT yang AWS Clean Rooms mendukung. Lihat [SELECT](sql-commands-select-spark.md). ## Catatan penggunaan Anda dapat menggunakan klausa WITH dalam pernyataan SQL berikut: + PILIH, DENGAN, UNION, UNION ALL, INTERSECT, INTERSECT ALL, KECUALI, atau KECUALI SEMUA Jika klausa FROM dari kueri yang berisi klausa WITH tidak mereferensikan salah satu tabel yang ditentukan oleh klausa WITH, klausa WITH diabaikan dan kueri berjalan seperti biasa. Sebuah tabel yang didefinisikan oleh subquery klausa WITH dapat direferensikan hanya dalam lingkup kueri SELECT bahwa klausa WITH dimulai. Misalnya, Anda dapat mereferensikan tabel tersebut dalam klausa FROM dari subquery dalam daftar SELECT, klausa WHERE, atau HAVING. Anda tidak dapat menggunakan klausa WITH dalam subquery dan mereferensikan tabelnya di klausa FROM dari kueri utama atau subquery lainnya. Pola kueri ini menghasilkan pesan kesalahan formulir `relation table_name doesn't exist` untuk tabel klausa WITH. Anda tidak dapat menentukan klausa WITH lain di dalam subquery klausa WITH. Anda tidak dapat meneruskan referensi ke tabel yang ditentukan oleh subkueri klausa WITH. Misalnya, query berikut mengembalikan kesalahan karena referensi forward ke tabel W2 dalam definisi tabel W1: ``` with w1 as (select * from w2), w2 as (select * from w1) select * from sales; ERROR: relation "w2" does not exist ``` ## Contoh Contoh berikut menunjukkan kasus yang paling sederhana dari query yang berisi klausa WITH. Query WITH bernama VENUECOPY memilih semua baris dari tabel VENUE. Kueri utama pada gilirannya memilih semua baris dari VENUECOPY. Tabel VENUECOPY hanya ada selama durasi kueri ini. ``` with venuecopy as (select * from venue) select * from venuecopy order by 1 limit 10; ``` ``` venueid | venuename | venuecity | venuestate | venueseats ---------+----------------------------+-----------------+------------+------------ 1 | Toyota Park | Bridgeview | IL | 0 2 | Columbus Crew Stadium | Columbus | OH | 0 3 | RFK Stadium | Washington | DC | 0 4 | CommunityAmerica Ballpark | Kansas City | KS | 0 5 | Gillette Stadium | Foxborough | MA | 68756 6 | New York Giants Stadium | East Rutherford | NJ | 80242 7 | BMO Field | Toronto | ON | 0 8 | The Home Depot Center | Carson | CA | 0 9 | Dick's Sporting Goods Park | Commerce City | CO | 0 v 10 | Pizza Hut Park | Frisco | TX | 0 (10 rows) ``` Contoh berikut menunjukkan klausa WITH yang menghasilkan dua tabel, bernama VENUE\$1SALES dan TOP\$1VENUES. Tabel WITH query kedua memilih dari yang pertama. Pada gilirannya, klausa WHERE dari blok kueri utama berisi subquery yang membatasi tabel TOP\$1VENUES. ``` with venue_sales as (select venuename, venuecity, sum(pricepaid) as venuename_sales from sales, venue, event where venue.venueid=event.venueid and event.eventid=sales.eventid group by venuename, venuecity), top_venues as (select venuename from venue_sales where venuename_sales > 800000) select venuename, venuecity, venuestate, sum(qtysold) as venue_qty, sum(pricepaid) as venue_sales from sales, venue, event where venue.venueid=event.venueid and event.eventid=sales.eventid and venuename in(select venuename from top_venues) group by venuename, venuecity, venuestate order by venuename; ``` ``` venuename | venuecity | venuestate | venue_qty | venue_sales ------------------------+---------------+------------+-----------+------------- August Wilson Theatre | New York City | NY | 3187 | 1032156.00 Biltmore Theatre | New York City | NY | 2629 | 828981.00 Charles Playhouse | Boston | MA | 2502 | 857031.00 Ethel Barrymore Theatre | New York City | NY | 2828 | 891172.00 Eugene O'Neill Theatre | New York City | NY | 2488 | 828950.00 Greek Theatre | Los Angeles | CA | 2445 | 838918.00 Helen Hayes Theatre | New York City | NY | 2948 | 978765.00 Hilton Theatre | New York City | NY | 2999 | 885686.00 Imperial Theatre | New York City | NY | 2702 | 877993.00 Lunt-Fontanne Theatre | New York City | NY | 3326 | 1115182.00 Majestic Theatre | New York City | NY | 2549 | 894275.00 Nederlander Theatre | New York City | NY | 2934 | 936312.00 Pasadena Playhouse | Pasadena | CA | 2739 | 820435.00 Winter Garden Theatre | New York City | NY | 2838 | 939257.00 (14 rows) ``` Dua contoh berikut menunjukkan aturan untuk ruang lingkup referensi tabel berdasarkan subquery klausa WITH. Kueri pertama berjalan, tetapi yang kedua gagal dengan kesalahan yang diharapkan. Kueri pertama memiliki subquery klausa WITH di dalam daftar SELECT dari kueri utama. Tabel yang ditentukan oleh klausa WITH (HOLIDAYS) direferensikan dalam klausa FROM subquery dalam daftar SELECT: ``` select caldate, sum(pricepaid) as daysales, (with holidays as (select * from date where holiday ='t') select sum(pricepaid) from sales join holidays on sales.dateid=holidays.dateid where caldate='2008-12-25') as dec25sales from sales join date on sales.dateid=date.dateid where caldate in('2008-12-25','2008-12-31') group by caldate order by caldate; caldate | daysales | dec25sales -----------+----------+------------ 2008-12-25 | 70402.00 | 70402.00 2008-12-31 | 12678.00 | 70402.00 (2 rows) ``` Kueri kedua gagal karena mencoba mereferensikan tabel HOLIDAYS di kueri utama serta di subquery daftar SELECT. Referensi kueri utama berada di luar cakupan. ``` select caldate, sum(pricepaid) as daysales, (with holidays as (select * from date where holiday ='t') select sum(pricepaid) from sales join holidays on sales.dateid=holidays.dateid where caldate='2008-12-25') as dec25sales from sales join holidays on sales.dateid=holidays.dateid where caldate in('2008-12-25','2008-12-31') group by caldate order by caldate; ERROR: relation "holidays" does not exist ``` # Klausa FROM Klausa FROM dalam kueri mencantumkan referensi tabel (tabel, tampilan, dan subkueri) tempat data dipilih. Jika beberapa referensi tabel terdaftar, tabel harus digabungkan, menggunakan sintaks yang sesuai baik dalam klausa FROM atau klausa WHERE. Jika tidak ada kriteria gabungan yang ditentukan, sistem memproses kueri sebagai cross-join (produk Cartesian). **Topics** + [Sintaksis](#FROM_clause30-synopsis) + [Parameter](#FROM_clause30-parameters) + [Catatan penggunaan](#FROM_clause_usage_notes) ## Sintaksis ``` FROM table_reference [, ...] ``` di mana *table\$1reference* adalah salah satu dari berikut ini: ``` with_subquery_table_name | table_name | ( subquery ) [ [ AS ] alias ] table_reference [ NATURAL ] join_type table_reference [ USING ( join_column [, ...] ) ] table_reference [ INNER ] join_type table_reference ON expr ``` ## Parameter *dengan\$1subquery\$1table\$1name* Sebuah tabel didefinisikan oleh subquery di. [DENGAN klausa](WITH_clause.md) *table\$1name* Nama tabel atau tampilan. *alias* Nama alternatif sementara untuk tabel atau tampilan. Alias harus disediakan untuk tabel yang berasal dari subquery. Dalam referensi tabel lainnya, alias bersifat opsional. Kata AS kunci selalu opsional. Alias tabel menyediakan pintasan yang nyaman untuk mengidentifikasi tabel di bagian lain dari kueri, seperti klausa WHERE. Contoh: ``` select * from sales s, listing l where s.listid=l.listid ``` Jika Anda mendefinisikan alias tabel didefinisikan, maka alias harus digunakan untuk referensi tabel dalam query. Misalnya, jika kueri adalah`SELECT "tbl"."col" FROM "tbl" AS "t"`, kueri akan gagal karena nama tabel pada dasarnya diganti sekarang. Kueri yang valid dalam kasus ini adalah`SELECT "t"."col" FROM "tbl" AS "t"`. *column\$1alias* Nama alternatif sementara untuk kolom dalam tabel atau tampilan. *subkueri* Ekspresi kueri yang mengevaluasi ke tabel. Tabel hanya ada selama durasi kueri dan biasanya diberi nama atau *alias*. Namun, alias tidak diperlukan. Anda juga dapat menentukan nama kolom untuk tabel yang berasal dari subquery. Penamaan alias kolom penting saat Anda ingin menggabungkan hasil subkueri ke tabel lain dan saat Anda ingin memilih atau membatasi kolom tersebut di tempat lain dalam kueri. Subquery mungkin berisi klausa ORDER BY, tetapi klausa ini mungkin tidak berpengaruh jika klausa LIMIT atau OFFSET tidak juga ditentukan. ALAMI Mendefinisikan gabungan yang secara otomatis menggunakan semua pasangan kolom bernama identik dalam dua tabel sebagai kolom bergabung. Tidak diperlukan kondisi gabungan eksplisit. Misalnya, jika tabel CATEGORY dan EVENT keduanya memiliki kolom bernama CATID, gabungan alami dari tabel tersebut adalah gabungan di atas kolom CATID mereka. Jika gabungan NATURAL ditentukan tetapi tidak ada pasangan kolom bernama identik yang ada di tabel yang akan digabungkan, kueri default ke cross-join. *join\$1type* Tentukan salah satu jenis join berikut: + [BATIN] BERGABUNG + KIRI [LUAR] BERGABUNG + KANAN [LUAR] BERGABUNG + PENUH [LUAR] BERGABUNG + CROSS JOIN Cross-join adalah gabungan yang tidak memenuhi syarat; mereka mengembalikan produk Cartesian dari dua tabel. Gabungan dalam dan luar adalah gabungan yang memenuhi syarat. Mereka memenuhi syarat baik secara implisit (dalam gabungan alami); dengan sintaks ON atau USING dalam klausa FROM; atau dengan kondisi klausa WHERE. Gabungan bagian dalam mengembalikan baris yang cocok saja, berdasarkan kondisi gabungan atau daftar kolom yang bergabung. Gabungan luar mengembalikan semua baris yang akan dikembalikan oleh gabungan dalam yang setara ditambah baris yang tidak cocok dari tabel “kiri”, tabel “kanan”, atau kedua tabel. Tabel kiri adalah tabel yang terdaftar pertama, dan tabel kanan adalah tabel kedua yang terdaftar. Baris yang tidak cocok berisi nilai NULL untuk mengisi celah di kolom output. PADA *join\$1condition* Jenis spesifikasi gabungan di mana kolom bergabung dinyatakan sebagai kondisi yang mengikuti kata kunci ON. Contoh: ``` sales join listing on sales.listid=listing.listid and sales.eventid=listing.eventid ``` MENGGUNAKAN (*join\$1column* [,...]) Jenis spesifikasi gabungan di mana kolom bergabung tercantum dalam tanda kurung. Jika beberapa kolom bergabung ditentukan, mereka dibatasi oleh koma. Kata kunci USING harus mendahului daftar. Contoh: ``` sales join listing using (listid,eventid) ``` ## Catatan penggunaan Kolom yang bergabung harus memiliki tipe data yang sebanding. Gabungan ALAMI atau MENGGUNAKAN hanya mempertahankan satu dari setiap pasangan kolom penggabungan dalam kumpulan hasil perantara. Gabungan dengan sintaks ON mempertahankan kedua kolom yang bergabung dalam set hasil perantara. Lihat juga [DENGAN klausa](WITH_clause.md). # Klausa JOIN Klausa SQL JOIN digunakan untuk menggabungkan data dari dua atau lebih tabel berdasarkan bidang umum. Hasilnya mungkin atau mungkin tidak berubah tergantung pada metode gabungan yang ditentukan. Gabungan luar kiri dan kanan mempertahankan nilai dari salah satu tabel yang digabungkan ketika tidak ada kecocokan yang ditemukan di tabel lainnya. Kombinasi tipe JOIN dan kondisi gabungan menentukan baris mana yang termasuk dalam set hasil akhir. Klausa SELECT dan WHERE kemudian mengontrol kolom mana yang dikembalikan dan bagaimana baris disaring. Memahami berbagai jenis JOIN dan cara menggunakannya secara efektif adalah keterampilan penting dalam SQL, karena memungkinkan Anda untuk menggabungkan data dari beberapa tabel dengan cara yang fleksibel dan kuat. ## Sintaks ``` SELECT column1, column2, ..., columnn FROM table1 join_type table2 ON table1.column = table2.column; ``` ## Parameter *PILIH kolom1, kolom2,..., kolomN* Kolom yang ingin Anda sertakan dalam set hasil. Anda dapat memilih kolom dari salah satu atau kedua tabel yang terlibat dalam JOIN. *DARI tabel1* Tabel pertama (kiri) dalam operasi JOIN. *[BERGABUNG \$1 BERGABUNG DALAM \$1 KIRI [LUAR] BERGABUNG \$1 KANAN [LUAR] BERGABUNG \$1 LENGKAP [LUAR] BERGABUNG] tabel2:* Jenis JOIN yang akan dilakukan. JOIN atau INNER JOIN hanya mengembalikan baris dengan nilai yang cocok di kedua tabel. LEFT [OUTER] JOIN mengembalikan semua baris dari tabel kiri, dengan baris yang cocok dari tabel kanan. RIGHT [OUTER] JOIN mengembalikan semua baris dari tabel kanan, dengan baris yang cocok dari tabel kiri. FULL [OUTER] JOIN mengembalikan semua baris dari kedua tabel, terlepas dari apakah ada kecocokan atau tidak. CROSS JOIN menciptakan produk Cartesian dari baris dari dua tabel. *ON table1.column = table2.column* Kondisi bergabung, yang menentukan bagaimana baris dalam dua tabel dicocokkan. Kondisi bergabung dapat didasarkan pada satu atau lebih kolom. *Kondisi DIMANA:* Klausa opsional yang dapat digunakan untuk memfilter hasil yang ditetapkan lebih lanjut, berdasarkan kondisi tertentu. ## Contoh Contoh berikut adalah gabungan antara dua tabel dengan klausa USING. Dalam hal ini, kolom listid dan eventid digunakan sebagai kolom gabungan. Hasilnya dibatasi hingga lima baris. ``` select listid, listing.sellerid, eventid, listing.dateid, numtickets from listing join sales using (listid, eventid) order by 1 limit 5; listid | sellerid | eventid | dateid | numtickets -------+----------+---------+--------+----------- 1 | 36861 | 7872 | 1850 | 10 4 | 8117 | 4337 | 1970 | 8 5 | 1616 | 8647 | 1963 | 4 5 | 1616 | 8647 | 1963 | 4 6 | 47402 | 8240 | 2053 | 18 ``` # Bergabunglah dengan tipe ## BATIN Ini adalah tipe gabungan default. Mengembalikan baris yang memiliki nilai yang cocok di kedua referensi tabel. INNER JOIN adalah jenis gabungan yang paling umum digunakan dalam SQL. Ini adalah cara yang ampuh untuk menggabungkan data dari beberapa tabel berdasarkan kolom umum atau kumpulan kolom. **Sintaksis:** ``` SELECT column1, column2, ..., columnn FROM table1 INNER JOIN table2 ON table1.column = table2.column; ``` Kueri berikut akan mengembalikan semua baris di mana ada nilai customer\$1id yang cocok antara pelanggan dan tabel pesanan. Set hasil akan berisi kolom customer\$1id, name, order\$1id, dan order\$1date. ``` SELECT customers.customer_id, customers.name, orders.order_id, orders.order_date FROM customers INNER JOIN orders ON customers.customer_id = orders.customer_id; ``` Kueri berikut adalah gabungan dalam (tanpa kata kunci JOIN) antara tabel LISTING dan tabel PENJUALAN, di mana LISTID dari tabel LISTING adalah antara 1 dan 5. Kueri ini cocok dengan nilai kolom LISTID dalam tabel LISTING (tabel kiri) dan tabel PENJUALAN (tabel kanan). Hasilnya menunjukkan bahwa LISTID 1, 4, dan 5 sesuai dengan kriteria. ``` select listing.listid, sum(pricepaid) as price, sum(commission) as comm from listing, sales where listing.listid = sales.listid and listing.listid between 1 and 5 group by 1 order by 1; listid | price | comm -------+--------+-------- 1 | 728.00 | 109.20 4 | 76.00 | 11.40 5 | 525.00 | 78.75 ``` Contoh berikut adalah gabungan batin dengan klausa ON. Dalam hal ini, baris NULL tidak dikembalikan. ``` select listing.listid, sum(pricepaid) as price, sum(commission) as comm from sales join listing on sales.listid=listing.listid and sales.eventid=listing.eventid where listing.listid between 1 and 5 group by 1 order by 1; listid | price | comm -------+--------+-------- 1 | 728.00 | 109.20 4 | 76.00 | 11.40 5 | 525.00 | 78.75 ``` Kueri berikut adalah gabungan batin dari dua subquery dalam klausa FROM. Kueri menemukan jumlah tiket yang terjual dan tidak terjual untuk berbagai kategori acara (konser dan pertunjukan). Subquery klausa FROM adalah subquery *tabel*; mereka dapat mengembalikan beberapa kolom dan baris. ``` select catgroup1, sold, unsold from (select catgroup, sum(qtysold) as sold from category c, event e, sales s where c.catid = e.catid and e.eventid = s.eventid group by catgroup) as a(catgroup1, sold) join (select catgroup, sum(numtickets)-sum(qtysold) as unsold from category c, event e, sales s, listing l where c.catid = e.catid and e.eventid = s.eventid and s.listid = l.listid group by catgroup) as b(catgroup2, unsold) on a.catgroup1 = b.catgroup2 order by 1; catgroup1 | sold | unsold ----------+--------+-------- Concerts | 195444 |1067199 Shows | 149905 | 817736 ``` ## KIRI [LUAR] Mengembalikan semua nilai dari referensi tabel kiri dan nilai cocok dari referensi tabel kanan, atau menambahkan NULL jika tidak ada kecocokan. Ini juga disebut sebagai *gabungan luar kiri*. Ia mengembalikan semua baris dari tabel kiri (pertama), dan baris yang cocok dari tabel kanan (kedua). Jika tidak ada kecocokan di tabel kanan, set hasil akan berisi nilai NULL untuk kolom dari tabel kanan. Kata kunci OUTER dapat dihilangkan, dan gabungan dapat ditulis hanya sebagai LEFT JOIN. Kebalikan dari LEFT OUTER JOIN adalah RIGHT OUTER JOIN, yang mengembalikan semua baris dari tabel kanan dan baris yang cocok dari tabel kiri. **Sintaksis:** ``` SELECT column1, column2, ..., columnn FROM table1 LEFT [OUTER] JOIN table2 ON table1.column = table2.column; ``` Kueri berikut akan mengembalikan semua baris dari tabel pelanggan, bersama dengan baris yang cocok dari tabel pesanan. Jika pelanggan tidak memiliki pesanan, set hasil akan tetap menyertakan informasi pelanggan tersebut, dengan nilai NULL untuk kolom order\$1id dan order\$1date. ``` SELECT customers.customer_id, customers.name, orders.order_id, orders.order_date FROM customers LEFT OUTER JOIN orders ON customers.customer_id = orders.customer_id; ``` Kueri berikut adalah gabungan luar kiri. Gabungan luar kiri dan kanan mempertahankan nilai dari salah satu tabel yang digabungkan ketika tidak ada kecocokan yang ditemukan di tabel lainnya. Tabel kiri dan kanan adalah tabel pertama dan kedua yang tercantum dalam sintaks. Nilai NULL digunakan untuk mengisi “celah” di set hasil. Kueri ini cocok dengan nilai kolom LISTID dalam tabel LISTING (tabel kiri) dan tabel PENJUALAN (tabel kanan). Hasilnya menunjukkan bahwa LISTIDs 2 dan 3 tidak menghasilkan penjualan apa pun. ``` select listing.listid, sum(pricepaid) as price, sum(commission) as comm from listing left outer join sales on sales.listid = listing.listid where listing.listid between 1 and 5 group by 1 order by 1; listid | price | comm -------+--------+-------- 1 | 728.00 | 109.20 2 | NULL | NULL 3 | NULL | NULL 4 | 76.00 | 11.40 5 | 525.00 | 78.75 ``` ## KANAN [LUAR] Mengembalikan semua nilai dari referensi tabel kanan dan nilai cocok dari referensi tabel kiri, atau menambahkan NULL jika tidak ada kecocokan. Ini juga disebut sebagai *gabungan luar kanan*. Ia mengembalikan semua baris dari tabel kanan (kedua), dan baris yang cocok dari tabel kiri (pertama). Jika tidak ada kecocokan di tabel kiri, set hasil akan berisi nilai NULL untuk kolom dari tabel kiri. Kata kunci OUTER dapat dihilangkan, dan gabungan dapat ditulis hanya sebagai RIGHT JOIN. Kebalikan dari RIGHT OUTER JOIN adalah LEFT OUTER JOIN, yang mengembalikan semua baris dari tabel kiri dan baris yang cocok dari tabel kanan. **Sintaksis:** ``` SELECT column1, column2, ..., columnn FROM table1 RIGHT [OUTER] JOIN table2 ON table1.column = table2.column; ``` Kueri berikut akan mengembalikan semua baris dari tabel pelanggan, bersama dengan baris yang cocok dari tabel pesanan. Jika pelanggan tidak memiliki pesanan, set hasil akan tetap menyertakan informasi pelanggan tersebut, dengan nilai NULL untuk kolom order\$1id dan order\$1date. ``` SELECT orders.order_id, orders.order_date, customers.customer_id, customers.name FROM orders RIGHT OUTER JOIN customers ON orders.customer_id = customers.customer_id; ``` Kueri berikut adalah gabungan luar kanan. Kueri ini cocok dengan nilai kolom LISTID dalam tabel LISTING (tabel kiri) dan tabel PENJUALAN (tabel kanan). Hasilnya menunjukkan bahwa LISTIDs 1, 4, dan 5 sesuai dengan kriteria. ``` select listing.listid, sum(pricepaid) as price, sum(commission) as comm from listing right outer join sales on sales.listid = listing.listid where listing.listid between 1 and 5 group by 1 order by 1; listid | price | comm -------+--------+-------- 1 | 728.00 | 109.20 4 | 76.00 | 11.40 5 | 525.00 | 78.75 ``` ## PENUH [LUAR] Mengembalikan semua nilai dari kedua hubungan, menambahkan nilai NULL di sisi yang tidak memiliki kecocokan. Ini juga disebut sebagai *gabungan luar penuh*. Ia mengembalikan semua baris dari kedua tabel kiri dan kanan, terlepas dari apakah ada kecocokan atau tidak. Jika tidak ada kecocokan, set hasil akan berisi nilai NULL untuk kolom dari tabel yang tidak memiliki baris yang cocok. Kata kunci OUTER dapat dihilangkan, dan gabungan dapat ditulis hanya sebagai FULL JOIN. FULL OUTER JOIN lebih jarang digunakan daripada LEFT OUTER JOIN atau RIGHT OUTER JOIN, tetapi dapat berguna dalam skenario tertentu di mana Anda perlu melihat semua data dari kedua tabel, bahkan jika tidak ada kecocokan. **Sintaksis:** ``` SELECT column1, column2, ..., columnn FROM table1 FULL [OUTER] JOIN table2 ON table1.column = table2.column; ``` Kueri berikut akan mengembalikan semua baris dari tabel pelanggan dan pesanan. Jika pelanggan tidak memiliki pesanan, set hasil akan tetap menyertakan informasi pelanggan tersebut, dengan nilai NULL untuk kolom order\$1id dan order\$1date. Jika pesanan tidak memiliki pelanggan terkait, kumpulan hasil akan menyertakan urutan itu, dengan nilai NULL untuk customer\$1id dan kolom nama. ``` SELECT customers.customer_id, customers.name, orders.order_id, orders.order_date FROM customers FULL OUTER JOIN orders ON customers.customer_id = orders.customer_id; ``` Kueri berikut adalah gabungan penuh. Gabungan penuh mempertahankan nilai dari tabel yang digabungkan ketika tidak ada kecocokan yang ditemukan di tabel lainnya. Tabel kiri dan kanan adalah tabel pertama dan kedua yang tercantum dalam sintaks. Nilai NULL digunakan untuk mengisi “celah” di set hasil. Kueri ini cocok dengan nilai kolom LISTID dalam tabel LISTING (tabel kiri) dan tabel PENJUALAN (tabel kanan). Hasilnya menunjukkan bahwa LISTIDs 2 dan 3 tidak menghasilkan penjualan apa pun. ``` select listing.listid, sum(pricepaid) as price, sum(commission) as comm from listing full join sales on sales.listid = listing.listid where listing.listid between 1 and 5 group by 1 order by 1; listid | price | comm -------+--------+-------- 1 | 728.00 | 109.20 2 | NULL | NULL 3 | NULL | NULL 4 | 76.00 | 11.40 5 | 525.00 | 78.75 ``` Kueri berikut adalah gabungan penuh. Kueri ini cocok dengan nilai kolom LISTID dalam tabel LISTING (tabel kiri) dan tabel PENJUALAN (tabel kanan). Hanya baris yang tidak menghasilkan penjualan apa pun (LISTIDs 2 dan 3) yang ada di hasil. ``` select listing.listid, sum(pricepaid) as price, sum(commission) as comm from listing full join sales on sales.listid = listing.listid where listing.listid between 1 and 5 and (listing.listid IS NULL or sales.listid IS NULL) group by 1 order by 1; listid | price | comm -------+--------+-------- 2 | NULL | NULL 3 | NULL | NULL ``` ## [KIRI] SEMI Mengembalikan nilai dari sisi kiri referensi tabel yang memiliki kecocokan dengan kanan. Ini juga disebut sebagai *semi join kiri*. Ia mengembalikan hanya baris dari tabel kiri (pertama) yang memiliki baris yang cocok di kanan (kedua) tabel. Itu tidak mengembalikan kolom apa pun dari tabel kanan - hanya kolom dari tabel kiri. LEFT SEMI JOIN berguna ketika Anda ingin menemukan baris dalam satu tabel yang memiliki kecocokan di tabel lain, tanpa perlu mengembalikan data apa pun dari tabel kedua. LEFT SEMI JOIN adalah alternatif yang lebih efisien untuk menggunakan subquery dengan klausa IN atau EXISTS. **Sintaksis:** ``` SELECT column1, column2, ..., columnn FROM table1 LEFT SEMI JOIN table2 ON table1.column = table2.column; ``` Kueri berikut akan mengembalikan hanya customer\$1id dan kolom nama dari tabel pelanggan, untuk pelanggan yang memiliki setidaknya satu pesanan dalam tabel pesanan. Set hasil tidak akan menyertakan kolom apa pun dari tabel pesanan. ``` SELECT customers.customer_id, customers.name FROM customers LEFT SEMI JOIN orders ON customers.customer_id = orders.customer_id; ``` ## CROSS JOIN Mengembalikan produk Cartesian dari dua hubungan. Ini berarti bahwa set hasil akan berisi semua kemungkinan kombinasi baris dari dua tabel, tanpa kondisi atau filter apa pun yang diterapkan. CROSS JOIN berguna ketika Anda perlu menghasilkan semua kemungkinan kombinasi data dari dua tabel, seperti dalam kasus membuat laporan yang menampilkan semua kemungkinan kombinasi informasi pelanggan dan produk. CROSS JOIN berbeda dengan tipe join lainnya (INNER JOIN, LEFT JOIN, dll.) Karena tidak memiliki kondisi gabungan dalam klausa ON. Kondisi bergabung tidak diperlukan untuk CROSS JOIN. **Sintaksis:** ``` SELECT column1, column2, ..., columnn FROM table1 CROSS JOIN table2; ``` Kueri berikut akan mengembalikan kumpulan hasil yang berisi semua kemungkinan kombinasi customer\$1id, customer\$1name, product\$1id, dan product\$1name dari tabel pelanggan dan produk. Jika tabel pelanggan memiliki 10 baris dan tabel produk memiliki 20 baris, set hasil CROSS JOIN akan berisi 10 x 20 = 200 baris. ``` SELECT customers.customer_id, customers.name, products.product_id, products.product_name FROM customers CROSS JOIN products; ``` Kueri berikut adalah gabungan silang atau gabungan Cartesian dari tabel LISTING dan tabel PENJUALAN dengan predikat untuk membatasi hasil. Kueri ini cocok dengan nilai kolom LISTID dalam tabel PENJUALAN dan tabel LISTING untuk LISTIDs 1, 2, 3, 4, dan 5 di kedua tabel. Hasilnya menunjukkan bahwa 20 baris cocok dengan kriteria. ``` select sales.listid as sales_listid, listing.listid as listing_listid from sales cross join listing where sales.listid between 1 and 5 and listing.listid between 1 and 5 order by 1,2; sales_listid | listing_listid -------------+--------------- 1 | 1 1 | 2 1 | 3 1 | 4 1 | 5 4 | 1 4 | 2 4 | 3 4 | 4 4 | 5 5 | 1 5 | 1 5 | 2 5 | 2 5 | 3 5 | 3 5 | 4 5 | 4 5 | 5 5 | 5 ``` ## ANTI BERGABUNG Mengembalikan nilai-nilai dari referensi tabel kiri yang tidak cocok dengan referensi tabel kanan. Ini juga disebut sebagai *anti join kiri*. ANTI JOIN adalah operasi yang berguna ketika Anda ingin menemukan baris dalam satu tabel yang tidak memiliki kecocokan di tabel lain. **Sintaksis:** ``` SELECT column1, column2, ..., columnn FROM table1 LEFT ANTI JOIN table2 ON table1.column = table2.column; ``` Kueri berikut akan mengembalikan semua pelanggan yang belum melakukan pemesanan. ``` SELECT customers.customer_id, customers.name FROM customers LEFT ANTI JOIN orders ON customers.customer_id = orders.customer_id WHERE orders.order_id IS NULL; ``` ## ALAMI Menentukan bahwa baris dari dua hubungan secara implisit akan dicocokkan pada kesetaraan untuk semua kolom dengan nama yang cocok. Secara otomatis mencocokkan kolom dengan nama dan tipe data yang sama antara dua tabel. Itu tidak mengharuskan Anda untuk secara eksplisit menentukan kondisi gabungan di klausa ON. Ini menggabungkan semua kolom yang cocok antara dua tabel ke dalam set hasil. NATURAL JOIN adalah singkatan yang nyaman ketika tabel yang Anda gabungkan memiliki kolom dengan nama dan tipe data yang sama. Namun, umumnya disarankan untuk menggunakan INNER JOIN yang lebih eksplisit... Sintaks ON untuk membuat kondisi gabungan lebih eksplisit dan lebih mudah dipahami. **Sintaksis:** ``` SELECT column1, column2, ..., columnn FROM table1 NATURAL JOIN table2; ``` Contoh berikut adalah gabungan alami antara dua tabel, `employees` dan`departments`, dengan kolom berikut: + `employees`tabel:`employee_id`,`first_name`,`last_name`, `department_id ` + `departments`meja:`department_id`, `department_name ` Kueri berikut akan mengembalikan kumpulan hasil yang mencakup nama depan, nama belakang, dan nama departemen untuk semua baris yang cocok antara dua tabel, berdasarkan `department_id` kolom. ``` SELECT e.first_name, e.last_name, d.department_name FROM employees e NATURAL JOIN departments d; ``` Contoh berikut adalah gabungan alami antara dua tabel. Dalam hal ini, kolom listid, sellerid, eventid, dan dateid memiliki nama dan tipe data yang identik di kedua tabel dan digunakan sebagai kolom gabungan. Hasilnya dibatasi hingga lima baris. ``` select listid, sellerid, eventid, dateid, numtickets from listing natural join sales order by 1 limit 5; listid | sellerid | eventid | dateid | numtickets -------+-----------+---------+--------+----------- 113 | 29704 | 4699 | 2075 | 22 115 | 39115 | 3513 | 2062 | 14 116 | 43314 | 8675 | 1910 | 28 118 | 6079 | 1611 | 1862 | 9 163 | 24880 | 8253 | 1888 | 14 ``` # Klausa WHERE Klausa WHERE berisi kondisi yang menggabungkan tabel atau menerapkan predikat ke kolom dalam tabel. Tabel dapat bergabung dalam dengan menggunakan sintaks yang sesuai baik dalam klausa WHERE atau klausa FROM. Kriteria gabungan luar harus ditentukan dalam klausa FROM. ## Sintaksis ``` [ WHERE condition ] ``` ## *ketentuan* Setiap kondisi pencarian dengan hasil Boolean, seperti kondisi gabungan atau predikat pada kolom tabel. Contoh berikut adalah ketentuan gabungan yang valid: ``` sales.listid=listing.listid sales.listid<>listing.listid ``` Contoh berikut adalah kondisi yang valid pada kolom dalam tabel: ``` catgroup like 'S%' venueseats between 20000 and 50000 eventname in('Jersey Boys','Spamalot') year=2008 length(catdesc)>25 date_part(month, caldate)=6 ``` Kondisi bisa sederhana atau kompleks; untuk kondisi kompleks, Anda dapat menggunakan tanda kurung untuk mengisolasi unit logis. Dalam contoh berikut, kondisi bergabung diapit oleh tanda kurung. ``` where (category.catid=event.catid) and category.catid in(6,7,8) ``` ## Catatan penggunaan Anda dapat menggunakan alias dalam klausa WHERE untuk referensi ekspresi daftar pilih. Anda tidak dapat membatasi hasil fungsi agregat dalam klausa WHERE; gunakan klausa HAVING untuk tujuan ini. Kolom yang dibatasi dalam klausa WHERE harus berasal dari referensi tabel dalam klausa FROM. ## Contoh Kueri berikut menggunakan kombinasi batasan klausa WHERE yang berbeda, termasuk kondisi gabungan untuk tabel PENJUALAN dan EVENT, predikat pada kolom EVENTNAME, dan dua predikat pada kolom STARTTIME. ``` select eventname, starttime, pricepaid/qtysold as costperticket, qtysold from sales, event where sales.eventid = event.eventid and eventname='Hannah Montana' and date_part(quarter, starttime) in(1,2) and date_part(year, starttime) = 2008 order by 3 desc, 4, 2, 1 limit 10; eventname | starttime | costperticket | qtysold ----------------+---------------------+-------------------+--------- Hannah Montana | 2008-06-07 14:00:00 | 1706.00000000 | 2 Hannah Montana | 2008-05-01 19:00:00 | 1658.00000000 | 2 Hannah Montana | 2008-06-07 14:00:00 | 1479.00000000 | 1 Hannah Montana | 2008-06-07 14:00:00 | 1479.00000000 | 3 Hannah Montana | 2008-06-07 14:00:00 | 1163.00000000 | 1 Hannah Montana | 2008-06-07 14:00:00 | 1163.00000000 | 2 Hannah Montana | 2008-06-07 14:00:00 | 1163.00000000 | 4 Hannah Montana | 2008-05-01 19:00:00 | 497.00000000 | 1 Hannah Montana | 2008-05-01 19:00:00 | 497.00000000 | 2 Hannah Montana | 2008-05-01 19:00:00 | 497.00000000 | 4 (10 rows) ``` # Klausa VALUES Klausa VALUES digunakan untuk menyediakan satu set nilai baris langsung dalam query, tanpa perlu referensi tabel. Klausa VALUES dapat digunakan dalam skenario berikut: + Anda dapat menggunakan klausa VALUES dalam pernyataan INSERT INTO untuk menentukan nilai untuk baris baru yang dimasukkan ke dalam tabel. + Anda dapat menggunakan klausa VALUES sendiri untuk membuat kumpulan hasil sementara, atau tabel sebaris, tanpa perlu mereferensikan tabel. + Anda dapat menggabungkan klausa VALUES dengan klausa SQL lainnya, seperti WHERE, ORDER BY, atau LIMIT, untuk memfilter, mengurutkan, atau membatasi baris dalam kumpulan hasil. Klausul ini sangat berguna ketika Anda perlu menyisipkan, menanyakan, atau memanipulasi sekumpulan kecil data secara langsung dalam pernyataan SQL Anda, tanpa perlu membuat atau mereferensikan tabel permanen. Ini memungkinkan Anda untuk menentukan nama kolom dan nilai yang sesuai untuk setiap baris, memberi Anda fleksibilitas untuk membuat set hasil sementara atau menyisipkan data dengan cepat, tanpa overhead mengelola tabel terpisah. ## Sintaksis ``` VALUES ( expression [ , ... ] ) [ table_alias ] ``` ## Parameter *ekspresi* Ekspresi yang menentukan kombinasi dari satu atau lebih nilai, operator dan fungsi SQL yang menghasilkan nilai. *table\$1alias* Alias yang menentukan nama sementara dengan daftar nama kolom opsional. ## Contoh Contoh berikut membuat tabel sebaris, hasil seperti tabel sementara yang diatur dengan dua kolom, dan. `col1` `col2` Baris tunggal dalam set hasil berisi nilai-nilai `"one"` dan`1`, masing-masing. `SELECT * FROM`Bagian dari query hanya mengambil semua kolom dan baris dari set hasil sementara ini. Nama kolom (`col1`dan`col2`) secara otomatis dihasilkan oleh sistem database, karena klausa VALUES tidak secara eksplisit menentukan nama kolom. ``` SELECT * FROM VALUES ("one", 1); +----+----+ |col1|col2| +----+----+ | one| 1| +----+----+ ``` Jika Anda ingin menentukan nama kolom kustom, Anda dapat melakukannya dengan menggunakan klausa AS setelah klausa VALUES, seperti ini: ``` SELECT * FROM (VALUES ("one", 1)) AS my_table (name, id); +------+----+ | name | id | +------+----+ | one | 1 | +------+----+ ``` Ini akan membuat set hasil sementara dengan nama kolom `name` dan`id`, bukan default `col1` dan`col2`. # Klausa GROUP BY Klausa GROUP BY mengidentifikasi kolom pengelompokan untuk kueri. Kolom pengelompokan harus dideklarasikan saat kueri menghitung agregat dengan fungsi standar seperti SUM, AVG, dan COUNT. Jika fungsi agregat hadir dalam ekspresi SELECT, kolom apa pun dalam ekspresi SELECT yang tidak dalam fungsi agregat harus berada dalam klausa GROUP BY. Untuk informasi selengkapnya, lihat [AWS Clean Rooms Fungsi Spark SQL](sql-functions-topic-spark.md). ## Sintaks ``` GROUP BY group_by_clause [, ...] group_by_clause := { expr | ROLLUP ( expr [, ...] ) | } ``` ## *Parameter* *expr* Daftar kolom atau ekspresi harus cocok dengan daftar ekspresi non-agregat dalam daftar pilih kueri. Misalnya, pertimbangkan kueri sederhana berikut. ``` select listid, eventid, sum(pricepaid) as revenue, count(qtysold) as numtix from sales group by listid, eventid order by 3, 4, 2, 1 limit 5; listid | eventid | revenue | numtix -------+---------+---------+-------- 89397 | 47 | 20.00 | 1 106590 | 76 | 20.00 | 1 124683 | 393 | 20.00 | 1 103037 | 403 | 20.00 | 1 147685 | 429 | 20.00 | 1 (5 rows) ``` Dalam kueri ini, daftar pilih terdiri dari dua ekspresi agregat. Yang pertama menggunakan fungsi SUM dan yang kedua menggunakan fungsi COUNT. Dua kolom yang tersisa, LISTID dan EVENTID, harus dinyatakan sebagai kolom pengelompokan. Ekspresi dalam klausa GROUP BY juga dapat mereferensikan daftar pilih dengan menggunakan nomor urut. Misalnya, contoh sebelumnya dapat disingkat sebagai berikut. ``` select listid, eventid, sum(pricepaid) as revenue, count(qtysold) as numtix from sales group by 1,2 order by 3, 4, 2, 1 limit 5; listid | eventid | revenue | numtix -------+---------+---------+-------- 89397 | 47 | 20.00 | 1 106590 | 76 | 20.00 | 1 124683 | 393 | 20.00 | 1 103037 | 403 | 20.00 | 1 147685 | 429 | 20.00 | 1 (5 rows) ``` *ROLLUP* Anda dapat menggunakan ekstensi agregasi ROLLUP untuk melakukan pekerjaan beberapa operasi GROUP BY dalam satu pernyataan. Untuk informasi selengkapnya tentang ekstensi agregasi dan fungsi terkait, lihat[Ekstensi agregasi](GROUP_BY_aggregation-extensions.md). # Ekstensi agregasi AWS Clean Rooms mendukung ekstensi agregasi untuk melakukan pekerjaan beberapa operasi GROUP BY dalam satu pernyataan. ## *SET PENGELOMPOKAN* Menghitung satu atau lebih kumpulan pengelompokan dalam satu pernyataan. Kumpulan pengelompokan adalah kumpulan klausa GROUP BY tunggal, satu set kolom 0 atau lebih yang dengannya Anda dapat mengelompokkan kumpulan hasil kueri. GROUP BY GROUPING SETS setara dengan menjalankan query UNION ALL pada satu set hasil yang dikelompokkan berdasarkan kolom yang berbeda. Misalnya, GROUP BY GROUPING SETS ((a), (b)) setara dengan GROUP BY a UNION ALL GROUP BY b. Contoh berikut mengembalikan biaya produk tabel pesanan dikelompokkan sesuai dengan kategori produk dan jenis produk yang dijual. ``` SELECT category, product, sum(cost) as total FROM orders GROUP BY GROUPING SETS(category, product); category | product | total ----------------------+----------------------+------- computers | | 2100 cellphones | | 1610 | laptop | 2050 | smartphone | 1610 | mouse | 50 (5 rows) ``` ## *ROLLUP* Mengasumsikan hierarki di mana kolom sebelumnya dianggap sebagai orang tua dari kolom berikutnya. ROLLUP mengelompokkan data berdasarkan kolom yang disediakan, mengembalikan baris subtotal tambahan yang mewakili total di semua tingkat kolom pengelompokan, selain baris yang dikelompokkan. Misalnya, Anda dapat menggunakan GROUP BY ROLLUP ((a), (b)) untuk mengembalikan kumpulan hasil yang dikelompokkan terlebih dahulu oleh a, kemudian oleh b sambil mengasumsikan bahwa b adalah ayat dari a. ROLLUP juga mengembalikan baris dengan seluruh hasil yang ditetapkan tanpa pengelompokan kolom. GROUP BY ROLLUP ((a), (b)) setara dengan GROUP BY GROUPING SETS ((a, b), (a), ()). Contoh berikut mengembalikan biaya produk tabel pesanan dikelompokkan pertama berdasarkan kategori dan kemudian produk, dengan produk sebagai subdivisi kategori. ``` SELECT category, product, sum(cost) as total FROM orders GROUP BY ROLLUP(category, product) ORDER BY 1,2; category | product | total ----------------------+----------------------+------- cellphones | smartphone | 1610 cellphones | | 1610 computers | laptop | 2050 computers | mouse | 50 computers | | 2100 | | 3710 (6 rows) ``` ## *KUBUS* Kelompokkan data berdasarkan kolom yang disediakan, mengembalikan baris subtotal tambahan yang mewakili total di semua tingkat kolom pengelompokan, selain baris yang dikelompokkan. CUBE mengembalikan baris yang sama dengan ROLLUP, sambil menambahkan baris subtotal tambahan untuk setiap kombinasi kolom pengelompokan yang tidak dicakup oleh ROLLUP. Misalnya, Anda dapat menggunakan GROUP BY CUBE ((a), (b)) untuk mengembalikan kumpulan hasil yang dikelompokkan terlebih dahulu oleh a, kemudian oleh b sambil mengasumsikan bahwa b adalah subbagian dari a, lalu oleh b saja. CUBE juga mengembalikan baris dengan seluruh hasil yang ditetapkan tanpa pengelompokan kolom. GROUP BY CUBE ((a), (b)) setara dengan GROUP BY GROUPING SETS ((a, b), (a), (b), ()). Contoh berikut mengembalikan biaya produk tabel pesanan dikelompokkan pertama berdasarkan kategori dan kemudian produk, dengan produk sebagai subdivisi kategori. Berbeda dengan contoh sebelumnya untuk ROLLUP, pernyataan mengembalikan hasil untuk setiap kombinasi kolom pengelompokan. ``` SELECT category, product, sum(cost) as total FROM orders GROUP BY CUBE(category, product) ORDER BY 1,2; category | product | total ----------------------+----------------------+------- cellphones | smartphone | 1610 cellphones | | 1610 computers | laptop | 2050 computers | mouse | 50 computers | | 2100 | laptop | 2050 | mouse | 50 | smartphone | 1610 | | 3710 (9 rows) ``` # Klausa HAVING Klausa HAVING menerapkan kondisi untuk kumpulan hasil dikelompokkan menengah yang dikembalikan kueri. ## Sintaksis ``` [ HAVING condition ] ``` Misalnya, Anda dapat membatasi hasil fungsi SUM: ``` having sum(pricepaid) >10000 ``` Kondisi HAVING diterapkan setelah semua kondisi klausa WHERE diterapkan dan operasi GROUP BY selesai. Kondisi itu sendiri mengambil bentuk yang sama dengan kondisi klausa WHERE. ## Catatan penggunaan + Setiap kolom yang direferensikan dalam kondisi klausa HAVING harus berupa kolom pengelompokan atau kolom yang mengacu pada hasil fungsi agregat. + Dalam klausa HAVING, Anda tidak dapat menentukan: + Nomor urut yang mengacu pada item daftar pilih. Hanya klausa GROUP BY dan ORDER BY yang menerima nomor urut. ## Contoh Kueri berikut menghitung total penjualan tiket untuk semua acara berdasarkan nama, kemudian menghilangkan peristiwa di mana total penjualan kurang dari \$1800.000. Kondisi HAVING diterapkan pada hasil fungsi agregat dalam daftar pilih:`sum(pricepaid)`. ``` select eventname, sum(pricepaid) from sales join event on sales.eventid = event.eventid group by 1 having sum(pricepaid) > 800000 order by 2 desc, 1; eventname | sum ------------------+----------- Mamma Mia! | 1135454.00 Spring Awakening | 972855.00 The Country Girl | 910563.00 Macbeth | 862580.00 Jersey Boys | 811877.00 Legally Blonde | 804583.00 (6 rows) ``` Query berikut menghitung set hasil yang sama. Namun, dalam kasus ini, kondisi HAVING diterapkan ke agregat yang tidak ditentukan dalam daftar pilih:`sum(qtysold)`. Acara yang tidak menjual lebih dari 2.000 tiket dihilangkan dari hasil akhir. ``` select eventname, sum(pricepaid) from sales join event on sales.eventid = event.eventid group by 1 having sum(qtysold) >2000 order by 2 desc, 1; eventname | sum ------------------+----------- Mamma Mia! | 1135454.00 Spring Awakening | 972855.00 The Country Girl | 910563.00 Macbeth | 862580.00 Jersey Boys | 811877.00 Legally Blonde | 804583.00 Chicago | 790993.00 Spamalot | 714307.00 (8 rows) ``` # Tetapkan operator *Operator set* digunakan untuk membandingkan dan menggabungkan hasil dari dua ekspresi kueri terpisah. AWS Clean Rooms Spark SQL mendukung operator set berikut yang tercantum dalam tabel berikut. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/clean-rooms/latest/sql-reference/UNION.html) Misalnya, jika Anda ingin mengetahui pengguna situs web mana yang merupakan pembeli dan penjual tetapi nama pengguna mereka disimpan dalam kolom atau tabel terpisah, Anda dapat menemukan *persimpangan* kedua jenis pengguna ini. Jika Anda ingin tahu pengguna situs web mana yang merupakan pembeli tetapi bukan penjual, Anda dapat menggunakan operator EXCEPT untuk menemukan *perbedaan* antara dua daftar pengguna. Jika Anda ingin membuat daftar semua pengguna, apa pun perannya, Anda dapat menggunakan operator UNION. **catatan** Klausa ORDER BY, LIMIT, SELECT TOP, dan OFFSET tidak dapat digunakan dalam ekspresi kueri yang digabungkan oleh operator set UNION, UNION ALL, INTERSECT, dan EXCEPT. **Topics** + [Sintaksis](#UNION-synopsis) + [Parameter](#UNION-parameters) + [Urutan evaluasi untuk operator yang ditetapkan](#UNION-order-of-evaluation-for-set-operators) + [Catatan penggunaan](#UNION-usage-notes) + [Contoh kueri UNION](example_union_query.md) + [Contoh UNION ALL query](example_unionall_query.md) + [Contoh pertanyaan INTERSECT](example_intersect_query.md) + [Contoh KECUALI kueri](Example_EXCEPT_query.md) ## Sintaksis ``` subquery1 { { UNION [ ALL | DISTINCT ] | INTERSECT [ ALL | DISTINCT ] | EXCEPT [ ALL | DISTINCT ] } subquery2 } [...] } ``` ## Parameter *subkueri1, subkueri2* Ekspresi kueri yang sesuai, dalam bentuk daftar pilihannya, dengan ekspresi kueri kedua yang mengikuti operator UNION, UNION ALL, INTERSECT, INTERSECT ALL, KECUALI, atau KECUALI SEMUA. Kedua ekspresi harus berisi jumlah kolom keluaran yang sama dengan tipe data yang kompatibel; jika tidak, dua set hasil tidak dapat dibandingkan dan digabungkan. Operasi set tidak memungkinkan konversi implisit antara berbagai kategori tipe data. Untuk informasi selengkapnya, lihat [Ketik kompatibilitas dan konversi](s_Type_conversion.md). Anda dapat membuat kueri yang berisi ekspresi kueri dalam jumlah tak terbatas dan menautkannya dengan operator UNION, INTERSECT, dan EXCEPT dalam kombinasi apa pun. Misalnya, struktur kueri berikut ini valid, dengan asumsi bahwa tabel T1, T2, dan T3 berisi kumpulan kolom yang kompatibel: ``` select * from t1 union select * from t2 except select * from t3 ``` SERIKAT [SEMUA \$1 BERBEDA] Mengatur operasi yang mengembalikan baris dari dua ekspresi query, terlepas dari apakah baris berasal dari satu atau kedua ekspresi. BERPOTONGAN [SEMUA \$1 BERBEDA] Mengatur operasi yang mengembalikan baris yang berasal dari dua ekspresi query. Baris yang tidak dikembalikan oleh kedua ekspresi akan dibuang. KECUALI [SEMUA \$1 BERBEDA] Mengatur operasi yang mengembalikan baris yang berasal dari salah satu dari dua ekspresi query. Agar memenuhi syarat untuk hasil, baris harus ada di tabel hasil pertama tetapi bukan yang kedua. KECUALI SEMUA tidak menghapus duplikat dari baris hasil. MINUS dan EXCEPT adalah sinonim yang tepat. ## Urutan evaluasi untuk operator yang ditetapkan Operator set UNION dan EXCEPLE adalah asosiatif kiri. Jika tanda kurung tidak ditentukan untuk mempengaruhi urutan prioritas, kombinasi dari operator set ini dievaluasi dari kiri ke kanan. Misalnya, dalam kueri berikut, UNION T1 dan T2 dievaluasi terlebih dahulu, kemudian operasi EXCEPT dilakukan pada hasil UNION: ``` select * from t1 union select * from t2 except select * from t3 ``` Operator INTERSECT lebih diutamakan daripada operator UNION dan EXCEPT ketika kombinasi operator digunakan dalam kueri yang sama. Misalnya, kueri berikut mengevaluasi persimpangan T2 dan T3, lalu menyatukan hasilnya dengan T1: ``` select * from t1 union select * from t2 intersect select * from t3 ``` Dengan menambahkan tanda kurung, Anda dapat menerapkan urutan evaluasi yang berbeda. Dalam kasus berikut, hasil penyatuan T1 dan T2 berpotongan dengan T3, dan kueri kemungkinan akan menghasilkan hasil yang berbeda. ``` (select * from t1 union select * from t2) intersect (select * from t3) ``` ## Catatan penggunaan + Nama kolom yang dikembalikan dalam hasil kueri operasi set adalah nama kolom (atau alias) dari tabel dalam ekspresi kueri pertama. Karena nama kolom ini berpotensi menyesatkan, karena nilai dalam kolom berasal dari tabel di kedua sisi operator set, Anda mungkin ingin memberikan alias yang berarti untuk kumpulan hasil. + Ketika kueri operator yang disetel mengembalikan hasil desimal, kolom hasil yang sesuai dipromosikan untuk mengembalikan presisi dan skala yang sama. Misalnya, dalam kueri berikut, di mana T1.REVENUE adalah kolom DECIMAL (10,2) dan T2.REVENUE adalah kolom DECIMAL (8,4), hasil desimal dipromosikan ke DECIMAL (12,4): ``` select t1.revenue union select t2.revenue; ``` Skala ini `4` karena itu adalah skala maksimum dari dua kolom. Ketepatannya adalah `12` karena T1.REVENUE membutuhkan 8 digit di sebelah kiri titik desimal (12 - 4 = 8). Promosi jenis ini memastikan bahwa semua nilai dari kedua sisi UNION sesuai dengan hasilnya. Untuk nilai 64-bit, presisi hasil maksimum adalah 19 dan skala hasil maksimum adalah 18. Untuk nilai 128-bit, presisi hasil maksimum adalah 38 dan skala hasil maksimum adalah 37. Jika tipe data yang dihasilkan melebihi AWS Clean Rooms presisi dan batas skala, kueri mengembalikan kesalahan. + Untuk operasi set, dua baris diperlakukan sebagai identik jika, untuk setiap pasangan kolom yang sesuai, dua nilai data *sama* atau *keduanya NULL*. Misalnya, jika tabel T1 dan T2 keduanya berisi satu kolom dan satu baris, dan baris itu adalah NULL di kedua tabel, operasi INTERSECT di atas tabel tersebut mengembalikan baris itu. # Contoh kueri UNION Dalam query UNION berikut, baris dalam tabel PENJUALAN digabungkan dengan baris dalam tabel LISTING. Tiga kolom yang kompatibel dipilih dari setiap tabel; dalam hal ini, kolom yang sesuai memiliki nama dan tipe data yang sama. ``` select listid, sellerid, eventid from listing union select listid, sellerid, eventid from sales listid | sellerid | eventid --------+----------+--------- 1 | 36861 | 7872 2 | 16002 | 4806 3 | 21461 | 4256 4 | 8117 | 4337 5 | 1616 | 8647 ``` Contoh berikut menunjukkan bagaimana Anda dapat menambahkan nilai literal untuk output dari query UNION sehingga Anda dapat melihat ekspresi query yang dihasilkan setiap baris dalam set hasil. Kueri mengidentifikasi baris dari ekspresi kueri pertama sebagai “B” (untuk pembeli) dan baris dari ekspresi kueri kedua sebagai “S” (untuk penjual). Kueri mengidentifikasi pembeli dan penjual untuk transaksi tiket yang harganya \$110.000 atau lebih. Satu-satunya perbedaan antara dua ekspresi kueri di kedua sisi operator UNION adalah kolom bergabung untuk tabel PENJUALAN. ``` select listid, lastname, firstname, username, pricepaid as price, 'S' as buyorsell from sales, users where sales.sellerid=users.userid and pricepaid >=10000 union select listid, lastname, firstname, username, pricepaid, 'B' as buyorsell from sales, users where sales.buyerid=users.userid and pricepaid >=10000 listid | lastname | firstname | username | price | buyorsell --------+----------+-----------+----------+-----------+----------- 209658 | Lamb | Colette | VOR15LYI | 10000.00 | B 209658 | West | Kato | ELU81XAA | 10000.00 | S 212395 | Greer | Harlan | GXO71KOC | 12624.00 | S 212395 | Perry | Cora | YWR73YNZ | 12624.00 | B 215156 | Banks | Patrick | ZNQ69CLT | 10000.00 | S 215156 | Hayden | Malachi | BBG56AKU | 10000.00 | B ``` Contoh berikut menggunakan operator UNION ALL karena baris duplikat, jika ditemukan, perlu dipertahankan dalam hasilnya. Untuk rangkaian acara tertentu IDs, kueri mengembalikan 0 atau lebih baris untuk setiap penjualan yang terkait dengan setiap acara, dan 0 atau 1 baris untuk setiap daftar acara tersebut. Acara IDs unik untuk setiap baris dalam tabel LISTING dan EVENT, tetapi mungkin ada beberapa penjualan untuk kombinasi acara dan daftar yang sama IDs di tabel PENJUALAN. Kolom ketiga dalam set hasil mengidentifikasi sumber baris. Jika berasal dari tabel PENJUALAN, itu ditandai “Ya” di kolom SALESROW. (SALESROW adalah alias untuk SALES.LISTID.) Jika baris berasal dari tabel LISTING, itu ditandai “Tidak” di kolom SALESROW. Dalam hal ini, set hasil terdiri dari tiga baris penjualan untuk daftar 500, acara 7787. Dengan kata lain, tiga transaksi berbeda terjadi untuk daftar dan kombinasi acara ini. Dua daftar lainnya, 501 dan 502, tidak menghasilkan penjualan apa pun, jadi satu-satunya baris yang dihasilkan kueri untuk daftar ini IDs berasal dari tabel LISTING (SALESROW = 'Tidak'). ``` select eventid, listid, 'Yes' as salesrow from sales where listid in(500,501,502) union all select eventid, listid, 'No' from listing where listid in(500,501,502) eventid | listid | salesrow ---------+--------+---------- 7787 | 500 | No 7787 | 500 | Yes 7787 | 500 | Yes 7787 | 500 | Yes 6473 | 501 | No 5108 | 502 | No ``` Jika Anda menjalankan kueri yang sama tanpa kata kunci ALL, hasilnya hanya mempertahankan satu transaksi penjualan. ``` select eventid, listid, 'Yes' as salesrow from sales where listid in(500,501,502) union select eventid, listid, 'No' from listing where listid in(500,501,502) eventid | listid | salesrow ---------+--------+---------- 7787 | 500 | No 7787 | 500 | Yes 6473 | 501 | No 5108 | 502 | No ``` # Contoh UNION ALL query Contoh berikut menggunakan operator UNION ALL karena baris duplikat, jika ditemukan, perlu dipertahankan dalam hasilnya. Untuk rangkaian acara tertentu IDs, kueri mengembalikan 0 atau lebih baris untuk setiap penjualan yang terkait dengan setiap acara, dan 0 atau 1 baris untuk setiap daftar acara tersebut. Acara IDs unik untuk setiap baris dalam tabel LISTING dan EVENT, tetapi mungkin ada beberapa penjualan untuk kombinasi acara dan daftar yang sama IDs di tabel PENJUALAN. Kolom ketiga dalam set hasil mengidentifikasi sumber baris. Jika berasal dari tabel PENJUALAN, itu ditandai “Ya” di kolom SALESROW. (SALESROW adalah alias untuk SALES.LISTID.) Jika baris berasal dari tabel LISTING, itu ditandai “Tidak” di kolom SALESROW. Dalam hal ini, set hasil terdiri dari tiga baris penjualan untuk daftar 500, acara 7787. Dengan kata lain, tiga transaksi berbeda terjadi untuk daftar dan kombinasi acara ini. Dua daftar lainnya, 501 dan 502, tidak menghasilkan penjualan apa pun, jadi satu-satunya baris yang dihasilkan kueri untuk daftar ini IDs berasal dari tabel LISTING (SALESROW = 'Tidak'). ``` select eventid, listid, 'Yes' as salesrow from sales where listid in(500,501,502) union all select eventid, listid, 'No' from listing where listid in(500,501,502) eventid | listid | salesrow ---------+--------+---------- 7787 | 500 | No 7787 | 500 | Yes 7787 | 500 | Yes 7787 | 500 | Yes 6473 | 501 | No 5108 | 502 | No ``` Jika Anda menjalankan kueri yang sama tanpa kata kunci ALL, hasilnya hanya mempertahankan satu transaksi penjualan. ``` select eventid, listid, 'Yes' as salesrow from sales where listid in(500,501,502) union select eventid, listid, 'No' from listing where listid in(500,501,502) eventid | listid | salesrow ---------+--------+---------- 7787 | 500 | No 7787 | 500 | Yes 6473 | 501 | No 5108 | 502 | No ``` # Contoh pertanyaan INTERSECT Bandingkan contoh berikut dengan contoh UNION pertama. Satu-satunya perbedaan antara kedua contoh adalah operator set yang digunakan, tetapi hasilnya sangat berbeda. Hanya satu baris yang sama: ``` 235494 | 23875 | 8771 ``` Ini adalah satu-satunya baris dalam hasil terbatas dari 5 baris yang ditemukan di kedua tabel. ``` select listid, sellerid, eventid from listing intersect select listid, sellerid, eventid from sales listid | sellerid | eventid --------+----------+--------- 235494 | 23875 | 8771 235482 | 1067 | 2667 235479 | 1589 | 7303 235476 | 15550 | 793 235475 | 22306 | 7848 ``` Pertanyaan berikut menemukan peristiwa (yang tiketnya terjual) yang terjadi di tempat-tempat di New York City dan Los Angeles pada bulan Maret. Perbedaan antara dua ekspresi kueri adalah kendala pada kolom VENUECITY. ``` select distinct eventname from event, sales, venue where event.eventid=sales.eventid and event.venueid=venue.venueid and date_part(month,starttime)=3 and venuecity='Los Angeles' intersect select distinct eventname from event, sales, venue where event.eventid=sales.eventid and event.venueid=venue.venueid and date_part(month,starttime)=3 and venuecity='New York City'; eventname ---------------------------- A Streetcar Named Desire Dirty Dancing Electra Running with Annalise Hairspray Mary Poppins November Oliver! Return To Forever Rhinoceros South Pacific The 39 Steps The Bacchae The Caucasian Chalk Circle The Country Girl Wicked Woyzeck ``` # Contoh KECUALI kueri Tabel CATEGORY dalam database berisi 11 baris berikut: ``` catid | catgroup | catname | catdesc -------+----------+-----------+-------------------------------------------- 1 | Sports | MLB | Major League Baseball 2 | Sports | NHL | National Hockey League 3 | Sports | NFL | National Football League 4 | Sports | NBA | National Basketball Association 5 | Sports | MLS | Major League Soccer 6 | Shows | Musicals | Musical theatre 7 | Shows | Plays | All non-musical theatre 8 | Shows | Opera | All opera and light opera 9 | Concerts | Pop | All rock and pop music concerts 10 | Concerts | Jazz | All jazz singers and bands 11 | Concerts | Classical | All symphony, concerto, and choir concerts (11 rows) ``` Asumsikan bahwa tabel CATEGORY\$1STAGE (tabel pementasan) berisi satu baris tambahan: ``` catid | catgroup | catname | catdesc -------+----------+-----------+-------------------------------------------- 1 | Sports | MLB | Major League Baseball 2 | Sports | NHL | National Hockey League 3 | Sports | NFL | National Football League 4 | Sports | NBA | National Basketball Association 5 | Sports | MLS | Major League Soccer 6 | Shows | Musicals | Musical theatre 7 | Shows | Plays | All non-musical theatre 8 | Shows | Opera | All opera and light opera 9 | Concerts | Pop | All rock and pop music concerts 10 | Concerts | Jazz | All jazz singers and bands 11 | Concerts | Classical | All symphony, concerto, and choir concerts 12 | Concerts | Comedy | All stand up comedy performances (12 rows) ``` Kembalikan perbedaan antara dua tabel. Dengan kata lain, kembalikan baris yang ada di tabel CATEGORY\$1STAGE tetapi tidak di tabel CATEGORY: ``` select * from category_stage except select * from category; catid | catgroup | catname | catdesc -------+----------+---------+---------------------------------- 12 | Concerts | Comedy | All stand up comedy performances (1 row) ``` Kueri setara berikut menggunakan sinonim MINUS. ``` select * from category_stage minus select * from category; catid | catgroup | catname | catdesc -------+----------+---------+---------------------------------- 12 | Concerts | Comedy | All stand up comedy performances (1 row) ``` Jika Anda membalikkan urutan ekspresi SELECT, kueri tidak mengembalikan baris. # Klausa ORDER BY Klausa ORDER BY mengurutkan kumpulan hasil kueri. **catatan** Ekspresi ORDER BY terluar harus hanya memiliki kolom yang ada di daftar pilih. **Topics** + [Sintaksis](#ORDER_BY_clause-synopsis) + [Parameter](#ORDER_BY_clause-parameters) + [Catatan penggunaan](#ORDER_BY_usage_notes) + [Contoh dengan ORDER BY](Examples_with_ORDER_BY.md) ## Sintaksis ``` [ ORDER BY expression [ ASC | DESC ] ] [ NULLS FIRST | NULLS LAST ] [ LIMIT { count | ALL } ] [ OFFSET start ] ``` ## Parameter *ekspresi* Ekspresi yang mendefinisikan urutan pengurutan hasil query. Ini terdiri dari satu atau lebih kolom dalam daftar pilih. Hasil dikembalikan berdasarkan urutan UTF-8 biner. Anda juga dapat menentukan yang berikut: + Nomor urut yang mewakili posisi entri daftar pilih (atau posisi kolom dalam tabel jika tidak ada daftar pilih) + Alias yang menentukan entri daftar pilih Ketika klausa ORDER BY berisi beberapa ekspresi, kumpulan hasil diurutkan menurut ekspresi pertama, maka ekspresi kedua diterapkan ke baris yang memiliki nilai yang cocok dari ekspresi pertama, dan seterusnya. ASC \$1 DESC Opsi yang mendefinisikan urutan pengurutan untuk ekspresi, sebagai berikut: + ASC: naik (misalnya, rendah ke tinggi untuk nilai numerik dan 'A' ke 'Z' untuk string karakter). Jika tidak ada opsi yang ditentukan, data diurutkan dalam urutan menaik secara default. + DESC: turun (tinggi ke rendah untuk nilai numerik; 'Z' ke 'A' untuk string). NULLS PERTAMA \$1 NULLS TERAKHIR Opsi yang menentukan apakah nilai NULL harus diurutkan terlebih dahulu, sebelum nilai non-null, atau terakhir, setelah nilai non-null. Secara default, nilai NULL diurutkan dan diberi peringkat terakhir dalam urutan ASC, dan diurutkan dan diberi peringkat pertama dalam urutan DESC. BATASAN *nomor* \$1 SEMUA Opsi yang mengontrol jumlah baris yang diurutkan yang dikembalikan kueri. Bilangan LIMIT harus berupa bilangan bulat positif; nilai maksimumnya adalah`2147483647`. LIMIT 0 tidak mengembalikan baris. Anda dapat menggunakan sintaks ini untuk tujuan pengujian: untuk memeriksa apakah kueri berjalan (tanpa menampilkan baris apa pun) atau mengembalikan daftar kolom dari tabel. Klausa ORDER BY berlebihan jika Anda menggunakan LIMIT 0 untuk mengembalikan daftar kolom. Defaultnya adalah LIMIT ALL. *OFFSET mulai* Opsi yang menentukan untuk melewati jumlah baris sebelum *memulai sebelum mulai* mengembalikan baris. Nomor OFFSET harus berupa bilangan bulat positif; nilai maksimumnya adalah. `2147483647` Saat digunakan dengan opsi LIMIT, baris OFFSET dilewati sebelum mulai menghitung baris LIMIT yang dikembalikan. Jika opsi LIMIT tidak digunakan, jumlah baris dalam kumpulan hasil dikurangi dengan jumlah baris yang dilewati. Baris yang dilewati oleh klausa OFFSET masih harus dipindai, jadi mungkin tidak efisien untuk menggunakan nilai OFFSET yang besar. ## Catatan penggunaan Perhatikan perilaku yang diharapkan berikut dengan klausa ORDER BY: + Nilai NULL dianggap “lebih tinggi” dari semua nilai lainnya. Dengan urutan urutan menaik default, nilai NULL mengurutkan di akhir. Untuk mengubah perilaku ini, gunakan opsi NULLS FIRST. + Ketika kueri tidak berisi klausa ORDER BY, sistem mengembalikan set hasil tanpa urutan baris yang dapat diprediksi. Kueri yang sama dijalankan dua kali mungkin mengembalikan set hasil dalam urutan yang berbeda. + Opsi LIMIT dan OFFSET dapat digunakan tanpa klausa ORDER BY; namun, untuk mengembalikan serangkaian baris yang konsisten, gunakan opsi ini bersama dengan ORDER BY. + Dalam sistem parallel seperti AWS Clean Rooms, ketika ORDER BY tidak menghasilkan urutan yang unik, urutan baris adalah nondeterministik. Artinya, jika ekspresi ORDER BY menghasilkan nilai duplikat, urutan pengembalian baris tersebut mungkin berbeda dari sistem lain atau dari satu proses AWS Clean Rooms ke yang berikutnya. + AWS Clean Rooms tidak mendukung literal string dalam klausa ORDER BY. # Contoh dengan ORDER BY Kembalikan semua 11 baris dari tabel KATEGORI, diurutkan berdasarkan kolom kedua, CATGROUP. Untuk hasil yang memiliki nilai CATGROUP yang sama, urutkan nilai kolom CATDESC dengan panjang string karakter. Kemudian urutkan berdasarkan kolom CATID dan CATNAME. ``` select * from category order by 2, 1, 3; catid | catgroup | catname | catdesc -------+----------+-----------+---------------------------------------- 10 | Concerts | Jazz | All jazz singers and bands 9 | Concerts | Pop | All rock and pop music concerts 11 | Concerts | Classical | All symphony, concerto, and choir conce 6 | Shows | Musicals | Musical theatre 7 | Shows | Plays | All non-musical theatre 8 | Shows | Opera | All opera and light opera 5 | Sports | MLS | Major League Soccer 1 | Sports | MLB | Major League Baseball 2 | Sports | NHL | National Hockey League 3 | Sports | NFL | National Football League 4 | Sports | NBA | National Basketball Association (11 rows) ``` Kembalikan kolom yang dipilih dari tabel PENJUALAN, diurutkan berdasarkan nilai QTYSOLD tertinggi. Batasi hasilnya ke 10 baris teratas: ``` select salesid, qtysold, pricepaid, commission, saletime from sales order by qtysold, pricepaid, commission, salesid, saletime desc salesid | qtysold | pricepaid | commission | saletime ---------+---------+-----------+------------+--------------------- 15401 | 8 | 272.00 | 40.80 | 2008-03-18 06:54:56 61683 | 8 | 296.00 | 44.40 | 2008-11-26 04:00:23 90528 | 8 | 328.00 | 49.20 | 2008-06-11 02:38:09 74549 | 8 | 336.00 | 50.40 | 2008-01-19 12:01:21 130232 | 8 | 352.00 | 52.80 | 2008-05-02 05:52:31 55243 | 8 | 384.00 | 57.60 | 2008-07-12 02:19:53 16004 | 8 | 440.00 | 66.00 | 2008-11-04 07:22:31 489 | 8 | 496.00 | 74.40 | 2008-08-03 05:48:55 4197 | 8 | 512.00 | 76.80 | 2008-03-23 11:35:33 16929 | 8 | 568.00 | 85.20 | 2008-12-19 02:59:33 ``` Kembalikan daftar kolom dan tidak ada baris dengan menggunakan sintaks LIMIT 0: ``` select * from venue limit 0; venueid | venuename | venuecity | venuestate | venueseats ---------+-----------+-----------+------------+------------ (0 rows) ``` # Contoh subquery Contoh berikut menunjukkan cara yang berbeda di mana subquery cocok dengan kueri SELECT. Lihat [Contoh](join-clause.md#Join_examples) contoh lain dari penggunaan subquery. ## PILIH daftar subquery Contoh berikut berisi subquery dalam daftar SELECT. Subquery ini adalah *skalar*: ia mengembalikan hanya satu kolom dan satu nilai, yang diulang dalam hasil untuk setiap baris yang dikembalikan dari query luar. Kueri membandingkan nilai Q1SALES yang dihitung subquery dengan nilai penjualan untuk dua kuartal lainnya (2 dan 3) pada tahun 2008, seperti yang didefinisikan oleh kueri luar. ``` select qtr, sum(pricepaid) as qtrsales, (select sum(pricepaid) from sales join date on sales.dateid=date.dateid where qtr='1' and year=2008) as q1sales from sales join date on sales.dateid=date.dateid where qtr in('2','3') and year=2008 group by qtr order by qtr; qtr | qtrsales | q1sales -------+-------------+------------- 2 | 30560050.00 | 24742065.00 3 | 31170237.00 | 24742065.00 (2 rows) ``` ## Subquery klausa WHERE Contoh berikut berisi subquery tabel dalam klausa WHERE. Subquery ini menghasilkan beberapa baris. Dalam hal ini, baris hanya berisi satu kolom, tetapi subquery tabel dapat berisi beberapa kolom dan baris, sama seperti tabel lainnya. Kueri menemukan 10 penjual teratas dalam hal tiket maksimum yang terjual. Daftar 10 teratas dibatasi oleh subquery, yang menghapus pengguna yang tinggal di kota di mana ada tempat tiket. Kueri ini dapat ditulis dengan cara yang berbeda; misalnya, subquery dapat ditulis ulang sebagai gabungan dalam kueri utama. ``` select firstname, lastname, city, max(qtysold) as maxsold from users join sales on users.userid=sales.sellerid where users.city not in(select venuecity from venue) group by firstname, lastname, city order by maxsold desc, city desc limit 10; firstname | lastname | city | maxsold -----------+-----------+----------------+--------- Noah | Guerrero | Worcester | 8 Isadora | Moss | Winooski | 8 Kieran | Harrison | Westminster | 8 Heidi | Davis | Warwick | 8 Sara | Anthony | Waco | 8 Bree | Buck | Valdez | 8 Evangeline | Sampson | Trenton | 8 Kendall | Keith | Stillwater | 8 Bertha | Bishop | Stevens Point | 8 Patricia | Anderson | South Portland | 8 (10 rows) ``` ## DENGAN subquery klausa Lihat [DENGAN klausa](WITH_clause.md). # Subquery berkorelasi Contoh berikut berisi *subquery berkorelasi* dalam klausa WHERE; subquery semacam ini berisi satu atau lebih korelasi antara kolom dan kolom yang dihasilkan oleh kueri luar. Dalam hal ini, korelasinya adalah`where s.listid=l.listid`. Untuk setiap baris yang dihasilkan kueri luar, subquery dijalankan untuk memenuhi syarat atau mendiskualifikasi baris. ``` select salesid, listid, sum(pricepaid) from sales s where qtysold= (select max(numtickets) from listing l where s.listid=l.listid) group by 1,2 order by 1,2 limit 5; salesid | listid | sum --------+--------+---------- 27 | 28 | 111.00 81 | 103 | 181.00 142 | 149 | 240.00 146 | 152 | 231.00 194 | 210 | 144.00 (5 rows) ``` ## Pola subquery berkorelasi yang tidak didukung Perencana kueri menggunakan metode penulisan ulang kueri yang disebut decorrelation subquery untuk mengoptimalkan beberapa pola subquery berkorelasi untuk eksekusi di lingkungan MPP. Beberapa jenis subkueri berkorelasi mengikuti pola yang tidak AWS Clean Rooms dapat mendekorasi dan tidak mendukung. Kueri yang berisi referensi korelasi berikut mengembalikan kesalahan: + Referensi korelasi yang melewati blok kueri, juga dikenal sebagai “referensi korelasi tingkat lewati.” Misalnya, dalam kueri berikut, blok yang berisi referensi korelasi dan blok yang dilewati dihubungkan oleh predikat NOT EXISTS: ``` select event.eventname from event where not exists (select * from listing where not exists (select * from sales where event.eventid=sales.eventid)); ``` Blok yang dilewati dalam kasus ini adalah subquery terhadap tabel LISTING. Referensi korelasi menghubungkan tabel EVENT dan SALES. + Referensi korelasi dari subquery yang merupakan bagian dari klausa ON dalam kueri luar: ``` select * from category left join event on category.catid=event.catid and eventid = (select max(eventid) from sales where sales.eventid=event.eventid); ``` Klausa ON berisi referensi korelasi dari SALES di subquery ke EVENT di kueri luar. + Referensi korelasi sensitif nol ke tabel sistem. AWS Clean Rooms Contoh: ``` select attrelid from my_locks sl, my_attribute where sl.table_id=my_attribute.attrelid and 1 not in (select 1 from my_opclass where sl.lock_owner = opcowner); ``` + Referensi korelasi dari dalam subquery yang berisi fungsi jendela. ``` select listid, qtysold from sales s where qtysold not in (select sum(numtickets) over() from listing l where s.listid=l.listid); ``` + Referensi dalam kolom GROUP BY ke hasil subquery yang berkorelasi. Contoh: ``` select listing.listid, (select count (sales.listid) from sales where sales.listid=listing.listid) as list from listing group by list, listing.listid; ``` + Referensi korelasi dari subquery dengan fungsi agregat dan klausa GROUP BY, terhubung ke kueri luar oleh predikat IN. (Pembatasan ini tidak berlaku untuk fungsi agregat MIN dan MAX.) Contoh: ``` select * from listing where listid in (select sum(qtysold) from sales where numtickets>4 group by salesid); ```