Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Fungsi
Di bagian ini, Anda dapat menemukan daftar fungsi yang tersedia di Amazon Quick. Untuk melihat daftar fungsi yang diurutkan berdasarkan kategori, dengan definisi singkat, lihat [Fungsi berdasarkan kategori](https://docs.aws.amazon.com/quicksight/latest/user/functions-by-category.html).
**Topics**
+ [addDateTime](addDateTime-function.md)
+ [addWorkDays](addWorkDays-function.md)
+ [Abs](abs-function.md)
+ [Ceil](ceil-function.md)
+ [Coalesce](coalesce-function.md)
+ [Concat](concat-function.md)
+ [contains](contains-function.md)
+ [decimalToInt](decimalToInt-function.md)
+ [dateDiff](dateDiff-function.md)
+ [endsWith](endsWith-function.md)
+ [epochDate](epochDate-function.md)
+ [Exp](exp-function.md)
+ [Extract](extract-function.md)
+ [Floor](floor-function.md)
+ [formatDate](formatDate-function.md)
+ [Ifelse](ifelse-function.md)
+ [in](in-function.md)
+ [intToDecimal](intToDecimal-function.md)
+ [isNotNull](isNotNull-function.md)
+ [isNull](isNull-function.md)
+ [isWorkDay](isWorkDay-function.md)
+ [Left](left-function.md)
+ [Locate](locate-function.md)
+ [Log](log-function.md)
+ [Ln](ln-function.md)
+ [Ltrim](ltrim-function.md)
+ [Mod](mod-function.md)
+ [netWorkDays](netWorkDays-function.md)
+ [Now](now-function.md)
+ [notIn](notIn-function.md)
+ [nullIf](nullIf-function.md)
+ [parseDate](parseDate-function.md)
+ [parseDecimal](parseDecimal-function.md)
+ [parseInt](parseInt-function.md)
+ [parseJson](parseJson-function.md)
+ [Replace](replace-function.md)
+ [Right](right-function.md)
+ [Round](round-function.md)
+ [Rtrim](rtrim-function.md)
+ [Split](split-function.md)
+ [Sqrt](sqrt-function.md)
+ [startsWith](startsWith-function.md)
+ [Strlen](strlen-function.md)
+ [Substring](substring-function.md)
+ [switch](switch-function.md)
+ [toLower](toLower-function.md)
+ [toString](toString-function.md)
+ [toUpper](toUpper-function.md)
+ [trim](trim-function.md)
+ [truncDate](truncDate-function.md)
# addDateTime
`addDateTime`menambah atau mengurangi satuan waktu dari nilai datetime. Misalnya, `addDateTime(2,'YYYY',parseDate('02-JUL-2018', 'dd-MMM-yyyy') )` mengembalikan `02-JUL-2020`. Anda dapat menggunakan fungsi ini untuk melakukan matematika tanggal pada data tanggal dan waktu Anda.
## Sintaksis
```
addDateTime(amount, period, datetime)
```
## Pendapat
*jumlah*
Nilai integer positif atau negatif yang mewakili jumlah waktu yang ingin Anda tambahkan atau kurangi dari bidang datetime yang disediakan.
*periode*
Nilai positif atau negatif yang mewakili jumlah waktu yang ingin Anda tambahkan atau kurangi dari bidang datetime yang disediakan. Periode yang valid adalah sebagai berikut:
+ YYYY: Ini mengembalikan bagian tahun dari tanggal tersebut.
+ T: Ini mengembalikan kuartal yang menjadi tanggal (1-4).
+ MM: Ini mengembalikan bagian bulan dari tanggal tersebut.
+ DD: Ini mengembalikan bagian hari dari tanggal tersebut.
+ WK: Ini mengembalikan bagian minggu dari tanggal tersebut. Minggu dimulai pada hari Minggu di Amazon Quick.
+ HH: Ini mengembalikan porsi jam dari tanggal tersebut.
+ MI: Ini mengembalikan bagian menit dari tanggal tersebut.
+ SS: Ini mengembalikan bagian kedua dari tanggal.
+ MS: Ini mengembalikan bagian milidetik dari tanggal.
*datetime*
Tanggal atau waktu yang Anda inginkan untuk melakukan matematika tanggal.
## Jenis pengembalian
Datetime
## Contoh
Katakanlah Anda memiliki bidang yang disebut `purchase_date` yang memiliki nilai-nilai berikut.
```
2018 May 13 13:24
2017 Jan 31 23:06
2016 Dec 28 06:45
```
Menggunakan perhitungan berikut, `addDateTime` memodifikasi nilai-nilai seperti yang ditunjukkan berikut.
```
addDateTime(-2, 'YYYY', purchaseDate)
2016 May 13 13:24
2015 Jan 31 23:06
2014 Dec 28 06:45
addDateTime(4, 'DD', purchaseDate)
2018 May 17 13:24
2017 Feb 4 23:06
2017 Jan 1 06:45
addDateTime(20, 'MI', purchaseDate)
2018 May 13 13:44
2017 Jan 31 23:26
2016 Dec 28 07:05
```
# addWorkDays
`addWorkDays`Menambahkan atau mengurangi jumlah hari kerja yang ditentukan ke nilai tanggal tertentu. Fungsi mengembalikan tanggal untuk hari kerja, yang jatuh hari kerja yang ditentukan setelah atau sebelum nilai tanggal input yang diberikan.
## Sintaksis
```
addWorkDays(initDate, numWorkDays)
```
## Pendapat
*InitDate*
Tanggal non-Null valid yang bertindak sebagai tanggal mulai untuk perhitungan.
+ **Bidang dataset** - `date` Bidang apa pun dari kumpulan data yang Anda tambahkan fungsi ini.
+ **Fungsi tanggal** - Setiap keluaran tanggal dari `date` fungsi lain, misalnya`parseDate`,`epochDate`,`addDateTime`., dan sebagainya.
**Example**
```
addWorkDays(epochDate(1659484800), numWorkDays)
```
+ **Bidang terhitung** - Setiap bidang dihitung cepat yang mengembalikan `date` nilai.
**Example**
```
calcFieldStartDate = addDateTime(10, “DD”, startDate)
addWorkDays(calcFieldStartDate, numWorkDays)
```
+ **Parameter** - Setiap `datetime` parameter Cepat.
**Example**
```
addWorkDays($paramStartDate, numWorkDays)
```
+ Setiap kombinasi dari nilai-nilai argumen yang dinyatakan di atas.
*numWorkDays*
Sebuah integer non-Null yang bertindak sebagai tanggal akhir untuk perhitungan.
+ **Literal** — Sebuah literal integer langsung diketik dalam editor ekspresi.
**Example**
```
```
+ **Bidang dataset** - Setiap bidang tanggal dari kumpulan data
**Example**
```
```
+ **Fungsi atau perhitungan skalar** — Fungsi cepat skalar apa pun yang mengembalikan output integer dari yang lain, misalnya `decimalToInt``abs`, dan seterusnya.
**Example**
```
addWorkDays(initDate, decimalToInt(sqrt (abs(numWorkDays)) ) )
```
+ **Bidang terhitung** - Setiap bidang dihitung cepat yang mengembalikan `date` nilai.
**Example**
```
someOtherIntegerCalcField = (num_days * 2) + 12
addWorkDays(initDate, someOtherIntegerCalcField)
```
+ **Parameter** - Setiap `datetime` parameter Cepat.
**Example**
```
addWorkDays(initDate, $param_numWorkDays)
```
+ Setiap kombinasi dari nilai-nilai argumen yang dinyatakan di atas.
## Jenis pengembalian
Bilangan Bulat
## Nilai Ouptut
Nilai output yang diharapkan meliputi:
+ Bilangan bulat positif (ketika start\$1date < end\$1date)
+ Integer negatif (ketika start\$1date > end\$1date)
+ NULL ketika salah satu atau kedua argumen mendapatkan nilai null dari. `dataset field`
## Kesalahan masukan
Nilai argumen yang tidak diizinkan menyebabkan kesalahan, seperti yang ditunjukkan pada contoh berikut.
+ Menggunakan NULL literal sebagai argumen dalam ekspresi tidak diizinkan.
**Example**
```
addWorkDays(NULL, numWorkDays)
```
**Example**
```
Error
At least one of the arguments in this function does not have correct type.
Correct the expression and choose Create again.
```
+ Menggunakan string literal sebagai argumen, atau tipe data lain selain tanggal, dalam ekspresi tidak diizinkan. Dalam contoh berikut, string **"2022-08-10"** terlihat seperti tanggal, tetapi sebenarnya adalah string. Untuk menggunakannya, Anda harus menggunakan fungsi yang mengonversi ke tipe data tanggal.
**Example**
```
addWorkDays("2022-08-10", 10)
```
**Example**
```
Error
Expression addWorkDays("2022-08-10", numWorkDays) for function addWorkDays has
incorrect argument type addWorkDays(String, Number).
Function syntax expects Date, Integer.
```
## Contoh
Sebuah integer positif sebagai `numWorkDays` argumen akan menghasilkan tanggal di masa depan tanggal input. Sebuah integer negatif sebagai `numWorkDays` argumen akan menghasilkan tanggal yang dihasilkan di masa lalu dari tanggal input. Nilai nol untuk `numWorkDays` argumen menghasilkan nilai yang sama dengan tanggal input apakah itu jatuh pada hari kerja atau akhir pekan.
`addWorkDays`Fungsi beroperasi pada granularitas:. `DAY` Akurasi tidak dapat dipertahankan pada setiap granularitas yang lebih rendah atau lebih tinggi dari `DAY` tingkat.
```
addWorkDays(startDate, endDate)
```
Mari kita asumsikan ada bidang bernama `employmentStartDate` dengan nilai-nilai berikut:
```
2022-08-10 2022-08-06 2022-08-07
```
Menggunakan bidang di atas dan perhitungan berikut, `addWorkDays` mengembalikan nilai-nilai yang dimodifikasi seperti yang ditunjukkan di bawah ini:
```
addWorkDays(employmentStartDate, 7)
2022-08-19
2022-08-16
2022-08-16
addWorkDays(employmentStartDate, -5)
2022-08-02
2022-08-01
2022-08-03
addWorkDays(employmentStartDate, 0)
2022-08-10
2022-08-06
2022-08-07
```
Contoh berikut menghitung total bonus pro-rated yang harus dibayarkan kepada setiap karyawan selama 2 tahun berdasarkan berapa hari setiap karyawan benar-benar bekerja.
```
last_day_of_work = addWorkDays(employment_start_date, 730)
total_days_worked = netWorkDays(employment_start_date, last_day_of_work)
total_bonus = total_days_worked * bonus_per_day
```
![\[alt text not found\]](http://docs.aws.amazon.com/id_id/quick/latest/userguide/images/addWorkDays-function-example.png)
# Abs
`abs`mengembalikan nilai absolut dari ekspresi yang diberikan.
## Sintaksis
```
abs(expression)
```
## Pendapat
*ekspresi*
Ekspresi harus numerik. Ini bisa berupa nama bidang, nilai literal, atau fungsi lain.
# Ceil
`ceil`membulatkan nilai desimal ke bilangan bulat tertinggi berikutnya. Misalnya, `ceil(29.02)` mengembalikan `30`.
## Sintaksis
```
ceil(decimal)
```
## Pendapat
*desimal*
Bidang yang menggunakan tipe data desimal, nilai literal seperti**17.62**, atau panggilan ke fungsi lain yang mengeluarkan desimal.
## Jenis pengembalian
Bilangan Bulat
## Contoh
Contoh berikut membulatkan bidang desimal ke bilangan bulat tertinggi berikutnya.
```
ceil(salesAmount)
```
Berikut ini adalah nilai bidang yang diberikan.
```
20.13
892.03
57.54
```
Untuk nilai bidang ini, nilai berikut dikembalikan.
```
21
893
58
```
# Coalesce
`coalesce`mengembalikan nilai argumen pertama yang tidak null. Ketika nilai non-null ditemukan, argumen yang tersisa dalam daftar tidak dievaluasi. Jika semua argumen adalah nol, hasilnya adalah nol. String 0-panjang adalah nilai yang valid dan tidak dianggap setara dengan null.
## Sintaksis
```
coalesce(expression1, expression2 [, expression3, ...])
```
## Pendapat
`coalesce`mengambil dua atau lebih ekspresi sebagai argumen. Semua ekspresi harus memiliki tipe data yang sama atau dapat secara implisit dilemparkan ke tipe data yang sama.
*ekspresi*
Ekspresi dapat berupa numerik, datetime, atau string. Ini bisa berupa nama bidang, nilai literal, atau fungsi lain.
## Jenis pengembalian
`coalesce`mengembalikan nilai dari tipe data yang sama sebagai argumen masukan.
## Contoh
Contoh berikut mengambil alamat penagihan pelanggan jika ada, alamat jalannya jika tidak ada alamat penagihan, atau mengembalikan “Tidak ada alamat yang terdaftar” jika tidak ada alamat yang tersedia.
```
coalesce(billingAddress, streetAddress, 'No address listed')
```
# Concat
`concat`menggabungkan dua atau lebih string.
## Sintaksis
```
concat(expression1, expression2 [, expression3 ...])
```
## Pendapat
`concat`mengambil dua atau lebih ekspresi string sebagai argumen.
*ekspresi*
Ekspresi harus berupa string. Ini bisa berupa nama bidang yang menggunakan tipe data string, nilai literal seperti**'12 Main Street'**, atau panggilan ke fungsi lain yang mengeluarkan string.
## Jenis pengembalian
String
## Contoh
Contoh berikut menggabungkan tiga bidang string dan menambahkan spasi yang sesuai.
```
concat(salutation, ' ', firstName, ' ', lastName)
```
Berikut ini adalah nilai bidang yang diberikan.
```
salutation firstName lastName
-------------------------------------------------------
Ms. Li Juan
Dr. Ana Carolina Silva
Mr. Nikhil Jayashankar
```
Untuk nilai bidang ini, nilai berikut dikembalikan.
```
Ms. Li Juan
Dr. Ana Carolina Silva
Mr. Nikhil Jayashankar
```
Contoh berikut menggabungkan dua string literal.
```
concat('Hello', 'world')
```
Nilai berikut dikembalikan.
```
Helloworld
```
# contains
`contains`mengevaluasi apakah substring yang Anda tentukan ada dalam ekspresi. Jika ekspresi berisi substring, berisi mengembalikan true, dan jika tidak maka mengembalikan false.
## Sintaksis
```
contains(expression, substring, string-comparison-mode)
```
## Pendapat
*ekspresi*
Ekspresi harus berupa string. Ini bisa berupa nama bidang yang menggunakan tipe data string, nilai literal seperti**'12 Main Street'**, atau panggilan ke fungsi lain yang mengeluarkan string.
*substring*
Kumpulan karakter untuk memeriksa *ekspresi*. Substring dapat terjadi satu kali atau lebih dalam *ekspresi*.
*string-comparison-mode*
(Opsional) Menentukan mode perbandingan string untuk menggunakan:
+ `CASE_SENSITIVE`— Perbandingan string peka huruf besar/kecil.
+ `CASE_INSENSITIVE`— Perbandingan string tidak peka huruf besar/kecil.
Nilai ini default saat kosong. `CASE_SENSITIVE`
## Jenis pengembalian
Boolean
## Contoh
### Contoh case sensitive default
Contoh case sensitive berikut mengevaluasi jika `state_nm` mengandung**New**.
```
contains(state_nm, "New")
```
Berikut ini adalah nilai bidang yang diberikan.
```
New York
new york
```
Untuk nilai bidang ini, nilai berikut dikembalikan.
```
true
false
```
### Contoh tidak peka huruf besar/kecil
Contoh case insensitive berikut mengevaluasi jika `state_nm` mengandung. **new**
```
contains(state_nm, "new", CASE_INSENSITIVE)
```
Berikut ini adalah nilai bidang yang diberikan.
```
New York
new york
```
Untuk nilai bidang ini, nilai berikut dikembalikan.
```
true
true
```
### Contoh dengan pernyataan bersyarat
[https://docs.aws.amazon.com/quicksight/latest/user/stdevIf-function.html](https://docs.aws.amazon.com/quicksight/latest/user/stdevIf-function.html)
Contoh berikut `Sales` hanya dijumlahkan jika `state_nm` berisi**New**.
```
sumIf(Sales,contains(state_nm, "New"))
```
### Tidak mengandung contoh
`NOT`Operator bersyarat dapat digunakan untuk mengevaluasi jika ekspresi tidak mengandung substring yang ditentukan.
```
NOT(contains(state_nm, "New"))
```
### Contoh menggunakan nilai numerik
Nilai numerik dapat digunakan dalam ekspresi atau substring argumen dengan menerapkan fungsi. `toString`
```
contains(state_nm, toString(5) )
```
# decimalToInt
`decimalToInt`mengubah nilai desimal ke tipe data integer dengan menghapus titik desimal dan angka apa pun setelahnya. `decimalToInt`tidak membulatkan. Misalnya, `decimalToInt(29.99)` mengembalikan `29`.
## Sintaksis
```
decimalToInt(decimal)
```
## Pendapat
*desimal*
Bidang yang menggunakan tipe data desimal, nilai literal seperti**17.62**, atau panggilan ke fungsi lain yang mengeluarkan desimal.
## Jenis pengembalian
Bilangan Bulat
## Contoh
Contoh berikut mengkonversi bidang desimal ke integer.
```
decimalToInt(salesAmount)
```
Berikut ini adalah nilai bidang yang diberikan.
```
20.13
892.03
57.54
```
Untuk nilai bidang ini, nilai berikut dikembalikan.
```
20
892
57
```
# dateDiff
`dateDiff`mengembalikan selisih hari antara dua bidang tanggal. Jika Anda menyertakan nilai untuk periode tersebut, `dateDiff` mengembalikan selisih interval periode, bukan dalam hari.
## Sintaksis
```
dateDiff(date1, date2,[period])
```
## Pendapat
`dateDiff`mengambil dua tanggal sebagai argumen. Menentukan periode adalah opsional.
*tanggal 1*
Kencan pertama dalam perbandingan. Kolom tanggal atau panggilan ke fungsi lain yang menampilkan tanggal.
*tanggal 2*
Tanggal kedua dalam perbandingan. Kolom tanggal atau panggilan ke fungsi lain yang menampilkan tanggal.
*periode*
Periode perbedaan yang ingin Anda kembalikan, terlampir dalam tanda kutip. Periode yang valid adalah sebagai berikut:
+ YYYY: Ini mengembalikan bagian tahun dari tanggal tersebut.
+ T: Ini mengembalikan tanggal hari pertama kuartal tanggal tersebut.
+ MM: Ini mengembalikan bagian bulan dari tanggal tersebut.
+ DD: Ini mengembalikan bagian hari dari tanggal tersebut.
+ WK: Ini mengembalikan bagian minggu dari tanggal tersebut. Minggu dimulai pada hari Minggu di Amazon Quick.
+ HH: Ini mengembalikan porsi jam dari tanggal.
+ MI: Ini mengembalikan bagian menit dari tanggal.
+ SS: Ini mengembalikan bagian kedua dari tanggal.
+ MS: Ini mengembalikan bagian milidetik dari tanggal.
## Jenis pengembalian
Bilangan Bulat
## Contoh
Contoh berikut mengembalikan perbedaan antara dua tanggal.
```
dateDiff(orderDate, shipDate, "MM")
```
Berikut ini adalah nilai bidang yang diberikan.
```
orderDate shipdate
=============================
01/01/18 03/05/18
09/13/17 10/20/17
```
Untuk nilai bidang ini, nilai berikut dikembalikan.
```
2
1
```
# endsWith
`endsWith`mengevaluasi jika ekspresi berakhir dengan substring yang Anda tentukan. Jika ekspresi berakhir dengan substring, `endsWith` mengembalikan true, dan jika tidak maka mengembalikan false.
## Sintaksis
```
endsWith(expression, substring, string-comparison-mode)
```
## Pendapat
*ekspresi*
Ekspresi harus berupa string. Ini bisa berupa nama bidang yang menggunakan tipe data string, nilai literal seperti**'12 Main Street'**, atau panggilan ke fungsi lain yang mengeluarkan string.
*substring*
Kumpulan karakter untuk memeriksa *ekspresi*. Substring dapat terjadi satu kali atau lebih dalam *ekspresi*.
*string-comparison-mode*
(Opsional) Menentukan mode perbandingan string untuk menggunakan:
+ `CASE_SENSITIVE`— Perbandingan string peka huruf besar/kecil.
+ `CASE_INSENSITIVE`— Perbandingan string tidak peka huruf besar/kecil.
Nilai ini defaultnya saat kosong. `CASE_SENSITIVE`
## Jenis pengembalian
Boolean
## Contoh
### Contoh case sensitive default
Contoh case sensitive berikut mengevaluasi jika `state_nm` **"York"** endsWith.
```
endsWith(state_nm, "York")
```
Berikut ini adalah nilai bidang yang diberikan.
```
New York
new york
```
Untuk nilai bidang ini, nilai berikut dikembalikan.
```
true
false
```
### Contoh tidak peka huruf besar/kecil
Contoh case insensitive berikut mengevaluasi jika `state_nm` endsWith. **"york"**
```
endsWith(state_nm, "york", CASE_INSENSITIVE)
```
Berikut ini adalah nilai bidang yang diberikan.
```
New York
new york
```
Untuk nilai bidang ini, nilai berikut dikembalikan.
```
true
true
```
### Contoh dengan pernyataan bersyarat
`endsWith`[https://docs.aws.amazon.com/quicksight/latest/user/stdevIf-function.html](https://docs.aws.amazon.com/quicksight/latest/user/stdevIf-function.html)
Contoh berikut `Sales` hanya dijumlahkan jika `state_nm` diakhiri dengan**"York"**.
```
sumIf(Sales,endsWith(state_nm, "York"))
```
### Tidak mengandung contoh
`NOT`Operator bersyarat dapat digunakan untuk mengevaluasi jika ekspresi tidak dimulai dengan substring yang ditentukan.
```
NOT(endsWith(state_nm, "York"))
```
### Contoh menggunakan nilai numerik
Nilai numerik dapat digunakan dalam ekspresi atau substring argumen dengan menerapkan fungsi. `toString`
```
endsWith(state_nm, toString(5) )
```
# epochDate
`epochDate`**[mengubah tanggal epoch menjadi tanggal standar dalam format YYYY-MM-DD **T** KK:mm: SS.sss Z, menggunakan sintaks pola format yang ditentukan dalam Kelas dalam dokumentasi proyek Joda. DateTimeFormat](http://www.joda.org/joda-time/apidocs/org/joda/time/format/DateTimeFormat.html)** Contohnya adalah `2015-10-15T19:11:51.003Z`.
`epochDate`didukung untuk digunakan dengan analisis berdasarkan kumpulan data yang disimpan di Quick (). SPICE
## Sintaksis
```
epochDate(epochdate)
```
## Pendapat
*epokdat*
Tanggal epoch, yang merupakan representasi bilangan bulat dari tanggal sebagai jumlah detik sejak 00:00:00 UTC pada 1 Januari 1970.
*epochdate* harus berupa bilangan bulat. Ini bisa berupa nama bidang yang menggunakan tipe data integer, nilai integer literal, atau panggilan ke fungsi lain yang mengeluarkan bilangan bulat. Jika nilai integer lebih panjang dari 10 digit, digit setelah tempat ke-10 dibuang.
## Jenis pengembalian
Date
## Contoh
Contoh berikut mengonversi tanggal epoch menjadi tanggal standar.
```
epochDate(3100768000)
```
Nilai berikut dikembalikan.
```
2068-04-04T12:26:40.000Z
```
# Exp
`exp`mengembalikan dasar log alami e dinaikkan ke kekuatan ekspresi yang diberikan.
## Sintaksis
```
exp(expression)
```
## Pendapat
*ekspresi*
Ekspresi harus numerik. Ini bisa berupa nama bidang, nilai literal, atau fungsi lain.
# Extract
`extract`mengembalikan bagian tertentu dari nilai tanggal. Meminta bagian terkait waktu dari tanggal yang tidak berisi informasi waktu mengembalikan 0.
## Sintaksis
```
extract(period, date)
```
## Pendapat
*periode*
Periode yang ingin Anda ekstrak dari nilai tanggal. Periode yang valid adalah sebagai berikut:
+ YYYY: Ini mengembalikan bagian tahun dari tanggal tersebut.
+ T: Ini mengembalikan kuartal yang menjadi tanggal (1-4).
+ MM: Ini mengembalikan bagian bulan dari tanggal tersebut.
+ DD: Ini mengembalikan bagian hari dari tanggal tersebut.
+ WD: Ini mengembalikan hari dalam seminggu sebagai bilangan bulat, dengan hari Minggu sebagai 1.
+ HH: Ini mengembalikan porsi jam dari tanggal.
+ MI: Ini mengembalikan bagian menit dari tanggal.
+ SS: Ini mengembalikan bagian kedua dari tanggal.
+ MS: Ini mengembalikan bagian milidetik dari tanggal.
**catatan**
Mengekstrak milidetik tidak didukung dalam database Presto di bawah versi 0.216.
*tanggal*
Kolom tanggal atau panggilan ke fungsi lain yang menampilkan tanggal.
## Jenis pengembalian
Bilangan Bulat
## Contoh
Contoh berikut mengekstrak hari dari nilai tanggal.
```
extract('DD', orderDate)
```
Berikut ini adalah nilai bidang yang diberikan.
```
orderDate
=========
01/01/14
09/13/16
```
Untuk nilai bidang ini, nilai berikut dikembalikan.
```
01
13
```
# Floor
`floor`mengurangi nilai desimal ke bilangan bulat terendah berikutnya. Misalnya, `floor(29.08)` mengembalikan `29`.
## Sintaksis
```
floor(decimal)
```
## Pendapat
*desimal*
Bidang yang menggunakan tipe data desimal, nilai literal seperti**17.62**, atau panggilan ke fungsi lain yang mengeluarkan desimal.
## Jenis pengembalian
Bilangan Bulat
## Contoh
Contoh berikut mengurangi bidang desimal ke bilangan bulat terendah berikutnya.
```
floor(salesAmount)
```
Berikut ini adalah nilai bidang yang diberikan.
```
20.13
892.03
57.54
```
Untuk nilai bidang ini, nilai berikut dikembalikan.
```
20
892
57
```
# formatDate
`formatDate`memformat tanggal menggunakan pola yang Anda tentukan. Saat Anda menyiapkan data, Anda dapat menggunakan `formatDate` untuk memformat ulang tanggal. Untuk memformat ulang tanggal dalam analisis, Anda memilih opsi format dari menu konteks pada bidang tanggal.
## Sintaksis
```
formatDate(date, ['format'])
```
## Pendapat
*tanggal*
Kolom tanggal atau panggilan ke fungsi lain yang menampilkan tanggal.
*format*
(Opsional) String yang berisi pola format untuk diterapkan. Argumen ini menerima pola format yang ditentukan dalam [format tanggal yang didukung](https://docs.aws.amazon.com/quicksight/latest/user/supported-date-formats.html).
**Jika Anda tidak menentukan format, string ini default ke YYYY-MM-DD T KK:mm:ss:SSS.**
## Jenis pengembalian
String
## Contoh
Contoh berikut memformat tanggal UTC.
```
formatDate(orderDate, 'dd-MMM-yyyy')
```
Berikut ini adalah nilai bidang yang diberikan.
```
order date
=========
2012-12-14T00:00:00.000Z
2013-12-29T00:00:00.000Z
2012-11-15T00:00:00.000Z
```
Untuk nilai bidang ini, nilai berikut dikembalikan.
```
13 Dec 2012
28 Dec 2013
14 Nov 2012
```
## Contoh
Jika tanggal berisi tanda kutip atau apostrof tunggal, misalnya`yyyyMMdd'T'HHmmss`, Anda dapat menangani format tanggal ini dengan menggunakan salah satu metode berikut.
+ Lampirkan seluruh tanggal dalam tanda kutip ganda, seperti yang ditunjukkan pada contoh berikut:
```
formatDate({myDateField}, "yyyyMMdd'T'HHmmss")
```
+ Lepaskan tanda kutip atau apostrof tunggal dengan menambahkan garis miring terbalik (`\`) di sebelah kiri tanda kutip atau apostrof, seperti yang ditunjukkan pada contoh berikut:
```
formatDate({myDateField}, 'yyyyMMdd\'T\'HHmmss')
```
# Ifelse
`ifelse`mengevaluasi satu set *if*, *maka* pasangan ekspresi, dan mengembalikan nilai argumen *then* untuk argumen *if* pertama yang mengevaluasi ke true. Jika tidak ada argumen *if* yang dievaluasi menjadi true, maka nilai argumen *else* dikembalikan.
## Sintaksis
```
ifelse(if-expression-1, then-expression-1 [, if-expression-n, then-expression-n ...], else-expression)
```
## Pendapat
`ifelse`membutuhkan satu atau lebih *if*, *maka* pasangan ekspresi, dan membutuhkan tepat satu ekspresi untuk argumen *else*.
*jika-ekspresi*
Ekspresi yang akan dievaluasi sebagai benar atau tidak. Ini bisa berupa nama bidang seperti**address1**, nilai literal seperti**'Unknown'**, atau fungsi lain seperti`toString(salesAmount)`. Contohnya adalah `isNotNull(FieldName)`.
Jika Anda menggunakan beberapa operator AND dan OR dalam `if` argumen, lampirkan pernyataan dalam tanda kurung untuk mengidentifikasi urutan pemrosesan. Misalnya, `if` argumen berikut mengembalikan catatan dengan bulan 1, 2, atau 5 dan tahun 2000.
```
ifelse((month = 5 OR month < 3) AND year = 2000, 'yes', 'no')
```
`if`Argumen berikutnya menggunakan operator yang sama, tetapi mengembalikan catatan dengan bulan 5 dan tahun apa pun, atau dengan bulan 1 atau 2 dan satu tahun 2000.
```
ifelse(month = 5 OR (month < 3 AND year = 2000), 'yes', 'no')
```
*kemudian ekspresi*
Ekspresi untuk kembali *jika argumen if* dievaluasi sebagai benar. Ini bisa berupa nama bidang seperti**address1**, nilai literal seperti**'Unknown'**, atau panggilan ke fungsi lain. Ekspresi harus memiliki tipe data yang sama dengan `then` argumen dan `else` argumen lainnya.
*ekspresi orang lain*
Ekspresi untuk kembali jika tidak ada argumen *if* yang dievaluasi sebagai benar. Ini bisa berupa nama bidang seperti**address1**, nilai literal seperti**'Unknown'**, atau fungsi lain seperti`toString(salesAmount)`. Ekspresi harus memiliki tipe data yang sama dengan semua `then` argumen.
## Jenis pengembalian
`ifelse`mengembalikan nilai tipe data yang sama dengan nilai dalam ekspresi *saat itu*. Semua data yang dikembalikan *kemudian* dan ekspresi *lain* harus dari tipe data yang sama atau dikonversi ke tipe data yang sama.
## Contoh
Contoh berikut menghasilkan kolom alias untuk bidang`country`.
```
ifelse(country = "United States", "US", country = "China", "CN", country = "India", "IN", "Others")
```
Untuk kasus penggunaan seperti mengevaluasi setiap nilai dalam bidang terhadap daftar literal, dan mengembalikan hasil yang sesuai dengan nilai pencocokan pertama., sakelar fungsi disarankan untuk menyederhanakan pekerjaan Anda. Contoh sebelumnya dapat ditulis ulang ke pernyataan berikut menggunakan [https://docs.aws.amazon.com/quicksight/latest/user/switch-function.html](https://docs.aws.amazon.com/quicksight/latest/user/switch-function.html):
```
switch(country,"United States","US","China","CN","India","IN","Others")
```
Contoh berikut mengkategorikan penjualan per pelanggan ke dalam tingkat yang dapat dibaca manusia.
```
ifelse(salesPerCustomer < 1000, “VERY_LOW”, salesPerCustomer < 10000, “LOW”, salesPerCustomer < 100000, “MEDIUM”, “HIGH”)
```
Contoh berikut menggunakan AND, OR, dan TIDAK untuk membandingkan beberapa ekspresi menggunakan operator bersyarat untuk menandai pelanggan teratas TIDAK di Washington atau Oregon dengan promosi khusus, yang membuat lebih dari 10 pesanan. Jika tidak ada nilai yang dikembalikan, nilainya `'n/a'` digunakan.
```
ifelse(( (NOT (State = 'WA' OR State = 'OR')) AND Orders > 10), 'Special Promotion XYZ', 'n/a')
```
Contoh berikut hanya menggunakan OR untuk menghasilkan kolom baru yang berisi nama benua yang sesuai dengan masing-masing`country`.
```
ifelse(country = "United States" OR country = "Canada", "North America", country = "China" OR country = "India" OR country = "Japan", "Asia", "Others")
```
Contoh sebelumnya dapat disederhanakan seperti yang ditunjukkan pada contoh berikutnya. Contoh berikut menggunakan `ifelse` dan [https://docs.aws.amazon.com/quicksight/latest/user/in-function.html](https://docs.aws.amazon.com/quicksight/latest/user/in-function.html)untuk membuat nilai dalam kolom baru untuk setiap baris di mana nilai diuji dalam daftar literal. Anda bisa menggunakannya `ifelse` [https://docs.aws.amazon.com/quicksight/latest/user/notIn-function.html](https://docs.aws.amazon.com/quicksight/latest/user/notIn-function.html)juga.
```
ifelse(in(country,["United States", "Canada"]), "North America", in(country,["China","Japan","India"]),"Asia","Others")
```
Penulis dapat menyimpan daftar literal dalam parameter multivalue dan menggunakannya dalam fungsi [https://docs.aws.amazon.com/quicksight/latest/user/in-function.html](https://docs.aws.amazon.com/quicksight/latest/user/in-function.html)atau [https://docs.aws.amazon.com/quicksight/latest/user/notIn-function.html](https://docs.aws.amazon.com/quicksight/latest/user/notIn-function.html). Contoh berikut adalah setara dengan contoh sebelumnya, kecuali bahwa daftar literal disimpan dalam dua parameter multivalue.
```
ifelse(in(country,${NorthAmericaCountryParam}), "North America", in(country,${AsiaCountryParam}),"Asia", "Others")
```
Contoh berikut menetapkan grup ke catatan penjualan berdasarkan total penjualan. Struktur setiap `if-then` frase meniru perilaku *antara*, kata kunci yang saat ini tidak berfungsi dalam ekspresi bidang terhitung. Misalnya, hasil perbandingan `salesTotal >= 0 AND salesTotal < 500` mengembalikan nilai yang sama dengan perbandingan `salesTotal between 0 and 499` SQL.
```
ifelse(salesTotal >= 0 AND salesTotal < 500, 'Group 1', salesTotal >= 500 AND salesTotal < 1000, 'Group 2', 'Group 3')
```
Contoh berikut menguji nilai NULL dengan menggunakan `coalesce` untuk mengembalikan nilai non-NULL pertama. Alih-alih perlu mengingat arti NULL di bidang tanggal, Anda dapat menggunakan deskripsi yang dapat dibaca sebagai gantinya. Jika tanggal pemutusan adalah NULL, contoh mengembalikan tanggal penangguhan, kecuali keduanya adalah NULL. Kemudian `coalesce(DiscoDate, SuspendDate, '12/31/2491')` kembali`'12/31/2491'`. Nilai yang dikembalikan harus sesuai dengan tipe data lainnya. Tanggal ini mungkin tampak seperti nilai yang tidak biasa, tetapi tanggal di abad ke-25 secara wajar mensimulasikan “akhir waktu,” yang didefinisikan sebagai tanggal tertinggi dalam data mart.
```
ifelse ( (coalesce(DiscoDate, SuspendDate, '12/31/2491') = '12/31/2491'), 'Active subscriber', 'Inactive subscriber')
```
Berikut ini menunjukkan contoh yang lebih kompleks dalam format yang lebih mudah dibaca, hanya untuk menunjukkan bahwa Anda tidak perlu mengompres kode Anda semua menjadi satu baris panjang. Contoh ini memberikan beberapa perbandingan nilai hasil survei. Ini menangani nilai NULL potensial untuk bidang ini dan mengkategorikan dua rentang yang dapat diterima. Ini juga memberi label satu rentang yang membutuhkan lebih banyak pengujian dan yang lain tidak valid (di luar jangkauan). Untuk semua nilai yang tersisa, ini menerapkan `else` kondisi, dan memberi label baris sebagai membutuhkan pengujian ulang tiga tahun setelah tanggal pada baris itu.
```
ifelse
(
isNull({SurveyResult}), 'Untested',
{SurveyResult}=1, 'Range 1',
{SurveyResult}=2, 'Range 2',
{SurveyResult}=3, 'Need more testing',
{SurveyResult}=99, 'Out of Range',
concat
(
'Retest by ',
toString
(
addDateTime(3, "YYYY", {Date})
)
)
)
```
Contoh berikut memberikan nama wilayah “secara manual” dibuat untuk sekelompok negara bagian. Ini juga menggunakan spasi dan komentar, dibungkus`/* */`, untuk membuatnya lebih mudah untuk mempertahankan kode.
```
ifelse
( /* NE REGION*/
locate('New York, New Jersey, Connecticut, Vermont, Maine, Rhode Island, New Hampshire',{State}) > 0,
'Northeast',
/* SE REGION*/
locate('Georgia, Alabama, South Carolina, Louisiana',{State}) > 0,
'Southeast',
'Other Region'
)
```
Logika untuk penandaan wilayah rusak sebagai berikut:
1. Kami mencantumkan status yang kami inginkan untuk setiap wilayah, melampirkan setiap daftar dalam tanda kutip untuk membuat setiap daftar string, sebagai berikut:
+ `'New York, New Jersey, Connecticut, Vermont, Maine, Rhode Island, New Hampshire'`
+ `'Georgia, Alabama, South Carolina, Louisiana'`
+ Anda dapat menambahkan lebih banyak set, atau menggunakan negara, kota, provinsi, atau What3Words jika Anda mau.
1. Kami bertanya apakah nilai untuk `State` (untuk setiap baris) ditemukan dalam daftar, dengan menggunakan `locate` fungsi untuk mengembalikan nilai bukan nol jika keadaan ditemukan dalam daftar, sebagai berikut.
```
locate('New York, New Jersey, Connecticut, Vermont, Maine, Rhode Island, New Hampshire',{State})
and
locate('Georgia, Alabama, South Carolina, Louisiana',{State})
```
1. `locate`Fungsi mengembalikan angka bukan `TRUE` atau`FALSE`, tetapi `ifelse` membutuhkan nilai`TRUE`/`FALSE`Boolean. Untuk menyiasatinya, kita bisa membandingkan hasilnya `locate` dengan angka. Jika negara ada dalam daftar, nilai pengembalian lebih besar dari nol.
1. Tanyakan apakah negara ada.
```
locate('New York, New Jersey, Connecticut, Vermont, Maine, Rhode Island, New Hampshire',{State}) > 0
```
1. Jika ada wilayah tersebut, beri label sebagai wilayah tertentu, dalam hal ini wilayah Timur Laut.
```
/*The if expression:*/ locate('New York, New Jersey, Connecticut, Vermont, Maine, Rhode Island, New Hampshire',{State}) > 0,
/*The then expression:*/ 'Northeast',
```
1. Karena kami memiliki status yang tidak ada dalam daftar, dan karena `ifelse` memerlukan satu `else` ekspresi, kami menyediakan `'Other Region'` sebagai label untuk status sisa.
```
/*The if expression:*/ locate('New York, New Jersey, Connecticut, Vermont, Maine, Rhode Island, New Hampshire',{State}) > 0,
/*The then expression:*/ 'Northeast',
/*The else expression:*/ 'Other Region'
```
1. Kami membungkus semua itu dalam `ifelse( )` fungsi untuk mendapatkan versi final. Contoh berikut meninggalkan negara bagian wilayah Tenggara yang asli. Anda dapat menambahkannya kembali sebagai pengganti *``* tag.
Jika Anda ingin menambahkan lebih banyak wilayah, Anda dapat membuat lebih banyak salinan dari dua baris tersebut dan mengubah daftar negara agar sesuai dengan tujuan Anda. Anda dapat mengubah nama wilayah menjadi sesuatu yang cocok untuk Anda, dan mengubah nama bidang dari `State` apa pun yang Anda butuhkan.
```
ifelse
(
/*The if expression:*/ locate('New York, New Jersey, Connecticut, Vermont, Maine, Rhode Island, New Hampshire',{State}) > 0,
/*The then expression:*/ 'Northeast',
/**/
/*The else expression:*/ 'Other Region'
)
```
**catatan**
Ada cara lain untuk melakukan perbandingan awal untuk ekspresi if. Misalnya, anggaplah Anda mengajukan pertanyaan “Status apa yang tidak hilang dari daftar ini?” daripada “Negara bagian mana yang ada dalam daftar?” Jika Anda melakukannya, Anda mungkin mengungkapkannya secara berbeda. Anda dapat membandingkan pernyataan locate ke nol untuk menemukan nilai yang hilang dari daftar, dan kemudian menggunakan operator NOT untuk mengklasifikasikannya sebagai “tidak hilang,” sebagai berikut.
```
/*The if expression:*/ NOT (locate('New York, New Jersey, Connecticut, Vermont, Maine, Rhode Island, New Hampshire',{State}) = 0),
```
Kedua versi itu benar. Versi yang Anda pilih harus paling masuk akal bagi Anda dan tim Anda, sehingga Anda dapat mempertahankannya dengan mudah. Jika semua opsi tampak sama, pilih yang paling sederhana.
# in
`in`mengevaluasi jika ekspresi ada dalam daftar literal. Jika daftar berisi ekspresi, dalam mengembalikan true, dan sebaliknya mengembalikan false. `in`peka huruf besar/kecil untuk input tipe string.
`in`menerima dua jenis daftar literal, satu secara manual dimasukkan daftar dan yang lainnya adalah parameter [multivalue](https://docs.aws.amazon.com/quicksight/latest/user/parameters-in-quicksight.html).
## Sintaksis
Menggunakan daftar yang dimasukkan secara manual:
```
in(expression, [literal-1, ...])
```
Menggunakan parameter multivalue:
```
in(expression, $multivalue_parameter)
```
## Pendapat
*ekspresi*
Ekspresi yang akan dibandingkan dengan unsur-unsur dalam daftar literal. Ini bisa berupa nama bidang seperti`address`, nilai literal seperti '**Unknown**', parameter nilai tunggal, atau panggilan ke fungsi skalar lain—asalkan fungsi ini bukan fungsi agregat atau perhitungan tabel.
*daftar literal*
(wajib) Ini bisa berupa daftar yang dimasukkan secara manual atau parameter multivalue. Argumen ini menerima hingga 5.000 elemen. Namun, dalam kueri langsung ke sumber data pihak ketiga, misalnya Oracle atau Teradata, batasannya bisa lebih kecil.
+ ***daftar yang dimasukkan secara manual*** - Satu atau lebih nilai literal dalam daftar untuk dibandingkan dengan ekspresi. Daftar harus dilampirkan dalam tanda kurung siku. Semua literal untuk membandingkan harus memiliki tipe data yang sama dengan ekspresi.
+ parameter ***multivalue — Parameter*** multivalue yang telah ditentukan sebelumnya diteruskan sebagai daftar literal. Parameter multivalue harus memiliki tipe data yang sama dengan ekspresi.
## Jenis pengembalian
Boolean: BENAR/SALAH
## Contoh dengan daftar statis
Contoh berikut mengevaluasi `origin_state_name` bidang untuk nilai-nilai dalam daftar string. Saat membandingkan input tipe string, `in` hanya mendukung perbandingan peka huruf besar/kecil.
```
in(origin_state_name,["Georgia", "Ohio", "Texas"])
```
Berikut ini adalah nilai bidang yang diberikan.
```
"Washington"
"ohio"
"Texas"
```
Untuk nilai bidang ini nilai berikut dikembalikan.
```
false
false
true
```
Nilai pengembalian ketiga benar karena hanya “Texas” adalah salah satu nilai yang disertakan.
Contoh berikut mengevaluasi `fl_date` bidang untuk nilai-nilai dalam daftar string. Untuk mencocokkan jenisnya, `toString` digunakan untuk mentransmisikan tipe tanggal ke tipe string.
```
in(toString(fl_date),["2015-05-14","2015-05-15","2015-05-16"])
```
![\[Gambar hasil contoh fungsi, ditunjukkan dalam bentuk tabel.\]](http://docs.aws.amazon.com/id_id/quick/latest/userguide/images/in-function-example-manual-list.png)
Literal dan nilai NULL didukung dalam argumen ekspresi untuk dibandingkan dengan literal dalam daftar. Kedua dari dua contoh berikut akan menghasilkan kolom baru nilai TRUE.
```
in("Washington",["Washington","Ohio"])
```
```
in(NULL,[NULL,"Ohio"])
```
## Contoh dengan parameter mutivalue
Katakanlah seorang penulis membuat [parameter multivalue](https://docs.aws.amazon.com/quicksight/latest/user/parameters-in-quicksight.html) yang berisi daftar semua nama negara. Kemudian penulis menambahkan kontrol untuk memungkinkan pembaca memilih nilai dari daftar.
Selanjutnya, pembaca memilih tiga nilai — “Georgia”, “Ohio”, dan “Texas” — dari kontrol daftar drop-down parameter. Dalam hal ini, ekspresi berikut setara dengan contoh pertama, di mana ketiga nama negara dilewatkan sebagai daftar literal untuk dibandingkan dengan `original_state_name` bidang.
```
in (origin_state_name, ${stateName MultivalueParameter})
```
## Contoh dengan `ifelse`
`in`dapat bersarang di fungsi lain sebagai nilai boolean. Salah satu contohnya adalah bahwa penulis dapat mengevaluasi ekspresi apa pun dalam daftar dan mengembalikan nilai yang mereka inginkan dengan menggunakan `in` dan`ifelse`. Contoh berikut mengevaluasi apakah penerbangan berada dalam daftar negara bagian AS tertentu dan mengembalikan kategori negara bagian yang berbeda berdasarkan perbandingan. `dest_state_name`
```
ifelse(in(dest_state_name,["Washington", "Oregon","California"]), "WestCoastUSState", "Other US State")
```
![\[Gambar hasil contoh fungsi, ditunjukkan dalam bentuk tabel.\]](http://docs.aws.amazon.com/id_id/quick/latest/userguide/images/in-function-with-ifelse.png)
# intToDecimal
`intToDecimal`mengkonversi nilai integer ke tipe data desimal.
## Sintaksis
```
intToDecimal(integer)
```
## Pendapat
*int*
Bidang yang menggunakan tipe data integer, nilai literal seperti**14**, atau panggilan ke fungsi lain yang mengeluarkan integer.
## Jenis pengembalian
Desimal (Tetap) dalam pengalaman persiapan data lama.
Desimal (Float) dalam pengalaman persiapan data baru.
## Contoh
Contoh berikut mengkonversi bidang integer ke desimal.
```
intToDecimal(price)
```
Berikut ini adalah nilai bidang yang diberikan.
```
20
892
57
```
Untuk nilai bidang ini, nilai berikut dikembalikan.
```
20.0
892.0
58.0
```
Anda dapat menerapkan pemformatan di dalam analisis, misalnya untuk memformat `price` sebagai mata uang.
# isNotNull
`isNotNull`mengevaluasi ekspresi untuk melihat apakah itu bukan nol. Jika ekspresi tidak null, `isNotNull` mengembalikan true, dan sebaliknya mengembalikan false.
## Sintaksis
```
isNotNull(expression)
```
## Pendapat
*ekspresi*
Ekspresi yang akan dievaluasi sebagai nol atau tidak. Ini bisa berupa nama bidang seperti **address1** atau panggilan ke fungsi lain yang mengeluarkan string.
## Jenis pengembalian
Boolean
## Contoh
Contoh berikut mengevaluasi bidang sales\$1amount untuk nilai null.
```
isNotNull(salesAmount)
```
Berikut ini adalah nilai bidang yang diberikan.
```
20.13
(null)
57.54
```
Untuk nilai bidang ini, nilai berikut dikembalikan.
```
true
false
true
```
# isNull
`isNull`mengevaluasi ekspresi untuk melihat apakah itu nol. Jika ekspresi adalah null, `isNull` mengembalikan true, dan jika tidak maka mengembalikan false.
## Sintaksis
```
isNull(expression)
```
## Pendapat
*ekspresi*
Ekspresi yang akan dievaluasi sebagai nol atau tidak. Ini bisa berupa nama bidang seperti **address1** atau panggilan ke fungsi lain yang mengeluarkan string.
## Jenis pengembalian
Boolean
## Contoh
Contoh berikut mengevaluasi bidang sales\$1amount untuk nilai null.
```
isNull(salesAmount)
```
Berikut ini adalah nilai bidang yang diberikan.
```
20.13
(null)
57.54
```
Untuk nilai bidang ini, nilai berikut dikembalikan.
```
false
true
false
```
Contoh berikut menguji nilai NULL dalam sebuah `ifelse` pernyataan, dan mengembalikan nilai yang dapat dibaca manusia sebagai gantinya.
```
ifelse( isNull({ActiveFlag}) , 'Inactive', 'Active')
```
# isWorkDay
`isWorkDay`mengevaluasi nilai tanggal-waktu tertentu untuk menentukan apakah nilainya adalah hari kerja atau tidak.
`isWorkDay`mengasumsikan standar 5 hari kerja seminggu mulai dari Senin dan berakhir pada hari Jumat. Sabtu dan Minggu diasumsikan sebagai akhir pekan. Fungsi selalu menghitung hasilnya pada `DAY` perincian dan tidak termasuk tanggal input yang diberikan.
## Sintaksis
```
isWorkDay(inputDate)
```
## Pendapat
*InputDate*
Nilai tanggal-waktu yang ingin Anda evaluasi. Nilai yang valid adalah sebagai berikut:
+ Bidang dataset: `date` Bidang apa pun dari kumpulan data yang Anda tambahkan fungsi ini.
+ Fungsi Tanggal: Setiap keluaran tanggal dari `date` fungsi lain, misalnya,`parseDate`.
+ Bidang terhitung: Setiap bidang terhitung cepat yang mengembalikan `date` nilai.
+ Parameter: Setiap `DateTime` parameter Cepat.
## Jenis pengembalian
Integer (`0`atau`1`)
## Contoh
Exaple berikut menentukan apakah `application_date` bidang tersebut adalah hari kerja atau tidak.
Mari kita asumsikan bahwa ada bidang bernama `application_date` dengan nilai-nilai berikut:
```
2022-08-10
2022-08-06
2022-08-07
```
Bila Anda menggunakan bidang ini dan menambahkan perhitungan berikut, `isWorkDay` mengembalikan nilai-nilai di bawah ini:
```
isWorkDay({application_date})
1
0
0
```
Contoh berikut menyaring karyawan yang pekerjaannya berakhir pada hari kerja dan menentukan apakah pekerjaan mereka dimulai pada hari kerja atau akhir pekan menggunakan format bersyarat:
```
is_start_date_work_day = isWorkDay(employment_start_date)
is_end_date_work_day = isWorkDay(employment_end_date)
```
![\[alt text not found\]](http://docs.aws.amazon.com/id_id/quick/latest/userguide/images/isWorkDay-example.png)
# Left
`left`mengembalikan karakter paling kiri dari string, termasuk spasi. Anda menentukan jumlah karakter yang akan dikembalikan.
## Sintaksis
```
left(expression, limit)
```
## Pendapat
*ekspresi*
Ekspresi harus berupa string. Ini bisa berupa nama bidang yang menggunakan tipe data string, nilai literal seperti**'12 Main Street'**, atau panggilan ke fungsi lain yang mengeluarkan string.
*membatasi*
Jumlah karakter yang akan dikembalikan dari *ekspresi*, mulai dari karakter pertama dalam string.
## Jenis pengembalian
String
## Contoh
Contoh berikut mengembalikan 3 karakter pertama dari string.
```
left('Seattle Store #14', 3)
```
Nilai berikut dikembalikan.
```
Sea
```
# Locate
`locate`menempatkan substring yang Anda tentukan dalam string lain, dan mengembalikan jumlah karakter sampai karakter pertama dalam substring. Fungsi mengembalikan 0 jika tidak menemukan substring. Fungsinya berbasis 1.
## Sintaksis
```
locate(expression, substring, start)
```
## Pendapat
*ekspresi*
Ekspresi harus berupa string. Ini bisa berupa nama bidang yang menggunakan tipe data string, nilai literal seperti**'12 Main Street'**, atau panggilan ke fungsi lain yang mengeluarkan string.
*substring*
Kumpulan karakter dalam *ekspresi* yang ingin Anda temukan. Substring dapat terjadi satu kali atau lebih dalam *ekspresi*.
*mulai*
(Opsional) Jika *substring* terjadi lebih dari sekali, gunakan *start* untuk mengidentifikasi di mana dalam string fungsi harus mulai mencari substring. Misalnya, Anda ingin menemukan contoh kedua substring dan Anda pikir itu biasanya terjadi setelah 10 karakter pertama. Anda menentukan nilai *awal* 10. Ini harus dimulai dari 1.
## Jenis pengembalian
Bilangan Bulat
## Contoh
Contoh berikut mengembalikan informasi tentang di mana kejadian pertama substring 'dan' muncul dalam string.
```
locate('1 and 2 and 3 and 4', 'and')
```
Nilai berikut dikembalikan.
```
3
```
Contoh berikut mengembalikan informasi tentang di mana kejadian pertama substring 'dan' muncul dalam string setelah karakter keempat.
```
locate('1 and 2 and 3 and 4', 'and', 4)
```
Nilai berikut dikembalikan.
```
9
```
# Log
`log`mengembalikan logaritma basis 10 dari ekspresi yang diberikan.
## Sintaksis
```
log(expression)
```
## Pendapat
*ekspresi*
Ekspresi harus numerik. Ini bisa berupa nama bidang, nilai literal, atau fungsi lain.
# Ln
`ln`mengembalikan logaritma natural dari ekspresi yang diberikan.
## Sintaksis
```
ln(expression)
```
## Pendapat
*ekspresi*
Ekspresi harus numerik. Ini bisa berupa nama bidang, nilai literal, atau fungsi lain.
# Ltrim
`ltrim`menghapus ruang kosong sebelumnya dari string.
## Sintaksis
```
ltrim(expression)
```
## Pendapat
*ekspresi*
Ekspresi harus berupa string. Ini bisa berupa nama bidang yang menggunakan tipe data string, nilai literal seperti**'12 Main Street'**, atau panggilan ke fungsi lain yang mengeluarkan string.
## Jenis pengembalian
String
## Contoh
Contoh berikut menghapus spasi sebelumnya dari string.
```
ltrim(' Seattle Store #14')
```
Nilai berikut dikembalikan.
```
Seattle Store #14
```
# Mod
Gunakan `mod` fungsi untuk menemukan sisanya setelah membagi angka dengan pembagi. Anda dapat menggunakan `mod` fungsi atau operator modulo (%) secara bergantian.
## Sintaksis
```
mod(number, divisor)
```
```
number%divisor
```
## Pendapat
*jumlah*
Angka adalah bilangan bulat positif yang ingin Anda bagi dan temukan sisanya.
*pembagi*
Pembagi adalah bilangan bulat positif yang Anda bagi dengan. Jika pembagi adalah nol, fungsi ini mengembalikan kesalahan pada pembagian dengan 0.
## Contoh
Contoh berikut mengembalikan modulo 17 ketika membagi dengan 6. Contoh pertama menggunakan operator%, dan contoh kedua menggunakan fungsi mod.
```
17%6
```
```
mod( 17, 6 )
```
Nilai berikut dikembalikan.
```
5
```
# netWorkDays
`netWorkDays`mengembalikan jumlah hari kerja antara dua bidang tanggal yang disediakan atau bahkan nilai tanggal kustom yang dihasilkan menggunakan fungsi Tanggal cepat lainnya seperti `parseDate` atau `epochDate` sebagai bilangan bulat.
`netWorkDays`mengasumsikan standar 5 hari kerja seminggu mulai dari Senin dan berakhir pada hari Jumat. Sabtu dan Minggu diasumsikan sebagai akhir pekan. Perhitungannya termasuk keduanya `startDate` dan`endDate`. Fungsi beroperasi dan menunjukkan hasil untuk perincian HARI.
## Sintaksis
```
netWorkDays(startDate, endDate)
```
## Pendapat
*StartDate*
Tanggal non-Null valid yang bertindak sebagai tanggal mulai untuk perhitungan.
+ Bidang dataset: `date` Bidang apa pun dari kumpulan data yang Anda tambahkan fungsi ini.
+ Fungsi Tanggal: Setiap keluaran tanggal dari `date` fungsi lain, misalnya,`parseDate`.
+ Bidang terhitung: Setiap bidang terhitung cepat yang mengembalikan `date` nilai.
+ Parameter: Setiap `DateTime` parameter Cepat.
+ Setiap kombinasi dari nilai-nilai argumen yang dinyatakan di atas.
*EndDate*
Tanggal non-Null valid yang bertindak sebagai tanggal akhir perhitungan.
+ Bidang dataset: `date` Bidang apa pun dari kumpulan data yang Anda tambahkan fungsi ini.
+ Fungsi Tanggal: Setiap keluaran tanggal dari `date` fungsi lain, misalnya,`parseDate`.
+ Bidang terhitung: Setiap bidang terhitung cepat yang mengembalikan `date` nilai.
+ Parameter: Setiap `DateTime` parameter Cepat.
+ Setiap kombinasi dari nilai-nilai argumen yang dinyatakan di atas.
## Jenis pengembalian
Bilangan Bulat
## Nilai Ouptut
Nilai output yang diharapkan meliputi:
+ Bilangan bulat positif (ketika start\$1date < end\$1date)
+ Integer negatif (ketika start\$1date > end\$1date)
+ NULL ketika salah satu atau kedua argumen mendapatkan nilai null dari. `dataset field`
## Contoh
Contoh berikut mengembalikan jumlah hari kerja jatuh di antara dua tanggal.
Mari kita asumsikan bahwa ada bidang bernama `application_date` dengan nilai-nilai berikut:
```
netWorkDays({startDate}, {endDate})
```
Berikut ini adalah nilai bidang yang diberikan.
```
startDate endDate netWorkDays
9/4/2022 9/11/2022 5
9/9/2022 9/2/2022 -6
9/10/2022 9/11/2022 0
9/12/2022 9/12/2022 1
```
Contoh berikut menghitung jumlah hari kerja setiap karyawan dan gaji yang dikeluarkan per hari untuk setiap karyawan:
```
days_worked = netWorkDays({employment_start_date}, {employment_end_date})
salary_per_day = {salary}/{days_worked}
```
Contoh berikut menyaring karyawan yang pekerjaannya berakhir pada hari kerja dan menentukan apakah pekerjaan mereka dimulai pada hari kerja atau akhir pekan menggunakan format bersyarat:
```
is_start_date_work_day = netWorkDays(employment_start_date)
is_end_date_work_day = netWorkDays(employment_end_date)
```
![\[alt text not found\]](http://docs.aws.amazon.com/id_id/quick/latest/userguide/images/netWorkDays-function-example.png)
# Now
Untuk dataset database yang langsung query database, `now` mengembalikan tanggal dan waktu saat ini menggunakan pengaturan dan format yang ditentukan oleh database server. Set data for SPICE dan Salesforce, `now` mengembalikan tanggal dan waktu UTC, dalam format `yyyy-MM-ddTkk:mm:ss:SSSZ` (misalnya, 2015-10-15T 19:11:51:003 Z).
## Sintaksis
```
now()
```
## Jenis pengembalian
Date
# notIn
`notIn`mengevaluasi jika ekspresi ada dalam daftar literal. Jika daftar tidak berisi ekspresi, `notIn` mengembalikan true, dan sebaliknya mengembalikan false. `notIn`peka huruf besar/kecil untuk input tipe string.
`notIn`menerima dua jenis daftar literal, satu secara manual dimasukkan daftar dan yang lainnya adalah parameter [multivalue](https://docs.aws.amazon.com/quicksight/latest/user/parameters-in-quicksight.html).
## Sintaksis
Menggunakan daftar yang dimasukkan secara manual:
```
notIn(expression, [literal-1, ...])
```
Menggunakan parameter multivalue:
```
notIn(expression, $multivalue_parameter)
```
## Pendapat
*ekspresi*
Ekspresi yang akan dibandingkan dengan unsur-unsur dalam daftar literal. Ini bisa berupa nama bidang seperti`address`, nilai literal seperti '**Unknown**', parameter nilai tunggal, atau panggilan ke fungsi skalar lain—asalkan fungsi ini bukan fungsi agregat atau perhitungan tabel.
*daftar literal*
(wajib) Ini bisa berupa daftar yang dimasukkan secara manual atau parameter multivalue. Argumen ini menerima hingga 5.000 elemen. Namun, dalam kueri langsung ke sumber data pihak ketiga, misalnya Oracle atau Teradata, batasannya bisa lebih kecil.
+ ***daftar yang dimasukkan secara manual*** - Satu atau lebih nilai literal dalam daftar untuk dibandingkan dengan ekspresi. Daftar harus dilampirkan dalam tanda kurung siku. Semua literal untuk membandingkan harus memiliki tipe data yang sama dengan ekspresi.
+ parameter ***multivalue — Parameter*** multivalue yang telah ditentukan sebelumnya diteruskan sebagai daftar literal. Parameter multivalue harus memiliki tipe data yang sama dengan ekspresi.
## Jenis pengembalian
Boolean: BENAR/SALAH
## Contoh dengan daftar yang dimasukkan secara manual
Contoh berikut mengevaluasi `origin_state_name` bidang untuk nilai-nilai dalam daftar string. Saat membandingkan input tipe string, `notIn` hanya mendukung perbandingan peka huruf besar/kecil.
```
notIn(origin_state_name,["Georgia", "Ohio", "Texas"])
```
Berikut ini adalah nilai bidang yang diberikan.
```
"Washington"
"ohio"
"Texas"
```
Untuk nilai bidang ini nilai berikut dikembalikan.
```
true
true
false
```
Nilai pengembalian ketiga adalah false karena hanya “Texas” adalah salah satu nilai yang dikecualikan.
Contoh berikut mengevaluasi `fl_date` bidang untuk nilai-nilai dalam daftar string. Untuk mencocokkan jenisnya, `toString` digunakan untuk mentransmisikan tipe tanggal ke tipe string.
```
notIn(toString(fl_date),["2015-05-14","2015-05-15","2015-05-16"])
```
![\[Gambar hasil contoh fungsi, ditunjukkan dalam bentuk tabel.\]](http://docs.aws.amazon.com/id_id/quick/latest/userguide/images/notin-function-example-manual-list.png)
Literal dan nilai NULL didukung dalam argumen ekspresi untuk dibandingkan dengan literal dalam daftar. Kedua dari dua contoh berikut akan menghasilkan kolom baru nilai FALSE.
```
notIn("Washington",["Washington","Ohio"])
```
```
notIn(NULL,[NULL,"Ohio"])
```
## Contoh dengan parameter mutivalue
Katakanlah seorang penulis membuat [parameter multivalue](https://docs.aws.amazon.com/quicksight/latest/user/parameters-in-quicksight.html) yang berisi daftar semua nama negara. Kemudian penulis menambahkan kontrol untuk memungkinkan pembaca memilih nilai dari daftar.
Selanjutnya, pembaca memilih tiga nilai — “Georgia”, “Ohio”, dan “Texas” — dari kontrol daftar drop-down parameter. Dalam hal ini, ekspresi berikut setara dengan contoh pertama, di mana ketiga nama negara dilewatkan sebagai daftar literal untuk dibandingkan dengan `original_state_name` bidang.
```
notIn (origin_state_name, ${stateName MultivalueParameter})
```
## Contoh dengan `ifelse`
`notIn`dapat bersarang di fungsi lain sebagai nilai boolean. Salah satu contohnya adalah bahwa penulis dapat mengevaluasi ekspresi apa pun dalam daftar dan mengembalikan nilai yang mereka inginkan dengan menggunakan `notIn` dan`ifelse`. Contoh berikut mengevaluasi apakah penerbangan berada dalam daftar negara bagian AS tertentu dan mengembalikan kategori negara bagian yang berbeda berdasarkan perbandingan. `dest_state_name`
```
ifelse(notIn(dest_state_name,["Washington", "Oregon","California"]), "notWestCoastUSState", "WestCoastUSState")
```
![\[Gambar hasil contoh fungsi, ditunjukkan dalam bentuk tabel.\]](http://docs.aws.amazon.com/id_id/quick/latest/userguide/images/notin-function-with-ifelse.png)
# nullIf
`nullIf`membandingkan dua ekspresi. Jika mereka sama, fungsi mengembalikan null. Jika mereka tidak sama, fungsi mengembalikan ekspresi pertama.
## Sintaksis
```
nullIf(expression1, expression2)
```
## Pendapat
`nullIf`mengambil dua ekspresi sebagai argumen.
*ekspresi*
Ekspresi dapat berupa numerik, datetime, atau string. Ini bisa berupa nama bidang, nilai literal, atau fungsi lain.
## Jenis pengembalian
String
## Contoh
Contoh berikut mengembalikan nol jika alasan penundaan pengiriman tidak diketahui.
```
nullIf(delayReason, 'unknown')
```
Berikut ini adalah nilai bidang yang diberikan.
```
delayReason
============
unknown
back ordered
weather delay
```
Untuk nilai bidang ini, nilai berikut dikembalikan.
```
(null)
back ordered
weather delay
```
# parseDate
`parseDate`mem-parsing string untuk menentukan apakah itu berisi nilai tanggal, dan mengembalikan tanggal standar dalam format `yyyy-MM-ddTkk:mm:ss.SSSZ` (menggunakan sintaks pola format yang ditentukan dalam [Kelas DateTimeFormat](http://www.joda.org/joda-time/apidocs/org/joda/time/format/DateTimeFormat.html) dalam dokumentasi proyek Joda), misalnya 2015-10-15T 19:11:51.003 Z. Fungsi ini mengembalikan semua baris yang berisi tanggal dalam format yang valid dan melewatkan setiap baris yang tidak, termasuk baris yang berisi nilai nol.
Quick mendukung tanggal dalam kisaran dari 1 Januari 1900 00:00:00 UTC hingga 31 Desember 2037 23:59:59 UTC. Untuk informasi selengkapnya, lihat [Format tanggal yang didukung](https://docs.aws.amazon.com/quicksight/latest/user/supported-date-formats.html).
## Sintaksis
```
parseDate(expression, ['format'])
```
## Pendapat
*ekspresi*
Ekspresi harus berupa string. Ini bisa berupa nama bidang yang menggunakan tipe data string, nilai literal seperti**'1/1/2016'**, atau panggilan ke fungsi lain yang mengeluarkan string.
*format*
(Opsional) String yang berisi pola format yang harus dicocokkan dengan *date\$1string*. Misalnya, jika Anda menggunakan bidang dengan data seperti**01/03/2016**, Anda menentukan format 'MM/dd/yyyy'. Jika Anda tidak menentukan format, itu defaultnya. `yyyy-MM-dd` Baris yang datanya tidak sesuai dengan *format* dilewati.
Format tanggal yang berbeda didukung berdasarkan jenis kumpulan data yang digunakan. Gunakan tabel berikut untuk melihat detail format tanggal yang didukung.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/quick/latest/userguide/parseDate-function.html)
## Jenis pengembalian
Date
## Contoh
Contoh berikut mengevaluasi `prodDate` untuk menentukan apakah itu berisi nilai tanggal.
```
parseDate(prodDate, 'MM/dd/yyyy')
```
Berikut ini adalah nilai bidang yang diberikan.
```
prodDate
--------
01-01-1999
12/31/2006
1/18/1982
7/4/2010
```
Untuk nilai bidang ini, baris berikut dikembalikan.
```
12-31-2006T00:00:00.000Z
01-18-1982T00:00:00.000Z
07-04-2010T00:00:00.000Z
```
# parseDecimal
`parseDecimal`mem-parsing string untuk menentukan apakah itu berisi nilai desimal. Fungsi ini mengembalikan semua baris yang berisi nilai desimal, integer, atau null, dan melewatkan setiap baris yang tidak. Jika baris berisi nilai integer, itu dikembalikan sebagai desimal dengan hingga 4 tempat desimal. Misalnya, nilai '2' dikembalikan sebagai '2.0'.
## Sintaksis
```
parseDecimal(expression)
```
## Pendapat
*ekspresi*
Ekspresi harus berupa string. Ini bisa berupa nama bidang yang menggunakan tipe data string, nilai literal seperti**'9.62'**, atau panggilan ke fungsi lain yang mengeluarkan string.
## Jenis pengembalian
Desimal (Tetap) dalam pengalaman persiapan data lama.
Desimal (Float) dalam pengalaman persiapan data baru.
## Contoh
Contoh berikut mengevaluasi `fee` untuk menentukan apakah mengandung nilai desimal.
```
parseDecimal(fee)
```
Berikut ini adalah nilai bidang yang diberikan.
```
fee
--------
2
2a
12.13
3b
3.9
(null)
198.353398
```
Untuk nilai bidang ini, baris berikut dikembalikan.
```
2.0
12.13
3.9
(null)
198.3533
```
# parseInt
`parseInt`mem-parsing string untuk menentukan apakah itu berisi nilai integer. Fungsi ini mengembalikan semua baris yang berisi nilai desimal, integer, atau null, dan melewatkan setiap baris yang tidak. Jika baris berisi nilai desimal, itu dikembalikan sebagai bilangan bulat terdekat, dibulatkan ke bawah. Misalnya, nilai '2,99' dikembalikan sebagai '2'.
## Sintaksis
```
parseInt(expression)
```
## Pendapat
*ekspresi*
Ekspresi harus berupa string. Ini bisa berupa nama bidang yang menggunakan tipe data string, nilai literal seperti**'3'**, atau panggilan ke fungsi lain yang mengeluarkan string.
## Jenis pengembalian
Bilangan Bulat
## Contoh
Contoh berikut mengevaluasi `feeType` untuk menentukan apakah itu berisi nilai-nilai integer.
```
parseInt(feeType)
```
Berikut ini adalah nilai bidang yang diberikan.
```
feeType
--------
2
2.1
2a
3
3b
(null)
5
```
Untuk nilai bidang ini, baris berikut dikembalikan.
```
2
2
3
(null)
5
```
# parseJson
Gunakan `parseJson` untuk mengekstrak nilai dari objek JSON.
Jika kumpulan data Anda disimpan dalam QuickSPICE, Anda dapat menggunakannya `parseJson` saat menyiapkan kumpulan data, tetapi tidak di bidang terhitung selama analisis.
Untuk kueri langsung, Anda dapat menggunakan `parseJson` keduanya selama persiapan dan analisis data. `parseJson`Fungsi ini berlaku untuk string atau tipe data asli JSON, tergantung pada dialek, seperti yang ditunjukkan pada tabel berikut.
| Dialek | Tipe |
| --- | --- |
| PostgreSQL | JSON |
| Amazon Redshift | String |
| Microsoft SQL Server | String |
| MySQL | JSON |
| Teradata | JSON |
| Oracle | String |
| Presto | String |
| Kepingan salju | Jenis data semi-terstruktur objek dan array |
| Hive | String |
## Sintaksis
```
parseJson(fieldName, path)
```
## Pendapat
*fieldName*
Bidang yang berisi objek JSON yang ingin Anda uraikan.
*path*
Path ke elemen data Anda ingin mengurai dari objek JSON. Hanya huruf, angka, dan spasi kosong yang didukung dalam argumen jalur. Sintaks jalur yang valid meliputi:
+ *\$1* — Objek Root
+ *.* — Operator anak
+ *[]* — Operator subskrip untuk array
## Jenis pengembalian
String
## Contoh
Contoh berikut mengevaluasi JSON masuk untuk mengambil nilai untuk kuantitas item. Dengan menggunakan ini selama persiapan data, Anda dapat membuat tabel dari JSON.
```
parseJson({jsonField}, “$.items.qty”)
```
Berikut ini menunjukkan JSON.
```
{
"customer": "John Doe",
"items": {
"product": "Beer",
"qty": 6
},
"list1": [
"val1",
"val2"
],
"list2": [
{
"list21key1": "list1value1"
}
]
}
```
Untuk contoh ini, nilai berikut dikembalikan.
```
6
```
## Contoh
Contoh berikut mengevaluasi `JSONObject1` untuk mengekstrak pasangan nilai kunci pertama (KVP), berlabel`"State"`, dan menetapkan nilai ke bidang terhitung yang Anda buat.
```
parseJson(JSONObject1, “$.state”)
```
Berikut ini adalah nilai bidang yang diberikan.
```
JSONObject1
-----------
{"State":"New York","Product":"Produce","Date Sold":"1/16/2018","Sales Amount":"$3423.39"}
{"State":"North Carolina","Product":"Bakery Products","Date Sold":"2/1/2018","Sales Amount":"$3226.42"}
{"State":"Utah","Product":"Water","Date Sold":"4/24/2018","Sales Amount":"$7001.52"}
```
Untuk nilai bidang ini, baris berikut dikembalikan.
```
New York
North Carolina
Utah
```
# Replace
`replace`menggantikan bagian dari string dengan string lain yang Anda tentukan.
## Sintaksis
```
replace(expression, substring, replacement)
```
## Pendapat
*ekspresi*
Ekspresi harus berupa string. Ini bisa berupa nama bidang yang menggunakan tipe data string, nilai literal seperti**'12 Main Street'**, atau panggilan ke fungsi lain yang mengeluarkan string.
*substring*
Kumpulan karakter dalam *ekspresi* yang ingin Anda ganti. Substring dapat terjadi satu kali atau lebih dalam *ekspresi*.
*Penggantian*
String yang ingin Anda ganti dengan *substring*.
## Jenis pengembalian
String
## Contoh
Contoh berikut menggantikan substring 'dan' dengan 'atau'.
```
replace('1 and 2 and 3', 'and', 'or')
```
String berikut dikembalikan.
```
1 or 2 or 3
```
# Right
`right`mengembalikan karakter paling kanan dari string, termasuk spasi. Anda menentukan jumlah karakter yang akan dikembalikan.
## Sintaksis
```
right(expression, limit)
```
## Pendapat
*ekspresi*
Ekspresi harus berupa string. Ini bisa berupa nama bidang yang menggunakan tipe data string, nilai literal seperti**'12 Main Street'**, atau panggilan ke fungsi lain yang mengeluarkan string.
*membatasi*
Jumlah karakter yang akan dikembalikan dari *ekspresi*, mulai dari karakter terakhir dalam string.
## Jenis pengembalian
String
## Contoh
Contoh berikut mengembalikan lima karakter terakhir dari string.
```
right('Seattle Store#14', 12)
```
Nilai berikut dikembalikan.
```
tle Store#14
```
# Round
`round`membulatkan nilai desimal ke bilangan bulat terdekat jika tidak ada skala yang ditentukan, atau ke tempat desimal terdekat jika skala ditentukan.
## Sintaksis
```
round(decimal, scale)
```
## Pendapat
*desimal*
Bidang yang menggunakan tipe data desimal, nilai literal seperti**17.62**, atau panggilan ke fungsi lain yang mengeluarkan desimal.
*skala*
Jumlah tempat desimal untuk digunakan untuk nilai kembali.
## Jenis pengembalian
| operan | Jenis pengembalian dalam pengalaman persiapan data lama | Jenis pengembalian dalam pengalaman persiapan data baru |
| --- | --- | --- |
| INT | DESIMAL (TETAP) | DESIMAL (TETAP) |
| DESIMAL (TETAP) | DESIMAL (TETAP) | DESIMAL (TETAP) |
| DESIMAL (MENGAMBANG) | DESIMAL (TETAP) | DESIMAL (MENGAMBANG) |
## Contoh
Contoh berikut membulatkan bidang desimal ke tempat desimal kedua terdekat.
```
round(salesAmount, 2)
```
Berikut ini adalah nilai bidang yang diberikan.
```
20.1307
892.0388
57.5447
```
Untuk nilai bidang ini, nilai berikut dikembalikan.
```
20.13
892.04
58.54
```
# Rtrim
`rtrim`menghapus ruang kosong berikut dari string.
## Sintaksis
```
rtrim(expression)
```
## Pendapat
*ekspresi*
Ekspresi harus berupa string. Ini bisa berupa nama bidang yang menggunakan tipe data string, nilai literal seperti**'12 Main Street'**, atau panggilan ke fungsi lain yang mengeluarkan string.
## Jenis pengembalian
String
## Contoh
Contoh berikut menghapus spasi berikut dari string.
```
rtrim('Seattle Store #14 ')
```
Untuk nilai bidang ini, nilai berikut dikembalikan.
```
Seattle Store #14
```
# Split
`split`membagi string menjadi array substring, berdasarkan pembatas yang Anda pilih, dan mengembalikan item yang ditentukan oleh posisi.
Anda hanya dapat menambahkan `split` ke bidang terhitung selama persiapan data, bukan ke analisis. Fungsi ini tidak didukung dalam kueri langsung ke Microsoft SQL Server.
## Sintaksis
```
split(expression, delimiter , position)
```
## Pendapat
*ekspresi*
Ekspresi harus berupa string. Ini bisa berupa nama bidang yang menggunakan tipe data string, nilai literal seperti**'12 Main Street;1402 35th Ave;1818 Elm Ct;11 Janes Lane'**, atau panggilan ke fungsi lain yang mengeluarkan string.
*pembatas*
Karakter yang membatasi di mana string dipecah menjadi substring. Misalnya, `split('one|two|three', '|', 2)` menjadi yang berikut.
```
one
two
three
```
Jika Anda memilih`position = 2`, `split` kembali`'two'`.
*posisi*
(Wajib) Posisi item untuk kembali dari array. Posisi item pertama dalam array adalah 1.
## Jenis pengembalian
Array string
## Contoh
Contoh berikut membagi string ke dalam array, menggunakan karakter titik koma (;) sebagai pembatas, dan mengembalikan elemen ketiga dari array.
```
split('123 Test St;1402 35th Ave;1818 Elm Ct;11 Janes Lane', ';', 3)
```
Item berikut dikembalikan.
```
1818 Elm Ct
```
Fungsi ini melewatkan item yang berisi nilai nol atau string kosong.
# Sqrt
`sqrt`mengembalikan akar kuadrat dari ekspresi yang diberikan.
## Sintaksis
```
sqrt(expression)
```
## Pendapat
*ekspresi*
Ekspresi harus numerik. Ini bisa berupa nama bidang, nilai literal, atau fungsi lain.
# startsWith
`startsWith`mengevaluasi jika ekspresi dimulai dengan substring yang Anda tentukan. Jika ekspresi dimulai dengan substring, `startsWith` mengembalikan true, dan sebaliknya mengembalikan false.
## Sintaksis
```
startsWith(expression, substring, string-comparison-mode)
```
## Pendapat
*ekspresi*
Ekspresi harus berupa string. Ini bisa berupa nama bidang yang menggunakan tipe data string, nilai literal seperti**'12 Main Street'**, atau panggilan ke fungsi lain yang mengeluarkan string.
*substring*
Kumpulan karakter untuk memeriksa *ekspresi*. Substring dapat terjadi satu kali atau lebih dalam *ekspresi*.
*string-comparison-mode*
(Opsional) Menentukan mode perbandingan string untuk menggunakan:
+ `CASE_SENSITIVE`— Perbandingan string peka huruf besar/kecil.
+ `CASE_INSENSITIVE`— Perbandingan string tidak peka huruf besar/kecil.
Nilai ini defaultnya saat kosong. `CASE_SENSITIVE`
## Jenis pengembalian
Boolean
## Contoh
### Contoh case sensitive default
Contoh case sensitive berikut mengevaluasi jika `state_nm` **New** startsWith.
```
startsWith(state_nm, "New")
```
Berikut ini adalah nilai bidang yang diberikan.
```
New York
new york
```
Untuk nilai bidang ini, nilai berikut dikembalikan.
```
true
false
```
### Contoh tidak peka huruf besar/kecil
Contoh case insensitive berikut mengevaluasi jika `state_nm` startsWith. **new**
```
startsWith(state_nm, "new", CASE_INSENSITIVE)
```
Berikut ini adalah nilai bidang yang diberikan.
```
New York
new york
```
Untuk nilai bidang ini, nilai berikut dikembalikan.
```
true
true
```
### Contoh dengan pernyataan bersyarat
`startsWith`[https://docs.aws.amazon.com/quicksight/latest/user/stdevIf-function.html](https://docs.aws.amazon.com/quicksight/latest/user/stdevIf-function.html)
Contoh berikut `Sales` hanya dijumlahkan jika state\$1nm dimulai dengan. **New**
```
sumIf(Sales,startsWith(state_nm, "New"))
```
### Tidak mengandung contoh
`NOT`Operator bersyarat dapat digunakan untuk mengevaluasi jika ekspresi tidak dimulai dengan substring yang ditentukan.
```
NOT(startsWith(state_nm, "New"))
```
### Contoh menggunakan nilai numerik
Nilai numerik dapat digunakan dalam ekspresi atau substring argumen dengan menerapkan fungsi. `toString`
```
startsWith(state_nm, toString(5) )
```
# Strlen
`strlen`mengembalikan jumlah karakter dalam string, termasuk spasi.
## Sintaksis
```
strlen(expression)
```
## Pendapat
*ekspresi*
Ekspresi dapat berupa nama bidang yang menggunakan tipe data string seperti**address1**, nilai literal seperti**'Unknown'**, atau fungsi lain seperti`substring(field_name,0,5)`.
## Jenis pengembalian
Bilangan Bulat
## Contoh
Contoh berikut mengembalikan panjang string yang ditentukan.
```
strlen('1421 Main Street')
```
Nilai berikut dikembalikan.
```
16
```
# Substring
`substring`mengembalikan karakter dalam string, mulai dari lokasi yang ditentukan oleh argumen *awal* dan melanjutkan untuk jumlah karakter yang ditentukan oleh argumen *panjang*.
## Sintaksis
```
substring(expression, start, length)
```
## Pendapat
*ekspresi*
Ekspresi dapat berupa nama bidang yang menggunakan tipe data string seperti**address1**, nilai literal seperti**'Unknown'**, atau fungsi lain seperti`substring(field_name,1,5)`.
*mulai*
Lokasi karakter untuk memulai. *start* bersifat inklusif, sehingga karakter pada posisi awal adalah karakter pertama dalam nilai yang dikembalikan. Nilai minimum untuk *memulai* adalah 1.
*panjang*
Jumlah karakter tambahan untuk dimasukkan setelah *memulai*. *panjang* sudah termasuk *awal*, jadi karakter terakhir yang dikembalikan adalah (*panjang* - 1) setelah karakter awal.
## Jenis pengembalian
String
## Contoh
Contoh berikut mengembalikan karakter ke-13 hingga ke-19 dalam sebuah string. Awal string adalah indeks 1, jadi Anda mulai menghitung pada karakter pertama.
```
substring('Fantasy and Science Fiction',13,7)
```
Nilai berikut dikembalikan.
```
Science
```
# switch
`switch`*membandingkan *ekspresi kondisi dengan label literal*, dalam satu set label literal dan pasangan ekspresi kembali.* *Kemudian mengembalikan *ekspresi kembali* yang sesuai dengan label literal pertama yang sama dengan ekspresi kondisi.* *Jika tidak ada label sama dengan *kondisi-ekspresi, mengembalikan default-ekspresi*. `switch`* Setiap ekspresi *kembali dan ekspresi* *default harus memiliki tipe* data yang sama.
## Sintaksis
```
switch(condition-expression, label-1, return-expression-1 [, label-n, return-expression-n ...],
default-expression)
```
## Pendapat
`switch`membutuhkan satu atau lebih *if*, *maka* pasangan ekspresi, dan membutuhkan tepat satu ekspresi untuk argumen *else*.
*kondisi-ekspresi*
Ekspresi yang akan dibandingkan dengan label-literal. Ini bisa berupa nama bidang seperti`address`, nilai literal seperti '`Unknown`', atau fungsi skalar lain seperti`toString(salesAmount)`.
*label*
*Secara literal untuk dibandingkan dengan argumen *kondisi-ekspresi*, semua literal harus memiliki tipe data yang sama dengan argumen kondisi-ekspresi.* `switch`menerima hingga 5000 label.
*kembali-ekspresi*
Ekspresi untuk kembali jika nilai labelnya sama dengan nilai ekspresi *kondisi*. Ini bisa berupa nama bidang seperti`address`, nilai literal seperti '`Unknown`', atau fungsi skalar lain seperti`toString(salesAmount)`. *Semua argumen *return-expression* harus memiliki tipe data yang sama dengan default-expression.*
*default-ekspresi*
Ekspresi untuk mengembalikan jika tidak ada nilai argumen label sama dengan nilai ekspresi *kondisi*. Ini bisa berupa nama bidang seperti`address`, nilai literal seperti '`Unknown`', atau fungsi skalar lain seperti`toString(salesAmount)`. *Ekspresi default* *harus memiliki tipe data yang sama dengan semua argumen ekspresi kembali.*
## Jenis pengembalian
`switch`mengembalikan nilai dari tipe data yang sama dengan nilai-nilai dalam ekspresi *kembali.* Semua data yang dikembalikan *return-expression* dan *default-expression* harus dari tipe data yang sama atau dikonversi ke tipe data yang sama.
## Contoh Umum
Contoh berikut mengembalikan Wilayah AWS kode nama wilayah masukan.
```
switch(region_name,
"US East (N. Virginia)", "us-east-1",
"Europe (Ireland)", "eu-west-1",
"US West (N. California)", "us-west-1",
"other regions")
```
Berikut ini adalah nilai bidang yang diberikan.
```
"US East (N. Virginia)"
"US West (N. California)"
"Asia Pacific (Tokyo)"
```
Untuk nilai bidang ini nilai berikut dikembalikan.
```
"us-east-1"
"us-west-1"
"other regions"
```
## Gunakan sakelar untuk mengganti `ifelse`
Kasus `ifelse` penggunaan berikut adalah setara dengan contoh sebelumnya, untuk `ifelse` mengevaluasi apakah nilai satu bidang sama dengan nilai literal yang berbeda, menggunakan `switch` sebagai gantinya adalah pilihan yang lebih baik.
```
ifelse(region_name = "US East (N. Virginia)", "us-east-1",
region_name = "Europe (Ireland)", "eu-west-1",
region_name = "US West (N. California)", "us-west-1",
"other regions")
```
## Ekspresi sebagai nilai kembali
Contoh berikut menggunakan ekspresi dalam ekspresi *kembali:*
```
switch({origin_city_name},
"Albany, NY", {arr_delay} + 20,
"Alexandria, LA", {arr_delay} - 10,
"New York, NY", {arr_delay} * 2,
{arr_delay})
```
Contoh sebelumnya mengubah waktu tunda yang diharapkan untuk setiap penerbangan dari kota tertentu.
![\[Gambar hasil contoh fungsi, ditunjukkan dalam bentuk tabel.\]](http://docs.aws.amazon.com/id_id/quick/latest/userguide/images/switch-function-example.png)
# toLower
`toLower`memformat string dalam semua huruf kecil. `toLower`melompati baris yang berisi nilai nol.
## Sintaksis
```
toLower(expression)
```
## Pendapat
*ekspresi*
Ekspresi harus berupa string. Ini bisa berupa nama bidang yang menggunakan tipe data string, nilai literal seperti**'12 Main Street'**, atau panggilan ke fungsi lain yang mengeluarkan string.
## Jenis pengembalian
String
## Contoh
Contoh berikut mengkonversi nilai string menjadi huruf kecil.
```
toLower('Seattle Store #14')
```
Nilai berikut dikembalikan.
```
seattle store #14
```
# toString
`toString`memformat ekspresi input sebagai string. `toString`melompati baris yang berisi nilai nol.
## Sintaksis
```
toString(expression)
```
## Pendapat
*ekspresi*
Ekspresi dapat berupa bidang tipe data apa pun, nilai literal seperti**14.62**, atau panggilan ke fungsi lain yang mengembalikan tipe data apa pun.
## Jenis pengembalian
String
## Contoh
Contoh berikut mengembalikan nilai-nilai dari `payDate` (yang menggunakan tipe `date` data) sebagai string.
```
toString(payDate)
```
Berikut ini adalah nilai bidang yang diberikan.
```
payDate
--------
1992-11-14T00:00:00.000Z
2012-10-12T00:00:00.000Z
1973-04-08T00:00:00.000Z
```
Untuk nilai bidang ini, baris berikut dikembalikan.
```
1992-11-14T00:00:00.000Z
2012-10-12T00:00:00.000Z
1973-04-08T00:00:00.000Z
```
# toUpper
`toUpper`memformat string dalam semua huruf besar. `toUpper`melompati baris yang berisi nilai nol.
## Sintaksis
```
toUpper(expression)
```
## Pendapat
*ekspresi*
Ekspresi harus berupa string. Ini bisa berupa nama bidang yang menggunakan tipe data string, nilai literal seperti**'12 Main Street'**, atau panggilan ke fungsi lain yang mengeluarkan string.
## Jenis pengembalian
String
## Contoh
Contoh berikut mengkonversi nilai string menjadi huruf besar.
```
toUpper('Seattle Store #14')
```
Nilai berikut dikembalikan.
```
SEATTLE STORE #14
```
# trim
`trim`menghapus ruang kosong sebelumnya dan mengikuti dari string.
## Sintaksis
```
trim(expression)
```
## Pendapat
*ekspresi*
Ekspresi harus berupa string. Ini bisa berupa nama bidang yang menggunakan tipe data string, nilai literal seperti**'12 Main Street'**, atau panggilan ke fungsi lain yang mengeluarkan string.
## Jenis pengembalian
String
## Contoh
Contoh berikut menghapus spasi berikut dari string.
```
trim(' Seattle Store #14 ')
```
Untuk nilai bidang ini, nilai berikut dikembalikan.
```
Seattle Store #14
```
# truncDate
`truncDate`mengembalikan nilai tanggal yang mewakili bagian tertentu dari tanggal. Misalnya, meminta bagian tahun dari nilai 2012-09-02T 00:00:00.000 Z mengembalikan 2012-01-01T 00:00:00.000 Z. Menentukan periode terkait waktu untuk tanggal yang tidak berisi informasi waktu mengembalikan nilai tanggal awal tidak berubah.
## Sintaksis
```
truncDate('period', date)
```
## Pendapat
*periode*
Periode tanggal yang ingin Anda kembalikan. Periode yang valid adalah sebagai berikut:
+ YYYY: Ini mengembalikan bagian tahun dari tanggal tersebut.
+ T: Ini mengembalikan tanggal hari pertama kuartal tanggal tersebut.
+ MM: Ini mengembalikan bagian bulan dari tanggal tersebut.
+ DD: Ini mengembalikan bagian hari dari tanggal tersebut.
+ WK: Ini mengembalikan bagian minggu dari tanggal tersebut. Minggu dimulai pada hari Minggu di Amazon Quick.
+ HH: Ini mengembalikan porsi jam dari tanggal tersebut.
+ MI: Ini mengembalikan bagian menit dari tanggal tersebut.
+ SS: Ini mengembalikan bagian kedua dari tanggal.
+ MS: Ini mengembalikan bagian milidetik dari tanggal.
*tanggal*
Kolom tanggal atau panggilan ke fungsi lain yang menampilkan tanggal.
## Jenis pengembalian
Date
## Contoh
Contoh berikut mengembalikan tanggal yang mewakili bulan dari tanggal pesanan.
```
truncDate('MM', orderDate)
```
Berikut ini adalah nilai bidang yang diberikan.
```
orderDate
=========
2012-12-14T00:00:00.000Z
2013-12-29T00:00:00.000Z
2012-11-15T00:00:00.000Z
```
Untuk nilai bidang ini, nilai berikut dikembalikan.
```
2012-12-01T00:00:00.000Z
2013-12-01T00:00:00.000Z
2012-11-01T00:00:00.000Z
```