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 agregat
**Topics**
+ [Fungsi ANY\$1VALUE](r_ANY_VALUE.md)
+ [PERKIRAAN fungsi PERCENTILE\$1DISC](r_APPROXIMATE_PERCENTILE_DISC.md)
+ [Fungsi AVG](r_AVG.md)
+ [Fungsi COUNT](r_COUNT.md)
+ [Fungsi LISTAGG](r_LISTAGG.md)
+ [Fungsi MAX](r_MAX.md)
+ [Fungsi MEDIAN](r_MEDIAN.md)
+ [Fungsi MIN](r_MIN.md)
+ [Fungsi PERCENTILE\$1CONT](r_PERCENTILE_CONT.md)
+ [Fungsi STDDEV\$1SAMP dan STDDEV\$1POP](r_STDDEV_functions.md)
+ [Fungsi SUM](r_SUM.md)
+ [Fungsi VAR\$1SAMP dan VAR\$1POP](r_VARIANCE_functions.md)
Fungsi agregat menghitung nilai hasil tunggal dari satu set nilai masukan.
Pernyataan SELECT menggunakan fungsi agregat dapat mencakup dua klausa opsional: GROUP BY dan HAVING. Sintaks untuk klausa ini adalah sebagai berikut (menggunakan fungsi COUNT sebagai contoh):
```
SELECT count (*) expression FROM table_reference
WHERE condition [GROUP BY expression ] [ HAVING condition]
```
Klausa GROUP BY menggabungkan dan mengelompokkan hasil berdasarkan nilai unik dalam kolom atau kolom tertentu. Klausa HAVING membatasi hasil yang dikembalikan ke baris di mana kondisi agregat tertentu benar, seperti count (\$1) > 1. Klausa HAVING digunakan dengan cara yang sama seperti WHERE untuk membatasi baris berdasarkan nilai kolom. Untuk contoh klausa tambahan ini, lihat. [COUNT](r_COUNT.md)
Fungsi agregat tidak menerima fungsi agregat bersarang atau fungsi jendela sebagai argumen.
# Fungsi ANY\$1VALUE
Fungsi ANY\$1VALUE mengembalikan nilai apapun dari nilai ekspresi masukan nondeterministik. Fungsi ini kembali `NULL` jika ekspresi masukan tidak menghasilkan baris yang dikembalikan. Fungsi ini juga dapat kembali `NULL` jika ada `NULL` nilai dalam ekspresi input. Jika input berisi `NULL` nilai-nilai yang dicampur dengan `NULL` non-nilai, `NULL` mungkin dikembalikan. Jika semua nilai`NULL`, `NULL` dikembalikan. Jika tidak ada baris yang cocok dengan kondisi, `NULL` dikembalikan.
## Sintaksis
```
ANY_VALUE( [ DISTINCT | ALL ] expression )
```
## Argumen
BERBEDA \$1 SEMUA
Tentukan DISTINCT atau ALL untuk mengembalikan nilai apa pun dari nilai ekspresi input. Argumen DISTINCT tidak berpengaruh dan diabaikan.
*ekspresi*
Kolom target atau ekspresi di mana fungsi beroperasi. *Ekspresi* adalah salah satu tipe data berikut:
+ SMALLINT
+ INTEGER
+ BIGINT
+ DECIMAL
+ REAL
+ PRECISON GANDA
+ BOOLEAN
+ CHAR
+ VARCHAR
+ DATE
+ TIMESTAMP
+ TIMESTAMPTZ
+ TIME
+ JADWAL
+ INTERVAL TAHUN KE BULAN
+ INTERVAL HARI KE DETIK
+ VARBYTE
+ SUPER
+ HLLSKETSA
+ GEOMETRY
+ GEOGRAPHY
## Pengembalian
Mengembalikan tipe data yang sama sebagai *ekspresi*.
## Catatan penggunaan
Jika pernyataan yang menentukan fungsi ANY\$1VALUE untuk kolom juga menyertakan referensi kolom kedua, kolom kedua harus muncul dalam klausa GROUP BY atau disertakan dalam fungsi agregat.
## Contoh
Contoh menggunakan tabel peristiwa yang dibuat di [Langkah 4: Muat data sampel dari Amazon S3](https://docs.aws.amazon.com/redshift/latest/gsg/rs-gsg-create-sample-db.html) di Panduan Memulai *Amazon Redshift*. Contoh berikut mengembalikan sebuah instance dari dateid mana eventname adalah Eagles.
```
select any_value(dateid) as dateid, eventname from event where eventname ='Eagles' group by eventname;
```
Berikut ini adalah hasilnya.
```
dateid | eventname
-------+---------------
1878 | Eagles
```
Contoh berikut mengembalikan instance dari setiap dateid di mana eventname adalah Eagles atau Cold War Kids.
```
select any_value(dateid) as dateid, eventname from event where eventname in('Eagles', 'Cold War Kids') group by eventname;
```
Berikut ini adalah hasilnya.
```
dateid | eventname
-------+---------------
1922 | Cold War Kids
1878 | Eagles
```
# PERKIRAAN fungsi PERCENTILE\$1DISC
PERKIRAAN PERCENTILE\$1DISC adalah fungsi distribusi terbalik yang mengasumsikan model distribusi diskrit. Dibutuhkan nilai persentil dan spesifikasi semacam dan mengembalikan elemen dari set yang diberikan. Pendekatan memungkinkan fungsi berjalan lebih cepat, dengan kesalahan relatif rendah sekitar 0,5 persen.
Untuk nilai *persentil* tertentu, PERKIRAAN PERCENTILE\$1DISC menggunakan algoritma ringkasan kuantil untuk memperkirakan persentil diskrit ekspresi dalam klausa ORDER BY. *PERKIRAAN PERCENTILE\$1DISC mengembalikan nilai dengan nilai distribusi kumulatif terkecil (sehubungan dengan spesifikasi jenis yang sama) yang lebih besar dari atau sama dengan persentil.*
## Sintaksis
```
APPROXIMATE PERCENTILE_DISC ( percentile )
WITHIN GROUP (ORDER BY expr)
```
## Argumen
*persentil*
Konstanta numerik antara 0 dan 1. Null diabaikan dalam perhitungan.
DALAM GRUP (ORDER BY *expr)*
Klausul yang menentukan numerik atau date/time nilai untuk mengurutkan dan menghitung persentil atas.
## Pengembalian
Tipe data yang sama dengan ekspresi ORDER BY dalam klausa WITHIN GROUP.
## Catatan penggunaan
Jika pernyataan PERKIRAAN PERCENTILE\$1DISC menyertakan klausa GROUP BY, kumpulan hasil terbatas. Batas bervariasi berdasarkan jenis node dan jumlah node. Jika batas terlampaui, fungsi gagal dan mengembalikan kesalahan berikut.
```
GROUP BY limit for approximate percentile_disc exceeded.
```
Jika Anda perlu mengevaluasi lebih banyak grup daripada batas izin, pertimbangkan untuk menggunakannya[Fungsi PERCENTILE\$1CONT](r_PERCENTILE_CONT.md).
## Contoh
Contoh berikut mengembalikan jumlah penjualan, total penjualan, dan nilai persentil kelima puluh untuk 10 tanggal teratas.
```
select top 10 date.caldate,
count(totalprice), sum(totalprice),
approximate percentile_disc(0.5)
within group (order by totalprice)
from listing
join date on listing.dateid = date.dateid
group by date.caldate
order by 3 desc;
caldate | count | sum | percentile_disc
-----------+-------+------------+----------------
2008-01-07 | 658 | 2081400.00 | 2020.00
2008-01-02 | 614 | 2064840.00 | 2178.00
2008-07-22 | 593 | 1994256.00 | 2214.00
2008-01-26 | 595 | 1993188.00 | 2272.00
2008-02-24 | 655 | 1975345.00 | 2070.00
2008-02-04 | 616 | 1972491.00 | 1995.00
2008-02-14 | 628 | 1971759.00 | 2184.00
2008-09-01 | 600 | 1944976.00 | 2100.00
2008-07-29 | 597 | 1944488.00 | 2106.00
2008-07-23 | 592 | 1943265.00 | 1974.00
```
# Fungsi AVG
Fungsi AVG mengembalikan rata-rata (rata-rata aritmatika) dari nilai ekspresi masukan. Fungsi AVG bekerja dengan nilai numerik dan mengabaikan nilai NULL.
## Sintaksis
```
AVG ( [ DISTINCT | ALL ] expression )
```
## Argumen
*ekspresi*
Kolom target atau ekspresi tempat fungsi beroperasi. *Ekspresi* adalah salah satu tipe data berikut:
+ SMALLINT
+ INTEGER
+ BIGINT
+ NUMERIC
+ DECIMAL
+ REAL
+ PRECISON GANDA
+ SUPER
BERBEDA \$1 SEMUA
Dengan argumen DISTINCT, fungsi menghilangkan semua nilai duplikat dari ekspresi yang ditentukan sebelum menghitung rata-rata. Dengan argumen ALL, fungsi mempertahankan semua nilai duplikat dari ekspresi untuk menghitung rata-rata. SEMUA adalah default.
## Jenis Data
Tipe argumen yang didukung oleh fungsi AVG adalah SMALLINT, INTEGER, BIGINT, NUMERIC, DECIMAL, REAL, DOUBLE PRECISION, dan SUPER.
Jenis pengembalian yang didukung oleh fungsi AVG adalah:
+ BIGINT untuk argumen tipe integer
+ PRESISI GANDA untuk argumen floating point
+ Mengembalikan tipe data yang sama sebagai ekspresi untuk jenis argumen lainnya.
Presisi default untuk hasil fungsi AVG dengan argumen NUMERIK atau DECIMAL adalah 38. Skala hasilnya sama dengan skala argumen. Misalnya, AVG kolom DEC (5,2) mengembalikan tipe data DEC (38,2).
## Contoh
Temukan jumlah rata-rata yang terjual per transaksi dari tabel PENJUALAN:
```
select avg(qtysold)from sales;
avg
-----
2
(1 row)
```
Temukan harga total rata-rata yang tercantum untuk semua listing:
```
select avg(numtickets*priceperticket) as avg_total_price from listing;
avg_total_price
-----------------
3034.41
(1 row)
```
Temukan harga rata-rata yang dibayarkan, dikelompokkan berdasarkan bulan dalam urutan menurun:
```
select avg(pricepaid) as avg_price, month
from sales, date
where sales.dateid = date.dateid
group by month
order by avg_price desc;
avg_price | month
-----------+-------
659.34 | MAR
655.06 | APR
645.82 | JAN
643.10 | MAY
642.72 | JUN
642.37 | SEP
640.72 | OCT
640.57 | DEC
635.34 | JUL
635.24 | FEB
634.24 | NOV
632.78 | AUG
(12 rows)
```
# Fungsi COUNT
Fungsi COUNT menghitung baris yang ditentukan oleh ekspresi.
Fungsi COUNT memiliki variasi berikut.
+ 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.
+ COUNT (*ekspresi* DISTINCT) menghitung jumlah nilai non-Null yang berbeda dalam kolom atau ekspresi.
+ PERKIRAAN COUNT DISTINCT mendekati jumlah nilai non-NULL yang berbeda dalam kolom atau ekspresi.
## Sintaksis
```
COUNT( * | expression )
```
```
COUNT ( [ DISTINCT | ALL ] expression )
```
```
APPROXIMATE COUNT ( DISTINCT expression )
```
## Argumen
*ekspresi*
Kolom target atau ekspresi tempat fungsi beroperasi. Fungsi COUNT mendukung semua tipe data argumen.
BERBEDA \$1 SEMUA
Dengan argumen DISTINCT, fungsi menghilangkan semua nilai duplikat dari ekspresi yang ditentukan sebelum melakukan penghitungan. Dengan argumen ALL, fungsi mempertahankan semua nilai duplikat dari ekspresi untuk menghitung. SEMUA adalah default.
KIRA-KIRA
Ketika digunakan dengan PERKIRAAN, fungsi COUNT DISTINCT menggunakan HyperLogLog algoritma untuk memperkirakan jumlah nilai non-NULL yang berbeda dalam kolom atau ekspresi. Kueri yang menggunakan kata kunci PERKIRAAN berjalan lebih cepat, dengan kesalahan relatif rendah sekitar 2%. Perkiraan dijamin untuk kueri yang mengembalikan sejumlah besar nilai berbeda, dalam jutaan atau lebih per kueri, atau per grup, jika ada klausa grup demi klausa. Untuk set nilai berbeda yang lebih kecil, dalam ribuan, perkiraan mungkin lebih lambat daripada hitungan yang tepat. PERKIRAAN hanya dapat digunakan dengan COUNT DISTINCT.
## Jenis pengembalian
Fungsi COUNT mengembalikan BIGINT.
## Contoh
Hitung semua pengguna dari negara bagian Florida:
```
select count(*) from users where state='FL';
count
-------
510
```
Hitung semua nama acara dari tabel EVENT:
```
select count(eventname) from event;
count
-------
8798
```
Hitung semua nama acara dari tabel EVENT:
```
select count(all eventname) from event;
count
-------
8798
```
Hitung semua tempat unik IDs dari tabel EVENT:
```
select count(distinct venueid) as venues from event;
venues
--------
204
```
Hitung berapa kali setiap penjual mencantumkan batch lebih dari empat tiket untuk dijual. Kelompokkan hasil berdasarkan ID penjual:
```
select count(*), sellerid from listing
where numtickets > 4
group by sellerid
order by 1 desc, 2;
count | sellerid
------+----------
12 | 6386
11 | 17304
11 | 20123
11 | 25428
...
```
Contoh berikut membandingkan nilai pengembalian dan waktu eksekusi untuk COUNT dan PERKIRAAN COUNT.
```
select count(distinct pricepaid) from sales;
count
-------
4528
Time: 48.048 ms
select approximate count(distinct pricepaid) from sales;
count
-------
4553
Time: 21.728 ms
```
# Fungsi LISTAGG
Untuk setiap grup dalam kueri, fungsi agregat LISTAGG mengurutkan baris untuk grup tersebut sesuai dengan ekspresi ORDER BY, lalu menggabungkan nilai menjadi satu string.
## Sintaksis
```
LISTAGG( [DISTINCT] aggregate_expression [, 'delimiter' ] )
[ WITHIN GROUP (ORDER BY order_list) ]
```
## Argumen
DISTINCT
Klausa yang menghilangkan nilai duplikat dari ekspresi yang ditentukan sebelum menggabungkan. Spasi trailing diabaikan. Misalnya, 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*
Konstanta string untuk memisahkan nilai gabungan. Default-nya adalah NULL.
*DALAM GRUP (PESANAN BERDASARKAN order\$1list)*
Sebuah klausa yang menentukan urutan dari nilai agregat.
## Pengembalian
VARCHAR (MAKS). Jika set hasil lebih besar dari ukuran VARCHAR maksimum, LISTAGG mengembalikan kesalahan berikut:
```
Invalid operation: Result size exceeds LISTAGG limit
```
## Catatan penggunaan
+ Jika pernyataan menyertakan beberapa fungsi LISTAGG yang menggunakan klausa WITHERE GROUP, setiap klausa WITHIN GROUP harus menggunakan nilai ORDER BY yang sama.
Misalnya, pernyataan berikut mengembalikan kesalahan.
```
SELECT LISTAGG(sellerid)
WITHIN GROUP (ORDER BY dateid) AS sellers,
LISTAGG(dateid)
WITHIN GROUP (ORDER BY sellerid) AS dates
FROM sales;
```
Pernyataan berikut berjalan dengan sukses.
```
SELECT LISTAGG(sellerid)
WITHIN GROUP (ORDER BY dateid) AS sellers,
LISTAGG(dateid)
WITHIN GROUP (ORDER BY dateid) AS dates
FROM sales;
SELECT LISTAGG(sellerid)
WITHIN GROUP (ORDER BY dateid) AS sellers,
LISTAGG(dateid) AS dates
FROM sales;
```
+ Anda tidak dapat menggunakan fungsi agregat LISTAGG, PERCENTILE\$1CONT, dan MEDIAN dengan fungsi agregat berbeda lainnya.
## Contoh
Contoh berikut agregat penjual IDs, dipesan oleh ID penjual.
```
SELECT LISTAGG(sellerid, ', ')
WITHIN GROUP (ORDER BY sellerid)
FROM sales
WHERE eventid = 4337;
listagg
----------------------------------------------------------------------------------------------------------------------------------------
380, 380, 1178, 1178, 1178, 2731, 8117, 12905, 32043, 32043, 32043, 32432, 32432, 38669, 38750, 41498, 45676, 46324, 47188, 47188, 48294
```
Contoh berikut menggunakan DISTINCT untuk mengembalikan daftar penjual unik IDs.
```
SELECT LISTAGG(DISTINCT sellerid, ', ')
WITHIN GROUP (ORDER BY sellerid)
FROM sales
WHERE eventid = 4337;
listagg
-------------------------------------------------------------------------------------------
380, 1178, 2731, 8117, 12905, 32043, 32432, 38669, 38750, 41498, 45676, 46324, 47188, 48294
```
Contoh berikut agregat penjual IDs dalam urutan tanggal.
```
SELECT LISTAGG(sellerid, ', ')
WITHIN GROUP (ORDER BY dateid)
FROM sales
WHERE eventid = 4337;
listagg
-----------------------------------------------------------------------------------------------------------------------------------------
41498, 47188, 47188, 1178, 1178, 1178, 380, 45676, 46324, 48294, 32043, 32043, 32432, 12905, 8117, 38750, 2731, 32432, 32043, 380, 38669
```
Contoh berikut mengembalikan daftar tanggal penjualan yang dipisahkan pipa untuk pembeli dengan ID 660.
```
SELECT LISTAGG(
(SELECT caldate FROM date WHERE date.dateid=sales.dateid), ' | '
)
WITHIN GROUP (ORDER BY sellerid DESC, salesid ASC)
FROM sales
WHERE buyerid = 660;
listagg
-------------------------------------------------
2008-07-16 | 2008-07-09 | 2008-01-01 | 2008-10-26
```
Contoh berikut mengembalikan daftar penjualan yang dipisahkan koma IDs untuk pembeli IDs 660, 661, dan 662.
```
SELECT buyerid,
LISTAGG(salesid,', ')
WITHIN GROUP (ORDER BY salesid) AS sales_id
FROM sales
WHERE buyerid BETWEEN 660 AND 662
GROUP BY buyerid
ORDER BY buyerid;
buyerid | sales_id
--------+-----------------------------------------------------
660 | 32872, 33095, 33514, 34548
661 | 19951, 20517, 21695, 21931
662 | 3318, 3823, 4215, 51980, 53202, 55908, 57832, 171603
```
# Fungsi MAX
Fungsi MAX mengembalikan nilai maksimum dalam satu set baris. DISTINCT atau ALL dapat digunakan tetapi tidak mempengaruhi hasilnya.
## Sintaksis
```
MAX ( [ DISTINCT | ALL ] expression )
```
## Argumen
*ekspresi*
Kolom target atau ekspresi tempat fungsi beroperasi. *Ekspresi* adalah salah satu tipe data berikut:
+ SMALLINT
+ INTEGER
+ BIGINT
+ DECIMAL
+ REAL
+ PRECISON GANDA
+ CHAR
+ VARCHAR
+ DATE
+ TIMESTAMP
+ TIMESTAMPTZ
+ TIME
+ JADWAL
+ VARBYTE
+ SUPER
BERBEDA \$1 SEMUA
Dengan argumen DISTINCT, fungsi menghilangkan semua nilai duplikat dari ekspresi yang ditentukan sebelum menghitung maksimum. Dengan argumen ALL, fungsi mempertahankan semua nilai duplikat dari ekspresi untuk menghitung maksimum. SEMUA adalah default.
## Jenis Data
Mengembalikan tipe data yang sama sebagai *ekspresi*. Ekuivalen Boolean dari fungsi MIN adalah[Fungsi BOOL\$1AND](r_BOOL_AND.md), dan setara Boolean dari MAX adalah. [Fungsi BOOL\$1OR](r_BOOL_OR.md)
## Contoh
Temukan harga tertinggi yang dibayarkan dari semua penjualan:
```
select max(pricepaid) from sales;
max
----------
12624.00
(1 row)
```
Temukan harga tertinggi yang dibayarkan per tiket dari semua penjualan:
```
select max(pricepaid/qtysold) as max_ticket_price
from sales;
max_ticket_price
-----------------
2500.00000000
(1 row)
```
# Fungsi MEDIAN
Menghitung nilai median untuk rentang nilai. `NULL`nilai dalam rentang diabaikan.
MEDIAN adalah fungsi distribusi terbalik yang mengasumsikan model distribusi kontinu.
Median adalah kasus khusus. [PERSENTILE\$1CONT](r_PERCENTILE_CONT.md)
## Sintaksis
```
MEDIAN(median_expression)
```
## Argumen
*median\$1expression*
Kolom target atau ekspresi tempat fungsi beroperasi.
## 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_MEDIAN.html)
## Catatan penggunaan
Jika argumen *median\$1expression* adalah tipe `DECIMAL` data 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.
Jika pernyataan menyertakan beberapa panggilan ke fungsi agregat berbasis sortir (LISTAGG, PERCENTILE\$1CONT, atau MEDIAN), semuanya harus menggunakan nilai ORDER BY yang sama. Perhatikan bahwa MEDIAN menerapkan urutan implisit oleh pada nilai ekspresi.
Misalnya, pernyataan berikut mengembalikan kesalahan.
```
SELECT TOP 10 salesid, SUM(pricepaid),
PERCENTILE_CONT(0.6) WITHIN GROUP(ORDER BY salesid),
MEDIAN(pricepaid)
FROM sales
GROUP BY salesid, pricepaid;
An error occurred when executing the SQL command:
SELECT TOP 10 salesid, SUM(pricepaid),
PERCENTILE_CONT(0.6) WITHIN GROUP(ORDER BY salesid),
MEDIAN(pricepaid)
FROM sales
GROUP BY salesid, pricepaid;
ERROR: within group ORDER BY clauses for aggregate functions must be the same
```
Pernyataan berikut berjalan dengan sukses.
```
SELECT TOP 10 salesid, SUM(pricepaid),
PERCENTILE_CONT(0.6) WITHIN GROUP(ORDER BY salesid),
MEDIAN(salesid)
FROM sales
GROUP BY salesid, pricepaid;
```
## Contoh
Contoh berikut menggunakan database sampel TICKIT. Untuk informasi selengkapnya, lihat [Database sampel](c_sampledb.md).
Contoh berikut menunjukkan bahwa MEDIAN menghasilkan hasil yang sama seperti PERCENTILE\$1CONT (0.5).
```
SELECT TOP 10 DISTINCT sellerid, qtysold,
PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY qtysold),
MEDIAN(qtysold)
FROM sales
GROUP BY sellerid, qtysold;
+----------+---------+-----------------+--------+
| sellerid | qtysold | percentile_cont | median |
+----------+---------+-----------------+--------+
| 2 | 2 | 2 | 2 |
| 26 | 1 | 1 | 1 |
| 33 | 1 | 1 | 1 |
| 38 | 1 | 1 | 1 |
| 43 | 1 | 1 | 1 |
| 48 | 2 | 2 | 2 |
| 48 | 3 | 3 | 3 |
| 77 | 4 | 4 | 4 |
| 85 | 4 | 4 | 4 |
| 95 | 2 | 2 | 2 |
+----------+---------+-----------------+--------+
```
Contoh berikut menemukan jumlah median yang dijual untuk setiap sellerid.
```
SELECT sellerid,
MEDIAN(qtysold)
FROM sales
GROUP BY sellerid
ORDER BY sellerid
LIMIT 10;
+----------+--------+
| sellerid | median |
+----------+--------+
| 1 | 1.5 |
| 2 | 2 |
| 3 | 2 |
| 4 | 2 |
| 5 | 1 |
| 6 | 1 |
| 7 | 1.5 |
| 8 | 1 |
| 9 | 4 |
| 12 | 2 |
+----------+--------+
```
Untuk memverifikasi hasil kueri sebelumnya untuk sellerid pertama, gunakan contoh berikut.
```
SELECT qtysold
FROM sales
WHERE sellerid=1;
+---------+
| qtysold |
+---------+
| 2 |
| 1 |
+---------+
```
# Fungsi MIN
Fungsi MIN mengembalikan nilai minimum dalam satu set baris. DISTINCT atau ALL dapat digunakan tetapi tidak mempengaruhi hasilnya.
## Sintaksis
```
MIN ( [ DISTINCT | ALL ] expression )
```
## Argumen
*ekspresi*
Kolom target atau ekspresi tempat fungsi beroperasi. *Ekspresi* adalah salah satu tipe data berikut:
+ SMALLINT
+ INTEGER
+ BIGINT
+ DECIMAL
+ REAL
+ PRECISON GANDA
+ CHAR
+ VARCHAR
+ DATE
+ TIMESTAMP
+ TIMESTAMPTZ
+ TIME
+ JADWAL
+ VARBYTE
+ SUPER
BERBEDA \$1 SEMUA
Dengan argumen DISTINCT, fungsi menghilangkan semua nilai duplikat dari ekspresi yang ditentukan sebelum menghitung minimum. Dengan argumen ALL, fungsi mempertahankan semua nilai duplikat dari ekspresi untuk menghitung minimum. SEMUA adalah default.
## Jenis Data
Mengembalikan tipe data yang sama sebagai *ekspresi*. Ekuivalen Boolean dari fungsi MIN adalah[Fungsi BOOL\$1AND](r_BOOL_AND.md), dan Boolean setara dengan MAX adalah. [Fungsi BOOL\$1OR](r_BOOL_OR.md)
## Contoh
Temukan harga terendah yang dibayarkan dari semua penjualan:
```
select min(pricepaid) from sales;
min
-------
20.00
(1 row)
```
Temukan harga terendah yang dibayarkan per tiket dari semua penjualan:
```
select min(pricepaid/qtysold)as min_ticket_price
from sales;
min_ticket_price
------------------
20.00000000
(1 row)
```
# Fungsi 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)`.
## Sintaksis
```
PERCENTILE_CONT(percentile)
WITHIN GROUP(ORDER BY expr)
```
## Argumen
*persentil*
Konstanta numerik antara 0 dan 1. `NULL`nilai diabaikan dalam perhitungan.
*expr*
Menentukan numerik atau date/time nilai-nilai untuk mengurutkan dan menghitung persentil atas.
## 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_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.
Jika pernyataan menyertakan beberapa panggilan ke fungsi agregat berbasis sortir (LISTAGG, PERCENTILE\$1CONT, atau MEDIAN), semuanya harus menggunakan nilai ORDER BY yang sama. Perhatikan bahwa MEDIAN menerapkan urutan implisit oleh pada nilai ekspresi.
Misalnya, pernyataan berikut mengembalikan kesalahan.
```
SELECT TOP 10 salesid, SUM(pricepaid),
PERCENTILE_CONT(0.6) WITHIN GROUP(ORDER BY salesid),
MEDIAN(pricepaid)
FROM sales
GROUP BY salesid, pricepaid;
An error occurred when executing the SQL command:
SELECT TOP 10 salesid, SUM(pricepaid),
PERCENTILE_CONT(0.6) WITHIN GROUP(ORDER BY salesid),
MEDIAN(pricepaid)
FROM sales
GROUP BY salesid, pricepaid;
ERROR: within group ORDER BY clauses for aggregate functions must be the same
```
Pernyataan berikut berjalan dengan sukses.
```
SELECT TOP 10 salesid, SUM(pricepaid),
PERCENTILE_CONT(0.6) WITHIN GROUP(ORDER BY salesid),
MEDIAN(salesid)
FROM sales
GROUP BY salesid, pricepaid;
```
## Contoh
Contoh berikut menggunakan database sampel TICKIT. Untuk informasi selengkapnya, lihat [Database sampel](c_sampledb.md).
Contoh berikut menunjukkan bahwa PERCENTILE\$1CONT (0.5) menghasilkan hasil yang sama dengan MEDIAN.
```
SELECT TOP 10 DISTINCT sellerid, qtysold,
PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY qtysold),
MEDIAN(qtysold)
FROM sales
GROUP BY sellerid, qtysold;
+----------+---------+-----------------+--------+
| sellerid | qtysold | percentile_cont | median |
+----------+---------+-----------------+--------+
| 2 | 2 | 2 | 2 |
| 26 | 1 | 1 | 1 |
| 33 | 1 | 1 | 1 |
| 38 | 1 | 1 | 1 |
| 43 | 1 | 1 | 1 |
| 48 | 2 | 2 | 2 |
| 48 | 3 | 3 | 3 |
| 77 | 4 | 4 | 4 |
| 85 | 4 | 4 | 4 |
| 95 | 2 | 2 | 2 |
+----------+---------+-----------------+--------+
```
Contoh berikut menemukan PERCENTILE\$1CONT (0,5) dan PERCENTILE\$1CONT (0,75) untuk kuantitas yang dijual untuk setiap sellerid dalam tabel PENJUALAN.
```
SELECT sellerid,
PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY qtysold) as pct_50,
PERCENTILE_CONT(0.75) WITHIN GROUP(ORDER BY qtysold) as pct_75
FROM sales
GROUP BY sellerid
ORDER BY sellerid
LIMIT 10;
+----------+--------+---------+
| sellerid | pct_50 | pct_75 |
+----------+--------+---------+
| 1 | 1.5 | 1.75 |
| 2 | 2 | 2.25 |
| 3 | 2 | 3 |
| 4 | 2 | 2 |
| 5 | 1 | 1.5 |
| 6 | 1 | 1 |
| 7 | 1.5 | 1.75 |
| 8 | 1 | 1 |
| 9 | 4 | 4 |
| 12 | 2 | 3.25 |
+----------+--------+---------+
```
Untuk memverifikasi hasil kueri sebelumnya untuk sellerid pertama, gunakan contoh berikut.
```
SELECT qtysold
FROM sales
WHERE sellerid=1;
+---------+
| qtysold |
+---------+
| 2 |
| 1 |
+---------+
```
# Fungsi STDDEV\$1SAMP dan STDDEV\$1POP
Fungsi STDDEV\$1SAMP dan STDDEV\$1POP mengembalikan sampel dan standar deviasi populasi dari satu set nilai numerik (integer, desimal, atau floating-point). Hasil dari fungsi STDDEV\$1SAMP setara dengan akar kuadrat dari varians sampel dari kumpulan nilai yang sama.
STDDEV\$1SAMP dan STDDEV adalah sinonim untuk fungsi yang sama.
## Sintaksis
```
STDDEV_SAMP | STDDEV ( [ DISTINCT | ALL ] expression)
STDDEV_POP ( [ DISTINCT | ALL ] expression)
```
Ekspresi harus memiliki tipe data integer, desimal, atau floating point. Terlepas dari tipe data ekspresi, tipe pengembalian fungsi ini adalah angka presisi ganda.
**catatan**
Standar deviasi dihitung menggunakan aritmatika floating point, yang dapat mengakibatkan sedikit ketidaktepatan.
## Catatan penggunaan
Ketika standar deviasi sampel (STDDEV atau STDDEV\$1SAMP) dihitung untuk ekspresi yang terdiri dari satu nilai, hasil fungsinya adalah NULL bukan 0.
## Contoh
Kueri berikut mengembalikan rata-rata nilai di kolom VENUESEATS dari tabel VENUE, diikuti oleh standar deviasi sampel dan standar deviasi populasi dari kumpulan nilai yang sama. VENUESEATS adalah kolom INTEGER. Skala hasil dikurangi menjadi 2 digit.
```
select avg(venueseats),
cast(stddev_samp(venueseats) as dec(14,2)) stddevsamp,
cast(stddev_pop(venueseats) as dec(14,2)) stddevpop
from venue;
avg | stddevsamp | stddevpop
-------+------------+-----------
17503 | 27847.76 | 27773.20
(1 row)
```
Kueri berikut mengembalikan standar deviasi sampel untuk kolom KOMISI dalam tabel PENJUALAN. KOMISI adalah kolom DESIMAL. Skala hasilnya dikurangi menjadi 10 digit.
```
select cast(stddev(commission) as dec(18,10))
from sales;
stddev
----------------
130.3912659086
(1 row)
```
Kueri berikut menampilkan standar deviasi sampel untuk kolom COMMISSION sebagai integer.
```
select cast(stddev(commission) as integer)
from sales;
stddev
--------
130
(1 row)
```
Kueri berikut mengembalikan standar deviasi sampel dan akar kuadrat dari varians sampel untuk kolom KOMISI. Hasil perhitungan ini sama.
```
select
cast(stddev_samp(commission) as dec(18,10)) stddevsamp,
cast(sqrt(var_samp(commission)) as dec(18,10)) sqrtvarsamp
from sales;
stddevsamp | sqrtvarsamp
----------------+----------------
130.3912659086 | 130.3912659086
(1 row)
```
# Fungsi SUM
Fungsi SUM mengembalikan jumlah kolom input atau nilai ekspresi. Fungsi SUM bekerja dengan nilai numerik dan mengabaikan nilai NULL.
## Sintaksis
```
SUM ( [ DISTINCT | ALL ] expression )
```
## Argumen
*ekspresi*
Kolom target atau ekspresi tempat fungsi beroperasi. *Ekspresi* adalah salah satu tipe data berikut:
+ SMALLINT
+ INTEGER
+ BIGINT
+ NUMERIC
+ DECIMAL
+ REAL
+ PRECISON GANDA
+ SUPER
BERBEDA \$1 SEMUA
Dengan argumen DISTINCT, fungsi menghilangkan semua nilai duplikat dari ekspresi yang ditentukan sebelum menghitung jumlah. Dengan argumen ALL, fungsi mempertahankan semua nilai duplikat dari ekspresi untuk menghitung jumlah. SEMUA adalah default.
## Jenis Data
Jenis argumen yang didukung oleh fungsi SUM adalah SMALLINT, INTEGER, BIGINT, NUMERIC, DECIMAL, REAL, DOUBLE PRECISION, dan SUPER.
Jenis pengembalian yang didukung oleh fungsi SUM adalah
+ BIGINT untuk argumen BIGINT, SMALLINT, dan INTEGER
+ NUMERIK untuk argumen NUMERIK
+ PRESISI GANDA untuk argumen floating point
+ Mengembalikan tipe data yang sama sebagai ekspresi untuk jenis argumen lainnya.
Presisi default untuk hasil fungsi SUM dengan argumen NUMERIK atau DECIMAL adalah 38. Skala hasilnya sama dengan skala argumen. Misalnya, SUM kolom DEC (5,2) mengembalikan tipe data DEC (38,2).
## Contoh
Temukan jumlah semua komisi yang dibayarkan dari tabel PENJUALAN:
```
select sum(commission) from sales;
sum
-------------
16614814.65
(1 row)
```
Temukan jumlah kursi di semua tempat di negara bagian Florida:
```
select sum(venueseats) from venue
where venuestate = 'FL';
sum
--------
250411
(1 row)
```
Temukan jumlah kursi yang terjual pada bulan Mei:
```
select sum(qtysold) from sales, date
where sales.dateid = date.dateid and date.month = 'MAY';
sum
-------
32291
(1 row)
```
# Fungsi VAR\$1SAMP dan VAR\$1POP
Fungsi VAR\$1SAMP dan VAR\$1POP mengembalikan sampel dan varians populasi dari sekumpulan nilai numerik (integer, desimal, atau floating-point). Hasil dari fungsi VAR\$1SAMP setara dengan standar deviasi sampel kuadrat dari kumpulan nilai yang sama.
VAR\$1SAMP dan VARIANCE adalah sinonim untuk fungsi yang sama.
## Sintaksis
```
VAR_SAMP | VARIANCE ( [ DISTINCT | ALL ] expression)
VAR_POP ( [ DISTINCT | ALL ] expression)
```
Ekspresi harus memiliki tipe data integer, desimal, atau floating-point. Terlepas dari tipe data ekspresi, tipe pengembalian fungsi ini adalah angka presisi ganda.
**catatan**
Hasil dari fungsi-fungsi ini dapat bervariasi di seluruh cluster data warehouse, tergantung pada konfigurasi cluster dalam setiap kasus.
## Catatan penggunaan
Ketika varians sampel (VARIANCE atau VAR\$1SAMP) dihitung untuk ekspresi yang terdiri dari satu nilai, hasil fungsinya adalah NULL bukan 0.
## Contoh
Kueri berikut mengembalikan sampel bulat dan varians populasi kolom NUMTICKETS dalam tabel LISTING.
```
select avg(numtickets),
round(var_samp(numtickets)) varsamp,
round(var_pop(numtickets)) varpop
from listing;
avg | varsamp | varpop
-----+---------+--------
10 | 54 | 54
(1 row)
```
Kueri berikut menjalankan perhitungan yang sama tetapi melemparkan hasilnya ke nilai desimal.
```
select avg(numtickets),
cast(var_samp(numtickets) as dec(10,4)) varsamp,
cast(var_pop(numtickets) as dec(10,4)) varpop
from listing;
avg | varsamp | varpop
-----+---------+---------
10 | 53.6291 | 53.6288
(1 row)
```