Amazon Redshift tidak akan lagi mendukung pembuatan Python UDFs baru mulai Patch 198. Python yang ada UDFs akan terus berfungsi hingga 30 Juni 2026. Untuk informasi lebih lanjut, lihat [posting blog](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/).
Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# 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](#r_FROM_clause30-synopsis)
+ [Parameter](#r_FROM_clause30-parameters)
+ [Catatan penggunaan](#r_FROM_clause_usage_notes)
+ [Contoh PIVOT dan UNPIVOT](r_FROM_clause-pivot-unpivot-examples.md)
+ [JOIN contoh](r_Join_examples.md)
+ [Contoh UNNEST](r_FROM_clause-unnest-examples.md)
## Sintaksis
```
FROM table_reference [, ...]
```
di mana *table\$1reference* adalah salah satu dari berikut ini:
```
with_subquery_table_name [ table_alias ]
table_name [ * ] [ table_alias ]
( subquery ) [ table_alias ]
table_reference [ NATURAL ] join_type table_reference
[ ON join_condition | USING ( join_column [, ...] ) ]
table_reference join_type super_expression
[ ON join_condition ]
table_reference PIVOT (
aggregate(expr) [ [ AS ] aggregate_alias ]
FOR column_name IN ( expression [ AS ] in_alias [, ...] )
) [ table_alias ]
table_reference UNPIVOT [ INCLUDE NULLS | EXCLUDE NULLS ] (
value_column_name
FOR name_column_name IN ( column_reference [ [ AS ]
in_alias ] [, ...] )
) [ table_alias ]
UNPIVOT expression AS value_alias [ AT attribute_alias ]
( super_expression.attribute_name ) AS value_alias [ AT index_alias ]
UNNEST ( column_reference )
[AS] table_alias ( unnested_column_name )
UNNEST ( column_reference ) WITH OFFSET
[AS] table_alias ( unnested_column_name, [offset_column_name] )
```
*Table\$1alias* opsional dapat digunakan untuk memberikan nama sementara ke tabel dan referensi tabel kompleks dan, jika diinginkan, kolomnya juga, seperti berikut ini:
```
[ AS ] alias [ ( column_alias [, ...] ) ]
```
## Parameter
*dengan\$1subquery\$1table\$1name*
Sebuah tabel didefinisikan oleh subquery di. [DENGAN klausa](r_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 kunci AS 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
```
*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)
```
POROS
Memutar output dari baris ke kolom, untuk tujuan mewakili data tabular dalam format yang mudah dibaca. Output direpresentasikan secara horizontal di beberapa kolom. PIVOT mirip dengan kueri GROUP BY dengan agregasi, menggunakan ekspresi agregat untuk menentukan format output. Namun, berbeda dengan GROUP BY, hasilnya dikembalikan dalam kolom, bukan baris.
Untuk contoh yang menunjukkan cara melakukan kueri dengan PIVOT dan UNPIVOT, lihat. [Contoh PIVOT dan UNPIVOT](r_FROM_clause-pivot-unpivot-examples.md)
UNPIVOT
*Memutar kolom menjadi baris dengan UNPIVOT* - Operator mengubah kolom hasil, dari tabel input atau hasil kueri, menjadi baris, untuk membuat output lebih mudah dibaca. UNPIVOT menggabungkan data kolom masukannya menjadi dua kolom hasil: kolom nama dan kolom nilai. Kolom nama berisi nama kolom dari input, sebagai entri baris. Kolom nilai berisi nilai-nilai dari kolom masukan, seperti hasil agregasi. Misalnya, jumlah item dalam berbagai kategori.
*Object unpivoting with UNPIVOT (SUPER)* - Anda dapat melakukan unpivoting objek, di mana *ekspresi adalah ekspresi* SUPER mengacu pada item klausa FROM lainnya. Untuk informasi selengkapnya, lihat [Objek tidak berputar](query-super.md#unpivoting). Ini juga memiliki contoh yang menunjukkan cara menanyakan data semi-terstruktur, seperti data yang diformat JSON.
*super\$1ekspresi*
Ekspresi SUPER yang valid. Amazon Redshift mengembalikan satu baris untuk setiap nilai dalam atribut yang ditentukan. Untuk informasi selengkapnya tentang tipe data SUPER, lihat[Tipe SUPER](r_SUPER_type.md). Untuk informasi selengkapnya tentang nilai SUPER unnested, lihat. [Kueri yang tidak bersarang](query-super.md#unnest)
*atribut\$1nama*
Nama atribut dalam ekspresi SUPER.
*index\$1alias*
Alias untuk indeks yang menandakan posisi nilai dalam ekspresi SUPER.
UNNEST
Memperluas struktur bersarang, biasanya array SUPER, ke dalam kolom yang berisi elemen unnested. Untuk informasi selengkapnya tentang menghapus data SUPER, lihat. [Meminta data semi-terstruktur](query-super.md) Sebagai contoh, lihat [Contoh UNNEST](r_FROM_clause-unnest-examples.md).
*unnested\$1column\$1name*
Nama kolom yang berisi elemen unnested.
TIDAK BERSARANG... DENGAN OFFSET
Menambahkan kolom offset ke output unnested, dengan offset mewakili indeks berbasis nol dari setiap elemen dalam array. Varian ini berguna ketika Anda ingin melihat posisi elemen dalam array. Untuk informasi selengkapnya tentang menghapus data SUPER, lihat. [Meminta data semi-terstruktur](query-super.md) Sebagai contoh, lihat [Contoh UNNEST](r_FROM_clause-unnest-examples.md).
*offset\$1column\$1name*
Nama kustom untuk kolom offset yang memungkinkan Anda secara eksplisit menentukan bagaimana kolom indeks akan muncul di output. Parameter ini bersifat opsional. Secara default, nama kolom offset adalah`offset_col`.
## 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 kumpulan hasil perantara.
Lihat juga [DENGAN klausa](r_WITH_clause.md).
# Contoh PIVOT dan UNPIVOT
PIVOT dan UNPIVOT adalah parameter dalam klausa FROM yang memutar output kueri dari baris ke kolom dan kolom ke baris, masing-masing. Mereka mewakili hasil kueri tabel dalam format yang mudah dibaca. Contoh berikut menggunakan data uji dan kueri untuk menunjukkan cara menggunakannya.
Untuk informasi selengkapnya tentang parameter ini dan parameter lainnya, lihat [klausa FROM](https://docs.aws.amazon.com/redshift/latest/dg/r_FROM_clause30.html).
## Contoh PIVOT
Siapkan tabel sampel dan data dan gunakan untuk menjalankan contoh query berikutnya.
```
CREATE TABLE part (
partname varchar,
manufacturer varchar,
quality int,
price decimal(12, 2)
);
INSERT INTO part VALUES ('prop', 'local parts co', 2, 10.00);
INSERT INTO part VALUES ('prop', 'big parts co', NULL, 9.00);
INSERT INTO part VALUES ('prop', 'small parts co', 1, 12.00);
INSERT INTO part VALUES ('rudder', 'local parts co', 1, 2.50);
INSERT INTO part VALUES ('rudder', 'big parts co', 2, 3.75);
INSERT INTO part VALUES ('rudder', 'small parts co', NULL, 1.90);
INSERT INTO part VALUES ('wing', 'local parts co', NULL, 7.50);
INSERT INTO part VALUES ('wing', 'big parts co', 1, 15.20);
INSERT INTO part VALUES ('wing', 'small parts co', NULL, 11.80);
```
PIVOT aktif `partname` dengan `AVG` agregasi aktif. `price`
```
SELECT *
FROM (SELECT partname, price FROM part) PIVOT (
AVG(price) FOR partname IN ('prop', 'rudder', 'wing')
);
```
Hasil query dalam output berikut.
```
prop | rudder | wing
---------+----------+---------
10.33 | 2.71 | 11.50
```
Pada contoh sebelumnya, hasilnya diubah menjadi kolom. Contoh berikut menunjukkan `GROUP BY` kueri yang mengembalikan harga rata-rata dalam baris, bukan di kolom.
```
SELECT partname, avg(price)
FROM (SELECT partname, price FROM part)
WHERE partname IN ('prop', 'rudder', 'wing')
GROUP BY partname;
```
Hasil query dalam output berikut.
```
partname | avg
----------+-------
prop | 10.33
rudder | 2.71
wing | 11.50
```
`PIVOT`Contoh dengan `manufacturer` sebagai kolom implisit.
```
SELECT *
FROM (SELECT quality, manufacturer FROM part) PIVOT (
count(*) FOR quality IN (1, 2, NULL)
);
```
Hasil query dalam output berikut.
```
manufacturer | 1 | 2 | null
-------------------+----+----+------
local parts co | 1 | 1 | 1
big parts co | 1 | 1 | 1
small parts co | 1 | 0 | 2
```
Kolom tabel masukan yang tidak direferensikan dalam `PIVOT` definisi ditambahkan secara implisit ke tabel hasil. Ini adalah kasus untuk `manufacturer` kolom pada contoh sebelumnya. Contoh ini juga menunjukkan bahwa `NULL` adalah nilai yang valid untuk `IN` operator.
`PIVOT`dalam contoh di atas mengembalikan informasi yang sama sebagai query berikut, yang meliputi`GROUP BY`. Perbedaannya adalah bahwa `PIVOT` mengembalikan nilai `0` untuk kolom `2` dan produsen`small parts co`. `GROUP BY`Kueri tidak berisi baris yang sesuai. Dalam kebanyakan kasus, `PIVOT` menyisipkan `NULL` jika baris tidak memiliki data input untuk kolom tertentu. Namun, agregat hitungan tidak kembali `NULL` dan `0` merupakan nilai default.
```
SELECT manufacturer, quality, count(*)
FROM (SELECT quality, manufacturer FROM part)
WHERE quality IN (1, 2) OR quality IS NULL
GROUP BY manufacturer, quality
ORDER BY manufacturer;
```
Hasil query dalam output berikut.
```
manufacturer | quality | count
---------------------+---------+-------
big parts co | | 1
big parts co | 2 | 1
big parts co | 1 | 1
local parts co | 2 | 1
local parts co | 1 | 1
local parts co | | 1
small parts co | 1 | 1
small parts co | | 2
```
Operator PIVOT menerima alias opsional pada ekspresi agregat dan pada setiap nilai untuk operator. `IN` Gunakan alias untuk menyesuaikan nama kolom. Jika tidak ada alias agregat, hanya alias `IN` daftar yang digunakan. Jika tidak, alias agregat ditambahkan ke nama kolom dengan garis bawah untuk memisahkan nama.
```
SELECT *
FROM (SELECT quality, manufacturer FROM part) PIVOT (
count(*) AS count FOR quality IN (1 AS high, 2 AS low, NULL AS na)
);
```
Hasil query dalam output berikut.
```
manufacturer | high_count | low_count | na_count
-------------------+-------------+-----------+----------
local parts co | 1 | 1 | 1
big parts co | 1 | 1 | 1
small parts co | 1 | 0 | 2
```
Siapkan tabel sampel dan data berikut dan gunakan untuk menjalankan contoh query berikutnya. Data tersebut menunjukkan tanggal pemesanan untuk koleksi hotel.
```
CREATE TABLE bookings (
booking_id int,
hotel_code char(8),
booking_date date,
price decimal(12, 2)
);
INSERT INTO bookings VALUES (1, 'FOREST_L', '02/01/2023', 75.12);
INSERT INTO bookings VALUES (2, 'FOREST_L', '02/02/2023', 75.00);
INSERT INTO bookings VALUES (3, 'FOREST_L', '02/04/2023', 85.54);
INSERT INTO bookings VALUES (4, 'FOREST_L', '02/08/2023', 75.00);
INSERT INTO bookings VALUES (5, 'FOREST_L', '02/11/2023', 75.00);
INSERT INTO bookings VALUES (6, 'FOREST_L', '02/14/2023', 90.00);
INSERT INTO bookings VALUES (7, 'FOREST_L', '02/21/2023', 60.00);
INSERT INTO bookings VALUES (8, 'FOREST_L', '02/22/2023', 85.00);
INSERT INTO bookings VALUES (9, 'FOREST_L', '02/27/2023', 90.00);
INSERT INTO bookings VALUES (10, 'DESERT_S', '02/01/2023', 98.00);
INSERT INTO bookings VALUES (11, 'DESERT_S', '02/02/2023', 75.00);
INSERT INTO bookings VALUES (12, 'DESERT_S', '02/04/2023', 85.00);
INSERT INTO bookings VALUES (13, 'DESERT_S', '02/05/2023', 75.00);
INSERT INTO bookings VALUES (14, 'DESERT_S', '02/06/2023', 34.00);
INSERT INTO bookings VALUES (15, 'DESERT_S', '02/09/2023', 85.00);
INSERT INTO bookings VALUES (16, 'DESERT_S', '02/12/2023', 23.00);
INSERT INTO bookings VALUES (17, 'DESERT_S', '02/13/2023', 76.00);
INSERT INTO bookings VALUES (18, 'DESERT_S', '02/14/2023', 85.00);
INSERT INTO bookings VALUES (19, 'OCEAN_WV', '02/01/2023', 98.00);
INSERT INTO bookings VALUES (20, 'OCEAN_WV', '02/02/2023', 75.00);
INSERT INTO bookings VALUES (21, 'OCEAN_WV', '02/04/2023', 85.00);
INSERT INTO bookings VALUES (22, 'OCEAN_WV', '02/06/2023', 75.00);
INSERT INTO bookings VALUES (23, 'OCEAN_WV', '02/09/2023', 34.00);
INSERT INTO bookings VALUES (24, 'OCEAN_WV', '02/12/2023', 85.00);
INSERT INTO bookings VALUES (25, 'OCEAN_WV', '02/13/2023', 23.00);
INSERT INTO bookings VALUES (26, 'OCEAN_WV', '02/14/2023', 76.00);
INSERT INTO bookings VALUES (27, 'OCEAN_WV', '02/16/2023', 85.00);
INSERT INTO bookings VALUES (28, 'CITY_BLD', '02/01/2023', 98.00);
INSERT INTO bookings VALUES (29, 'CITY_BLD', '02/02/2023', 75.00);
INSERT INTO bookings VALUES (30, 'CITY_BLD', '02/04/2023', 85.00);
INSERT INTO bookings VALUES (31, 'CITY_BLD', '02/12/2023', 75.00);
INSERT INTO bookings VALUES (32, 'CITY_BLD', '02/13/2023', 34.00);
INSERT INTO bookings VALUES (33, 'CITY_BLD', '02/17/2023', 85.00);
INSERT INTO bookings VALUES (34, 'CITY_BLD', '02/22/2023', 23.00);
INSERT INTO bookings VALUES (35, 'CITY_BLD', '02/23/2023', 76.00);
INSERT INTO bookings VALUES (36, 'CITY_BLD', '02/24/2023', 85.00);
```
Dalam contoh kueri ini, catatan pemesanan dihitung untuk memberikan total untuk setiap minggu. Tanggal akhir untuk setiap minggu menjadi nama kolom.
```
SELECT * FROM
(SELECT
booking_id,
(date_trunc('week', booking_date::date) + '5 days'::interval)::date as enddate,
hotel_code AS "hotel code"
FROM bookings
) PIVOT (
count(booking_id) FOR enddate IN ('2023-02-04','2023-02-11','2023-02-18')
);
```
Hasil query dalam output berikut.
```
hotel code | 2023-02-04 | 2023-02-11 | 2023-02-18
------------+-------------+------------+----------
FOREST_L | 3 | 2 | 1
DESERT_S | 4 | 3 | 2
OCEAN_WV | 3 | 3 | 3
CITY_BLD | 3 | 1 | 2
```
Amazon Redshift tidak mendukung CROSSTAB untuk berputar di beberapa kolom. Tetapi Anda dapat mengubah data baris ke kolom, dengan cara yang mirip dengan agregasi dengan PIVOT, dengan kueri seperti berikut ini. Ini menggunakan data sampel pemesanan yang sama dengan contoh sebelumnya.
```
SELECT
booking_date,
MAX(CASE WHEN hotel_code = 'FOREST_L' THEN 'forest is booked' ELSE '' END) AS FOREST_L,
MAX(CASE WHEN hotel_code = 'DESERT_S' THEN 'desert is booked' ELSE '' END) AS DESERT_S,
MAX(CASE WHEN hotel_code = 'OCEAN_WV' THEN 'ocean is booked' ELSE '' END) AS OCEAN_WV
FROM bookings
GROUP BY booking_date
ORDER BY booking_date asc;
```
Contoh kueri menghasilkan tanggal pemesanan yang tercantum di sebelah frasa singkat yang menunjukkan hotel mana yang dipesan.
```
booking_date | forest_l | desert_s | ocean_wv
---------------+------------------+------------------+--------------------
2023-02-01 | forest is booked | desert is booked | ocean is booked
2023-02-02 | forest is booked | desert is booked | ocean is booked
2023-02-04 | forest is booked | desert is booked | ocean is booked
2023-02-05 | | desert is booked |
2023-02-06 | | desert is booked |
```
Berikut ini adalah catatan penggunaan untuk`PIVOT`:
+ `PIVOT`dapat diterapkan ke tabel, sub-query, dan ekspresi tabel umum ()CTEs. `PIVOT`tidak dapat diterapkan pada `JOIN` ekspresi, rekursif CTEs`PIVOT`, atau `UNPIVOT` ekspresi apa pun. Juga tidak didukung adalah ekspresi `SUPER` unnested dan tabel bersarang Redshift Spectrum.
+ `PIVOT`mendukung fungsi`COUNT`,`SUM`,`MIN`,`MAX`, dan `AVG` agregat.
+ Ekspresi `PIVOT` agregat harus berupa panggilan dari fungsi agregat yang didukung. Ekspresi kompleks di atas agregat tidak didukung. Argumen agregat tidak dapat berisi referensi ke tabel selain tabel `PIVOT` input. Referensi berkorelasi ke kueri induk juga tidak didukung. Argumen agregat mungkin berisi sub-kueri. Ini dapat dikorelasikan secara internal atau pada tabel `PIVOT` input.
+ Nilai `PIVOT IN` daftar tidak dapat berupa referensi kolom atau sub-kueri. Setiap nilai harus jenis yang kompatibel dengan referensi `FOR` kolom.
+ Jika nilai `IN` daftar tidak memiliki alias, `PIVOT` menghasilkan nama kolom default. Untuk `IN` nilai konstan seperti 'abc' atau 5 nama kolom default adalah konstanta itu sendiri. Untuk ekspresi kompleks apa pun, nama kolom adalah nama default Amazon Redshift standar seperti. `?column?`
## Contoh UNPIVOT
Siapkan data sampel dan gunakan untuk menjalankan contoh berikutnya.
```
CREATE TABLE count_by_color (quality varchar, red int, green int, blue int);
INSERT INTO count_by_color VALUES ('high', 15, 20, 7);
INSERT INTO count_by_color VALUES ('normal', 35, NULL, 40);
INSERT INTO count_by_color VALUES ('low', 10, 23, NULL);
```
`UNPIVOT`pada kolom input merah, hijau, dan biru.
```
SELECT *
FROM (SELECT red, green, blue FROM count_by_color) UNPIVOT (
cnt FOR color IN (red, green, blue)
);
```
Hasil query dalam output berikut.
```
color | cnt
-------+-----
red | 15
red | 35
red | 10
green | 20
green | 23
blue | 7
blue | 40
```
Secara default, `NULL` nilai di kolom input dilewati dan tidak menghasilkan baris hasil.
Contoh berikut menunjukkan `UNPIVOT` dengan`INCLUDE NULLS`.
```
SELECT *
FROM (
SELECT red, green, blue
FROM count_by_color
) UNPIVOT INCLUDE NULLS (
cnt FOR color IN (red, green, blue)
);
```
Berikut ini adalah output yang dihasilkan.
```
color | cnt
-------+-----
red | 15
red | 35
red | 10
green | 20
green |
green | 23
blue | 7
blue | 40
blue |
```
Jika `INCLUDING NULLS` parameter diatur, nilai `NULL` masukan menghasilkan baris hasil.
`The following query shows UNPIVOT`dengan `quality` sebagai kolom implisit.
```
SELECT *
FROM count_by_color UNPIVOT (
cnt FOR color IN (red, green, blue)
);
```
Hasil query dalam output berikut.
```
quality | color | cnt
---------+-------+-----
high | red | 15
normal | red | 35
low | red | 10
high | green | 20
low | green | 23
high | blue | 7
normal | blue | 40
```
Kolom tabel input yang tidak direferensikan dalam `UNPIVOT` definisi ditambahkan secara implisit ke tabel hasil. Dalam contoh, ini adalah kasus untuk `quality` kolom.
Contoh berikut menunjukkan `UNPIVOT` dengan alias untuk nilai-nilai dalam `IN` daftar.
```
SELECT *
FROM count_by_color UNPIVOT (
cnt FOR color IN (red AS r, green AS g, blue AS b)
);
```
Hasil query sebelumnya dalam output berikut.
```
quality | color | cnt
---------+-------+-----
high | r | 15
normal | r | 35
low | r | 10
high | g | 20
low | g | 23
high | b | 7
normal | b | 40
```
`UNPIVOT`Operator menerima alias opsional pada setiap nilai `IN` daftar. Setiap alias menyediakan kustomisasi data di setiap `value` kolom.
Berikut ini adalah catatan penggunaan untuk`UNPIVOT`.
+ `UNPIVOT`dapat diterapkan ke tabel, sub-query, dan ekspresi tabel umum ()CTEs. `UNPIVOT`tidak dapat diterapkan pada `JOIN` ekspresi, rekursif CTEs`PIVOT`, atau `UNPIVOT` ekspresi apa pun. Juga tidak didukung adalah ekspresi `SUPER` unnested dan tabel bersarang Redshift Spectrum.
+ `UNPIVOT IN`Daftar harus berisi hanya referensi kolom tabel masukan. Kolom `IN` daftar harus memiliki tipe umum yang semuanya kompatibel dengannya. Kolom `UNPIVOT` nilai memiliki tipe umum ini. Kolom `UNPIVOT` nama adalah tipe`VARCHAR`.
+ Jika nilai `IN` daftar tidak memiliki alias, `UNPIVOT` menggunakan nama kolom sebagai nilai default.
# JOIN contoh
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. Untuk informasi selengkapnya tentang sintaks klausa JOIN, lihat. [Parameter](r_FROM_clause30.md#r_FROM_clause30-parameters)
Contoh berikut menggunakan data dari data `TICKIT` sampel. Untuk informasi selengkapnya tentang skema database, lihat[Database sampel](c_sampledb.md). Untuk mempelajari cara memuat data sampel, lihat [Memuat data](https://docs.aws.amazon.com/redshift/latest/gsg/rs-gsg-create-sample-db.html) di Panduan *Memulai Pergeseran Merah Amazon*.
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
```
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
```
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
```
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
```
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 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
```
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
```
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
```
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
```
# Contoh UNNEST
UNNEST adalah parameter dalam klausa FROM yang memperluas data bersarang ke dalam kolom yang menyimpan elemen data yang tidak bersarang. Untuk informasi tentang data yang tidak bersarang, lihat. [Meminta data semi-terstruktur](query-super.md)
Pernyataan berikut membuat dan mengisi `orders` tabel, yang berisi `products` kolom yang berisi array produk. IDs Contoh di bagian ini menggunakan data sampel dalam tabel ini.
```
CREATE TABLE orders (
order_id INT,
products SUPER
);
-- Populate table
INSERT INTO orders VALUES
(1001, JSON_PARSE('[
{
"product_id": "P456",
"name": "Monitor",
"price": 299.99,
"quantity": 1,
"specs": {
"size": "27 inch",
"resolution": "4K"
}
}
]
')),
(1002, JSON_PARSE('
[
{
"product_id": "P567",
"name": "USB Cable",
"price": 9.99,
"quantity": 3
},
{
"product_id": "P678",
"name": "Headphones",
"price": 159.99,
"quantity": 1,
"specs": {
"type": "Wireless",
"battery_life": "20 hours"
}
}
]
'));
```
Berikut ini adalah beberapa contoh query unnesting dengan data sampel menggunakan sintaks PartiQL.
## Melepaskan array tanpa kolom OFFSET
Kueri berikut menghapus array SUPER di kolom produk, dengan setiap baris mewakili item dari urutan dalam. `order_id`
```
SELECT o.order_id, unnested_products.product
FROM orders o, UNNEST(o.products) AS unnested_products(product);
order_id | product
----------+-----------------------------------------------------------------------------------------------------------------------------
1001 | {"product_id":"P456","name":"Monitor","price":299.99,"quantity":1,"specs":{"size":"27 inch","resolution":"4K"}}
1002 | {"product_id":"P567","name":"USB Cable","price":9.99,"quantity":3}
1002 | {"product_id":"P678","name":"Headphones","price":159.99,"quantity":1,"specs":{"type":"Wireless","battery_life":"20 hours"}}
(3 rows)
```
Kueri berikut menemukan produk paling mahal di setiap pesanan.
```
SELECT o.order_id, MAX(unnested_products.product)
FROM orders o, UNNEST(o.products) AS unnested_products(product);
order_id | product
----------+-----------------------------------------------------------------------------------------------------------------------------
1001 | {"product_id":"P456","name":"Monitor","price":299.99,"quantity":1,"specs":{"size":"27 inch","resolution":"4K"}}
1002 | {"product_id":"P678","name":"Headphones","price":159.99,"quantity":1,"specs":{"type":"Wireless","battery_life":"20 hours"}}
(2 rows)
```
## Melepaskan array dengan kolom OFFSET implisit
Kueri berikut menggunakan `UNNEST ... WITH OFFSET` parameter untuk menunjukkan posisi berbasis nol dari setiap produk dalam array urutannya.
```
SELECT o.order_id, up.product, up.offset_col
FROM orders o, UNNEST(o.products) WITH OFFSET AS up(product);
order_id | product | offset_col
----------+-----------------------------------------------------------------------------------------------------------------------------+------------
1001 | {"product_id":"P456","name":"Monitor","price":299.99,"quantity":1,"specs":{"size":"27 inch","resolution":"4K"}} | 0
1002 | {"product_id":"P567","name":"USB Cable","price":9.99,"quantity":3} | 0
1002 | {"product_id":"P678","name":"Headphones","price":159.99,"quantity":1,"specs":{"type":"Wireless","battery_life":"20 hours"}} | 1
(3 rows)
```
Karena pernyataan tidak menentukan alias untuk kolom offset, Amazon Redshift secara default menamainya. `offset_col`
## Melepaskan array dengan kolom OFFSET eksplisit
Kueri berikut juga menggunakan `UNNEST ... WITH OFFSET` parameter untuk menampilkan produk dalam array pesanan mereka. Perbedaan dalam kueri ini dibandingkan dengan kueri pada contoh sebelumnya adalah bahwa ia secara eksplisit menamai kolom offset dengan alias. `idx`
```
SELECT o.order_id, up.product, up.idx
FROM orders o, UNNEST(o.products) WITH OFFSET AS up(product, idx);
order_id | product | idx
----------+-----------------------------------------------------------------------------------------------------------------------------+-----
1001 | {"product_id":"P456","name":"Monitor","price":299.99,"quantity":1,"specs":{"size":"27 inch","resolution":"4K"}} | 0
1002 | {"product_id":"P567","name":"USB Cable","price":9.99,"quantity":3} | 0
1002 | {"product_id":"P678","name":"Headphones","price":159.99,"quantity":1,"specs":{"type":"Wireless","battery_life":"20 hours"}} | 1
(3 rows)
```