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.
# Fungsi jendela
Dengan menggunakan fungsi jendela, Anda dapat membuat kueri bisnis analitik dengan lebih efisien. Fungsi jendela beroperasi pada partisi atau “jendela” dari kumpulan hasil, dan mengembalikan nilai untuk setiap baris di jendela itu. Sebaliknya, fungsi non-windowed melakukan perhitungan mereka sehubungan dengan setiap baris dalam set hasil. Tidak seperti fungsi grup yang menggabungkan baris hasil, fungsi jendela mempertahankan semua baris dalam ekspresi tabel.
Nilai yang dikembalikan dihitung dengan menggunakan nilai dari kumpulan baris di jendela itu. Untuk setiap baris dalam tabel, jendela mendefinisikan satu set baris yang digunakan untuk menghitung atribut tambahan. Sebuah jendela didefinisikan menggunakan spesifikasi jendela (klausa OVER), dan didasarkan pada tiga konsep utama:
+ *Partisi jendela,* yang membentuk kelompok baris (klausa PARTISI)
+ *Pengurutan jendela*, yang mendefinisikan urutan atau urutan baris dalam setiap partisi (klausa ORDER BY)
+ *Bingkai jendela*, yang didefinisikan relatif terhadap setiap baris untuk lebih membatasi set baris (spesifikasi ROWS)
Fungsi jendela adalah rangkaian operasi terakhir yang dilakukan dalam kueri kecuali klausa ORDER BY akhir. Semua bergabung dan semua klausa WHERE, GROUP BY, dan HAVING selesai sebelum fungsi jendela diproses. Oleh karena itu, fungsi jendela hanya dapat muncul di daftar pilih atau klausa ORDER BY. Anda dapat menggunakan beberapa fungsi jendela dalam satu kueri dengan klausa bingkai yang berbeda. Anda juga dapat menggunakan fungsi jendela dalam ekspresi skalar lainnya, seperti CASE.
Fungsi jendela tidak dapat disarangkan. Misalnya, fungsi agregat [JUMLAH](r_SUM.md) dapat muncul di dalam fungsi jendela[JUMLAH](r_WF_SUM.md), tetapi fungsi jendela SUM tidak dapat muncul di dalam fungsi jendela lain SUM. Berikut ini tidak didukung karena fungsi jendela bersarang di fungsi jendela lain.
```
SELECT SUM(SUM(selectcol) OVER (PARTITION BY ordercol)) OVER (Partition by ordercol) FROM t;
```
## Ringkasan sintaks fungsi jendela
Fungsi jendela mengikuti sintaks standar, yaitu sebagai berikut.
```
function (expression) OVER (
[ PARTITION BY expr_list ]
[ ORDER BY order_list [ frame_clause ] ] )
```
Di sini, *fungsi* adalah salah satu fungsi yang dijelaskan dalam bagian ini.
*Expr\$1list* adalah sebagai berikut.
```
expression | column_name [, expr_list ]
```
*Order\$1list* adalah sebagai berikut.
```
expression | column_name [ ASC | DESC ]
[ NULLS FIRST | NULLS LAST ]
[, order_list ]
```
*Frame\$1clause* adalah sebagai berikut.
```
ROWS
{ UNBOUNDED PRECEDING | unsigned_value PRECEDING | CURRENT ROW } |
{ BETWEEN
{ UNBOUNDED PRECEDING | unsigned_value { PRECEDING | FOLLOWING } | CURRENT ROW}
AND
{ UNBOUNDED FOLLOWING | unsigned_value { PRECEDING | FOLLOWING } | CURRENT ROW }}
```
### Pendapat
*fungsi*
Fungsi jendela. Untuk detailnya, lihat deskripsi fungsi individual.
DI ATAS
Klausul yang mendefinisikan spesifikasi jendela. Klausa OVER wajib untuk fungsi jendela, dan membedakan fungsi jendela dari fungsi SQL lainnya.
PARTISI OLEH *expr\$1list*
(Opsional) Klausa PARTITION BY membagi hasil yang ditetapkan menjadi partisi, seperti klausa GROUP BY. Jika klausa partisi hadir, fungsi dihitung untuk baris di setiap partisi. Jika tidak ada klausa partisi yang ditentukan, partisi tunggal berisi seluruh tabel, dan fungsi dihitung untuk tabel lengkap itu.
Fungsi peringkat DENSE\$1RANK, NTILE, RANK, dan ROW\$1NUMBER memerlukan perbandingan global dari semua baris dalam kumpulan hasil. Ketika klausa PARTITION BY digunakan, pengoptimal kueri dapat menjalankan setiap agregasi secara paralel dengan menyebarkan beban kerja di beberapa irisan sesuai dengan partisi. Jika klausa PARTITION BY tidak ada, langkah agregasi harus dijalankan secara serial pada satu irisan, yang dapat memiliki dampak negatif yang signifikan pada kinerja, terutama untuk cluster besar.
Amazon Redshift tidak mendukung literal string di klausa PARTITION BY.
PESANAN BERDASARKAN *order\$1list*
(Opsional) Fungsi jendela diterapkan ke baris dalam setiap partisi yang diurutkan sesuai dengan spesifikasi pesanan di ORDER BY. *Klausa ORDER BY ini berbeda dari dan sama sekali tidak terkait dengan klausa ORDER BY di frame\$1clause.* Klausa ORDER BY dapat digunakan tanpa klausa PARTITION BY.
Untuk fungsi peringkat, klausa ORDER BY mengidentifikasi ukuran untuk nilai peringkat. Untuk fungsi agregasi, baris yang dipartisi harus diurutkan sebelum fungsi agregat dihitung untuk setiap frame. Untuk selengkapnya tentang jenis fungsi jendela, lihat[Fungsi jendela](#c_Window_functions).
Pengidentifikasi kolom atau ekspresi yang mengevaluasi ke pengidentifikasi kolom diperlukan dalam daftar urutan. Baik konstanta maupun ekspresi konstan tidak dapat digunakan sebagai pengganti nama kolom.
Nilai NULLS diperlakukan sebagai grup mereka sendiri, diurutkan dan diberi peringkat sesuai dengan opsi NULLS FIRST atau NULLS LAST. Secara default, nilai NULL diurutkan dan diberi peringkat terakhir dalam urutan ASC, dan diurutkan dan diberi peringkat pertama dalam urutan DESC.
Amazon Redshift tidak mendukung literal string dalam klausa ORDER BY.
Jika klausa ORDER BY dihilangkan, urutan baris adalah nondeterministik.
Dalam sistem paralel apa pun seperti Amazon Redshift, ketika klausa ORDER BY tidak menghasilkan urutan data yang unik dan total, urutan baris tidak deterministik. Artinya, jika ekspresi ORDER BY menghasilkan nilai duplikat (urutan sebagian), urutan pengembalian baris tersebut mungkin berbeda dari satu proses Amazon Redshift ke yang berikutnya. Pada gilirannya, fungsi jendela mungkin mengembalikan hasil yang tidak terduga atau tidak konsisten. Untuk informasi selengkapnya, lihat [Urutan data yang unik untuk fungsi jendela](#r_Examples_order_by_WF).
*column\$1name*
Nama kolom yang akan dipartisi oleh atau diurutkan oleh.
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 NULLS harus diurutkan terlebih dahulu, sebelum nilai non-null, atau terakhir, setelah nilai non-null. Secara default, NULLS diurutkan dan diberi peringkat terakhir dalam urutan ASC, dan diurutkan dan diberi peringkat pertama dalam urutan DESC.
*frame\$1clause*
Untuk fungsi agregat, klausa bingkai lebih lanjut menyempurnakan kumpulan baris di jendela fungsi saat menggunakan ORDER BY. Ini memungkinkan Anda untuk memasukkan atau mengecualikan set baris dalam hasil yang diurutkan. Klausa bingkai terdiri dari kata kunci ROWS dan penentu terkait.
Klausa bingkai tidak berlaku untuk fungsi peringkat. Selain itu, klausa bingkai tidak diperlukan ketika tidak ada klausa ORDER BY yang digunakan dalam klausa OVER untuk fungsi agregat. Jika klausa ORDER BY digunakan untuk fungsi agregat, klausa bingkai eksplisit diperlukan.
Ketika tidak ada klausa ORDER BY yang ditentukan, bingkai tersirat tidak dibatasi, setara dengan BARIS ANTARA TIDAK TERBATAS SEBELUMNYA DAN TIDAK TERBATAS BERIKUT.
BARIS
Klausa ini mendefinisikan bingkai jendela dengan menentukan offset fisik dari baris saat ini.
Klausa ini menentukan baris di jendela atau partisi saat ini yang akan digabungkan dengan nilai dalam baris saat ini. Ini menggunakan argumen yang menentukan posisi baris, yang bisa sebelum atau sesudah baris saat ini. Titik referensi untuk semua bingkai jendela adalah baris saat ini. Setiap baris menjadi baris saat ini secara bergantian saat bingkai jendela meluncur ke depan di partisi.
Bingkai dapat berupa serangkaian baris sederhana hingga dan termasuk baris saat ini.
```
{UNBOUNDED PRECEDING | offset PRECEDING | CURRENT ROW}
```
Atau bisa juga satu set baris antara dua batas.
```
BETWEEN
{ UNBOUNDED PRECEDING | offset { PRECEDING | FOLLOWING } | CURRENT ROW }
AND
{ UNBOUNDED FOLLOWING | offset { PRECEDING | FOLLOWING } | CURRENT ROW }
```
UNBOUNDED PRECEDING menunjukkan bahwa jendela dimulai pada baris pertama partisi; *offset* PRECEDING menunjukkan bahwa jendela memulai sejumlah baris yang setara dengan nilai offset sebelum baris saat ini. UNBOUNDED PRECEDING adalah default.
ROW SAAT INI menunjukkan jendela dimulai atau berakhir pada baris saat ini.
BERIKUT TIDAK TERBATAS menunjukkan bahwa jendela berakhir pada baris terakhir partisi; *offset* BERIKUT menunjukkan bahwa jendela mengakhiri sejumlah baris yang setara dengan nilai offset setelah baris saat ini.
*offset* mengidentifikasi jumlah fisik baris sebelum atau sesudah baris saat ini. Dalam hal ini, *offset* harus berupa konstanta yang mengevaluasi nilai numerik positif. Misalnya, 5 BERIKUT mengakhiri bingkai lima baris setelah baris saat ini.
Dimana BETWEEN tidak ditentukan, frame secara implisit dibatasi oleh baris saat ini. Misalnya, `ROWS 5 PRECEDING` sama dengan`ROWS BETWEEN 5 PRECEDING AND CURRENT ROW`. Juga, `ROWS UNBOUNDED FOLLOWING` sama dengan`ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING`.
Anda tidak dapat menentukan bingkai di mana batas awal lebih besar dari batas akhir. Misalnya, Anda tidak dapat menentukan salah satu frame berikut.
```
between 5 following and 5 preceding
between current row and 2 preceding
between 3 following and current row
```
## Urutan data yang unik untuk fungsi jendela
Jika klausa ORDER BY untuk fungsi jendela tidak menghasilkan urutan data yang unik dan total, urutan baris adalah nondeterministik. Jika ekspresi ORDER BY menghasilkan nilai duplikat (urutan sebagian), urutan pengembalian baris tersebut dapat bervariasi dalam beberapa kali proses. Dalam hal ini, fungsi jendela juga dapat mengembalikan hasil yang tidak terduga atau tidak konsisten.
Misalnya, kueri berikut mengembalikan hasil yang berbeda selama beberapa proses. Hasil yang berbeda ini terjadi karena `order by dateid` tidak menghasilkan urutan data yang unik untuk fungsi jendela SUM.
```
select dateid, pricepaid,
sum(pricepaid) over(order by dateid rows unbounded preceding) as sumpaid
from sales
group by dateid, pricepaid;
dateid | pricepaid | sumpaid
--------+-----------+-------------
1827 | 1730.00 | 1730.00
1827 | 708.00 | 2438.00
1827 | 234.00 | 2672.00
...
select dateid, pricepaid,
sum(pricepaid) over(order by dateid rows unbounded preceding) as sumpaid
from sales
group by dateid, pricepaid;
dateid | pricepaid | sumpaid
--------+-----------+-------------
1827 | 234.00 | 234.00
1827 | 472.00 | 706.00
1827 | 347.00 | 1053.00
...
```
Dalam hal ini, menambahkan kolom ORDER BY kedua ke fungsi jendela dapat menyelesaikan masalah.
```
select dateid, pricepaid,
sum(pricepaid) over(order by dateid, pricepaid rows unbounded preceding) as sumpaid
from sales
group by dateid, pricepaid;
dateid | pricepaid | sumpaid
--------+-----------+---------
1827 | 234.00 | 234.00
1827 | 337.00 | 571.00
1827 | 347.00 | 918.00
...
```
## Fungsi yang didukung
Amazon Redshift mendukung dua jenis fungsi jendela: agregat dan peringkat.
Berikut ini adalah fungsi agregat yang didukung:
+ [Fungsi jendela AVG](r_WF_AVG.md)
+ [Fungsi jendela COUNT](r_WF_COUNT.md)
+ [Fungsi jendela CUME\$1DIST](r_WF_CUME_DIST.md)
+ [Fungsi jendela DENSE\$1RANK](r_WF_DENSE_RANK.md)
+ [Fungsi jendela FIRST\$1VALUE](r_WF_first_value.md)
+ [Fungsi jendela LAG](r_WF_LAG.md)
+ [Fungsi jendela LAST\$1VALUE](r_WF_last_value.md)
+ [Fungsi jendela LEAD](r_WF_LEAD.md)
+ [Fungsi jendela LISTAGG](r_WF_LISTAGG.md)
+ [Fungsi jendela MAX](r_WF_MAX.md)
+ [Fungsi jendela MEDIAN](r_WF_MEDIAN.md)
+ [Fungsi jendela MIN](r_WF_MIN.md)
+ [Fungsi jendela NTH\$1VALUE](r_WF_NTH.md)
+ [Fungsi jendela PERCENTILE\$1CONT](r_WF_PERCENTILE_CONT.md)
+ [Fungsi jendela PERCENTILE\$1DISC](r_WF_PERCENTILE_DISC.md)
+ [Fungsi jendela RATIO\$1TO\$1REPORT](r_WF_RATIO_TO_REPORT.md)
+ [Fungsi jendela STDDEV\$1SAMP dan STDDEV\$1POP](r_WF_STDDEV.md)(STDDEV\$1SAMP dan STDDEV adalah sinonim)
+ [Fungsi jendela SUM](r_WF_SUM.md)
+ [Fungsi jendela VAR\$1SAMP dan VAR\$1POP](r_WF_VARIANCE.md)(VAR\$1SAMP dan VARIANCE adalah sinonim)
Berikut ini adalah fungsi peringkat yang didukung:
+ [Fungsi jendela DENSE\$1RANK](r_WF_DENSE_RANK.md)
+ [Fungsi jendela NTILE](r_WF_NTILE.md)
+ [Fungsi jendela PERCENT\$1RANK](r_WF_PERCENT_RANK.md)
+ [Fungsi jendela RANK](r_WF_RANK.md)
+ [Fungsi jendela ROW\$1NUMBER](r_WF_ROW_NUMBER.md)
## Contoh tabel untuk contoh fungsi jendela
Anda dapat menemukan contoh fungsi jendela tertentu dengan setiap deskripsi fungsi. Beberapa contoh menggunakan tabel bernama WINSALES, yang berisi 11 baris, seperti yang ditunjukkan berikut.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/redshift/latest/dg/c_Window_functions.html)
Script berikut membuat dan mengisi tabel WINSALES sampel.
```
CREATE TABLE winsales(
salesid int,
dateid date,
sellerid int,
buyerid char(10),
qty int,
qty_shipped int);
INSERT INTO winsales VALUES
(30001, '8/2/2003', 3, 'b', 10, 10),
(10001, '12/24/2003', 1, 'c', 10, 10),
(10005, '12/24/2003', 1, 'a', 30, null),
(40001, '1/9/2004', 4, 'a', 40, null),
(10006, '1/18/2004', 1, 'c', 10, null),
(20001, '2/12/2004', 2, 'b', 20, 20),
(40005, '2/12/2004', 4, 'a', 10, 10),
(20002, '2/16/2004', 2, 'c', 20, 20),
(30003, '4/18/2004', 3, 'b', 15, null),
(30004, '4/18/2004', 3, 'b', 20, null),
(30007, '9/7/2004', 3, 'c', 30, null);
```
# Fungsi jendela AVG
Fungsi jendela AVG mengembalikan rata-rata (rata-rata aritmatika) dari nilai ekspresi masukan. Fungsi AVG bekerja dengan nilai numerik dan mengabaikan nilai NULL.
## Sintaksis
```
AVG ( [ALL ] expression ) OVER
(
[ PARTITION BY expr_list ]
[ ORDER BY order_list
frame_clause ]
)
```
## Argumen
*ekspresi*
Kolom target atau ekspresi tempat fungsi beroperasi.
SEMUA
Dengan argumen ALL, fungsi mempertahankan semua nilai duplikat dari ekspresi untuk menghitung. ALL adalah default. DISTINCT tidak didukung.
DI ATAS
Menentukan klausa jendela untuk fungsi agregasi. Klausa OVER membedakan fungsi agregasi jendela dari fungsi agregasi set normal.
PARTISI OLEH *expr\$1list*
Mendefinisikan jendela untuk fungsi AVG dalam hal satu atau beberapa ekspresi.
PESANAN BERDASARKAN *order\$1list*
Mengurutkan baris dalam setiap partisi. Jika tidak ada PARTITION BY yang ditentukan, ORDER BY menggunakan seluruh tabel.
*frame\$1clause*
Jika klausa ORDER BY digunakan untuk fungsi agregat, klausa bingkai eksplisit diperlukan. Klausa bingkai menyempurnakan kumpulan baris di jendela fungsi, termasuk atau mengecualikan kumpulan baris dalam hasil yang diurutkan. Klausa bingkai terdiri dari kata kunci ROWS dan penentu terkait. Lihat [Ringkasan sintaks fungsi jendela](c_Window_functions.md#r_Window_function_synopsis).
## Jenis Data
Tipe argumen yang didukung oleh fungsi AVG adalah SMALLINT, INTEGER, BIGINT, NUMERIC, DECIMAL, REAL, dan DOUBLE PRECISION.
Jenis pengembalian yang didukung oleh fungsi AVG adalah:
+ BIGINT untuk argumen SMALLINT atau INTEGER
+ NUMERIK untuk argumen BIGINT
+ PRESISI GANDA untuk argumen floating point
## Contoh
Contoh berikut menghitung rata-rata bergulir dari jumlah yang dijual berdasarkan tanggal; pesan hasilnya berdasarkan ID tanggal dan ID penjualan:
```
select salesid, dateid, sellerid, qty,
avg(qty) over
(order by dateid, salesid rows unbounded preceding) as avg
from winsales
order by 2,1;
salesid | dateid | sellerid | qty | avg
---------+------------+----------+-----+-----
30001 | 2003-08-02 | 3 | 10 | 10
10001 | 2003-12-24 | 1 | 10 | 10
10005 | 2003-12-24 | 1 | 30 | 16
40001 | 2004-01-09 | 4 | 40 | 22
10006 | 2004-01-18 | 1 | 10 | 20
20001 | 2004-02-12 | 2 | 20 | 20
40005 | 2004-02-12 | 4 | 10 | 18
20002 | 2004-02-16 | 2 | 20 | 18
30003 | 2004-04-18 | 3 | 15 | 18
30004 | 2004-04-18 | 3 | 20 | 18
30007 | 2004-09-07 | 3 | 30 | 19
(11 rows)
```
Untuk deskripsi tabel WINSALES, lihat[Contoh tabel untuk contoh fungsi jendela](c_Window_functions.md#r_Window_function_example).
# Fungsi jendela COUNT
Fungsi jendela COUNT menghitung baris yang ditentukan oleh ekspresi.
Fungsi COUNT memiliki dua variasi. COUNT (\$1) menghitung semua baris dalam tabel target apakah mereka termasuk nol atau tidak. COUNT (ekspresi) menghitung jumlah baris dengan nilai non-Null dalam kolom atau ekspresi tertentu.
## Sintaksis
```
COUNT ( * | [ ALL ] expression) OVER
(
[ PARTITION BY expr_list ]
[ ORDER BY order_list
frame_clause ]
)
```
## Argumen
*ekspresi*
Kolom target atau ekspresi tempat fungsi beroperasi.
SEMUA
Dengan argumen ALL, fungsi mempertahankan semua nilai duplikat dari ekspresi untuk menghitung. ALL adalah default. DISTINCT tidak didukung.
DI ATAS
Menentukan klausa jendela untuk fungsi agregasi. Klausa OVER membedakan fungsi agregasi jendela dari fungsi agregasi set normal.
PARTISI OLEH *expr\$1list*
Mendefinisikan jendela untuk fungsi COUNT dalam hal satu atau lebih ekspresi.
PESANAN BERDASARKAN *order\$1list*
Mengurutkan baris dalam setiap partisi. Jika tidak ada PARTITION BY yang ditentukan, ORDER BY menggunakan seluruh tabel.
*frame\$1clause*
Jika klausa ORDER BY digunakan untuk fungsi agregat, klausa bingkai eksplisit diperlukan. Klausa bingkai menyempurnakan kumpulan baris di jendela fungsi, termasuk atau mengecualikan kumpulan baris dalam hasil yang diurutkan. Klausa bingkai terdiri dari kata kunci ROWS dan penentu terkait. Lihat [Ringkasan sintaks fungsi jendela](c_Window_functions.md#r_Window_function_synopsis).
## Jenis Data
Fungsi COUNT mendukung semua tipe data argumen.
Jenis pengembalian yang didukung oleh fungsi COUNT adalah BIGINT.
## Contoh
Contoh berikut menunjukkan ID penjualan, kuantitas, dan jumlah semua baris dari awal jendela data:
```
select salesid, qty,
count(*) over (order by salesid rows unbounded preceding) as count
from winsales
order by salesid;
salesid | qty | count
---------+-----+-----
10001 | 10 | 1
10005 | 30 | 2
10006 | 10 | 3
20001 | 20 | 4
20002 | 20 | 5
30001 | 10 | 6
30003 | 15 | 7
30004 | 20 | 8
30007 | 30 | 9
40001 | 40 | 10
40005 | 10 | 11
(11 rows)
```
Untuk deskripsi tabel WINSALES, lihat[Contoh tabel untuk contoh fungsi jendela](c_Window_functions.md#r_Window_function_example).
Contoh berikut menunjukkan bagaimana ID penjualan, kuantitas, dan jumlah baris non-null dari awal jendela data. (Dalam tabel WINSALES, kolom QTY\$1SHIPPED berisi beberapa.) NULLs
```
select salesid, qty, qty_shipped,
count(qty_shipped)
over (order by salesid rows unbounded preceding) as count
from winsales
order by salesid;
salesid | qty | qty_shipped | count
---------+-----+-------------+-------
10001 | 10 | 10 | 1
10005 | 30 | | 1
10006 | 10 | | 1
20001 | 20 | 20 | 2
20002 | 20 | 20 | 3
30001 | 10 | 10 | 4
30003 | 15 | | 4
30004 | 20 | | 4
30007 | 30 | | 4
40001 | 40 | | 4
40005 | 10 | 10 | 5
(11 rows)
```
# Fungsi jendela CUME\$1DIST
Menghitung distribusi kumulatif nilai dalam jendela atau partisi. Dengan asumsi urutan naik, distribusi kumulatif ditentukan menggunakan rumus ini:
`count of rows with values <= x / count of rows in the window or partition`
di mana *x* sama dengan nilai di baris kolom saat ini yang ditentukan dalam klausa ORDER BY. Dataset berikut menggambarkan penggunaan rumus ini:
```
Row# Value Calculation CUME_DIST
1 2500 (1)/(5) 0.2
2 2600 (2)/(5) 0.4
3 2800 (3)/(5) 0.6
4 2900 (4)/(5) 0.8
5 3100 (5)/(5) 1.0
```
Rentang nilai pengembalian adalah> 0 hingga 1, inklusif.
## Sintaksis
```
CUME_DIST ()
OVER (
[ PARTITION BY partition_expression ]
[ ORDER BY order_list ]
)
```
## Argumen
DI ATAS
Sebuah klausa yang menentukan partisi jendela. Klausa OVER tidak dapat berisi spesifikasi bingkai jendela.
PARTISI OLEH *partition\$1expression*
Tidak wajib. Ekspresi yang menetapkan rentang catatan untuk setiap grup dalam klausa OVER.
PESANAN BERDASARKAN *order\$1list*
Ekspresi untuk menghitung distribusi kumulatif. Ekspresi harus memiliki tipe data numerik atau secara implisit dapat dikonversi menjadi satu. Jika ORDER BY dihilangkan, nilai kembalinya adalah 1 untuk semua baris.
Jika ORDER BY tidak menghasilkan urutan unik, urutan baris adalah nondeterministik. Untuk informasi selengkapnya, lihat [Urutan data yang unik untuk fungsi jendela](c_Window_functions.md#r_Examples_order_by_WF).
## Jenis pengembalian
FLOAT8
## Contoh
Contoh berikut menghitung distribusi kumulatif kuantitas untuk setiap penjual:
```
select sellerid, qty, cume_dist()
over (partition by sellerid order by qty)
from winsales;
sellerid qty cume_dist
--------------------------------------------------
1 10.00 0.33
1 10.64 0.67
1 30.37 1
3 10.04 0.25
3 15.15 0.5
3 20.75 0.75
3 30.55 1
2 20.09 0.5
2 20.12 1
4 10.12 0.5
4 40.23 1
```
Untuk deskripsi tabel WINSALES, lihat[Contoh tabel untuk contoh fungsi jendela](c_Window_functions.md#r_Window_function_example).
# Fungsi jendela DENSE\$1RANK
Fungsi jendela DENSE\$1RANK menentukan peringkat nilai dalam sekelompok nilai, berdasarkan ekspresi ORDER BY dalam klausa OVER. Jika klausa PARTITION BY opsional ada, peringkat diatur ulang untuk setiap kelompok baris. Baris dengan nilai yang sama untuk kriteria peringkat menerima peringkat yang sama. Fungsi DENSE\$1RANK berbeda dari RANK dalam satu hal: jika dua atau lebih baris terikat, tidak ada celah dalam urutan nilai peringkat. Misalnya, jika dua baris diberi peringkat`1`, peringkat berikutnya adalah`2`.
Anda dapat memiliki fungsi peringkat dengan klausa PARTITION BY dan ORDER BY yang berbeda dalam kueri yang sama.
## Sintaksis
```
DENSE_RANK() OVER
(
[ PARTITION BY expr_list ]
[ ORDER BY order_list ]
)
```
## Argumen
( )
Fungsi ini tidak mengambil argumen, tetapi tanda kurung kosong diperlukan.
DI ATAS
Klausa jendela untuk fungsi DENSE\$1RANK.
PARTISI OLEH *expr\$1list*
(Opsional) Satu atau lebih ekspresi yang menentukan jendela.
PESANAN BERDASARKAN *order\$1list*
(Opsional) Ekspresi yang menjadi dasar nilai peringkat. Jika tidak ada PARTITION BY yang ditentukan, ORDER BY menggunakan seluruh tabel. Jika ORDER BY dihilangkan, nilai kembalinya adalah `1` untuk semua baris.
Jika ORDER BY tidak menghasilkan urutan unik, urutan baris adalah nondeterministik. Untuk informasi selengkapnya, lihat [Urutan data yang unik untuk fungsi jendela](c_Window_functions.md#r_Examples_order_by_WF).
## Jenis pengembalian
`BIGINT`
## Contoh
Contoh berikut menggunakan tabel sampel untuk fungsi jendela. Untuk informasi selengkapnya, lihat [Contoh tabel untuk contoh fungsi jendela](c_Window_functions.md#r_Window_function_example).
Contoh berikut memesan tabel dengan jumlah yang terjual dan memberikan peringkat padat dan peringkat reguler untuk setiap baris. Hasilnya diurutkan setelah hasil fungsi jendela diterapkan.
```
SELECT salesid, qty,
DENSE_RANK() OVER(ORDER BY qty DESC) AS d_rnk,
RANK() OVER(ORDER BY qty DESC) AS rnk
FROM winsales
ORDER BY 2,1;
+---------+-----+-------+-----+
| salesid | qty | d_rnk | rnk |
+---------+-----+-------+-----+
| 10001 | 10 | 5 | 8 |
| 10006 | 10 | 5 | 8 |
| 30001 | 10 | 5 | 8 |
| 40005 | 10 | 5 | 8 |
| 30003 | 15 | 4 | 7 |
| 20001 | 20 | 3 | 4 |
| 20002 | 20 | 3 | 4 |
| 30004 | 20 | 3 | 4 |
| 10005 | 30 | 2 | 2 |
| 30007 | 30 | 2 | 2 |
| 40001 | 40 | 1 | 1 |
+---------+-----+-------+-----+
```
Perhatikan perbedaan peringkat yang ditetapkan ke kumpulan baris yang sama saat fungsi DENSE\$1RANK dan RANK digunakan berdampingan dalam kueri yang sama.
Contoh berikut mempartisi tabel dengan sellerid, mengurutkan setiap partisi dengan kuantitas, dan memberikan peringkat padat untuk setiap baris. Hasilnya diurutkan setelah hasil fungsi jendela diterapkan.
```
SELECT salesid, sellerid, qty,
DENSE_RANK() OVER(PARTITION BY sellerid ORDER BY qty DESC) AS d_rnk
FROM winsales
ORDER BY 2,3,1;
+---------+----------+-----+-------+
| salesid | sellerid | qty | d_rnk |
+---------+----------+-----+-------+
| 10001 | 1 | 10 | 2 |
| 10006 | 1 | 10 | 2 |
| 10005 | 1 | 30 | 1 |
| 20001 | 2 | 20 | 1 |
| 20002 | 2 | 20 | 1 |
| 30001 | 3 | 10 | 4 |
| 30003 | 3 | 15 | 3 |
| 30004 | 3 | 20 | 2 |
| 30007 | 3 | 30 | 1 |
| 40005 | 4 | 10 | 2 |
| 40001 | 4 | 40 | 1 |
+---------+----------+-----+-------+
```
Untuk berhasil menggunakan contoh terakhir, gunakan perintah berikut untuk menyisipkan baris ke dalam tabel WINSALES. Baris ini memiliki buyerid, sellerid, dan qtysold yang sama dengan baris lainnya. Ini akan menyebabkan dua baris terikat pada contoh terakhir dan dengan demikian akan menunjukkan perbedaan antara fungsi DENSE\$1RANK dan RANK.
```
INSERT INTO winsales VALUES(30009, '2/2/2003', 3, 'b', 20, NULL);
```
Contoh berikut mempartisi tabel dengan buyerid dan sellerid, mengurutkan setiap partisi berdasarkan kuantitas, dan menetapkan peringkat padat dan peringkat reguler untuk setiap baris. Hasilnya diurutkan setelah fungsi jendela diterapkan.
```
SELECT salesid, sellerid, qty, buyerid,
DENSE_RANK() OVER(PARTITION BY buyerid, sellerid ORDER BY qty DESC) AS d_rnk,
RANK() OVER (PARTITION BY buyerid, sellerid ORDER BY qty DESC) AS rnk
FROM winsales
ORDER BY rnk;
+---------+----------+-----+---------+-------+-----+
| salesid | sellerid | qty | buyerid | d_rnk | rnk |
+---------+----------+-----+---------+-------+-----+
| 20001 | 2 | 20 | b | 1 | 1 |
| 30007 | 3 | 30 | c | 1 | 1 |
| 10006 | 1 | 10 | c | 1 | 1 |
| 10005 | 1 | 30 | a | 1 | 1 |
| 20002 | 2 | 20 | c | 1 | 1 |
| 30009 | 3 | 20 | b | 1 | 1 |
| 40001 | 4 | 40 | a | 1 | 1 |
| 30004 | 3 | 20 | b | 1 | 1 |
| 10001 | 1 | 10 | c | 1 | 1 |
| 40005 | 4 | 10 | a | 2 | 2 |
| 30003 | 3 | 15 | b | 2 | 3 |
| 30001 | 3 | 10 | b | 3 | 4 |
+---------+----------+-----+---------+-------+-----+
```
# Fungsi jendela FIRST\$1VALUE
Diberikan kumpulan baris yang diurutkan, FIRST\$1VALUE mengembalikan nilai ekspresi yang ditentukan sehubungan dengan baris pertama di bingkai jendela.
Untuk informasi tentang memilih baris terakhir dalam bingkai, lihat[Fungsi jendela LAST\$1VALUE](r_WF_last_value.md).
## Sintaksis
```
FIRST_VALUE( expression )[ IGNORE NULLS | RESPECT NULLS ]
OVER (
[ PARTITION BY expr_list ]
[ ORDER BY order_list frame_clause ]
)
```
## Argumen
*ekspresi*
Kolom target atau ekspresi tempat fungsi beroperasi.
ABAIKAN NULLS
Ketika opsi ini digunakan dengan FIRST\$1VALUE, fungsi mengembalikan nilai pertama dalam frame yang tidak NULL (atau NULL jika semua nilai NULL).
RESPECT NULLS
Menunjukkan bahwa Amazon Redshift harus menyertakan nilai nol dalam penentuan baris mana yang akan digunakan. RESPECT NULLS didukung secara default jika Anda tidak menentukan IGNORE NULLS.
DI ATAS
Memperkenalkan klausa jendela untuk fungsi tersebut.
PARTISI OLEH *expr\$1list*
Mendefinisikan jendela untuk fungsi dalam hal satu atau lebih ekspresi.
PESANAN BERDASARKAN *order\$1list*
Mengurutkan baris dalam setiap partisi. Jika tidak ada klausa PARTITION BY yang ditentukan, ORDER BY mengurutkan seluruh tabel. Jika Anda menentukan klausa ORDER BY, Anda juga harus menentukan *frame\$1clause*.
Hasil fungsi FIRST\$1VALUE tergantung pada urutan data. Hasilnya nondeterministik dalam kasus-kasus berikut:
+ Ketika tidak ada klausa ORDER BY ditentukan dan partisi berisi dua nilai yang berbeda untuk ekspresi
+ Ketika ekspresi mengevaluasi nilai yang berbeda yang sesuai dengan nilai yang sama dalam daftar ORDER BY.
*frame\$1clause*
Jika klausa ORDER BY digunakan untuk fungsi agregat, klausa bingkai eksplisit diperlukan. Klausa bingkai menyempurnakan kumpulan baris di jendela fungsi, termasuk atau mengecualikan kumpulan baris dalam hasil yang diurutkan. Klausa bingkai terdiri dari kata kunci ROWS dan penentu terkait. Lihat [Ringkasan sintaks fungsi jendela](c_Window_functions.md#r_Window_function_synopsis).
## Jenis pengembalian
Fungsi-fungsi ini mendukung ekspresi yang menggunakan tipe data Amazon Redshift primitif. Tipe pengembalian sama dengan tipe data *ekspresi*.
## Contoh
Contoh berikut menggunakan tabel VENUE dari sampel data TICKIT. Untuk informasi selengkapnya, lihat [Database sampel](c_sampledb.md).
Contoh berikut mengembalikan kapasitas tempat duduk untuk setiap tempat di meja VENUE, dengan hasil yang diurutkan berdasarkan kapasitas (tinggi ke rendah). Fungsi FIRST\$1VALUE digunakan untuk memilih nama tempat yang sesuai dengan baris pertama dalam bingkai: dalam hal ini, baris dengan jumlah kursi tertinggi. Hasilnya dipartisi berdasarkan status, jadi ketika nilai VENUESTATE berubah, nilai pertama yang baru dipilih. Bingkai jendela tidak terbatas sehingga nilai pertama yang sama dipilih untuk setiap baris di setiap partisi.
Untuk California, `Qualcomm Stadium` memiliki jumlah kursi (`70561`) tertinggi, jadi nama ini adalah nilai pertama untuk semua baris di `CA` partisi.
```
select venuestate, venueseats, venuename,
first_value(venuename)
over(partition by venuestate
order by venueseats desc
rows between unbounded preceding and unbounded following)
from (select * from venue where venueseats >0)
order by venuestate;
venuestate | venueseats | venuename | first_value
-----------+------------+--------------------------------+------------------------------
CA | 70561 | Qualcomm Stadium | Qualcomm Stadium
CA | 69843 | Monster Park | Qualcomm Stadium
CA | 63026 | McAfee Coliseum | Qualcomm Stadium
CA | 56000 | Dodger Stadium | Qualcomm Stadium
CA | 45050 | Angel Stadium of Anaheim | Qualcomm Stadium
CA | 42445 | PETCO Park | Qualcomm Stadium
CA | 41503 | AT&T Park | Qualcomm Stadium
CA | 22000 | Shoreline Amphitheatre | Qualcomm Stadium
CO | 76125 | INVESCO Field | INVESCO Field
CO | 50445 | Coors Field | INVESCO Field
DC | 41888 | Nationals Park | Nationals Park
FL | 74916 | Dolphin Stadium | Dolphin Stadium
FL | 73800 | Jacksonville Municipal Stadium | Dolphin Stadium
FL | 65647 | Raymond James Stadium | Dolphin Stadium
FL | 36048 | Tropicana Field | Dolphin Stadium
...
```
Contoh berikut menunjukkan penggunaan opsi IGNORE NULLS dan bergantung pada penambahan baris baru ke tabel VENUE:
```
insert into venue values(2000,null,'Stanford','CA',90000);
```
Baris baru ini berisi nilai NULL untuk kolom VENUENAME. Sekarang ulangi query FIRST\$1VALUE yang ditunjukkan sebelumnya di bagian ini:
```
select venuestate, venueseats, venuename,
first_value(venuename)
over(partition by venuestate
order by venueseats desc
rows between unbounded preceding and unbounded following)
from (select * from venue where venueseats >0)
order by venuestate;
venuestate | venueseats | venuename | first_value
-----------+------------+----------------------------+-------------
CA | 90000 | NULL | NULL
CA | 70561 | Qualcomm Stadium | NULL
CA | 69843 | Monster Park | NULL
...
```
Karena baris baru berisi nilai VENUESEATS tertinggi (`90000`) dan VENUENAME-nya adalah NULL, fungsi FIRST\$1VALUE mengembalikan NULL untuk partisi. `CA` Untuk mengabaikan baris seperti ini dalam evaluasi fungsi, tambahkan opsi IGNORE NULLS ke argumen fungsi:
```
select venuestate, venueseats, venuename,
first_value(venuename) ignore nulls
over(partition by venuestate
order by venueseats desc
rows between unbounded preceding and unbounded following)
from (select * from venue where venuestate='CA')
order by venuestate;
venuestate | venueseats | venuename | first_value
------------+------------+----------------------------+------------------
CA | 90000 | NULL | Qualcomm Stadium
CA | 70561 | Qualcomm Stadium | Qualcomm Stadium
CA | 69843 | Monster Park | Qualcomm Stadium
...
```
# Fungsi jendela LAG
Fungsi jendela LAG mengembalikan nilai untuk baris pada offset tertentu di atas (sebelum) baris saat ini di partisi.
## Sintaksis
```
LAG (value_expr [, offset ])
[ IGNORE NULLS | RESPECT NULLS ]
OVER ( [ PARTITION BY window_partition ] ORDER BY window_ordering )
```
## Argumen
*value\$1expr*
Kolom target atau ekspresi tempat fungsi beroperasi.
*mengimbangi*
Parameter opsional yang menentukan jumlah baris sebelum baris saat ini untuk mengembalikan nilai untuk. Offset dapat berupa bilangan bulat konstan atau ekspresi yang mengevaluasi ke bilangan bulat. Jika Anda tidak menentukan offset, Amazon Redshift `1` menggunakan sebagai nilai default. Offset `0` menunjukkan baris saat ini.
ABAIKAN NULLS
Spesifikasi opsional yang menunjukkan bahwa Amazon Redshift harus melewati nilai nol dalam penentuan baris mana yang akan digunakan. Nilai nol disertakan jika IGNORE NULLS tidak terdaftar.
Anda dapat menggunakan ekspresi NVL atau COALESCE untuk mengganti nilai null dengan nilai lain. Untuk informasi selengkapnya, lihat [Fungsi NVL dan COALESCE](r_NVL_function.md).
RESPECT NULLS
Menunjukkan bahwa Amazon Redshift harus menyertakan nilai nol dalam penentuan baris mana yang akan digunakan. RESPECT NULLS didukung secara default jika Anda tidak menentukan IGNORE NULLS.
DI ATAS
Menentukan jendela partisi dan pemesanan. Klausa OVER tidak dapat berisi spesifikasi bingkai jendela.
PARTISI OLEH *window\$1partition*
Argumen opsional yang menetapkan rentang catatan untuk setiap grup dalam klausa OVER.
PESANAN DENGAN *window\$1ordering*
Mengurutkan baris dalam setiap partisi.
Fungsi jendela LAG mendukung ekspresi yang menggunakan salah satu tipe data Amazon Redshift. Jenis pengembalian sama dengan tipe *value\$1expr*.
## Contoh
Contoh berikut menunjukkan jumlah tiket yang dijual kepada pembeli dengan ID pembeli 3 dan waktu pembeli 3 membeli tiket. Untuk membandingkan setiap penjualan dengan penjualan sebelumnya untuk pembeli 3, kueri mengembalikan jumlah sebelumnya yang dijual untuk setiap penjualan. Karena tidak ada pembelian sebelum 1/16/2008, nilai jual kuantitas pertama sebelumnya adalah nol:
```
select buyerid, saletime, qtysold,
lag(qtysold,1) over (order by buyerid, saletime) as prev_qtysold
from sales where buyerid = 3 order by buyerid, saletime;
buyerid | saletime | qtysold | prev_qtysold
---------+---------------------+---------+--------------
3 | 2008-01-16 01:06:09 | 1 |
3 | 2008-01-28 02:10:01 | 1 | 1
3 | 2008-03-12 10:39:53 | 1 | 1
3 | 2008-03-13 02:56:07 | 1 | 1
3 | 2008-03-29 08:21:39 | 2 | 1
3 | 2008-04-27 02:39:01 | 1 | 2
3 | 2008-08-16 07:04:37 | 2 | 1
3 | 2008-08-22 11:45:26 | 2 | 2
3 | 2008-09-12 09:11:25 | 1 | 2
3 | 2008-10-01 06:22:37 | 1 | 1
3 | 2008-10-20 01:55:51 | 2 | 1
3 | 2008-10-28 01:30:40 | 1 | 2
(12 rows)
```
# Fungsi jendela LAST\$1VALUE
Diberikan kumpulan baris yang diurutkan, fungsi LAST\$1VALUE mengembalikan nilai ekspresi sehubungan dengan baris terakhir dalam bingkai.
Untuk informasi tentang memilih baris pertama dalam bingkai, lihat[Fungsi jendela FIRST\$1VALUE](r_WF_first_value.md).
## Sintaksis
```
LAST_VALUE( expression )[ IGNORE NULLS | RESPECT NULLS ]
OVER (
[ PARTITION BY expr_list ]
[ ORDER BY order_list frame_clause ]
)
```
## Argumen
*ekspresi*
Kolom target atau ekspresi tempat fungsi beroperasi.
ABAIKAN NULLS
Fungsi mengembalikan nilai terakhir dalam frame yang tidak NULL (atau NULL jika semua nilai NULL).
RESPECT NULLS
Menunjukkan bahwa Amazon Redshift harus menyertakan nilai nol dalam penentuan baris mana yang akan digunakan. RESPECT NULLS didukung secara default jika Anda tidak menentukan IGNORE NULLS.
DI ATAS
Memperkenalkan klausa jendela untuk fungsi tersebut.
PARTISI OLEH *expr\$1list*
Mendefinisikan jendela untuk fungsi dalam hal satu atau lebih ekspresi.
PESANAN BERDASARKAN *order\$1list*
Mengurutkan baris dalam setiap partisi. Jika tidak ada klausa PARTITION BY yang ditentukan, ORDER BY mengurutkan seluruh tabel. Jika Anda menentukan klausa ORDER BY, Anda juga harus menentukan *frame\$1clause*.
Hasilnya tergantung pada urutan data. Hasilnya nondeterministik dalam kasus-kasus berikut:
+ Ketika tidak ada klausa ORDER BY ditentukan dan partisi berisi dua nilai yang berbeda untuk ekspresi
+ Ketika ekspresi mengevaluasi nilai yang berbeda yang sesuai dengan nilai yang sama dalam daftar ORDER BY.
*frame\$1clause*
Jika klausa ORDER BY digunakan untuk fungsi agregat, klausa bingkai eksplisit diperlukan. Klausa bingkai menyempurnakan kumpulan baris di jendela fungsi, termasuk atau mengecualikan kumpulan baris dalam hasil yang diurutkan. Klausa bingkai terdiri dari kata kunci ROWS dan penentu terkait. Lihat [Ringkasan sintaks fungsi jendela](c_Window_functions.md#r_Window_function_synopsis).
## Jenis pengembalian
Fungsi-fungsi ini mendukung ekspresi yang menggunakan tipe data Amazon Redshift primitif. Tipe pengembalian sama dengan tipe data *ekspresi*.
## Contoh
Contoh berikut menggunakan tabel VENUE dari sampel data TICKIT. Untuk informasi selengkapnya, lihat [Database sampel](c_sampledb.md).
Contoh berikut mengembalikan kapasitas tempat duduk untuk setiap tempat di meja VENUE, dengan hasil yang diurutkan berdasarkan kapasitas (tinggi ke rendah). Fungsi LAST\$1VALUE digunakan untuk memilih nama tempat yang sesuai dengan baris terakhir dalam bingkai: dalam hal ini, baris dengan jumlah kursi paling sedikit. Hasilnya dipartisi berdasarkan status, jadi ketika nilai VENUESTATE berubah, nilai terakhir yang baru dipilih. Bingkai jendela tidak terbatas sehingga nilai terakhir yang sama dipilih untuk setiap baris di setiap partisi.
Untuk California, `Shoreline Amphitheatre` dikembalikan untuk setiap baris di partisi karena memiliki jumlah kursi terendah (`22000`).
```
select venuestate, venueseats, venuename,
last_value(venuename)
over(partition by venuestate
order by venueseats desc
rows between unbounded preceding and unbounded following)
from (select * from venue where venueseats >0)
order by venuestate;
venuestate | venueseats | venuename | last_value
-----------+------------+--------------------------------+------------------------------
CA | 70561 | Qualcomm Stadium | Shoreline Amphitheatre
CA | 69843 | Monster Park | Shoreline Amphitheatre
CA | 63026 | McAfee Coliseum | Shoreline Amphitheatre
CA | 56000 | Dodger Stadium | Shoreline Amphitheatre
CA | 45050 | Angel Stadium of Anaheim | Shoreline Amphitheatre
CA | 42445 | PETCO Park | Shoreline Amphitheatre
CA | 41503 | AT&T Park | Shoreline Amphitheatre
CA | 22000 | Shoreline Amphitheatre | Shoreline Amphitheatre
CO | 76125 | INVESCO Field | Coors Field
CO | 50445 | Coors Field | Coors Field
DC | 41888 | Nationals Park | Nationals Park
FL | 74916 | Dolphin Stadium | Tropicana Field
FL | 73800 | Jacksonville Municipal Stadium | Tropicana Field
FL | 65647 | Raymond James Stadium | Tropicana Field
FL | 36048 | Tropicana Field | Tropicana Field
...
```
# Fungsi jendela LEAD
Fungsi jendela LEAD mengembalikan nilai untuk baris pada offset tertentu di bawah (setelah) baris saat ini di partisi.
## Sintaksis
```
LEAD (value_expr [, offset ])
[ IGNORE NULLS | RESPECT NULLS ]
OVER ( [ PARTITION BY window_partition ] ORDER BY window_ordering )
```
## Argumen
*value\$1expr*
Kolom target atau ekspresi tempat fungsi beroperasi.
*mengimbangi*
Parameter opsional yang menentukan jumlah baris di bawah baris saat ini untuk mengembalikan nilai untuk. Offset dapat berupa bilangan bulat konstan atau ekspresi yang mengevaluasi ke bilangan bulat. Jika Anda tidak menentukan offset, Amazon Redshift `1` menggunakan sebagai nilai default. Offset `0` menunjukkan baris saat ini.
ABAIKAN NULLS
Spesifikasi opsional yang menunjukkan bahwa Amazon Redshift harus melewati nilai nol dalam penentuan baris mana yang akan digunakan. Nilai nol disertakan jika IGNORE NULLS tidak terdaftar.
Anda dapat menggunakan ekspresi NVL atau COALESCE untuk mengganti nilai null dengan nilai lain. Untuk informasi selengkapnya, lihat [Fungsi NVL dan COALESCE](r_NVL_function.md).
RESPECT NULLS
Menunjukkan bahwa Amazon Redshift harus menyertakan nilai nol dalam penentuan baris mana yang akan digunakan. RESPECT NULLS didukung secara default jika Anda tidak menentukan IGNORE NULLS.
DI ATAS
Menentukan jendela partisi dan pemesanan. Klausa OVER tidak dapat berisi spesifikasi bingkai jendela.
PARTISI OLEH *window\$1partition*
Argumen opsional yang menetapkan rentang catatan untuk setiap grup dalam klausa OVER.
PESANAN DENGAN *window\$1ordering*
Mengurutkan baris dalam setiap partisi.
Fungsi jendela LEAD mendukung ekspresi yang menggunakan salah satu tipe data Amazon Redshift. Jenis pengembalian sama dengan tipe *value\$1expr*.
## Contoh
Contoh berikut memberikan komisi untuk acara-acara di tabel PENJUALAN yang tiketnya dijual pada 1 Januari 2008 dan 2 Januari 2008 dan komisi yang dibayarkan untuk penjualan tiket untuk penjualan berikutnya. Contoh berikut menggunakan database sampel TICKIT. Untuk informasi selengkapnya, lihat [Database sampel](c_sampledb.md).
```
SELECT eventid, commission, saletime, LEAD(commission, 1) over ( ORDER BY saletime ) AS next_comm
FROM sales
WHERE saletime BETWEEN '2008-01-09 00:00:00' AND '2008-01-10 12:59:59'
LIMIT 10;
+---------+------------+---------------------+-----------+
| eventid | commission | saletime | next_comm |
+---------+------------+---------------------+-----------+
| 1664 | 13.2 | 2008-01-09 01:00:21 | 69.6 |
| 184 | 69.6 | 2008-01-09 01:00:36 | 116.1 |
| 6870 | 116.1 | 2008-01-09 01:02:37 | 11.1 |
| 3718 | 11.1 | 2008-01-09 01:05:19 | 205.5 |
| 6772 | 205.5 | 2008-01-09 01:14:04 | 38.4 |
| 3074 | 38.4 | 2008-01-09 01:26:50 | 209.4 |
| 5254 | 209.4 | 2008-01-09 01:29:16 | 26.4 |
| 3724 | 26.4 | 2008-01-09 01:40:09 | 57.6 |
| 5303 | 57.6 | 2008-01-09 01:40:21 | 51.6 |
| 3678 | 51.6 | 2008-01-09 01:42:54 | 43.8 |
+---------+------------+---------------------+-----------+
```
Contoh berikut memberikan perbedaan maksimum untuk komisi untuk acara di tabel PENJUALAN dan komisi yang dibayarkan untuk penjualan tiket untuk penjualan berikutnya untuk acara yang sama. Contoh ini menunjukkan cara menggunakan LEAD dengan klausa GROUP BY. Karena fungsi jendela tidak diizinkan dalam klausa agregat, contoh ini menggunakan subquery. Contoh berikut menggunakan database sampel TICKIT. Untuk informasi selengkapnya, lihat [Database sampel](c_sampledb.md).
```
SELECT eventid, eventname, max(next_comm_diff) as max_commission_difference
FROM
(
SELECT sales.eventid, eventname, commission - LEAD(commission, 1) over (ORDER BY sales.eventid, saletime) AS next_comm_diff
FROM sales JOIN event ON sales.eventid = event.eventid
)
GROUP BY eventid, eventname
ORDER BY eventid
LIMIT 10
| eventid | eventname | max_commission_difference |
+---------+-----------------------------+---------------------------+
| 1 | Gotterdammerung | 7.95 |
| 2 | Boris Godunov | 227.85 |
| 3 | Salome | 1350.9 |
| 4 | La Cenerentola (Cinderella) | 790.05 |
| 5 | Il Trovatore | 214.05 |
| 6 | L Elisir d Amore | 510.9 |
| 7 | Doctor Atomic | 180.6 |
| 9 | The Fly | 147 |
| 10 | Rigoletto | 186.6 |
+---------+-----------------------------+---------------------------+
```
# Fungsi jendela LISTAGG
Untuk setiap grup dalam kueri, fungsi jendela LISTAGG memerintahkan baris untuk grup tersebut sesuai dengan ekspresi ORDER BY, lalu menggabungkan nilai menjadi satu string.
## Sintaksis
```
LISTAGG( [DISTINCT] expression [, 'delimiter' ] )
[ WITHIN GROUP (ORDER BY order_list) ]
OVER ( [PARTITION BY partition_expression] )
```
## Argumen
DISTINCT
(Opsional) Klausa yang menghilangkan nilai duplikat dari ekspresi yang ditentukan sebelum digabungkan. Spasi trailing diabaikan, sehingga string `'a'` dan `'a '` diperlakukan sebagai duplikat. LISTAGG menggunakan nilai pertama yang ditemui. Untuk informasi selengkapnya, lihat [Signifikansi trailing blanko](r_Character_types.md#r_Character_types-significance-of-trailing-blanks).
*aggregate\$1expression*
Ekspresi yang valid (seperti nama kolom) yang memberikan nilai untuk digabungkan. Nilai NULL dan string kosong diabaikan.
*pembatas*
(Opsional) Konstanta string ke akan memisahkan nilai gabungan. Default-nya adalah NULL.
DALAM GRUP (PESANAN BERDASARKAN *order\$1list*)
(Opsional) Sebuah klausa yang menentukan urutan dari nilai agregat. Deterministik hanya jika ORDER BY menyediakan urutan unik. Defaultnya adalah menggabungkan semua baris dan mengembalikan satu nilai.
DI ATAS
Sebuah klausa yang menentukan partisi jendela. Klausa OVER tidak dapat berisi urutan jendela atau spesifikasi bingkai jendela.
PARTISI OLEH *partition\$1expression*
(Opsional) Menetapkan rentang catatan untuk setiap grup dalam klausa OVER.
## Pengembalian
Jika set hasil lebih besar dari 16.000.000 byte, maka LISTAGG mengembalikan kesalahan berikut:
```
Invalid operation: Result size exceeds LISTAGG limit
```
## Contoh
Contoh berikut menggunakan tabel WINSALES. Untuk deskripsi tabel WINSALES, lihat[Contoh tabel untuk contoh fungsi jendela](c_Window_functions.md#r_Window_function_example).
Contoh berikut mengembalikan daftar penjual IDs, diurutkan oleh ID penjual.
```
select listagg(sellerid)
within group (order by sellerid)
over() from winsales;
listagg
------------
11122333344
...
...
11122333344
11122333344
(11 rows)
```
Contoh berikut mengembalikan daftar penjual IDs untuk pembeli B, dipesan berdasarkan tanggal.
```
select listagg(sellerid)
within group (order by dateid)
over () as seller
from winsales
where buyerid = 'b' ;
seller
---------
3233
3233
3233
3233
```
Contoh berikut mengembalikan daftar tanggal penjualan yang dipisahkan koma untuk pembeli B.
```
select listagg(dateid,',')
within group (order by sellerid desc,salesid asc)
over () as dates
from winsales
where buyerid = 'b';
dates
-------------------------------------------
2003-08-02,2004-04-18,2004-04-18,2004-02-12
2003-08-02,2004-04-18,2004-04-18,2004-02-12
2003-08-02,2004-04-18,2004-04-18,2004-02-12
2003-08-02,2004-04-18,2004-04-18,2004-02-12
```
Contoh berikut menggunakan DISTINCT untuk mengembalikan daftar tanggal penjualan unik untuk pembeli B.
```
select listagg(distinct dateid,',')
within group (order by sellerid desc,salesid asc)
over () as dates
from winsales
where buyerid = 'b';
dates
--------------------------------
2003-08-02,2004-04-18,2004-02-12
2003-08-02,2004-04-18,2004-02-12
2003-08-02,2004-04-18,2004-02-12
2003-08-02,2004-04-18,2004-02-12
```
Contoh berikut mengembalikan daftar penjualan yang dipisahkan koma IDs untuk setiap ID pembeli.
```
select buyerid,
listagg(salesid,',')
within group (order by salesid)
over (partition by buyerid) as sales_id
from winsales
order by buyerid;
+---------+-------------------------+
| buyerid | sales_id |
+---------+-------------------------+
| a | 10005,40001,40005 |
| a | 10005,40001,40005 |
| a | 10005,40001,40005 |
| b | 20001,30001,30003,30004 |
| b | 20001,30001,30003,30004 |
| b | 20001,30001,30003,30004 |
| b | 20001,30001,30003,30004 |
| c | 10001,10006,20002,30007 |
| c | 10001,10006,20002,30007 |
| c | 10001,10006,20002,30007 |
| c | 10001,10006,20002,30007 |
+---------+-------------------------+
```
Contoh berikut menunjukkan dukungan LISTAGG dengan hasil gabungan hingga 16.000.000 byte:
```
CREATE TABLE large_data (
id INT,
content VARCHAR(65535)
);
INSERT INTO large_data VALUES
(1, REPEAT('A', 65535)),
(2, REPEAT('B', 65535)),
(3, REPEAT('C', 65535));
SELECT LEN(LISTAGG(content, ',') WITHIN GROUP (ORDER BY id)) AS total_length
FROM large_data;
total_length
--------------
196607
```
# Fungsi jendela MAX
Fungsi jendela MAX mengembalikan maksimum nilai ekspresi masukan. Fungsi MAX bekerja dengan nilai numerik dan mengabaikan nilai NULL.
## Sintaksis
```
MAX ( [ ALL ] expression ) OVER
(
[ PARTITION BY expr_list ]
[ ORDER BY order_list frame_clause ]
)
```
## Argumen
*ekspresi*
Kolom target atau ekspresi tempat fungsi beroperasi.
SEMUA
Dengan argumen ALL, fungsi mempertahankan semua nilai duplikat dari ekspresi. ALL adalah default. DISTINCT tidak didukung.
DI ATAS
Sebuah klausa yang menentukan klausa jendela untuk fungsi agregasi. Klausa OVER membedakan fungsi agregasi jendela dari fungsi agregasi set normal.
PARTISI OLEH *expr\$1list*
Mendefinisikan jendela untuk fungsi MAX dalam hal satu atau lebih ekspresi.
PESANAN BERDASARKAN *order\$1list*
Mengurutkan baris dalam setiap partisi. Jika tidak ada PARTITION BY yang ditentukan, ORDER BY menggunakan seluruh tabel.
*frame\$1clause*
Jika klausa ORDER BY digunakan untuk fungsi agregat, klausa bingkai eksplisit diperlukan. Klausa bingkai menyempurnakan kumpulan baris di jendela fungsi, termasuk atau mengecualikan kumpulan baris dalam hasil yang diurutkan. Klausa bingkai terdiri dari kata kunci ROWS dan penentu terkait. Lihat [Ringkasan sintaks fungsi jendela](c_Window_functions.md#r_Window_function_synopsis).
## Jenis Data
Menerima tipe data apa pun sebagai input. Mengembalikan tipe data yang sama sebagai *ekspresi*.
## Contoh
Contoh berikut menunjukkan ID penjualan, kuantitas, dan kuantitas maksimum dari awal jendela data:
```
select salesid, qty,
max(qty) over (order by salesid rows unbounded preceding) as max
from winsales
order by salesid;
salesid | qty | max
---------+-----+-----
10001 | 10 | 10
10005 | 30 | 30
10006 | 10 | 30
20001 | 20 | 30
20002 | 20 | 30
30001 | 10 | 30
30003 | 15 | 30
30004 | 20 | 30
30007 | 30 | 30
40001 | 40 | 40
40005 | 10 | 40
(11 rows)
```
Untuk deskripsi tabel WINSALES, lihat[Contoh tabel untuk contoh fungsi jendela](c_Window_functions.md#r_Window_function_example).
Contoh berikut menunjukkan salesid, kuantitas, dan kuantitas maksimum dalam bingkai terbatas:
```
select salesid, qty,
max(qty) over (order by salesid rows between 2 preceding and 1 preceding) as max
from winsales
order by salesid;
salesid | qty | max
---------+-----+-----
10001 | 10 |
10005 | 30 | 10
10006 | 10 | 30
20001 | 20 | 30
20002 | 20 | 20
30001 | 10 | 20
30003 | 15 | 20
30004 | 20 | 15
30007 | 30 | 20
40001 | 40 | 30
40005 | 10 | 40
(11 rows)
```
# Fungsi jendela MEDIAN
Menghitung nilai median untuk rentang nilai di jendela atau partisi. Nilai NULL dalam rentang diabaikan.
MEDIAN adalah fungsi distribusi terbalik yang mengasumsikan model distribusi kontinu.
## Sintaksis
```
MEDIAN ( median_expression )
OVER ( [ PARTITION BY partition_expression ] )
```
## Argumen
*median\$1expression*
Ekspresi, seperti nama kolom, yang memberikan nilai untuk menentukan median. Ekspresi harus memiliki tipe data numerik atau datetime atau secara implisit dapat dikonversi menjadi satu.
DI ATAS
Sebuah klausa yang menentukan partisi jendela. Klausa OVER tidak dapat berisi urutan jendela atau spesifikasi bingkai jendela.
PARTISI OLEH *partition\$1expression*
Tidak wajib. Ekspresi yang menetapkan rentang catatan untuk setiap grup dalam klausa OVER.
## Jenis Data
Jenis pengembalian ditentukan oleh tipe data *median\$1expression*. Tabel berikut menunjukkan tipe kembali untuk setiap tipe data *median\$1expression*.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/redshift/latest/dg/r_WF_MEDIAN.html)
## Catatan penggunaan
Jika argumen *median\$1expression* adalah tipe data DECIMAL yang didefinisikan dengan presisi maksimum 38 digit, ada kemungkinan MEDIAN akan mengembalikan hasil yang tidak akurat atau kesalahan. Jika nilai pengembalian fungsi MEDIAN melebihi 38 digit, hasilnya terpotong agar sesuai, yang menyebabkan hilangnya presisi. Jika, selama interpolasi, hasil antara melebihi presisi maksimum, luapan numerik terjadi dan fungsi mengembalikan kesalahan. Untuk menghindari kondisi ini, sebaiknya gunakan tipe data dengan presisi lebih rendah atau mentransmisikan argumen *median\$1expression* ke presisi yang lebih rendah.
Misalnya, fungsi SUM dengan argumen DECIMAL mengembalikan presisi default 38 digit. Skala hasilnya sama dengan skala argumen. Jadi, misalnya, SUM kolom DECIMAL (5,2) mengembalikan tipe data DECIMAL (38,2).
Contoh berikut menggunakan fungsi SUM dalam argumen *median\$1expression* dari fungsi MEDIAN. Tipe data dari kolom PRICEPAID adalah DECIMAL (8,2), sehingga fungsi SUM mengembalikan DECIMAL (38,2).
```
select salesid, sum(pricepaid), median(sum(pricepaid))
over() from sales where salesid < 10 group by salesid;
```
Untuk menghindari potensi kehilangan presisi atau kesalahan luapan, lemparkan hasilnya ke tipe data DECIMAL dengan presisi lebih rendah, seperti yang ditunjukkan contoh berikut.
```
select salesid, sum(pricepaid), median(sum(pricepaid)::decimal(30,2))
over() from sales where salesid < 10 group by salesid;
```
## Contoh
Contoh berikut menghitung jumlah penjualan rata-rata untuk setiap penjual:
```
select sellerid, qty, median(qty)
over (partition by sellerid)
from winsales
order by sellerid;
sellerid qty median
---------------------------
1 10 10.0
1 10 10.0
1 30 10.0
2 20 20.0
2 20 20.0
3 10 17.5
3 15 17.5
3 20 17.5
3 30 17.5
4 10 25.0
4 40 25.0
```
Untuk deskripsi tabel WINSALES, lihat[Contoh tabel untuk contoh fungsi jendela](c_Window_functions.md#r_Window_function_example).
# Fungsi jendela MIN
Fungsi jendela MIN mengembalikan minimum nilai ekspresi masukan. Fungsi MIN bekerja dengan nilai numerik dan mengabaikan nilai NULL.
## Sintaksis
```
MIN ( [ ALL ] expression ) OVER
(
[ PARTITION BY expr_list ]
[ ORDER BY order_list frame_clause ]
)
```
## Argumen
*ekspresi*
Kolom target atau ekspresi tempat fungsi beroperasi.
SEMUA
Dengan argumen ALL, fungsi mempertahankan semua nilai duplikat dari ekspresi. ALL adalah default. DISTINCT tidak didukung.
DI ATAS
Menentukan klausa jendela untuk fungsi agregasi. Klausa OVER membedakan fungsi agregasi jendela dari fungsi agregasi set normal.
PARTISI OLEH *expr\$1list*
Mendefinisikan jendela untuk fungsi MIN dalam hal satu atau lebih ekspresi.
PESANAN BERDASARKAN *order\$1list*
Mengurutkan baris dalam setiap partisi. Jika tidak ada PARTITION BY yang ditentukan, ORDER BY menggunakan seluruh tabel.
*frame\$1clause*
Jika klausa ORDER BY digunakan untuk fungsi agregat, klausa bingkai eksplisit diperlukan. Klausa bingkai menyempurnakan kumpulan baris di jendela fungsi, termasuk atau mengecualikan kumpulan baris dalam hasil yang diurutkan. Klausa bingkai terdiri dari kata kunci ROWS dan penentu terkait. Lihat [Ringkasan sintaks fungsi jendela](c_Window_functions.md#r_Window_function_synopsis).
## Jenis Data
Menerima tipe data apa pun sebagai input. Mengembalikan tipe data yang sama sebagai *ekspresi*.
## Contoh
Contoh berikut menunjukkan ID penjualan, kuantitas, dan kuantitas minimum dari awal jendela data:
```
select salesid, qty,
min(qty) over
(order by salesid rows unbounded preceding)
from winsales
order by salesid;
salesid | qty | min
---------+-----+-----
10001 | 10 | 10
10005 | 30 | 10
10006 | 10 | 10
20001 | 20 | 10
20002 | 20 | 10
30001 | 10 | 10
30003 | 15 | 10
30004 | 20 | 10
30007 | 30 | 10
40001 | 40 | 10
40005 | 10 | 10
(11 rows)
```
Untuk deskripsi tabel WINSALES, lihat[Contoh tabel untuk contoh fungsi jendela](c_Window_functions.md#r_Window_function_example).
Contoh berikut menunjukkan ID penjualan, kuantitas, dan kuantitas minimum dalam bingkai terbatas:
```
select salesid, qty,
min(qty) over
(order by salesid rows between 2 preceding and 1 preceding) as min
from winsales
order by salesid;
salesid | qty | min
---------+-----+-----
10001 | 10 |
10005 | 30 | 10
10006 | 10 | 10
20001 | 20 | 10
20002 | 20 | 10
30001 | 10 | 20
30003 | 15 | 10
30004 | 20 | 10
30007 | 30 | 15
40001 | 40 | 20
40005 | 10 | 30
(11 rows)
```
# Fungsi jendela NTH\$1VALUE
Fungsi jendela NTH\$1VALUE mengembalikan nilai ekspresi dari baris tertentu dari bingkai jendela relatif terhadap baris pertama jendela.
## Sintaksis
```
NTH_VALUE (expr, offset)
[ IGNORE NULLS | RESPECT NULLS ]
OVER
( [ PARTITION BY window_partition ]
[ ORDER BY window_ordering
frame_clause ] )
```
## Argumen
*expr*
Kolom target atau ekspresi tempat fungsi beroperasi.
*mengimbangi*
Menentukan nomor baris relatif terhadap baris pertama di jendela untuk mengembalikan ekspresi. *Offset* dapat berupa konstanta atau ekspresi dan harus berupa bilangan bulat positif yang lebih besar dari 0.
ABAIKAN NULLS
Spesifikasi opsional yang menunjukkan bahwa Amazon Redshift harus melewati nilai nol dalam penentuan baris mana yang akan digunakan. Nilai nol disertakan jika IGNORE NULLS tidak terdaftar.
RESPECT NULLS
Menunjukkan bahwa Amazon Redshift harus menyertakan nilai nol dalam penentuan baris mana yang akan digunakan. RESPECT NULLS didukung secara default jika Anda tidak menentukan IGNORE NULLS.
DI ATAS
Menentukan partisi jendela, pemesanan, dan bingkai jendela.
PARTISI OLEH *window\$1partition*
Menetapkan rentang catatan untuk setiap grup dalam klausa OVER.
PESANAN DENGAN *window\$1ordering*
Mengurutkan baris dalam setiap partisi. Jika ORDER BY dihilangkan, bingkai default terdiri dari semua baris di partisi.
*frame\$1clause*
Jika klausa ORDER BY digunakan untuk fungsi agregat, klausa bingkai eksplisit diperlukan. Klausa bingkai menyempurnakan kumpulan baris di jendela fungsi, termasuk atau mengecualikan kumpulan baris dalam hasil yang diurutkan. Klausa bingkai terdiri dari kata kunci ROWS dan penentu terkait. Lihat [Ringkasan sintaks fungsi jendela](c_Window_functions.md#r_Window_function_synopsis).
Fungsi jendela NTH\$1VALUE mendukung ekspresi yang menggunakan salah satu tipe data Amazon Redshift. Jenis pengembalian sama dengan tipe *expr*.
## Contoh
Contoh berikut menunjukkan jumlah kursi di tempat terbesar ketiga di California, Florida, dan New York dibandingkan dengan jumlah kursi di tempat lain di negara bagian tersebut:
```
select venuestate, venuename, venueseats,
nth_value(venueseats, 3)
ignore nulls
over(partition by venuestate order by venueseats desc
rows between unbounded preceding and unbounded following)
as third_most_seats
from (select * from venue where venueseats > 0 and
venuestate in('CA', 'FL', 'NY'))
order by venuestate;
venuestate | venuename | venueseats | third_most_seats
------------+--------------------------------+------------+------------------
CA | Qualcomm Stadium | 70561 | 63026
CA | Monster Park | 69843 | 63026
CA | McAfee Coliseum | 63026 | 63026
CA | Dodger Stadium | 56000 | 63026
CA | Angel Stadium of Anaheim | 45050 | 63026
CA | PETCO Park | 42445 | 63026
CA | AT&T Park | 41503 | 63026
CA | Shoreline Amphitheatre | 22000 | 63026
FL | Dolphin Stadium | 74916 | 65647
FL | Jacksonville Municipal Stadium | 73800 | 65647
FL | Raymond James Stadium | 65647 | 65647
FL | Tropicana Field | 36048 | 65647
NY | Ralph Wilson Stadium | 73967 | 20000
NY | Yankee Stadium | 52325 | 20000
NY | Madison Square Garden | 20000 | 20000
(15 rows)
```
# Fungsi jendela NTILE
Fungsi jendela NTILE membagi baris yang diurutkan dalam partisi ke dalam jumlah kelompok peringkat yang ditentukan dengan ukuran yang sama mungkin dan mengembalikan grup tempat baris tertentu jatuh ke dalamnya.
## Sintaksis
```
NTILE (expr)
OVER (
[ PARTITION BY expression_list ]
[ ORDER BY order_list ]
)
```
## Argumen
*expr*
Jumlah kelompok peringkat dan harus menghasilkan nilai integer positif (lebih besar dari 0) untuk setiap partisi. Argumen *expr* tidak boleh dibatalkan.
DI ATAS
Sebuah klausa yang menentukan jendela partisi dan pemesanan. Klausa OVER tidak dapat berisi spesifikasi bingkai jendela.
PARTISI OLEH *window\$1partition*
Tidak wajib. Rentang catatan untuk setiap grup dalam klausa OVER.
PESANAN DENGAN *window\$1ordering*
Tidak wajib. Ekspresi yang mengurutkan baris dalam setiap partisi. Jika klausa ORDER BY dihilangkan, perilaku peringkatnya sama.
Jika ORDER BY tidak menghasilkan urutan unik, urutan baris adalah nondeterministik. Untuk informasi selengkapnya, lihat [Urutan data yang unik untuk fungsi jendela](c_Window_functions.md#r_Examples_order_by_WF).
## Jenis pengembalian
BIGINT
## Contoh
Contoh berikut peringkat ke dalam empat kelompok peringkat harga yang dibayarkan untuk tiket Hamlet pada 26 Agustus 2008. Hasil set adalah 17 baris, dibagi hampir merata di antara peringkat 1 sampai 4:
```
select eventname, caldate, pricepaid, ntile(4)
over(order by pricepaid desc) from sales, event, date
where sales.eventid=event.eventid and event.dateid=date.dateid and eventname='Hamlet'
and caldate='2008-08-26'
order by 4;
eventname | caldate | pricepaid | ntile
-----------+------------+-----------+-------
Hamlet | 2008-08-26 | 1883.00 | 1
Hamlet | 2008-08-26 | 1065.00 | 1
Hamlet | 2008-08-26 | 589.00 | 1
Hamlet | 2008-08-26 | 530.00 | 1
Hamlet | 2008-08-26 | 472.00 | 1
Hamlet | 2008-08-26 | 460.00 | 2
Hamlet | 2008-08-26 | 355.00 | 2
Hamlet | 2008-08-26 | 334.00 | 2
Hamlet | 2008-08-26 | 296.00 | 2
Hamlet | 2008-08-26 | 230.00 | 3
Hamlet | 2008-08-26 | 216.00 | 3
Hamlet | 2008-08-26 | 212.00 | 3
Hamlet | 2008-08-26 | 106.00 | 3
Hamlet | 2008-08-26 | 100.00 | 4
Hamlet | 2008-08-26 | 94.00 | 4
Hamlet | 2008-08-26 | 53.00 | 4
Hamlet | 2008-08-26 | 25.00 | 4
(17 rows)
```
# Fungsi jendela PERCENT\$1RANK
Menghitung peringkat persen dari baris yang diberikan. Peringkat persen ditentukan dengan menggunakan rumus ini:
`(x - 1) / (the number of rows in the window or partition - 1)`
dimana *x* adalah pangkat dari baris saat ini. Dataset berikut menggambarkan penggunaan rumus ini:
```
Row# Value Rank Calculation PERCENT_RANK
1 15 1 (1-1)/(7-1) 0.0000
2 20 2 (2-1)/(7-1) 0.1666
3 20 2 (2-1)/(7-1) 0.1666
4 20 2 (2-1)/(7-1) 0.1666
5 30 5 (5-1)/(7-1) 0.6666
6 30 5 (5-1)/(7-1) 0.6666
7 40 7 (7-1)/(7-1) 1.0000
```
Rentang nilai pengembalian adalah 0 hingga 1, inklusif. Baris pertama dalam set apa pun memiliki PERCENT\$1RANK 0.
## Sintaksis
```
PERCENT_RANK ()
OVER (
[ PARTITION BY partition_expression ]
[ ORDER BY order_list ]
)
```
## Argumen
( )
Fungsi ini tidak mengambil argumen, tetapi tanda kurung kosong diperlukan.
DI ATAS
Sebuah klausa yang menentukan partisi jendela. Klausa OVER tidak dapat berisi spesifikasi bingkai jendela.
PARTISI OLEH *partition\$1expression*
Tidak wajib. Ekspresi yang menetapkan rentang catatan untuk setiap grup dalam klausa OVER.
PESANAN BERDASARKAN *order\$1list*
Tidak wajib. Ekspresi untuk menghitung peringkat persen. Ekspresi harus memiliki tipe data numerik atau secara implisit dapat dikonversi menjadi satu. Jika ORDER BY dihilangkan, nilai kembalinya adalah 0 untuk semua baris.
Jika ORDER BY tidak menghasilkan urutan unik, urutan baris adalah nondeterministik. Untuk informasi selengkapnya, lihat [Urutan data yang unik untuk fungsi jendela](c_Window_functions.md#r_Examples_order_by_WF).
## Jenis pengembalian
FLOAT8
## Contoh
Contoh berikut menghitung peringkat persen dari jumlah penjualan untuk setiap penjual:
```
select sellerid, qty, percent_rank()
over (partition by sellerid order by qty)
from winsales;
sellerid qty percent_rank
----------------------------------------
1 10.00 0.0
1 10.64 0.5
1 30.37 1.0
3 10.04 0.0
3 15.15 0.33
3 20.75 0.67
3 30.55 1.0
2 20.09 0.0
2 20.12 1.0
4 10.12 0.0
4 40.23 1.0
```
Untuk deskripsi tabel WINSALES, lihat[Contoh tabel untuk contoh fungsi jendela](c_Window_functions.md#r_Window_function_example).
# Fungsi jendela PERCENTILE\$1CONT
PERCENTILE\$1CONT adalah fungsi distribusi terbalik yang mengasumsikan model distribusi kontinu. Dibutuhkan nilai persentil dan spesifikasi sortir, dan mengembalikan nilai interpolasi yang akan jatuh ke dalam nilai persentil yang diberikan sehubungan dengan spesifikasi sortir.
PERCENTILE\$1CONT menghitung interpolasi linier antara nilai setelah mengurutkannya. Menggunakan nilai persentil `(P)` dan jumlah baris bukan nol `(N)` dalam grup agregasi, fungsi menghitung nomor baris setelah mengurutkan baris sesuai dengan spesifikasi pengurutan. Nomor baris ini `(RN)` dihitung sesuai dengan `RN = (1+ (P*(N-1))` rumus. Hasil akhir dari fungsi agregat dihitung dengan interpolasi linier antara nilai-nilai dari baris pada nomor baris dan. `CRN = CEILING(RN)` `FRN = FLOOR(RN)`
Hasil akhirnya adalah sebagai berikut.
Jika `(CRN = FRN = RN)` maka hasilnya adalah `(value of expression from row at RN)`
Jika tidak, hasilnya adalah sebagai berikut:
`(CRN - RN) * (value of expression for row at FRN) + (RN - FRN) * (value of expression for row at CRN)`.
Anda hanya dapat menentukan klausa PARTITION dalam klausa OVER. Jika PARTITION ditentukan, untuk setiap baris, PERCENTILE\$1CONT mengembalikan nilai yang akan jatuh ke dalam persentil yang ditentukan di antara satu set nilai dalam partisi yang diberikan.
## Sintaksis
```
PERCENTILE_CONT ( percentile )
WITHIN GROUP (ORDER BY expr)
OVER ( [ PARTITION BY expr_list ] )
```
## Argumen
*persentil*
Konstanta numerik antara 0 dan 1. Null diabaikan dalam perhitungan.
DALAM GRUP (ORDER BY *expr)*
Menentukan numerik atau date/time nilai-nilai untuk mengurutkan dan menghitung persentil atas.
DI ATAS
Menentukan partisi jendela. Klausa OVER tidak dapat berisi urutan jendela atau spesifikasi bingkai jendela.
PARTISI OLEH *expr*
Argumen opsional yang menetapkan rentang catatan untuk setiap grup dalam klausa OVER.
## Pengembalian
Tipe pengembalian ditentukan oleh tipe data ekspresi ORDER BY dalam klausa WITHIN GROUP. Tabel berikut menunjukkan tipe pengembalian untuk setiap tipe data ekspresi ORDER BY.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/redshift/latest/dg/r_WF_PERCENTILE_CONT.html)
## Catatan penggunaan
Jika ekspresi ORDER BY adalah tipe data DECIMAL yang ditentukan dengan presisi maksimum 38 digit, ada kemungkinan bahwa PERCENTILE\$1CONT akan mengembalikan hasil yang tidak akurat atau kesalahan. Jika nilai pengembalian fungsi PERCENTILE\$1CONT melebihi 38 digit, hasilnya terpotong agar sesuai, yang menyebabkan hilangnya presisi. Jika, selama interpolasi, hasil antara melebihi presisi maksimum, luapan numerik terjadi dan fungsi mengembalikan kesalahan. Untuk menghindari kondisi ini, sebaiknya gunakan tipe data dengan presisi lebih rendah atau mentransmisikan ekspresi ORDER BY ke presisi yang lebih rendah.
Misalnya, fungsi SUM dengan argumen DECIMAL mengembalikan presisi default 38 digit. Skala hasilnya sama dengan skala argumen. Jadi, misalnya, SUM kolom DECIMAL (5,2) mengembalikan tipe data DECIMAL (38,2).
Contoh berikut menggunakan fungsi SUM dalam klausa ORDER BY dari fungsi PERCENTILE\$1CONT. Tipe data dari kolom PRICEPAID adalah DECIMAL (8,2), sehingga fungsi SUM mengembalikan DECIMAL (38,2).
```
select salesid, sum(pricepaid), percentile_cont(0.6)
within group (order by sum(pricepaid) desc) over()
from sales where salesid < 10 group by salesid;
```
Untuk menghindari potensi kehilangan presisi atau kesalahan luapan, lemparkan hasilnya ke tipe data DECIMAL dengan presisi lebih rendah, seperti yang ditunjukkan contoh berikut.
```
select salesid, sum(pricepaid), percentile_cont(0.6)
within group (order by sum(pricepaid)::decimal(30,2) desc) over()
from sales where salesid < 10 group by salesid;
```
## Contoh
Contoh berikut menggunakan tabel WINSALES. Untuk deskripsi tabel WINSALES, lihat[Contoh tabel untuk contoh fungsi jendela](c_Window_functions.md#r_Window_function_example).
```
select sellerid, qty, percentile_cont(0.5)
within group (order by qty)
over() as median from winsales;
sellerid | qty | median
----------+-----+--------
1 | 10 | 20.0
1 | 10 | 20.0
3 | 10 | 20.0
4 | 10 | 20.0
3 | 15 | 20.0
2 | 20 | 20.0
3 | 20 | 20.0
2 | 20 | 20.0
3 | 30 | 20.0
1 | 30 | 20.0
4 | 40 | 20.0
(11 rows)
```
```
select sellerid, qty, percentile_cont(0.5)
within group (order by qty)
over(partition by sellerid) as median from winsales;
sellerid | qty | median
----------+-----+--------
2 | 20 | 20.0
2 | 20 | 20.0
4 | 10 | 25.0
4 | 40 | 25.0
1 | 10 | 10.0
1 | 10 | 10.0
1 | 30 | 10.0
3 | 10 | 17.5
3 | 15 | 17.5
3 | 20 | 17.5
3 | 30 | 17.5
(11 rows)
```
Contoh berikut menghitung PERCENTILE\$1CONT dan PERCENTILE\$1DISC dari penjualan tiket untuk penjual di negara bagian Washington.
```
SELECT sellerid, state, sum(qtysold*pricepaid) sales,
percentile_cont(0.6) within group (order by sum(qtysold*pricepaid::decimal(14,2) ) desc) over(),
percentile_disc(0.6) within group (order by sum(qtysold*pricepaid::decimal(14,2) ) desc) over()
from sales s, users u
where s.sellerid = u.userid and state = 'WA' and sellerid < 1000
group by sellerid, state;
sellerid | state | sales | percentile_cont | percentile_disc
----------+-------+---------+-----------------+-----------------
127 | WA | 6076.00 | 2044.20 | 1531.00
787 | WA | 6035.00 | 2044.20 | 1531.00
381 | WA | 5881.00 | 2044.20 | 1531.00
777 | WA | 2814.00 | 2044.20 | 1531.00
33 | WA | 1531.00 | 2044.20 | 1531.00
800 | WA | 1476.00 | 2044.20 | 1531.00
1 | WA | 1177.00 | 2044.20 | 1531.00
(7 rows)
```
# Fungsi jendela PERCENTILE\$1DISC
PERCENTILE\$1DISC adalah fungsi distribusi terbalik yang mengasumsikan model distribusi diskrit. Dibutuhkan nilai persentil dan spesifikasi semacam dan mengembalikan elemen dari set yang diberikan.
Untuk nilai persentil yang diberikan P, PERCENTILE\$1DISC mengurutkan nilai ekspresi dalam klausa ORDER BY dan mengembalikan nilai dengan nilai distribusi kumulatif terkecil (sehubungan dengan spesifikasi pengurutan yang sama) yang lebih besar dari atau sama dengan P.
Anda hanya dapat menentukan klausa PARTITION dalam klausa OVER.
## Sintaksis
```
PERCENTILE_DISC ( percentile )
WITHIN GROUP (ORDER BY expr)
OVER ( [ PARTITION BY expr_list ] )
```
## Argumen
*persentil*
Konstanta numerik antara 0 dan 1. Null diabaikan dalam perhitungan.
DALAM GRUP (ORDER BY *expr)*
Menentukan numerik atau date/time nilai-nilai untuk mengurutkan dan menghitung persentil atas.
DI ATAS
Menentukan partisi jendela. Klausa OVER tidak dapat berisi urutan jendela atau spesifikasi bingkai jendela.
PARTISI OLEH *expr*
Argumen opsional yang menetapkan rentang catatan untuk setiap grup dalam klausa OVER.
## Pengembalian
Tipe data yang sama dengan ekspresi ORDER BY dalam klausa WITHIN GROUP.
## Contoh
Contoh berikut menggunakan tabel WINSALES. Untuk deskripsi tabel WINSALES, lihat[Contoh tabel untuk contoh fungsi jendela](c_Window_functions.md#r_Window_function_example).
```
SELECT sellerid, qty, PERCENTILE_DISC(0.5)
WITHIN GROUP (ORDER BY qty)
OVER() AS MEDIAN FROM winsales;
+----------+-----+--------+
| sellerid | qty | median |
+----------+-----+--------+
| 3 | 10 | 20 |
| 1 | 10 | 20 |
| 1 | 10 | 20 |
| 4 | 10 | 20 |
| 3 | 15 | 20 |
| 2 | 20 | 20 |
| 2 | 20 | 20 |
| 3 | 20 | 20 |
| 1 | 30 | 20 |
| 3 | 30 | 20 |
| 4 | 40 | 20 |
+----------+-----+--------+
SELECT sellerid, qty, PERCENTILE_DISC(0.5)
WITHIN GROUP (ORDER BY qty)
OVER(PARTITION BY sellerid) AS MEDIAN FROM winsales;
+----------+-----+--------+
| sellerid | qty | median |
+----------+-----+--------+
| 4 | 10 | 10 |
| 4 | 40 | 10 |
| 3 | 10 | 15 |
| 3 | 15 | 15 |
| 3 | 20 | 15 |
| 3 | 30 | 15 |
| 2 | 20 | 20 |
| 2 | 20 | 20 |
| 1 | 10 | 10 |
| 1 | 10 | 10 |
| 1 | 30 | 10 |
+----------+-----+--------+
```
Untuk menemukan PERCENTILE\$1DISC (0,25) dan PERCENTILE\$1DISC (0,75) untuk kuantitas saat dipartisi oleh ID penjual, gunakan contoh berikut.
```
SELECT sellerid, qty, PERCENTILE_DISC(0.25)
WITHIN GROUP (ORDER BY qty)
OVER(PARTITION BY sellerid) AS quartile1 FROM winsales;
+----------+-----+-----------+
| sellerid | qty | quartile1 |
+----------+-----+-----------+
| 4 | 10 | 10 |
| 4 | 40 | 10 |
| 2 | 20 | 20 |
| 2 | 20 | 20 |
| 3 | 10 | 10 |
| 3 | 15 | 10 |
| 3 | 20 | 10 |
| 3 | 30 | 10 |
| 1 | 10 | 10 |
| 1 | 10 | 10 |
| 1 | 30 | 10 |
+----------+-----+-----------+
SELECT sellerid, qty, PERCENTILE_DISC(0.75)
WITHIN GROUP (ORDER BY qty)
OVER(PARTITION BY sellerid) AS quartile3 FROM winsales;
+----------+-----+-----------+
| sellerid | qty | quartile3 |
+----------+-----+-----------+
| 3 | 10 | 20 |
| 3 | 15 | 20 |
| 3 | 20 | 20 |
| 3 | 30 | 20 |
| 4 | 10 | 40 |
| 4 | 40 | 40 |
| 2 | 20 | 20 |
| 2 | 20 | 20 |
| 1 | 10 | 30 |
| 1 | 10 | 30 |
| 1 | 30 | 30 |
+----------+-----+-----------+
```
# Fungsi jendela RANK
Fungsi jendela RANK menentukan peringkat nilai dalam sekelompok nilai, berdasarkan ekspresi ORDER BY dalam klausa OVER. Jika klausa PARTITION BY opsional ada, peringkat diatur ulang untuk setiap kelompok baris. Baris dengan nilai yang sama untuk kriteria peringkat menerima peringkat yang sama. Amazon Redshift menambahkan jumlah baris terikat ke peringkat terikat untuk menghitung peringkat berikutnya dan dengan demikian peringkat mungkin bukan angka berurutan. Misalnya, jika dua baris diberi peringkat 1, peringkat berikutnya adalah 3.
RANK berbeda dari [Fungsi jendela DENSE\$1RANK](r_WF_DENSE_RANK.md) dalam satu hal: Untuk DENSE\$1RANK, jika dua atau lebih baris mengikat, tidak ada celah dalam urutan nilai peringkat. Misalnya, jika dua baris diberi peringkat 1, peringkat berikutnya adalah 2.
Anda dapat memiliki fungsi peringkat dengan klausa PARTITION BY dan ORDER BY yang berbeda dalam kueri yang sama.
## Sintaksis
```
RANK () OVER
(
[ PARTITION BY expr_list ]
[ ORDER BY order_list ]
)
```
## Argumen
( )
Fungsi ini tidak mengambil argumen, tetapi tanda kurung kosong diperlukan.
DI ATAS
Jendela klausa untuk fungsi RANK.
PARTISI OLEH *expr\$1list*
Tidak wajib. Satu atau lebih ekspresi yang menentukan jendela.
PESANAN BERDASARKAN *order\$1list*
Tidak wajib. Mendefinisikan kolom yang menjadi dasar nilai peringkat. Jika tidak ada PARTITION BY yang ditentukan, ORDER BY menggunakan seluruh tabel. Jika ORDER BY dihilangkan, nilai kembalinya adalah 1 untuk semua baris.
Jika ORDER BY tidak menghasilkan urutan unik, urutan baris adalah nondeterministik. Untuk informasi selengkapnya, lihat [Urutan data yang unik untuk fungsi jendela](c_Window_functions.md#r_Examples_order_by_WF).
## Jenis pengembalian
INTEGER
## Contoh
Contoh berikut memesan tabel berdasarkan kuantitas yang dijual (naik default), dan menetapkan peringkat untuk setiap baris. Nilai peringkat 1 adalah nilai peringkat tertinggi. Hasilnya diurutkan setelah hasil fungsi jendela diterapkan:
```
select salesid, qty,
rank() over (order by qty) as rnk
from winsales
order by 2,1;
salesid | qty | rnk
--------+-----+-----
10001 | 10 | 1
10006 | 10 | 1
30001 | 10 | 1
40005 | 10 | 1
30003 | 15 | 5
20001 | 20 | 6
20002 | 20 | 6
30004 | 20 | 6
10005 | 30 | 9
30007 | 30 | 9
40001 | 40 | 11
(11 rows)
```
Perhatikan bahwa klausa ORDER BY luar dalam contoh ini menyertakan kolom 2 dan 1 untuk memastikan bahwa Amazon Redshift mengembalikan hasil yang diurutkan secara konsisten setiap kali kueri ini dijalankan. Misalnya, baris dengan penjualan IDs 10001 dan 10006 memiliki nilai QTY dan RNK yang identik. Memesan hasil akhir yang ditetapkan oleh kolom 1 memastikan bahwa baris 10001 selalu jatuh sebelum 10006. Untuk deskripsi tabel WINSALES, lihat[Contoh tabel untuk contoh fungsi jendela](c_Window_functions.md#r_Window_function_example).
Dalam contoh berikut, urutan dibalik untuk fungsi window (`order by qty desc`). Sekarang nilai peringkat tertinggi berlaku untuk nilai QTY terbesar.
```
select salesid, qty,
rank() over (order by qty desc) as rank
from winsales
order by 2,1;
salesid | qty | rank
---------+-----+-----
10001 | 10 | 8
10006 | 10 | 8
30001 | 10 | 8
40005 | 10 | 8
30003 | 15 | 7
20001 | 20 | 4
20002 | 20 | 4
30004 | 20 | 4
10005 | 30 | 2
30007 | 30 | 2
40001 | 40 | 1
(11 rows)
```
Untuk deskripsi tabel WINSALES, lihat[Contoh tabel untuk contoh fungsi jendela](c_Window_functions.md#r_Window_function_example).
Contoh berikut mempartisi tabel oleh SELLERID dan mengurutkan setiap partisi dengan kuantitas (dalam urutan menurun) dan menetapkan peringkat untuk setiap baris. Hasilnya diurutkan setelah hasil fungsi jendela diterapkan.
```
select salesid, sellerid, qty, rank() over
(partition by sellerid
order by qty desc) as rank
from winsales
order by 2,3,1;
salesid | sellerid | qty | rank
--------+----------+-----+-----
10001 | 1 | 10 | 2
10006 | 1 | 10 | 2
10005 | 1 | 30 | 1
20001 | 2 | 20 | 1
20002 | 2 | 20 | 1
30001 | 3 | 10 | 4
30003 | 3 | 15 | 3
30004 | 3 | 20 | 2
30007 | 3 | 30 | 1
40005 | 4 | 10 | 2
40001 | 4 | 40 | 1
(11 rows)
```
# Fungsi jendela RATIO\$1TO\$1REPORT
Menghitung rasio nilai dengan jumlah nilai di jendela atau partisi. Rasio terhadap nilai laporan ditentukan dengan menggunakan rumus:
`value of `**ratio\$1expression ratio\$1expression `argument for the current row / sum of`** `argument for the window or partition`
Dataset berikut menggambarkan penggunaan rumus ini:
```
Row# Value Calculation RATIO_TO_REPORT
1 2500 (2500)/(13900) 0.1798
2 2600 (2600)/(13900) 0.1870
3 2800 (2800)/(13900) 0.2014
4 2900 (2900)/(13900) 0.2086
5 3100 (3100)/(13900) 0.2230
```
Rentang nilai pengembalian adalah 0 hingga 1, inklusif. Jika *ratio\$1expression* adalah NULL, maka nilai kembaliannya adalah. `NULL` Jika nilai dalam *partition\$1expression* unik, maka fungsi akan kembali `1` untuk nilai itu.
## Sintaksis
```
RATIO_TO_REPORT ( ratio_expression )
OVER ( [ PARTITION BY partition_expression ] )
```
## Argumen
*ratio\$1expression*
Ekspresi, seperti nama kolom, yang memberikan nilai untuk menentukan rasio. Ekspresi harus memiliki tipe data numerik atau secara implisit dapat dikonversi menjadi satu.
Anda tidak dapat menggunakan fungsi analitik lainnya di *ratio\$1expression*.
DI ATAS
Sebuah klausa yang menentukan partisi jendela. Klausa OVER tidak dapat berisi urutan jendela atau spesifikasi bingkai jendela.
PARTISI OLEH *partition\$1expression*
Tidak wajib. Ekspresi yang menetapkan rentang catatan untuk setiap grup dalam klausa OVER.
## Jenis pengembalian
FLOAT8
## Contoh
Contoh berikut menggunakan tabel WINSALES. Untuk informasi tentang cara membuat tabel WINSALES, lihat[Contoh tabel untuk contoh fungsi jendela](c_Window_functions.md#r_Window_function_example).
Contoh berikut menghitung ratio-to-report nilai setiap baris kuantitas penjual dengan total jumlah semua penjual.
```
select sellerid, qty, ratio_to_report(qty)
over()
from winsales
order by sellerid;
sellerid qty ratio_to_report
--------------------------------------
1 30 0.13953488372093023
1 10 0.046511627906976744
1 10 0.046511627906976744
2 20 0.09302325581395349
2 20 0.09302325581395349
3 30 0.13953488372093023
3 20 0.09302325581395349
3 15 0.06976744186046512
3 10 0.046511627906976744
4 10 0.046511627906976744
4 40 0.18604651162790697
```
Contoh berikut menghitung rasio jumlah penjualan untuk setiap penjual dengan partisi.
```
select sellerid, qty, ratio_to_report(qty)
over(partition by sellerid)
from winsales;
sellerid qty ratio_to_report
-------------------------------------------
2 20 0.5
2 20 0.5
4 40 0.8
4 10 0.2
1 10 0.2
1 30 0.6
1 10 0.2
3 10 0.13333333333333333
3 15 0.2
3 20 0.26666666666666666
3 30 0.4
```
# Fungsi jendela ROW\$1NUMBER
Menetapkan nomor urut dari baris saat ini dalam sekelompok baris, dihitung dari 1, berdasarkan ekspresi ORDER BY dalam klausa OVER. Jika klausa PARTITION BY opsional ada, nomor urut diatur ulang untuk setiap kelompok baris. Baris dengan nilai yang sama untuk ekspresi ORDER BY menerima nomor baris yang berbeda secara nondeterministik.
## Sintaksis
```
ROW_NUMBER() OVER(
[ PARTITION BY expr_list ]
[ ORDER BY order_list ]
)
```
## Argumen
( )
Fungsi ini tidak mengambil argumen, tetapi tanda kurung kosong diperlukan.
DI ATAS
Klausul fungsi jendela untuk fungsi ROW\$1NUMBER.
PARTISI OLEH *expr\$1list*
Tidak wajib. Satu atau lebih ekspresi kolom yang membagi hasil menjadi set baris.
PESANAN BERDASARKAN *order\$1list*
Tidak wajib. Satu atau lebih ekspresi kolom yang mendefinisikan urutan baris dalam satu set. Jika tidak ada PARTITION BY yang ditentukan, ORDER BY menggunakan seluruh tabel.
Jika ORDER BY tidak menghasilkan urutan unik atau dihilangkan, urutan baris adalah nondeterministik. Untuk informasi selengkapnya, lihat [Urutan data yang unik untuk fungsi jendela](c_Window_functions.md#r_Examples_order_by_WF).
## Jenis pengembalian
BIGINT
## Contoh
Contoh berikut menggunakan `WINSALES` tabel. Untuk deskripsi `WINSALES` tabel, lihat[Contoh tabel untuk contoh fungsi jendela](c_Window_functions.md#r_Window_function_example).
Contoh berikut mengurutkan tabel dengan QTY (dalam urutan menaik), lalu menetapkan nomor baris untuk setiap baris. Hasilnya diurutkan setelah hasil fungsi jendela diterapkan.
```
SELECT salesid, sellerid, qty,
ROW_NUMBER() OVER(
ORDER BY qty ASC) AS row
FROM winsales
ORDER BY 4,1;
salesid sellerid qty row
---------+----------+-----+-----
30001 | 3 | 10 | 1
10001 | 1 | 10 | 2
10006 | 1 | 10 | 3
40005 | 4 | 10 | 4
30003 | 3 | 15 | 5
20001 | 2 | 20 | 6
20002 | 2 | 20 | 7
30004 | 3 | 20 | 8
10005 | 1 | 30 | 9
30007 | 3 | 30 | 10
40001 | 4 | 40 | 11
```
Contoh berikut mempartisi tabel oleh SELLERID dan memerintahkan setiap partisi dengan QTY (dalam urutan menaik), kemudian menetapkan nomor baris untuk setiap baris. Hasilnya diurutkan setelah hasil fungsi jendela diterapkan.
```
SELECT salesid, sellerid, qty,
ROW_NUMBER() OVER(
PARTITION BY sellerid
ORDER BY qty ASC) AS row_by_seller
FROM winsales
ORDER BY 2,4;
salesid | sellerid | qty | row_by_seller
---------+----------+-----+-----
10001 | 1 | 10 | 1
10006 | 1 | 10 | 2
10005 | 1 | 30 | 3
20001 | 2 | 20 | 1
20002 | 2 | 20 | 2
30001 | 3 | 10 | 1
30003 | 3 | 15 | 2
30004 | 3 | 20 | 3
30007 | 3 | 30 | 4
40005 | 4 | 10 | 1
40001 | 4 | 40 | 2
```
Contoh berikut menunjukkan hasil ketika tidak menggunakan klausa opsional.
```
SELECT salesid, sellerid, qty, ROW_NUMBER() OVER() AS row
FROM winsales
ORDER BY 4,1;
salesid sellerid qty row
---------+----------+-----+-----
30001 | 3 | 10 | 1
10001 | 1 | 10 | 2
10005 | 1 | 30 | 3
40001 | 4 | 40 | 4
10006 | 1 | 10 | 5
20001 | 2 | 20 | 6
40005 | 4 | 10 | 7
20002 | 2 | 20 | 8
30003 | 3 | 15 | 9
30004 | 3 | 20 | 10
30007 | 3 | 30 | 11
```
# Fungsi jendela STDDEV\$1SAMP dan STDDEV\$1POP
Fungsi jendela STDDEV\$1SAMP dan STDDEV\$1POP mengembalikan sampel dan standar deviasi populasi dari satu set nilai numerik (integer, desimal, atau floating-point). Lihat juga [Fungsi STDDEV\$1SAMP dan STDDEV\$1POP](r_STDDEV_functions.md).
STDDEV\$1SAMP dan STDDEV adalah sinonim untuk fungsi yang sama.
## Sintaksis
```
STDDEV_SAMP | STDDEV | STDDEV_POP
( [ ALL ] expression ) OVER
(
[ PARTITION BY expr_list ]
[ ORDER BY order_list
frame_clause ]
)
```
## Argumen
*ekspresi*
Kolom target atau ekspresi tempat fungsi beroperasi.
SEMUA
Dengan argumen ALL, fungsi mempertahankan semua nilai duplikat dari ekspresi. ALL adalah default. DISTINCT tidak didukung.
DI ATAS
Menentukan klausa jendela untuk fungsi agregasi. Klausa OVER membedakan fungsi agregasi jendela dari fungsi agregasi set normal.
PARTISI OLEH *expr\$1list*
Mendefinisikan jendela untuk fungsi dalam hal satu atau lebih ekspresi.
PESANAN BERDASARKAN *order\$1list*
Mengurutkan baris dalam setiap partisi. Jika tidak ada PARTITION BY yang ditentukan, ORDER BY menggunakan seluruh tabel.
*frame\$1clause*
Jika klausa ORDER BY digunakan untuk fungsi agregat, klausa bingkai eksplisit diperlukan. Klausa bingkai menyempurnakan kumpulan baris di jendela fungsi, termasuk atau mengecualikan kumpulan baris dalam hasil yang diurutkan. Klausa bingkai terdiri dari kata kunci ROWS dan penentu terkait. Lihat [Ringkasan sintaks fungsi jendela](c_Window_functions.md#r_Window_function_synopsis).
## Jenis Data
Jenis argumen yang didukung oleh fungsi STDDEV adalah SMALLINT, INTEGER, BIGINT, NUMERIC, DECIMAL, REAL, dan DOUBLE PRECISION.
Terlepas dari tipe data ekspresi, tipe pengembalian fungsi STDDEV adalah nomor presisi ganda.
## Contoh
Contoh berikut menunjukkan bagaimana menggunakan fungsi STDDEV\$1POP dan VAR\$1POP sebagai fungsi jendela. Kueri menghitung varians populasi dan deviasi standar populasi untuk nilai PRICEPAID dalam tabel PENJUALAN.
```
select salesid, dateid, pricepaid,
round(stddev_pop(pricepaid) over
(order by dateid, salesid rows unbounded preceding)) as stddevpop,
round(var_pop(pricepaid) over
(order by dateid, salesid rows unbounded preceding)) as varpop
from sales
order by 2,1;
salesid | dateid | pricepaid | stddevpop | varpop
--------+--------+-----------+-----------+---------
33095 | 1827 | 234.00 | 0 | 0
65082 | 1827 | 472.00 | 119 | 14161
88268 | 1827 | 836.00 | 248 | 61283
97197 | 1827 | 708.00 | 230 | 53019
110328 | 1827 | 347.00 | 223 | 49845
110917 | 1827 | 337.00 | 215 | 46159
150314 | 1827 | 688.00 | 211 | 44414
157751 | 1827 | 1730.00 | 447 | 199679
165890 | 1827 | 4192.00 | 1185 | 1403323
...
```
Fungsi standar deviasi dan varians sampel dapat digunakan dengan cara yang sama.
# Fungsi jendela SUM
Fungsi jendela SUM mengembalikan jumlah kolom input atau nilai ekspresi. Fungsi SUM bekerja dengan nilai numerik dan mengabaikan nilai NULL.
## Sintaksis
```
SUM ( [ ALL ] expression ) OVER
(
[ PARTITION BY expr_list ]
[ ORDER BY order_list
frame_clause ]
)
```
## Argumen
*ekspresi*
Kolom target atau ekspresi tempat fungsi beroperasi.
SEMUA
Dengan argumen ALL, fungsi mempertahankan semua nilai duplikat dari ekspresi. ALL adalah default. DISTINCT tidak didukung.
DI ATAS
Menentukan klausa jendela untuk fungsi agregasi. Klausa OVER membedakan fungsi agregasi jendela dari fungsi agregasi set normal.
PARTISI OLEH *expr\$1list*
Mendefinisikan jendela untuk fungsi SUM dalam hal satu atau lebih ekspresi.
PESANAN BERDASARKAN *order\$1list*
Mengurutkan baris dalam setiap partisi. Jika tidak ada PARTITION BY yang ditentukan, ORDER BY menggunakan seluruh tabel.
*frame\$1clause*
Jika klausa ORDER BY digunakan untuk fungsi agregat, klausa bingkai eksplisit diperlukan. Klausa bingkai menyempurnakan kumpulan baris di jendela fungsi, termasuk atau mengecualikan kumpulan baris dalam hasil yang diurutkan. Klausa bingkai terdiri dari kata kunci ROWS dan penentu terkait. Lihat [Ringkasan sintaks fungsi jendela](c_Window_functions.md#r_Window_function_synopsis).
## Jenis Data
Tipe argumen yang didukung oleh fungsi SUM adalah SMALLINT, INTEGER, BIGINT, NUMERIC, DECIMAL, REAL, dan DOUBLE PRECISION.
Jenis pengembalian yang didukung oleh fungsi SUM adalah:
+ BIGINT untuk argumen SMALLINT atau INTEGER
+ NUMERIK untuk argumen BIGINT
+ PRESISI GANDA untuk argumen floating-point
## Contoh
Contoh berikut membuat jumlah kumulatif (bergulir) jumlah penjualan yang diurutkan berdasarkan tanggal dan ID penjualan:
```
select salesid, dateid, sellerid, qty,
sum(qty) over (order by dateid, salesid rows unbounded preceding) as sum
from winsales
order by 2,1;
salesid | dateid | sellerid | qty | sum
---------+------------+----------+-----+-----
30001 | 2003-08-02 | 3 | 10 | 10
10001 | 2003-12-24 | 1 | 10 | 20
10005 | 2003-12-24 | 1 | 30 | 50
40001 | 2004-01-09 | 4 | 40 | 90
10006 | 2004-01-18 | 1 | 10 | 100
20001 | 2004-02-12 | 2 | 20 | 120
40005 | 2004-02-12 | 4 | 10 | 130
20002 | 2004-02-16 | 2 | 20 | 150
30003 | 2004-04-18 | 3 | 15 | 165
30004 | 2004-04-18 | 3 | 20 | 185
30007 | 2004-09-07 | 3 | 30 | 215
(11 rows)
```
Untuk deskripsi tabel WINSALES, lihat[Contoh tabel untuk contoh fungsi jendela](c_Window_functions.md#r_Window_function_example).
Contoh berikut membuat jumlah kumulatif (bergulir) jumlah penjualan berdasarkan tanggal, mempartisi hasil dengan ID penjual, dan memesan hasil berdasarkan tanggal dan ID penjualan dalam partisi:
```
select salesid, dateid, sellerid, qty,
sum(qty) over (partition by sellerid
order by dateid, salesid rows unbounded preceding) as sum
from winsales
order by 2,1;
salesid | dateid | sellerid | qty | sum
---------+------------+----------+-----+-----
30001 | 2003-08-02 | 3 | 10 | 10
10001 | 2003-12-24 | 1 | 10 | 10
10005 | 2003-12-24 | 1 | 30 | 40
40001 | 2004-01-09 | 4 | 40 | 40
10006 | 2004-01-18 | 1 | 10 | 50
20001 | 2004-02-12 | 2 | 20 | 20
40005 | 2004-02-12 | 4 | 10 | 50
20002 | 2004-02-16 | 2 | 20 | 40
30003 | 2004-04-18 | 3 | 15 | 25
30004 | 2004-04-18 | 3 | 20 | 45
30007 | 2004-09-07 | 3 | 30 | 75
(11 rows)
```
Contoh berikut memberi nomor semua baris secara berurutan dalam kumpulan hasil, diurutkan oleh kolom SELLERID dan SALESID:
```
select salesid, sellerid, qty,
sum(1) over (order by sellerid, salesid rows unbounded preceding) as rownum
from winsales
order by 2,1;
salesid | sellerid | qty | rownum
--------+----------+------+--------
10001 | 1 | 10 | 1
10005 | 1 | 30 | 2
10006 | 1 | 10 | 3
20001 | 2 | 20 | 4
20002 | 2 | 20 | 5
30001 | 3 | 10 | 6
30003 | 3 | 15 | 7
30004 | 3 | 20 | 8
30007 | 3 | 30 | 9
40001 | 4 | 40 | 10
40005 | 4 | 10 | 11
(11 rows)
```
Untuk deskripsi tabel WINSALES, lihat[Contoh tabel untuk contoh fungsi jendela](c_Window_functions.md#r_Window_function_example).
Contoh berikut memberi nomor semua baris secara berurutan dalam kumpulan hasil, partisi hasil dengan SELLERID, dan urutkan hasilnya berdasarkan SELLERID dan SALESID dalam partisi:
```
select salesid, sellerid, qty,
sum(1) over (partition by sellerid
order by sellerid, salesid rows unbounded preceding) as rownum
from winsales
order by 2,1;
salesid | sellerid | qty | rownum
---------+----------+-----+--------
10001 | 1 | 10 | 1
10005 | 1 | 30 | 2
10006 | 1 | 10 | 3
20001 | 2 | 20 | 1
20002 | 2 | 20 | 2
30001 | 3 | 10 | 1
30003 | 3 | 15 | 2
30004 | 3 | 20 | 3
30007 | 3 | 30 | 4
40001 | 4 | 40 | 1
40005 | 4 | 10 | 2
(11 rows)
```
# Fungsi jendela VAR\$1SAMP dan VAR\$1POP
Fungsi jendela VAR\$1SAMP dan VAR\$1POP mengembalikan sampel dan varians populasi dari sekumpulan nilai numerik (integer, desimal, atau floating-point). Lihat juga [Fungsi VAR\$1SAMP dan VAR\$1POP](r_VARIANCE_functions.md).
VAR\$1SAMP dan VARIANCE adalah sinonim untuk fungsi yang sama.
## Sintaksis
```
VAR_SAMP | VARIANCE | VAR_POP
( [ ALL ] expression ) OVER
(
[ PARTITION BY expr_list ]
[ ORDER BY order_list
frame_clause ]
)
```
## Argumen
*ekspresi*
Kolom target atau ekspresi tempat fungsi beroperasi.
SEMUA
Dengan argumen ALL, fungsi mempertahankan semua nilai duplikat dari ekspresi. ALL adalah default. DISTINCT tidak didukung.
DI ATAS
Menentukan klausa jendela untuk fungsi agregasi. Klausa OVER membedakan fungsi agregasi jendela dari fungsi agregasi set normal.
PARTISI OLEH *expr\$1list*
Mendefinisikan jendela untuk fungsi dalam hal satu atau lebih ekspresi.
PESANAN BERDASARKAN *order\$1list*
Mengurutkan baris dalam setiap partisi. Jika tidak ada PARTITION BY yang ditentukan, ORDER BY menggunakan seluruh tabel.
*frame\$1clause*
Jika klausa ORDER BY digunakan untuk fungsi agregat, klausa bingkai eksplisit diperlukan. Klausa bingkai menyempurnakan kumpulan baris di jendela fungsi, termasuk atau mengecualikan kumpulan baris dalam hasil yang diurutkan. Klausa bingkai terdiri dari kata kunci ROWS dan penentu terkait. Lihat [Ringkasan sintaks fungsi jendela](c_Window_functions.md#r_Window_function_synopsis).
## Jenis Data
Jenis argumen yang didukung oleh fungsi VARIANCE adalah SMALLINT, INTEGER, BIGINT, NUMERIC, DECIMAL, REAL, dan DOUBLE PRECISION.
Terlepas dari tipe data ekspresi, tipe pengembalian fungsi VARIANCE adalah angka presisi ganda.