Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Perintah PPL yang didukung
Tabel berikut menunjukkan perintah PPL yang didukung OpenSearch Dasbor untuk kueri CloudWatch Log, Amazon S3, atau Security Lake, dan perintah mana yang didukung oleh Logs Insights. CloudWatch CloudWatch Logs Insights menggunakan sintaks PPL yang sama dengan OpenSearch Dasbor saat menanyakan CloudWatch Log, dan tabel merujuk keduanya sebagai Log. CloudWatch
**catatan**
Saat Anda menganalisis data di luar OpenSearch Layanan, perintah mungkin dijalankan secara berbeda dari yang dilakukan pada OpenSearch indeks.
**Topics**
+ [Commands](#supported-ppl-commands)
+ [Fungsi](#supported-ppl-functions)
+ [Informasi tambahan untuk pengguna CloudWatch Log Insights yang menggunakan OpenSearch PPL](#supported-ppl-for-cloudwatch-users)
## Commands
| Perintah PPL | Deskripsi | CloudWatch Log | Amazon S3 | Danau Keamanan | Perintah contoh |
| --- | --- | --- | --- | --- | --- |
| [bidang perintah](#supported-ppl-fields-command) | Menampilkan satu set bidang yang membutuhkan proyeksi. | Didukung | Didukung | Didukung | fields field1, field2
|
| [Dimana perintah](#supported-ppl-where-command) | Memfilter data berdasarkan kondisi yang Anda tentukan. | Didukung | Didukung | Didukung | where field1="success"
| where field2 != "i -023fe0a90929d8822"
| fields field3, col4, col5, col6
| head 1000
|
| [perintah statistik](#supported-ppl-stats-command) | Melakukan agregasi dan perhitungan. | Didukung | Didukung | Didukung | stats count(),
count(`field1`),
min(`field1`),
max(`field1`),
avg(`field1`)
by field2
| head 1000
|
| [perintah parse](#supported-ppl-parse-command) | Mengekstrak pola ekspresi reguler (regex) dari string dan menampilkan pola yang diekstraksi. Pola yang diekstraksi dapat digunakan lebih lanjut untuk membuat bidang baru atau menyaring data. | Didukung | Didukung | Didukung | parse `field1` ".*/(?[^/]+$)"
| where field2 = "requestId"
| fields field2, `field2`
| head 1000
|
| [pola perintah](#supported-ppl-patterns-command) | Mengekstrak pola log dari bidang teks dan menambahkan hasil ke hasil pencarian. Mengelompokkan log berdasarkan polanya memudahkan pengumpulan statistik dari volume besar data log untuk analisis dan pemecahan masalah. | Tidak didukung | Didukung | Didukung | patterns new_field='no_numbers' pattern='[0-9]' message
| fields message, no_numbers
|
| [perintah urutkan](#supported-ppl-sort-command) | Urutkan hasil yang ditampilkan dengan nama bidang. Gunakan **sort - *FieldName***untuk mengurutkan dalam urutan menurun. | Didukung | Didukung | Didukung | stats count(),
count(`field1`),
min(`field1`) as field1Alias,
max(`field1`),
avg(`field1`)
by field2
| sort -field1Alias
| head 1000
|
| [perintah eval](#supported-ppl-eval-command) | Memodifikasi atau memproses nilai bidang dan menyimpannya di bidang yang berbeda. Ini berguna untuk memodifikasi kolom secara matematis, menerapkan fungsi string ke kolom, atau menerapkan fungsi tanggal ke kolom. | Didukung | Didukung | Didukung | eval field2 = `field1` * 2
| fields field1, field2
| head 20
|
| [ganti nama perintah](#supported-ppl-rename-command) | Mengganti nama satu atau beberapa bidang di hasil pencarian. | Didukung | Didukung | Didukung | rename field2 as field1
| fields field1
|
| [perintah kepala](#supported-ppl-head-command) | Membatasi hasil kueri yang ditampilkan ke baris N frst. | Didukung | Didukung | Didukung | fields `@message`
| head 20
|
| [perintah grok](#supported-ppl-grok-command) | Mem-parsing bidang teks dengan pola grok berdasarkan ekspresi reguler, dan menambahkan hasilnya ke hasil pencarian. | Didukung | Didukung | Didukung | grok email '.+@%{HOSTNAME:host}'
| fields email |
| [perintah atas](#supported-ppl-top-command) | Menemukan nilai yang paling sering untuk bidang. | Didukung | Didukung | Didukung | top 2 Field1 by Field2
|
| [perintah dedup](#supported-ppl-dedup-command) | Menghapus entri duplikat berdasarkan bidang yang Anda tentukan. | Didukung | Didukung | Didukung | dedup field1
| fields field1, field2, field3
|
| [bergabung dengan perintah](#supported-ppl-join-commands) | Bergabung dengan dua kumpulan data bersama-sama. | Didukung | Didukung | Didukung | source=customer
| join ON c_custkey = o_custkey orders
| head 10
|
| [perintah pencarian](#supported-ppl-lookup-commands) | Memperkaya data pencarian Anda dengan menambahkan atau mengganti data dari indeks pencarian (tabel dimensi). Anda dapat memperluas bidang indeks dengan nilai dari tabel dimensi, menambahkan atau mengganti nilai saat kondisi pencarian cocok | Tidak didukung | Didukung | Didukung | where orderType = 'Cancelled'
| lookup account_list, mkt_id AS mkt_code
replace amount, account_name as name
| stats count(mkt_code), avg(amount)
by name
|
| [perintah subquery](#supported-ppl-subquery-commands) | Melakukan kueri bersarang yang kompleks dalam pernyataan Piped Processing Language (PPL) Anda. | Didukung | Didukung | Didukung | where id in [
subquery source=users
| where user in [
subquery source=actions
| where action="login"
| fields user
]
| fields uid
]
|
| [perintah langka](#supported-ppl-rare-command) | Menemukan nilai yang paling tidak sering dari semua bidang dalam daftar bidang. | Didukung | Didukung | Didukung | rare Field1 by Field2
|
| [perintah trendline](#supported-ppl-trendline-commands) | Menghitung rata-rata bergerak bidang. | Didukung | Didukung | Didukung | trendline sma(2, field1) as field1Alias
|
| [perintah eventstats](#supported-ppl-eventstats-command) | Memperkaya data acara Anda dengan statistik ringkasan yang dihitung. Ini menganalisis bidang tertentu dalam acara Anda, menghitung berbagai ukuran statistik, dan kemudian menambahkan hasil ini ke setiap peristiwa asli sebagai bidang baru. | Didukung (kecuali`count()`) | Didukung | Didukung | eventstats sum(field1) by field2
|
| [meratakan perintah](#supported-ppl-flatten-command) | Meratakan bidang, Bidang harus dari jenis ini: `struct or array>` | Didukung | Didukung | Didukung | source=table | flatten field1
|
| [ringkasan bidang](#supported-ppl-field-summary-command) | Menghitung statistik dasar untuk setiap bidang (hitungan, hitungan berbeda, min, maks, rata-rata, stddev, dan rata-rata). | Didukung (satu bidang per kueri) | Didukung | Didukung | where field1 != 200
| fieldsummary includefields=field1 nulls=true
|
| [perintah fillnull](#supported-ppl-fillnull-command) | Mengisi bidang null dengan nilai yang Anda berikan. Ini dapat digunakan dalam satu atau lebih bidang. | Didukung | Didukung | Didukung | fields field1
| eval field2=field1
| fillnull value=0 field1
|
| [memperluas perintah](#supported-ppl-expand-command) | Memecah bidang yang berisi beberapa nilai menjadi baris terpisah, membuat baris baru untuk setiap nilai di bidang yang ditentukan. | Didukung | Didukung | Didukung | expand employee
| stats max(salary) as max
by state, company
|
| [mendeskripsikan perintah](#supported-ppl-describe-command) | Mendapat informasi rinci tentang struktur dan metadata tabel, skema, dan katalog | Tidak didukung | Didukung | Didukung | describe schema.table
|
## Fungsi
| Fungsi PPL | Deskripsi | CloudWatch Log | Amazon S3 | Danau Keamanan | Perintah contoh |
| --- | --- | --- | --- | --- | --- |
| [Fungsi string PPL](#supported-ppl-string-functions)
(`CONCAT`, `CONCAT_WS`, `LENGTH`, `LOWER`, `LTRIM`, `POSITION`, `REVERSE`, `RIGHT`, `RTRIM`, `SUBSTRING`, `TRIM`, `UPPER`) | Fungsi bawaan di PPL yang dapat memanipulasi dan mengubah data string dan teks dalam kueri PPL. Misalnya, mengonversi kasus, menggabungkan string, mengekstraksi bagian, dan membersihkan teks. | Didukung | Didukung | Didukung | eval col1Len = LENGTH(col1)
| fields col1Len
|
| [Fungsi tanggal dan waktu PPL](#supported-ppl-date-time-functions)
(`DAY`, `DAYOFMONTH`, `DAY_OF_MONTH`,`DAYOFWEEK`, `DAY_OF_WEEK`, `DAYOFYEAR`, `DAY_OF_YEAR`, `DAYNAME`, `FROM_UNIXTIME`, `HOUR`, `HOUR_OF_DAY`, `LAST_DAY`, `LOCALTIMESTAMP`, `LOCALTIME`, `MAKE_DATE`, `MINUTE`, `MINUTE_OF_HOUR`, `MONTH`, `MONTHNAME`, `MONTH_OF_YEAR`, `NOW`, `QUARTER`, `SECOND`, `SECOND_OF_MINUTE`, `SUBDATE`, `SYSDATE`, `TIMESTAMP`, `UNIX_TIMESTAMP`, `WEEK`, `WEEKDAY`, `WEEK_OF_YEAR`, `DATE_ADD`, `DATE_SUB`, `TIMESTAMPADD`, `TIMESTAMPDIFF`, `UTC_TIMESTAMP`, `CURRENT_TIMEZONE`) | Fungsi bawaan untuk menangani dan mengubah data tanggal dan stempel waktu dalam kueri PPL. ****Misalnya, **date\_add, date\_format****, datediff, dan current\_date**.**** | Didukung | Didukung | Didukung | eval newDate = ADDDATE(DATE('2020-08-26'), 1)
| fields newDate |
| [Fungsi kondisi PPL](#supported-ppl-condition-functions)
(`EXISTS`, `IF`, `IFNULL`, `ISNOTNULL`, `ISNULL`, `NULLIF`) | Fungsi bawaan yang melakukan perhitungan pada beberapa baris untuk menghasilkan nilai ringkasan tunggal. Misalnya, **jumlah**, **hitung**, **rata-rata**, **maks**, dan **min**. | Didukung | Didukung | Didukung | eval field2 = isnull(col1)
| fields field2, col1, field3
|
| [Fungsi matematika PPL](#supported-ppl-math-functions)
(`ABS`, `ACOS`, `ASIN`, `ATAN`, `ATAN2`, `CEIL`, `CEILING`, `CONV`, `COS`, `COT`, `CRC32`, `DEGREES`, `E`, `EXP`, `FLOOR`, `LN`, `LOG`, `LOG2`, `LOG10`, `MOD`, `PI`. `POW`, `POWER`, `RADIANS`, `RAND`, `ROUND`, `SIGN`, `SIN`, `SQRT`, `CBRT`) | Fungsi bawaan untuk melakukan perhitungan dan transformasi matematis dalam kueri PPL. Misalnya: **abs** (nilai absolut), **bulat (angka bulat**), **sqrt** (akar kuadrat), **pow** (perhitungan daya), dan **ceil** (membulatkan ke bilangan bulat terdekat). | Didukung | Didukung | Didukung | eval field2 = ACOS(col1)
| fields col1
|
| [Ekspresi PPL](#supported-ppl-expressions)
(Operator aritmatika (`+`,,`*`)`-`, Operator predikat (,) `>. <` `IN)` | Fungsi bawaan untuk ekspresi, terutama ekspresi nilai, mengembalikan nilai skalar. Ekspresi memiliki tipe dan bentuk yang berbeda. | Didukung | Didukung | Didukung | where age > (25 + 5)
| fields age
|
| [Fungsi alamat IP PPL](#supported-ppl-ip-address-functions)
(`CIDRMATCH`) | Fungsi bawaan untuk menangani alamat IP seperti CIDR. | Didukung | Didukung | Didukung | where cidrmatch(ip, '***********/24')
| fields ip
|
| [Fungsi PPL JSON](#supported-ppl-json-functions)
(`ARRAY_LENGTH`, `ARRAY_LENGTH`, `JSON`, `JSON_ARRAY`, `JSON_EXTRACT`, `JSON_KEYS`, `JSON_OBJECT`, `JSON_VALID`, `TO_JSON_STRING`) | Fungsi bawaan untuk menangani JSON termasuk array, ekstraksi, dan validasi. | Didukung | Didukung | Didukung | eval `json_extract('{"a":"b"}', '$.a')` = json_extract('{"a":"b"}', '$a') |
| [Fungsi PPL Lambda](#supported-ppl-lambda-functions)
(`EXISTS`, `FILTER`, `REDUCE`, `TRANSFORM`) | Fungsi bawaan untuk menangani JSON termasuk array, ekstraksi, dan validasi. | Tidak didukung | Didukung | Didukung | eval array = json_array(1, -1, 2),
result = filter(array, x -> x > 0)
| fields result
|
| [Fungsi hash kriptografi PPL](#supported-ppl-cryptographic-functions)
(`MD5`, `SHA1`, `SHA2`) | Fungsi bawaan yang memungkinkan Anda menghasilkan sidik jari data yang unik, yang dapat digunakan untuk verifikasi, perbandingan, atau sebagai bagian dari protokol keamanan yang lebih kompleks. | Didukung | Didukung | Didukung | eval `MD5('hello')` = MD5('hello')
| fields `MD5('hello')` |
## Informasi tambahan untuk pengguna CloudWatch Log Insights yang menggunakan OpenSearch PPL
Meskipun CloudWatch Logs Insights mendukung sebagian besar perintah dan fungsi OpenSearch PPL, beberapa perintah dan fungsi saat ini tidak didukung. Misalnya, saat ini tidak mendukung perintah Pencarian di PPL. Mulai 2 Juni 2025, CloudWatch Logs Insights sekarang mendukung fungsi JOIN, subqueries, Flatten, Fillnull, Expand, Cidrmatch, dan JSON di PPL. Untuk daftar lengkap perintah dan fungsi kueri yang didukung, lihat kolom Amazon CloudWatch Logs dalam tabel di atas.
### Contoh kueri dan kuota
Berikut ini berlaku untuk pengguna CloudWatch Log Insights dan OpenSearch pengguna yang melakukan kueri data CloudWatch .
Untuk informasi tentang batasan yang berlaku saat menanyakan CloudWatch Log dari OpenSearch Layanan, lihat [Kuota CloudWatch log](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/cloudwatch_limits_cwl.html) di Panduan Pengguna Amazon CloudWatch Logs. Batas melibatkan jumlah grup CloudWatch Log yang dapat Anda kueri, kueri bersamaan maksimum yang dapat Anda jalankan, waktu eksekusi kueri maksimum, dan jumlah baris maksimum yang dikembalikan dalam hasil. Batasannya sama terlepas dari bahasa yang Anda gunakan untuk menanyakan CloudWatch Log (yaitu, OpenSearch PPL, SQL, dan Wawasan Log QL).
### Perintah PPL
**Topics**
+ [komentar](#supported-ppl-comment)
+ [perintah korelasi](#supported-ppl-correlation-commands)
+ [perintah dedup](#supported-ppl-dedup-command)
+ [mendeskripsikan perintah](#supported-ppl-describe-command)
+ [perintah eval](#supported-ppl-eval-command)
+ [perintah eventstats](#supported-ppl-eventstats-command)
+ [memperluas perintah](#supported-ppl-expand-commands)
+ [jelaskan perintah](#supported-ppl-explain-command)
+ [perintah fillnull](#supported-ppl-fillnull-command)
+ [bidang perintah](#supported-ppl-fields-command)
+ [meratakan perintah](#supported-ppl-flatten-command)
+ [perintah grok](#supported-ppl-grok-command)
+ [perintah kepala](#supported-ppl-head-command)
+ [bergabung dengan perintah](#supported-ppl-join-commands)
+ [perintah pencarian](#supported-ppl-lookup-commands)
+ [perintah parse](#supported-ppl-parse-command)
+ [pola perintah](#supported-ppl-patterns-command)
+ [perintah langka](#supported-ppl-rare-command)
+ [ganti nama perintah](#supported-ppl-rename-command)
+ [perintah pencarian](#supported-ppl-search-command)
+ [perintah urutkan](#supported-ppl-sort-command)
+ [perintah statistik](#supported-ppl-stats-command)
+ [perintah subquery](#supported-ppl-subquery-commands)
+ [perintah atas](#supported-ppl-top-command)
+ [perintah trendline](#supported-ppl-trendline-commands)
+ [Dimana perintah](#supported-ppl-where-command)
+ [ringkasan bidang](#supported-ppl-field-summary-command)
+ [memperluas perintah](#supported-ppl-expand-command)
+ [Fungsi PPL](#supported-ppl-functions-details)
#### komentar
**catatan**
Untuk melihat integrasi sumber AWS data mana yang mendukung perintah PPL ini, lihat. [Commands](#supported-ppl-commands)
PPL mendukung komentar baris dan komentar blok. Sistem tidak mengevaluasi teks komentar.
**Komentar baris**
Komentar baris dimulai dengan dua garis miring//dan diakhiri dengan baris baru.
Contoh:
```
os> source=accounts | top gender // finds most common gender of all the accounts
fetched rows / total rows = 2/2
+----------+
| gender |
|----------|
| M |
| F |
+----------+
```
**Blokir Komentar**
Komentar blok dimulai dengan garis miring diikuti dengan tanda bintang\\ \*, dan diakhiri dengan tanda bintang diikuti dengan garis miring \*/.
Contoh:
```
os> source=accounts | dedup 2 gender /* dedup the document with gender field keep 2 duplication */ | fields account_number, gender
fetched rows / total rows = 3/3
+------------------+----------+
| account_number | gender |
|------------------+----------|
| 1 | M |
| 6 | M |
| 13 | F |
+------------------+----------+
```
#### perintah korelasi
**catatan**
Untuk melihat integrasi sumber AWS data mana yang mendukung perintah PPL ini, lihat. [Commands](#supported-ppl-commands)
Anda dapat mengkorelasikan sumber data yang berbeda sesuai dengan dimensi dan kerangka waktu umum.
Korelasi ini sangat penting ketika Anda berurusan dengan sejumlah besar data dari berbagai vertikal yang berbagi periode waktu yang sama tetapi tidak disinkronkan secara formal.
Dengan menghubungkan sumber data yang berbeda ini berdasarkan kerangka waktu dan dimensi serupa, Anda dapat memperkaya data Anda dan mengungkap wawasan berharga.
**Contoh**
Domain observabilitas memiliki tiga sumber data yang berbeda:
+ Beberapa catatan
+ Metrik-metrik
+ Jejak
Sumber data ini mungkin berbagi dimensi yang sama. Untuk transisi dari satu sumber data ke sumber data lainnya, Anda perlu menghubungkannya dengan benar. Dengan menggunakan konvensi penamaan semantik, Anda dapat mengidentifikasi elemen bersama di seluruh log, jejak, dan metrik.
Contoh:
```
{
"@timestamp": "2018-07-02T22:23:00.186Z",
"aws": {
"elb": {
"backend": {
"http": {
"response": {
"status_code": 500
}
},
"ip": "********",
"port": "80"
},
...
"target_port": [
"10.0.0.1:80"
],
"target_status_code": [
"500"
],
"traceId": "Root=1-58337262-36d228ad5d99923122bbe354",
"type": "http"
}
},
"cloud": {
"provider": "aws"
},
"http": {
"request": {
...
},
"communication": {
"source": {
"address": "**************",
"ip": "**************",
"port": 2817
}
},
"traceId": "Root=1-58337262-36d228ad5d99923122bbe354"
}
```
Contoh ini menunjukkan log AWS ELB yang datang dari layanan yang berada di. AWS Ini menunjukkan respons HTTP backend dengan kode status 500, menunjukkan kesalahan. Ini bisa memicu peringatan atau menjadi bagian dari proses pemantauan rutin Anda. Langkah Anda selanjutnya adalah mengumpulkan data yang relevan seputar acara ini untuk penyelidikan menyeluruh.
Meskipun Anda mungkin tergoda untuk menanyakan semua data yang terkait dengan jangka waktu, pendekatan ini bisa sangat melelahkan. Anda bisa berakhir dengan terlalu banyak informasi, menghabiskan lebih banyak waktu untuk menyaring data yang tidak relevan daripada mengidentifikasi akar penyebabnya.
Sebagai gantinya, Anda dapat menggunakan pendekatan yang lebih bertarget dengan menghubungkan data dari sumber yang berbeda. Anda dapat menggunakan dimensi ini untuk korelasi:
+ **IP** - `"ip": "10.0.0.1" | "ip": "**************"`
+ **Pelabuhan** - `"port": 2817 | "target_port": "10.0.0.1:80"`
Dengan asumsi Anda memiliki akses ke indeks jejak dan metrik tambahan, dan Anda terbiasa dengan struktur skema Anda, Anda dapat membuat kueri korelasi yang lebih tepat.
Berikut adalah contoh dokumen indeks jejak yang berisi informasi HTTP yang mungkin ingin Anda korelasikan:
```
{
"traceId": "c1d985bd02e1dbb85b444011f19a1ecc",
"spanId": "55a698828fe06a42",
"traceState": [],
"parentSpanId": "",
"name": "mysql",
"kind": "CLIENT",
"@timestamp": "2021-11-13T20:20:39+00:00",
"events": [
{
"@timestamp": "2021-03-25T17:21:03+00:00",
...
}
],
"links": [
{
"traceId": "c1d985bd02e1dbb85b444011f19a1ecc",
"spanId": "55a698828fe06a42w2",
},
"droppedAttributesCount": 0
}
],
"resource": {
"service@name": "database",
"telemetry@sdk@name": "opentelemetry",
"host@hostname": "ip-172-31-10-8.us-west-2.compute.internal"
},
"status": {
...
},
"attributes": {
"http": {
"user_agent": {
"original": "Mozilla/5.0"
},
"network": {
...
}
},
"request": {
...
}
},
"response": {
"status_code": "200",
"body": {
"size": 500
}
},
"client": {
"server": {
"socket": {
"address": "***********",
"domain": "example.com",
"port": 80
},
"address": "***********",
"port": 80
},
"resend_count": 0,
"url": {
"full": "http://example.com"
}
},
"server": {
"route": "/index",
"address": "***********",
"port": 8080,
"socket": {
...
},
"client": {
...
}
},
"url": {
...
}
}
}
}
}
```
Dalam pendekatan ini Anda dapat melihat `traceId` dan http client/server `ip` yang dapat dikorelasikan dengan log elb untuk lebih memahami perilaku dan kondisi sistem.
**Perintah kueri korelasi baru**
Berikut adalah perintah baru yang memungkinkan jenis penyelidikan ini:
```
source alb_logs, traces | where alb_logs.ip="10.0.0.1" AND alb_logs.cloud.provider="aws"|
correlate exact fields(traceId, ip) scope(@timestamp, 1D) mapping(alb_logs.ip = traces.attributes.http.server.address, alb_logs.traceId = traces.traceId )
```
Inilah yang dilakukan setiap bagian dari perintah:
1. `source alb_logs, traces`- Ini memilih sumber data yang ingin Anda korelasikan.
1. `where ip="10.0.0.1" AND cloud.provider="aws"`- Ini mempersempit ruang lingkup pencarian Anda.
1. `correlate exact fields(traceId, ip)`- Ini memberitahu sistem untuk menghubungkan data berdasarkan kecocokan yang tepat dari bidang berikut:
+ `ip`Bidang memiliki kondisi filter eksplisit, sehingga akan digunakan dalam korelasi untuk semua sumber data.
+ `traceId`Bidang tidak memiliki filter eksplisit, sehingga akan cocok dengan traceID yang sama di semua sumber data.
Nama bidang menunjukkan arti logis dari fungsi dalam perintah korelasi. Kondisi gabungan sebenarnya bergantung pada pernyataan pemetaan yang Anda berikan.
Istilah ini `exact` berarti bahwa pernyataan korelasi akan mengharuskan semua bidang untuk mencocokkan untuk memenuhi pernyataan kueri.
Istilah ini `approximate` akan mencoba untuk mencocokkan pada skenario kasus terbaik dan tidak akan menolak baris dengan kecocokan sebagian.
**Mengatasi pemetaan bidang yang berbeda**
Dalam kasus di mana bidang logis yang sama (seperti`ip`) memiliki nama yang berbeda di seluruh sumber data Anda, Anda perlu memberikan pemetaan eksplisit bidang jalur. Untuk mengatasi hal ini, Anda dapat memperluas kondisi korelasi Anda untuk mencocokkan nama bidang yang berbeda dengan arti logis yang serupa. Inilah cara Anda melakukan ini:
```
alb_logs.ip = traces.attributes.http.server.address, alb_logs.traceId = traces.traceId
```
Untuk setiap bidang yang berpartisipasi dalam gabungan korelasi, Anda harus memberikan pernyataan pemetaan yang relevan yang mencakup semua tabel yang akan digabungkan dengan perintah korelasi ini.
**Contoh**
Dalam contoh ini, ada 2 sumber: `alb_logs, traces`
Ada 2 bidang: `traceId, ip`
Ada 2 pernyataan pemetaan: `alb_logs.ip = traces.attributes.http.server.address, alb_logs.traceId = traces.traceId`
**Pelingkupan kerangka waktu korelasi**
Untuk menyederhanakan pekerjaan yang dilakukan oleh mesin eksekusi (driver), Anda dapat menambahkan pernyataan lingkup. Ini secara eksplisit mengarahkan kueri gabungan pada waktu yang seharusnya dicakupkan untuk pencarian ini.
`scope(@timestamp, 1D)`saya
Dalam contoh ini, ruang lingkup pencarian berfokus setiap hari, sehingga korelasi yang muncul pada hari yang sama dikelompokkan bersama. Mekanisme pelingkupan ini menyederhanakan dan memungkinkan kontrol yang lebih baik atas hasil, memungkinkan resolusi pencarian tambahan berdasarkan kebutuhan Anda.
**Driver pendukung**
Perintah korelasi baru sebenarnya adalah perintah gabungan 'tersembunyi'. Oleh karena itu, hanya driver PPL berikut yang mendukung perintah ini. Dalam driver ini, perintah korelasi akan langsung diterjemahkan ke dalam rencana logis Catalyst Join yang sesuai.
**Contoh**
`source alb_logs, traces, metrics | where ip="10.0.0.1" AND cloud.provider="aws"| correlate exact on (ip, port) scope(@timestamp, 2018-07-02T22:23:00, 1 D)`
**Rencana Logis:**
```
'Project [*]
+- 'Join Inner, ('ip && 'port)
:- 'Filter (('ip === "10.0.0.1" & 'cloud.provider === "aws") & inTimeScope('@timestamp, "2018-07-02T22:23:00", "1 D"))
+- 'UnresolvedRelation [alb_logs]
+- 'Join Inner, ('ip & 'port)
:- 'Filter (('ip === "10.0.0.1" & 'cloud.provider === "aws") & inTimeScope('@timestamp, "2018-07-02T22:23:00", "1 D"))
+- 'UnresolvedRelation [traces]
+- 'Filter (('ip === "10.0.0.1" & 'cloud.provider === "aws") & inTimeScope('@timestamp, "2018-07-02T22:23:00", "1 D"))
+- 'UnresolvedRelation [metrics]
```
Mesin katalis mengoptimalkan kueri ini sesuai dengan pemesanan gabungan yang paling efisien.
#### perintah dedup
**catatan**
Untuk melihat integrasi sumber AWS data mana yang mendukung perintah PPL ini, lihat. [Commands](#supported-ppl-commands)
Gunakan `dedup` perintah untuk menghapus dokumen identik dari hasil pencarian Anda berdasarkan bidang tertentu.
**Sintaksis**
Gunakan sintaks berikut:
```
dedup [int] [keepempty=] [consecutive=]
```
**`int`**
+ Tidak wajib.
+ `dedup`Perintah mempertahankan beberapa peristiwa untuk setiap kombinasi saat Anda menentukan. Jumlah untuk harus lebih besar dari 0. Jika Anda tidak menentukan nomor, hanya peristiwa yang terjadi pertama yang disimpan. Semua duplikat lainnya dihapus dari hasil.
+ Default: 1
**`keepempty`**
+ Tidak wajib.
+ Jika benar, simpan dokumen di mana bidang apa pun dalam daftar bidang memiliki nilai NULL atau HILANG.
+ Bawaan: salah
**`consecutive`**
+ Tidak wajib.
+ Jika benar, hanya menghapus peristiwa dengan kombinasi nilai duplikat berturut-turut.
+ Bawaan: salah
**`field-list`**
+ Wajib.
+ Daftar bidang yang dibatasi koma. Setidaknya satu bidang diperlukan.
**Contoh 1: Dedup oleh satu bidang**
Contoh ini menunjukkan cara mendedup dokumen menggunakan bidang gender.
Kueri PPL:
```
os> source=accounts | dedup gender | fields account_number, gender;
fetched rows / total rows = 2/2
+------------------+----------+
| account_number | gender |
|------------------+----------|
| 1 | M |
| 13 | F |
+------------------+----------+
```
**Contoh 2: Simpan 2 dokumen duplikat**
Contoh menunjukkan bagaimana mendedup dokumen dengan bidang gender, menyimpan dua duplikat.
Kueri PPL:
```
os> source=accounts | dedup 2 gender | fields account_number, gender;
fetched rows / total rows = 3/3
+------------------+----------+
| account_number | gender |
|------------------+----------|
| 1 | M |
| 6 | M |
| 13 | F |
+------------------+----------+
```
**Contoh 3: Simpan atau abaikan bidang kosong secara default**
Contoh menunjukkan cara dedup dokumen dengan menjaga bidang nilai null.
Kueri PPL:
```
os> source=accounts | dedup email keepempty=true | fields account_number, email;
fetched rows / total rows = 4/4
+------------------+-----------------------+
| account_number | email |
+------------------+-----------------------+
| 1 | john_doe@example.com |
| 6 | jane_doe@example.com |
| 13 | null |
| 18 | juan_li@example.com |
+------------------+-----------------------+
```
Contoh menunjukkan cara dedup dokumen dengan mengabaikan bidang nilai kosong.
Kueri PPL:
```
os> source=accounts | dedup email | fields account_number, email;
fetched rows / total rows = 3/3
+------------------+-----------------------+
| account_number | email |
+------------------+-----------------------+
| 1 | john_doe@example.com |
| 6 | jane_doe@example.com |
| 18 | juan_li@example.com |
+------------------+-----------------------+
```
**Contoh 4: Dedup dalam dokumen berturut-turut**
Contoh menunjukkan cara dedup dalam dokumen berturut-turut.
Kueri PPL:
```
os> source=accounts | dedup gender consecutive=true | fields account_number, gender;
fetched rows / total rows = 3/3
+------------------+----------+
| account_number | gender |
+------------------+----------+
| 1 | M |
| 13 | F |
| 18 | M |
+------------------+----------+
```
**Contoh tambahan**
+ `source = table | dedup a | fields a,b,c`
+ `source = table | dedup a,b | fields a,b,c`
+ `source = table | dedup a keepempty=true | fields a,b,c`
+ `source = table | dedup a,b keepempty=true | fields a,b,c`
+ `source = table | dedup 1 a | fields a,b,c`
+ `source = table | dedup 1 a,b | fields a,b,c`
+ `source = table | dedup 1 a keepempty=true | fields a,b,c`
+ `source = table | dedup 1 a,b keepempty=true | fields a,b,c`
+ `source = table | dedup 2 a | fields a,b,c`
+ `source = table | dedup 2 a,b | fields a,b,c`
+ `source = table | dedup 2 a keepempty=true | fields a,b,c`
+ `source = table | dedup 2 a,b keepempty=true | fields a,b,c`
+ `source = table | dedup 1 a consecutive=true| fields a,b,c`(deduplikasi berturut-turut tidak didukung)
**Batasan**
+ Untuk `| dedup 2 a, b keepempty=false`
```
DataFrameDropColumns('_row_number_)
+- Filter ('_row_number_ <= 2) // allowed duplication = 2
+- Window [row_number() windowspecdefinition('a, 'b, 'a ASC NULLS FIRST, 'b ASC NULLS FIRST, specifiedwindowframe(RowFrame, unboundedpreceding$(), currentrow$())) AS _row_number_], ['a, 'b], ['a ASC NULLS FIRST, 'b ASC NULLS FIRST]
+- Filter (isnotnull('a) AND isnotnull('b)) // keepempty=false
+- Project
+- UnresolvedRelation
```
+ Untuk `| dedup 2 a, b keepempty=true`
```
Union
:- DataFrameDropColumns('_row_number_)
: +- Filter ('_row_number_ <= 2)
: +- Window [row_number() windowspecdefinition('a, 'b, 'a ASC NULLS FIRST, 'b ASC NULLS FIRST, specifiedwindowframe(RowFrame, unboundedpreceding$(), currentrow$())) AS _row_number_], ['a, 'b], ['a ASC NULLS FIRST, 'b ASC NULLS FIRST]
: +- Filter (isnotnull('a) AND isnotnull('b))
: +- Project
: +- UnresolvedRelation
+- Filter (isnull('a) OR isnull('b))
+- Project
+- UnresolvedRelation
```
#### mendeskripsikan perintah
**catatan**
Untuk melihat integrasi sumber AWS data mana yang mendukung perintah PPL ini, lihat. [Commands](#supported-ppl-commands)
Gunakan `describe` perintah untuk mendapatkan informasi rinci tentang struktur dan metadata tabel, skema, dan katalog. Berikut adalah berbagai contoh dan kasus penggunaan `describe` perintah.
**Jelaskan**
+ `describe table`Perintah ini sama dengan perintah `DESCRIBE EXTENDED table` SQL
+ `describe schema.table`
+ `describe schema.`table``
+ `describe catalog.schema.table`
+ `describe catalog.schema.`table``
+ `describe `catalog`.`schema`.`table``
#### perintah eval
**catatan**
Untuk melihat integrasi sumber AWS data mana yang mendukung perintah PPL ini, lihat. [Commands](#supported-ppl-commands)
`eval`Perintah mengevaluasi ekspresi dan menambahkan hasilnya ke hasil pencarian.
**Sintaksis**
Gunakan sintaks berikut:
```
eval = ["," = ]...
```
+ `field`: Wajib. Jika nama bidang tidak ada, bidang baru ditambahkan. Jika nama bidang sudah ada, itu akan diganti.
+ `expression`: Wajib. Ekspresi apa pun yang didukung oleh sistem.
**Contoh 1: Buat bidang baru**
Contoh ini menunjukkan cara membuat `doubleAge` bidang baru untuk setiap dokumen. Yang baru `doubleAge` adalah hasil evaluasi usia dikalikan 2.
Kueri PPL:
```
os> source=accounts | eval doubleAge = age * 2 | fields age, doubleAge ;
fetched rows / total rows = 4/4
+-------+-------------+
| age | doubleAge |
|-------+-------------|
| 32 | 64 |
| 36 | 72 |
| 28 | 56 |
| 33 | 66 |
+-------+-------------+
```
**Contoh 2: Ganti bidang yang ada**
Contoh ini menunjukkan cara mengganti bidang usia yang ada dengan usia plus 1.
Kueri PPL:
```
os> source=accounts | eval age = age + 1 | fields age ;
fetched rows / total rows = 4/4
+-------+
| age |
|-------|
| 33 |
| 37 |
| 29 |
| 34 |
+-------+
```
**Contoh 3: Buat bidang baru dengan bidang yang ditentukan dalam eval**
Contoh ini menunjukkan cara membuat `ddAge` bidang baru dengan bidang yang ditentukan dalam perintah eval. Bidang baru `ddAge` adalah hasil evaluasi `doubleAge` dikalikan dengan 2, di mana `doubleAge` didefinisikan dalam perintah eval.
Kueri PPL:
```
os> source=accounts | eval doubleAge = age * 2, ddAge = doubleAge * 2 | fields age, doubleAge, ddAge ;
fetched rows / total rows = 4/4
+-------+-------------+---------+
| age | doubleAge | ddAge |
|-------+-------------+---------|
| 32 | 64 | 128 |
| 36 | 72 | 144 |
| 28 | 56 | 112 |
| 33 | 66 | 132 |
+-------+-------------+---------+
```
Asumsi:`a`,`b`, `c` adalah bidang yang ada di `table`
**Contoh tambahan**
+ `source = table | eval f = 1 | fields a,b,c,f`
+ `source = table | eval f = 1`(keluaran bidang a, b, c, f)
+ `source = table | eval n = now() | eval t = unix_timestamp(a) | fields n,t`
+ `source = table | eval f = a | where f > 1 | sort f | fields a,b,c | head 5`
+ `source = table | eval f = a * 2 | eval h = f * 2 | fields a,f,h`
+ `source = table | eval f = a * 2, h = f * 2 | fields a,f,h`
+ `source = table | eval f = a * 2, h = b | stats avg(f) by h`
+ `source = table | eval f = ispresent(a)`
+ `source = table | eval r = coalesce(a, b, c) | fields r`
+ `source = table | eval e = isempty(a) | fields e`
+ `source = table | eval e = isblank(a) | fields e`
+ `source = table | eval f = case(a = 0, 'zero', a = 1, 'one', a = 2, 'two', a = 3, 'three', a = 4, 'four', a = 5, 'five', a = 6, 'six', a = 7, 'se7en', a = 8, 'eight', a = 9, 'nine')`
+ `source = table | eval f = case(a = 0, 'zero', a = 1, 'one' else 'unknown')`
+ `source = table | eval f = case(a = 0, 'zero', a = 1, 'one' else concat(a, ' is an incorrect binary digit'))`
+ `source = table | eval f = a in ('foo', 'bar') | fields f`
+ `source = table | eval f = a not in ('foo', 'bar') | fields f`
**Eval dengan contoh kasus:**
```
source = table | eval e = eval status_category =
case(a >= 200 AND a < 300, 'Success',
a >= 300 AND a < 400, 'Redirection',
a >= 400 AND a < 500, 'Client Error',
a >= 500, 'Server Error'
else 'Unknown')
```
**Eval dengan contoh kasus lain:**
Asumsi:`a`,`b`, `c` adalah bidang yang ada di `table`
**Contoh tambahan**
+ `source = table | eval f = 1 | fields a,b,c,f`
+ `source = table | eval f = 1`(keluaran bidang a, b, c, f)
+ `source = table | eval n = now() | eval t = unix_timestamp(a) | fields n,t`
+ `source = table | eval f = a | where f > 1 | sort f | fields a,b,c | head 5`
+ `source = table | eval f = a * 2 | eval h = f * 2 | fields a,f,h`
+ `source = table | eval f = a * 2, h = f * 2 | fields a,f,h`
+ `source = table | eval f = a * 2, h = b | stats avg(f) by h`
+ `source = table | eval f = ispresent(a)`
+ `source = table | eval r = coalesce(a, b, c) | fields r`
+ `source = table | eval e = isempty(a) | fields e`
+ `source = table | eval e = isblank(a) | fields e`
+ `source = table | eval f = case(a = 0, 'zero', a = 1, 'one', a = 2, 'two', a = 3, 'three', a = 4, 'four', a = 5, 'five', a = 6, 'six', a = 7, 'se7en', a = 8, 'eight', a = 9, 'nine')`
+ `source = table | eval f = case(a = 0, 'zero', a = 1, 'one' else 'unknown')`
+ `source = table | eval f = case(a = 0, 'zero', a = 1, 'one' else concat(a, ' is an incorrect binary digit'))`
+ `source = table | eval f = a in ('foo', 'bar') | fields f`
+ `source = table | eval f = a not in ('foo', 'bar') | fields f`
**Eval dengan contoh kasus:**
```
source = table | eval e = eval status_category =
case(a >= 200 AND a < 300, 'Success',
a >= 300 AND a < 400, 'Redirection',
a >= 400 AND a < 500, 'Client Error',
a >= 500, 'Server Error'
else 'Unknown')
```
**Eval dengan contoh kasus lain:**
```
source = table | where ispresent(a) |
eval status_category =
case(a >= 200 AND a < 300, 'Success',
a >= 300 AND a < 400, 'Redirection',
a >= 400 AND a < 500, 'Client Error',
a >= 500, 'Server Error'
else 'Incorrect HTTP status code'
)
| stats count() by status_category
```
**Batasan**
+ Mengganti bidang yang ada tidak didukung. Kueri yang mencoba melakukannya akan menimbulkan pengecualian dengan pesan “Referensi 'a' ambigu”.
```
- `source = table | eval a = 10 | fields a,b,c`
- `source = table | eval a = a * 2 | stats avg(a)`
- `source = table | eval a = abs(a) | where a > 0`
- `source = table | eval a = signum(a) | where a < 0`
```
#### perintah eventstats
**catatan**
Untuk melihat integrasi sumber AWS data mana yang mendukung perintah PPL ini, lihat. [Commands](#supported-ppl-commands)
Gunakan `eventstats` perintah untuk memperkaya data acara Anda dengan statistik ringkasan yang dihitung. Ini beroperasi dengan menganalisis bidang tertentu dalam acara Anda, menghitung berbagai ukuran statistik, dan kemudian menambahkan hasil ini sebagai bidang baru untuk setiap peristiwa asli.
**Aspek kunci dari eventstats**
1. Ini melakukan perhitungan di seluruh set hasil atau dalam kelompok yang ditentukan.
1. Peristiwa asli tetap utuh, dengan bidang baru ditambahkan untuk memuat hasil statistik.
1. Perintah ini sangat berguna untuk analisis komparatif, mengidentifikasi outlier, atau memberikan konteks tambahan untuk peristiwa individu.
**Perbedaan antara stats dan eventstats**
`eventstats`Perintah `stats` dan keduanya digunakan untuk menghitung statistik, tetapi mereka memiliki beberapa perbedaan utama dalam cara mereka beroperasi dan apa yang mereka hasilkan.
**Format output**
+ `stats`: Menghasilkan tabel ringkasan dengan hanya statistik yang dihitung.
+ `eventstats`: Menambahkan statistik yang dihitung sebagai bidang baru ke peristiwa yang ada, melestarikan data asli.
**Retensi acara**
+ `stats`: Mengurangi hasil yang disetel hanya ke ringkasan statistik, membuang peristiwa individual.
+ `eventstats`: Mempertahankan semua peristiwa asli dan menambahkan bidang baru dengan statistik yang dihitung.
**Kasus penggunaan**
+ `stats`: Terbaik untuk membuat laporan ringkasan atau dasbor. Sering digunakan sebagai perintah akhir untuk meringkas hasil.
+ `eventstats`: Berguna saat Anda perlu memperkaya peristiwa dengan konteks statistik untuk analisis atau penyaringan lebih lanjut. Dapat digunakan pertengahan pencarian untuk menambahkan statistik yang dapat digunakan dalam perintah berikutnya.
**Sintaksis**
Gunakan sintaks berikut:
```
eventstats ... [by-clause]
```
**pengumpulan**
+ Wajib.
+ Fungsi agregasi.
+ Argumen agregasi harus berupa bidang.
**oleh-klausa**
+ Tidak wajib.
+ Sintaks: `by [span-expression,] [field,]...`
+ Klausa by dapat mencakup bidang dan ekspresi seperti fungsi skalar dan fungsi agregasi. Anda juga dapat menggunakan klausa rentang untuk membagi bidang tertentu menjadi ember dengan interval yang sama. Perintah eventstats kemudian melakukan agregasi berdasarkan bucket span ini.
+ Default: Jika Anda tidak menentukan klausa by, perintah eventstats akan mengagregat seluruh kumpulan hasil.
**ekspresi rentang**
+ Opsional, paling banyak satu.
+ Sintaks: `span(field_expr, interval_expr)`
+ Satuan ekspresi interval adalah unit alami secara default. Namun, untuk bidang jenis tanggal dan waktu, Anda perlu menentukan unit dalam ekspresi interval saat menggunakan unit tanggal/waktu.
Misalnya, untuk membagi lapangan `age` menjadi ember 10 tahun, gunakan`span(age, 10)`. Untuk bidang berbasis waktu, Anda dapat membagi `timestamp` bidang menjadi interval per jam menggunakan. `span(timestamp, 1h)`
**Unit waktu yang tersedia**
| Satuan interval rentang |
| --- |
| milidetik (ms) |
| kedua |
| menit (m, peka huruf besar/kecil) |
| jam (h) |
| hari (d) |
| minggu (w) |
| bulan (M, peka huruf besar/kecil) |
| kuartal (q) |
| tahun (y) |
**Fungsi agregasi**
**`COUNT`**
`COUNT`mengembalikan hitungan jumlah expr dalam baris diambil oleh pernyataan SELECT.
Untuk CloudWatch Log menggunakan kueri, `COUNT` tidak didukung.
Contoh:
```
os> source=accounts | eventstats count();
fetched rows / total rows = 4/4
+----------------+----------+-----------+----------+-----+--------+--------------------+------------+--------------------------+--------+-------+---------+
| account_number | balance | firstname | lastname | age | gender | address | employer | email | city | state | count() |
+----------------+----------+-----------+----------+-----+--------+--------------------+------------+--------------------------+--------+-------+---------+
| 1 | 39225 | Jane | Doe | 32 | M | *** Any Lane | AnyCorp | janedoe@anycorp.com | Brogan | IL | 4 |
| 6 | 5686 | Mary | Major | 36 | M | 671 Example Street | AnyCompany | marymajor@anycompany.com | Dante | TN | 4 |
| 13 | 32838 | Nikki | Wolf | 28 | F | 789 Any Street | AnyOrg | | Nogal | VA | 4 |
| 18 | 4180 | Juan | Li | 33 | M | *** Example Court | | juanli@exampleorg.com | Orick | MD | 4 |
+----------------+----------+-----------+----------+-----+--------+--------------------+------------+--------------------------+--------+-------+---------+
```
**`SUM`**
`SUM(expr)`mengembalikan jumlah expr.
Contoh:
```
os> source=accounts | eventstats sum(age) by gender;
fetched rows / total rows = 4/4
+----------------+----------+-----------+----------+-----+--------+-----------------------+------------+--------------------------+--------+-------+--------------------+
| account_number | balance | firstname | lastname | age | gender | address | employer | email | city | state | sum(age) by gender |
+----------------+----------+-----------+----------+-----+--------+-----------------------+------------+--------------------------+--------+-------+--------------------+
| 1 | 39225 | Jane | Doe | 32 | M | 880 Any Lane | AnyCorp | janedoe@anycorp.com | Brogan | IL | 101 |
| 6 | 5686 | Mary | Major | 36 | M | 671 Example Street | AnyCompany | marymajor@anycompany.com | Dante | TN | 101 |
| 13 | 32838 | Nikki | Wolf | 28 | F | 789 Any Street | AnyOrg | | Nogal | VA | 28 |
| 18 | 4180 | Juan | Li | 33 | M | 467 Example Court | | juanli@exampleorg.com | Orick | MD | 101 |
+----------------+----------+-----------+----------+-----+--------+-----------------------+------------+--------------------------+--------+-------+--------------------+
```
**`AVG`**
`AVG(expr)`mengembalikan nilai rata-rata expr.
Contoh:
```
os> source=accounts | eventstats avg(age) by gender;
fetched rows / total rows = 4/4
+----------------+----------+-----------+----------+-----+--------+-----------------------+------------+---------------------------+--------+-------+--------------------+
| account_number | balance | firstname | lastname | age | gender | address | employer | email | city | state | avg(age) by gender |
+----------------+----------+-----------+----------+-----+--------+-----------------------+------------+---------------------------+--------+-------+--------------------+
| 1 | 39225 | Jane | Doe | 32 | M | 880 Any Lane | AnyCorp | janedoe@anycorp.com | Brogan | IL | 33.67 |
| 6 | 5686 | Mary | Major | 36 | M | 671 Example Street | Any Company | marymajor@anycompany.com | Dante | TN | 33.67 |
| 13 | 32838 | Nikki | Wolf | 28 | F | 789 Any Street | AnyOrg | | Nogal | VA | 28.00 |
| 18 | 4180 | Juan | Li | 33 | M | 467 Example Court | | juanli@exampleorg.com | Orick | MD | 33.67 |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+--------------------+
```
**MAX**
`MAX(expr)`Mengembalikan nilai maksimum expr.
Contoh
```
os> source=accounts | eventstats max(age);
fetched rows / total rows = 4/4
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+-----------+
| account_number | balance | firstname | lastname | age | gender | address | employer | email | city | state | max(age) |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+-----------+
| 1 | 39225 | Jane | Doe | 32 | M | 880 Any Lane | AnyCorp | janedoe@anycorp.com | Brogan | IL | 36 |
| 6 | 5686 | Mary | Major | 36 | M | 671 Example Street | Any Company | marymajor@anycompany.com | Dante | TN | 36 |
| 13 | 32838 | Nikki | Wolf | 28 | F | 789 Any Street | AnyOrg | | Nogal | VA | 36 |
| 18 | 4180 | Juan | Li | 33 | M | *** Example Court | | juanli@exampleorg.com | Orick | MD | 36 |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+-----------+
```
**MIN**
`MIN(expr)`Mengembalikan nilai minimum expr.
Contoh
```
os> source=accounts | eventstats min(age);
fetched rows / total rows = 4/4
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+-----------+
| account_number | balance | firstname | lastname | age | gender | address | employer | email | city | state | min(age) |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+-----------+
| 1 | 39225 | Jane | Doe | 32 | M | 880 Any Lane | AnyCorp | janedoe@anycorp.com | Brogan | IL | 28 |
| 6 | 5686 | Mary | Major | 36 | M | 671 Example Street | Any Company | marymajor@anycompany.com | Dante | TN | 28 |
| 13 | 32838 | Nikki | Wolf | 28 | F | *** Any Street | AnyOrg | | Nogal | VA | 28 |
| 18 | 4180 | Juan | Li | 33 | M | *** Example Court | | juanli@exampleorg.com | Orick | MD | 28 |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+-----------+
```
**STDDEV\_SAMP**
`STDDEV_SAMP(expr)`Kembalikan standar deviasi sampel expr.
Contoh
```
os> source=accounts | eventstats stddev_samp(age);
fetched rows / total rows = 4/4
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+------------------------+
| account_number | balance | firstname | lastname | age | gender | address | employer | email | city | state | stddev_samp(age) |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+------------------------+
| 1 | 39225 | Jane | Doe | 32 | M | *** Any Lane | AnyCorp | janedoe@anycorp.com | Brogan | IL | 3.304037933599835 |
| 6 | 5686 | Mary | Major | 36 | M | 671 Example Street | Any Company | marymajor@anycompany.com | Dante | TN | 3.304037933599835 |
| 13 | 32838 | Nikki | Wolf | 28 | F | 789 Any Street | AnyOrg | | Nogal | VA | 3.304037933599835 |
| 18 | 4180 | Juan | Li | 33 | M | 467 Example Court | | juanli@exampleorg.com | Orick | MD | 3.304037933599835 |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+------------------------+
```
**STDDEV\_POP**
`STDDEV_POP(expr)`Kembalikan standar deviasi populasi expr.
Contoh
```
os> source=accounts | eventstats stddev_pop(age);
fetched rows / total rows = 4/4
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+------------------------+
| account_number | balance | firstname | lastname | age | gender | address | employer | email | city | state | stddev_pop(age) |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+------------------------+
| 1 | 39225 | Jane | Doe | 32 | M | 880 Any Lane | AnyCorp | janedoe@anycorp.com | Brogan | IL | 2.**************** |
| 6 | 5686 | Mary | Major | 36 | M | *** Example Street | Any Company | marymajor@anycompany.com | Dante | TN | 2.**************** |
| 13 | 32838 | Nikki | Wolf | 28 | F | *** Any Street | AnyOrg | | Nogal | VA | 2.**************** |
| 18 | 4180 | Juan | Li | 33 | M | *** Example Court | | juanli@exampleorg.com | Orick | MD | 2.**************** |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+------------------------+
```
**PERSENTIL atau PERCENTILE\_APPROX**
`PERCENTILE(expr, percent)`atau `PERCENTILE_APPROX(expr, percent)` Kembalikan nilai persentil perkiraan expr pada persentase yang ditentukan.
**persen**
+ Angka harus konstanta antara 0 dan 100.
Contoh
```
os> source=accounts | eventstats percentile(age, 90) by gender;
fetched rows / total rows = 4/4
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+--------------------------------+
| account_number | balance | firstname | lastname | age | gender | address | employer | email | city | state | percentile(age, 90) by gender |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+--------------------------------+
| 1 | 39225 | Jane | Doe | 32 | M | *** Any Lane | AnyCorp | janedoe@anycorp.com | Brogan | IL | 36 |
| 6 | 5686 | Mary | Major | 36 | M | 671 Example Street | Any Company | marymajor@anycompany.com | Dante | TN | 36 |
| 13 | 32838 | Nikki | Wolf | 28 | F | 789 Any Street | AnyOrg | | Nogal | VA | 28 |
| 18 | 4180 | Juan | Li | 33 | M | *** Example Court | | juanli@exampleorg.com | Orick | MD | 36 |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+--------------------------------+
```
**Contoh 1: Hitung rata-rata, jumlah, dan hitungan bidang berdasarkan grup**
Contoh menunjukkan menghitung usia rata-rata, jumlah usia dan jumlah peristiwa dari semua grup akun berdasarkan jenis kelamin.
```
os> source=accounts | eventstats avg(age) as avg_age, sum(age) as sum_age, count() as count by gender;
fetched rows / total rows = 4/4
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+-----------+-----------+-------+
| account_number | balance | firstname | lastname | age | gender | address | employer | email | city | state | avg_age | sum_age | count |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+-----------+-----------+-------+
| 1 | 39225 | Jane | Doe | 32 | M | *** Any Lane | AnyCorp | janedoe@anycorp.com | Brogan | IL | 33.666667 | 101 | 3 |
| 6 | 5686 | Mary | Major | 36 | M | 671 Example Street | Any Company | marymajor@anycompany.com | Dante | TN | 33.666667 | 101 | 3 |
| 13 | 32838 | Nikki | Wolf | 28 | F | 789 Any Street | AnyOrg | | Nogal | VA | 28.000000 | 28 | 1 |
| 18 | 4180 | Juan | Li | 33 | M | *** Example Court | | juanli@exampleorg.com | Orick | MD | 33.666667 | 101 | 3 |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+-----------+-----------+-------+
```
**Contoh 2: Hitung hitungan dengan rentang**
Contohnya mendapat hitungan usia dengan interval 10 tahun.
```
os> source=accounts | eventstats count(age) by span(age, 10) as age_span
fetched rows / total rows = 4/4
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+----------+
| account_number | balance | firstname | lastname | age | gender | address | employer | email | city | state | age_span |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+----------+
| 1 | 39225 | Jane | Doe | 32 | M | *** Any Lane | AnyCorp | janedoe@anycorp.com | Brogan | IL | 3 |
| 6 | 5686 | Mary | Major | 36 | M | 671 Example Street | Any Company | marymajor@anycompany.com | Dante | TN | 3 |
| 13 | 32838 | Nikki | Wolf | 28 | F | 789 Any Street | AnyOrg | | Nogal | VA | 1 |
| 18 | 4180 | Juan | Li | 33 | M | *** Example Court | | juanli@exampleorg.com | Orick | MD | 3 |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+----------+
```
**Contoh 3: Hitung hitungan berdasarkan jenis kelamin dan rentang**
Contohnya mendapatkan hitungan usia dengan interval 5 tahun dan kelompok berdasarkan jenis kelamin.
```
os> source=accounts | eventstats count() as cnt by span(age, 5) as age_span, gender
fetched rows / total rows = 4/4
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+---------------------------+--------+-------+-----+
| account_number | balance | firstname | lastname | age | gender | address | employer | email | city | state | cnt |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+---------------------------+--------+-------+-----+
| 1 | 39225 | Jane | Doe | 32 | M | *** Any Lane | AnyCorp | janedoe@anycorp.com | Brogan | IL | 2 |
| 6 | 5686 | Mary | Majo | 36 | M | 671 Example Street | Any Company | hattiebond@anycompany.com | Dante | TN | 1 |
| 13 | 32838 | Nikki | Wolf | 28 | F | *** Any Street | AnyOrg | | Nogal | VA | 1 |
| 18 | 4180 | Juan | Li | 33 | M | *** Example Court | | juanli@exampleorg.com | Orick | MD | 2 |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+---------------------------+--------+-------+-----+
```
**Penggunaan**
+ `source = table | eventstats avg(a)`
+ `source = table | where a < 50 | eventstats avg(c)`
+ `source = table | eventstats max(c) by b`
+ `source = table | eventstats count(c) by b | head 5`
+ `source = table | eventstats distinct_count(c)`
+ `source = table | eventstats stddev_samp(c)`
+ `source = table | eventstats stddev_pop(c)`
+ `source = table | eventstats percentile(c, 90)`
+ `source = table | eventstats percentile_approx(c, 99)`
**Agregasi dengan rentang**
+ `source = table | eventstats count(a) by span(a, 10) as a_span`
+ `source = table | eventstats sum(age) by span(age, 5) as age_span | head 2`
+ `source = table | eventstats avg(age) by span(age, 20) as age_span, country | sort - age_span | head 2`
**Agregasi dengan rentang jendela waktu (fungsi jendela jatuh)**
+ `source = table | eventstats sum(productsAmount) by span(transactionDate, 1d) as age_date | sort age_date`
+ `source = table | eventstats sum(productsAmount) by span(transactionDate, 1w) as age_date, productId`
**Kelompok agregasi berdasarkan berbagai tingkatan**
+ `source = table | eventstats avg(age) as avg_state_age by country, state | eventstats avg(avg_state_age) as avg_country_age by country`
+ `source = table | eventstats avg(age) as avg_city_age by country, state, city | eval new_avg_city_age = avg_city_age - 1 | eventstats avg(new_avg_city_age) as avg_state_age by country, state | where avg_state_age > 18 | eventstats avg(avg_state_age) as avg_adult_country_age by country`
#### memperluas perintah
**catatan**
Untuk melihat integrasi sumber AWS data mana yang mendukung perintah PPL ini, lihat. [Commands](#supported-ppl-commands)
Gunakan `expand` perintah untuk meratakan bidang tipe:
+ `Array`
+ `Map`
**Sintaksis**
Gunakan sintaks berikut:
```
expand [As alias]
```
**bidang**
+ Bidang yang akan diperluas (meledak). Harus dari tipe yang didukung.
**alias**
+ Tidak wajib. Nama yang akan digunakan sebagai pengganti nama bidang asli.
**Penggunaan**
`expand`Perintah menghasilkan baris untuk setiap elemen dalam bidang array atau peta tertentu, di mana:
+ Elemen array menjadi baris individual.
+ Pasangan nilai kunci peta dipecah menjadi baris terpisah, dengan masing-masing nilai kunci direpresentasikan sebagai baris.
+ Ketika alias disediakan, nilai yang meledak diwakili di bawah alias, bukan nama bidang asli.
+ Ini dapat digunakan dalam kombinasi dengan perintah lain, seperti, `stats``eval`, dan `parse` untuk memanipulasi atau mengekstrak data pasca-ekspansi.
**Contoh**
+ `source = table | expand employee | stats max(salary) as max by state, company`
+ `source = table | expand employee as worker | stats max(salary) as max by state, company`
+ `source = table | expand employee as worker | eval bonus = salary * 3 | fields worker, bonus`
+ `source = table | expand employee | parse description '(?.+@.+)' | fields employee, email`
+ `source = table | eval array=json_array(1, 2, 3) | expand array as uid | fields name, occupation, uid`
+ `source = table | expand multi_valueA as multiA | expand multi_valueB as multiB`
#### jelaskan perintah
**catatan**
Untuk melihat integrasi sumber AWS data mana yang mendukung perintah PPL ini, lihat. [Commands](#supported-ppl-commands)
`explain`Perintah ini membantu Anda memahami rencana eksekusi kueri, memungkinkan Anda menganalisis dan mengoptimalkan kueri untuk kinerja yang lebih baik. Pendahuluan ini memberikan gambaran singkat tentang tujuan perintah jelaskan dan pentingnya dalam optimasi kueri.
**Komentar**
+ `source=accounts | top gender // finds most common gender of all the accounts`(komentar baris)
+ `source=accounts | dedup 2 gender /* dedup the document with gender field keep 2 duplication */ | fields account_number, gender`(blok komentar)
**Jelaskan**
+ `describe table`Perintah ini sama dengan perintah `DESCRIBE EXTENDED table` SQL
+ `describe schema.table`
+ `describe schema.`table``
+ `describe catalog.schema.table`
+ `describe catalog.schema.`table``
+ `describe `catalog`.`schema`.`table``
**Jelaskan**
+ `explain simple | source = table | where a = 1 | fields a,b,c`
+ `explain extended | source = table`
+ `explain codegen | source = table | dedup a | fields a,b,c`
+ `explain cost | source = table | sort a | fields a,b,c`
+ `explain formatted | source = table | fields - a`
+ `explain simple | describe table`
**Bidang**
+ `source = table`
+ `source = table | fields a,b,c`
+ `source = table | fields + a,b,c`
+ `source = table | fields - b,c`
+ `source = table | eval b1 = b | fields - b1,c`
**Ringkasan lapangan**
+ `source = t | fieldsummary includefields=status_code nulls=false`
+ `source = t | fieldsummary includefields= id, status_code, request_path nulls=true`
+ `source = t | where status_code != 200 | fieldsummary includefields= status_code nulls=true`
**Bidang bersarang**
+ `source = catalog.schema.table1, catalog.schema.table2 | fields A.nested1, B.nested1`
+ `source = catalog.table | where struct_col2.field1.subfield > 'valueA' | sort int_col | fields int_col, struct_col.field1.subfield, struct_col2.field1.subfield`
+ `source = catalog.schema.table | where struct_col2.field1.subfield > 'valueA' | sort int_col | fields int_col, struct_col.field1.subfield, struct_col2.field1.subfield`
**Penyaring**
+ `source = table | where a = 1 | fields a,b,c`
+ `source = table | where a >= 1 | fields a,b,c`
+ `source = table | where a < 1 | fields a,b,c`
+ `source = table | where b != 'test' | fields a,b,c`
+ `source = table | where c = 'test' | fields a,b,c | head 3`
+ `source = table | where ispresent(b)`
+ `source = table | where isnull(coalesce(a, b)) | fields a,b,c | head 3`
+ `source = table | where isempty(a)`
+ `source = table | where isblank(a)`
+ `source = table | where case(length(a) > 6, 'True' else 'False') = 'True'`
+ `source = table | where a not in (1, 2, 3) | fields a,b,c`
+ `source = table | where a between 1 and 4`- Catatan: Ini mengembalikan >= 1 dan <= 4, yaitu [1, 4]
+ `source = table | where b not between '2024-09-10' and '2025-09-10'`- Catatan: Ini mengembalikan b >= '\*\*\*\*\*\*\*\*\*\*' dan b <= '2025-09-10'
+ `source = table | where cidrmatch(ip, '***********/24')`
+ `source = table | where cidrmatch(ipv6, '2003:db8::/32')`
+ `source = table | trendline sma(2, temperature) as temp_trend`
**Kueri terkait IP**
+ `source = table | where cidrmatch(ip, '**************')`
+ `source = table | where isV6 = false and isValid = true and cidrmatch(ipAddress, '**************')`
+ `source = table | where isV6 = true | eval inRange = case(cidrmatch(ipAddress, '2003:***::/32'), 'in' else 'out') | fields ip, inRange`
**Filter kompleks**
```
source = table | eval status_category =
case(a >= 200 AND a < 300, 'Success',
a >= 300 AND a < 400, 'Redirection',
a >= 400 AND a < 500, 'Client Error',
a >= 500, 'Server Error'
else 'Incorrect HTTP status code')
| where case(a >= 200 AND a < 300, 'Success',
a >= 300 AND a < 400, 'Redirection',
a >= 400 AND a < 500, 'Client Error',
a >= 500, 'Server Error'
else 'Incorrect HTTP status code'
) = 'Incorrect HTTP status code'
```
```
source = table
| eval factor = case(a > 15, a - 14, isnull(b), a - 7, a < 3, a + 1 else 1)
| where case(factor = 2, 'even', factor = 4, 'even', factor = 6, 'even', factor = 8, 'even' else 'odd') = 'even'
| stats count() by factor
```
**Filter dengan kondisi logis**
+ `source = table | where c = 'test' AND a = 1 | fields a,b,c`
+ `source = table | where c != 'test' OR a > 1 | fields a,b,c | head 1`
+ `source = table | where c = 'test' NOT a > 1 | fields a,b,c`
**Eval**
Asumsi:`a`,`b`, `c` adalah bidang yang ada di `table`
+ `source = table | eval f = 1 | fields a,b,c,f`
+ `source = table | eval f = 1`(keluaran bidang a, b, c, f)
+ `source = table | eval n = now() | eval t = unix_timestamp(a) | fields n,t`
+ `source = table | eval f = a | where f > 1 | sort f | fields a,b,c | head 5`
+ `source = table | eval f = a * 2 | eval h = f * 2 | fields a,f,h`
+ `source = table | eval f = a * 2, h = f * 2 | fields a,f,h`
+ `source = table | eval f = a * 2, h = b | stats avg(f) by h`
+ `source = table | eval f = ispresent(a)`
+ `source = table | eval r = coalesce(a, b, c) | fields r`
+ `source = table | eval e = isempty(a) | fields e`
+ `source = table | eval e = isblank(a) | fields e`
+ `source = table | eval f = case(a = 0, 'zero', a = 1, 'one', a = 2, 'two', a = 3, 'three', a = 4, 'four', a = 5, 'five', a = 6, 'six', a = 7, 'se7en', a = 8, 'eight', a = 9, 'nine')`
+ `source = table | eval f = case(a = 0, 'zero', a = 1, 'one' else 'unknown')`
+ `source = table | eval f = case(a = 0, 'zero', a = 1, 'one' else concat(a, ' is an incorrect binary digit'))`
+ `source = table | eval digest = md5(fieldName) | fields digest`
+ `source = table | eval digest = sha1(fieldName) | fields digest`
+ `source = table | eval digest = sha2(fieldName,256) | fields digest`
+ `source = table | eval digest = sha2(fieldName,512) | fields digest`
#### perintah fillnull
**catatan**
Untuk melihat integrasi sumber AWS data mana yang mendukung perintah PPL ini, lihat. [Commands](#supported-ppl-commands)
**Deskripsi**
Gunakan `fillnull` perintah untuk mengganti nilai null dengan nilai tertentu dalam satu atau beberapa bidang hasil pencarian Anda.
**Sintaksis**
Gunakan sintaks berikut:
```
fillnull [with in ["," ]] | [using = ["," = ]]
```
+ null-replacement: Wajib. Nilai yang digunakan untuk mengganti nilai null.
+ nullable-field: Wajib. Referensi lapangan. Nilai null di bidang ini akan diganti dengan nilai yang ditentukan dalam null-replacement.
**Contoh 1: Fillnull satu bidang**
Contoh menunjukkan cara menggunakan fillnull pada satu bidang:
```
os> source=logs | fields status_code | eval input=status_code | fillnull with 0 in status_code;
| input | status_code |
|-------|-------------|
| 403 | 403 |
| 403 | 403 |
| NULL | 0 |
| NULL | 0 |
| 200 | 200 |
| 404 | 404 |
| 500 | 500 |
| NULL | 0 |
| 500 | 500 |
| 404 | 404 |
| 200 | 200 |
| 500 | 500 |
| NULL | 0 |
| NULL | 0 |
| 404 | 404 |
```
**Contoh 2: Fillnull diterapkan ke beberapa bidang**
Contoh menunjukkan fillnull diterapkan ke beberapa bidang.
```
os> source=logs | fields request_path, timestamp | eval input_request_path=request_path, input_timestamp = timestamp | fillnull with '???' in request_path, timestamp;
| input_request_path | input_timestamp | request_path | timestamp |
|------------------------------------------------------------------------------------|
| /contact | NULL | /contact | ??? |
| /home | NULL | /home | ??? |
| /about | 2023-10-01 10:30:00 | /about | 2023-10-01 10:30:00 |
| /home | 2023-10-01 10:15:00 | /home | 2023-10-01 10:15:00 |
| NULL | 2023-10-01 10:20:00 | ??? | 2023-10-01 10:20:00 |
| NULL | 2023-10-01 11:05:00 | ??? | 2023-10-01 11:05:00 |
| /about | NULL | /about | ??? |
| /home | 2023-10-01 10:00:00 | /home | 2023-10-01 10:00:00 |
| /contact | NULL | /contact | ??? |
| NULL | 2023-10-01 10:05:00 | ??? | 2023-10-01 10:05:00 |
| NULL | 2023-10-01 10:50:00 | ??? | 2023-10-01 10:50:00 |
| /services | NULL | /services | ??? |
| /home | 2023-10-01 10:45:00 | /home | 2023-10-01 10:45:00 |
| /services | 2023-10-01 11:00:00 | /services | 2023-10-01 11:00:00 |
| NULL | 2023-10-01 10:35:00 | ??? | 2023-10-01 10:35:00 |
```
**Contoh 3: Fillnull diterapkan ke beberapa bidang dengan berbagai nilai penggantian null.**
Contoh menunjukkan fillnull dengan berbagai nilai yang digunakan untuk menggantikan nol.
+ `/error`di `request_path` lapangan
+ `1970-01-01 00:00:00`di `timestamp` lapangan
```
os> source=logs | fields request_path, timestamp | eval input_request_path=request_path, input_timestamp = timestamp | fillnull using request_path = '/error', timestamp='1970-01-01 00:00:00';
| input_request_path | input_timestamp | request_path | timestamp |
|------------------------------------------------------------------------------------|
| /contact | NULL | /contact | 1970-01-01 00:00:00 |
| /home | NULL | /home | 1970-01-01 00:00:00 |
| /about | 2023-10-01 10:30:00 | /about | 2023-10-01 10:30:00 |
| /home | 2023-10-01 10:15:00 | /home | 2023-10-01 10:15:00 |
| NULL | 2023-10-01 10:20:00 | /error | 2023-10-01 10:20:00 |
| NULL | 2023-10-01 11:05:00 | /error | 2023-10-01 11:05:00 |
| /about | NULL | /about | 1970-01-01 00:00:00 |
| /home | 2023-10-01 10:00:00 | /home | 2023-10-01 10:00:00 |
| /contact | NULL | /contact | 1970-01-01 00:00:00 |
| NULL | 2023-10-01 10:05:00 | /error | 2023-10-01 10:05:00 |
| NULL | 2023-10-01 10:50:00 | /error | 2023-10-01 10:50:00 |
| /services | NULL | /services | 1970-01-01 00:00:00 |
| /home | 2023-10-01 10:45:00 | /home | 2023-10-01 10:45:00 |
| /services | 2023-10-01 11:00:00 | /services | 2023-10-01 11:00:00 |
| NULL | 2023-10-01 10:35:00 | /error | 2023-10-01 10:35:00 |
```
#### bidang perintah
**catatan**
Untuk melihat integrasi sumber AWS data mana yang mendukung perintah PPL ini, lihat. [Commands](#supported-ppl-commands)
Gunakan `fields` perintah untuk menyimpan atau menghapus bidang dari hasil pencarian.
**Sintaksis**
Gunakan sintaks berikut:
```
field [+|-]
```
+ `index`: Opsional.
Jika plus (\+) digunakan, hanya bidang yang ditentukan dalam daftar bidang yang akan disimpan.
Jika minus (-) digunakan, semua bidang yang ditentukan dalam daftar bidang akan dihapus.
*Default*: \+
+ `field list`: Wajib. Daftar bidang yang dibatasi koma untuk disimpan atau dihapus.
**Contoh 1: Pilih bidang tertentu dari hasil**
Contoh ini menunjukkan cara mengambil`account_number`,`firstname`, dan `lastname` bidang dari hasil pencarian.
Kueri PPL:
```
os> source=accounts | fields account_number, firstname, lastname;
fetched rows / total rows = 4/4
+------------------+-------------+------------+
| account_number | firstname | lastname |
|------------------+-------------+------------|
| 1 | Jane | Doe |
| 6 | John | Doe |
| 13 | Jorge | Souza |
| 18 | Juan | Li |
+------------------+-------------+------------+
```
**Contoh 2: Hapus bidang tertentu dari hasil**
Contoh ini menunjukkan cara menghapus `account_number` bidang dari hasil pencarian.
Kueri PPL:
```
os> source=accounts | fields account_number, firstname, lastname | fields - account_number ;
fetched rows / total rows = 4/4
+-------------+------------+
| firstname | lastname |
|-------------+------------|
| Jane | Doe |
| John | Doe |
| Jorge | Souza |
| Juan | Li |
+-------------+------------+
```
**Contoh tambahan**
+ `source = table`
+ `source = table | fields a,b,c`
+ `source = table | fields + a,b,c`
+ `source = table | fields - b,c`
+ `source = table | eval b1 = b | fields - b1,c`
Contoh bidang bersarang:
```
`source = catalog.schema.table1, catalog.schema.table2 | fields A.nested1, B.nested1`
`source = catalog.table | where struct_col2.field1.subfield > 'valueA' | sort int_col | fields int_col, struct_col.field1.subfield, struct_col2.field1.subfield`
`source = catalog.schema.table | where struct_col2.field1.subfield > 'valueA' | sort int_col | fields int_col, struct_col.field1.subfield, struct_col2.field1.subfield`
```
#### meratakan perintah
**catatan**
Untuk melihat integrasi sumber AWS data mana yang mendukung perintah PPL ini, lihat. [Commands](#supported-ppl-commands)
Gunakan perintah flatten untuk memperluas bidang dari jenis berikut:
+ `struct`
+ `array>`
**Sintaksis**
Gunakan sintaks berikut:
```
flatten
```
+ *bidang*: Bidang yang akan diratakan. Bidang harus dari tipe yang didukung.
**Skema**
| col\_name | data\_type |
| --- | --- |
| \_waktu | string |
| menjembatani | array |
| kota | string |
| coor | struct |
| negeri | string |
**Data**
| \_waktu | menjembatani | kota | coor | negeri |
| --- | --- | --- | --- | --- |
| 2024-09-13T 12:00:00 | [{801, Jembatan Menara}, {928, Jembatan London}] | London | {35, 51.5074, -0.1278} | Inggris |
| 2024-09-13T 12:00:00 | [{232, Pont Neuf}, {160, Pont Alexandre III}] | Paris | {35, 48.8566, 2.3522} | France |
| 2024-09-13T 12:00:00 | [{48, Jembatan Rialto}, {11, Jembatan Sighs}] | Venesia | {2, 45.4408, 12.3155} | Italy |
| 2024-09-13T 12:00:00 | [{\*\*\*, Jembatan Charles}, {343, Jembatan Legiun}] | Praha | {200, 50,0755, 14.4378} | Czech Republic |
| 2024-09-13T 12:00:00 | [{375, Jembatan Rantai}, {333, Jembatan Liberty}] | Budapest | {96, 47.4979, 19.0402} | Hungary |
| 1990-09-13T 12:00:00 | NULL | Warsawa | NULL | Poland |
**Contoh 1: meratakan struct**
Contoh ini menunjukkan cara meratakan bidang struct.
Kueri PPL:
```
source=table | flatten coor
```
| \_waktu | menjembatani | kota | negeri | alt | lat | long |
| --- | --- | --- | --- | --- | --- | --- |
| 2024-09-13T 12:00:00 | [{801, Jembatan Menara}, {928, Jembatan London}] | London | Inggris | 35 | 51.5074 | -0,1278 |
| 2024-09-13T 12:00:00 | [{232, Pont Neuf}, {160, Pont Alexandre III}] | Paris | France | 35 | 48.8566 | 2.3522 |
| 2024-09-13T 12:00:00 | [{48, Jembatan Rialto}, {11, Jembatan Sighs}] | Venesia | Italy | 2 | 45.4408 | 12.3155 |
| 2024-09-13T 12:00:00 | [{516, Jembatan Charles}, {343, Jembatan Legiun}] | Praha | Czech Republic | 200 | 50.0755 | 14.4378 |
| 2024-09-13T 12:00:00 | [{375, Jembatan Rantai}, {333, Jembatan Liberty}] | Budapest | Hungary | 96 | 47.4979 | 19.0402 |
| 1990-09-13T 12:00:00 | NULL | Warsawa | Poland | NULL | NULL | NULL |
**Contoh 2: ratakan array**
Contoh menunjukkan bagaimana untuk meratakan array bidang struct.
Kueri PPL:
```
source=table | flatten bridges
```
| \_waktu | kota | coor | negeri | length | name |
| --- | --- | --- | --- | --- | --- |
| 2024-09-13T 12:00:00 | London | {35, 51.5074, -0.1278} | Inggris | 801 | Jembatan Menara |
| 2024-09-13T 12:00:00 | London | {35, 51.5074, -0.1278} | Inggris | 928 | Jembatan London |
| 2024-09-13T 12:00:00 | Paris | {35, 48.8566, 2.3522} | France | 232 | Pont Neuf |
| 2024-09-13T 12:00:00 | Paris | {35, 48.8566, 2.3522} | France | 160 | Pont Alexandre III |
| 2024-09-13T 12:00:00 | Venesia | {2, 45.4408, 12.3155} | Italy | 48 | Jembatan Rialto |
| 2024-09-13T 12:00:00 | Venesia | {2, 45.4408, 12.3155} | Italy | 11 | Jembatan Sighs |
| 2024-09-13T 12:00:00 | Praha | {200, 50,0755, 14.4378} | Czech Republic | 516 | Jembatan Charles |
| 2024-09-13T 12:00:00 | Praha | {200, 50,0755, 14.4378} | Czech Republic | 343 | Jembatan Legiun |
| 2024-09-13T 12:00:00 | Budapest | {96, 47.4979, 19.0402} | Hungary | 375 | Jembatan Rantai |
| 2024-09-13T 12:00:00 | Budapest | {96, 47.4979, 19.0402} | Hungary | 333 | Jembatan Liberty |
| 1990-09-13T 12:00:00 | Warsawa | NULL | Poland | NULL | NULL |
**Contoh 3: ratakan array dan struct**
Contoh ini menunjukkan cara meratakan beberapa bidang.
Kueri PPL:
```
source=table | flatten bridges | flatten coor
```
| \_waktu | kota | negeri | length | name | alt | lat | long |
| --- | --- | --- | --- | --- | --- | --- | --- |
| 2024-09-13T 12:00:00 | London | Inggris | 801 | Jembatan Menara | 35 | 51.5074 | -0,1278 |
| 2024-09-13T 12:00:00 | London | Inggris | 928 | Jembatan London | 35 | 51.5074 | -0,1278 |
| 2024-09-13T 12:00:00 | Paris | France | 232 | Pont Neuf | 35 | 48.8566 | 2.3522 |
| 2024-09-13T 12:00:00 | Paris | France | 160 | Pont Alexandre III | 35 | 48.8566 | 2.3522 |
| 2024-09-13T 12:00:00 | Venesia | Italy | 48 | Jembatan Rialto | 2 | 45.4408 | 12.3155 |
| 2024-09-13T 12:00:00 | Venesia | Italy | 11 | Jembatan Sighs | 2 | 45.4408 | 12.3155 |
| 2024-09-13T 12:00:00 | Praha | Czech Republic | 516 | Jembatan Charles | 200 | 50.0755 | 14.4378 |
| 2024-09-13T 12:00:00 | Praha | Czech Republic | 343 | Jembatan Legiun | 200 | 50.0755 | 14.4378 |
| 2024-09-13T 12:00:00 | Budapest | Hungary | 375 | Jembatan Rantai | 96 | 47.4979 | 19.0402 |
| 2024-09-13T 12:00:00 | Budapest | Hungary | 333 | Jembatan Liberty | 96 | 47.4979 | 19.0402 |
| 1990-09-13T 12:00:00 | Warsawa | Poland | NULL | NULL | NULL | NULL | NULL |
#### perintah grok
**catatan**
Untuk melihat integrasi sumber AWS data mana yang mendukung perintah PPL ini, lihat. [Commands](#supported-ppl-commands)
`grok`Perintah mem-parsing bidang teks dengan pola grok dan menambahkan hasil ke hasil pencarian.
**Sintaksis**
Gunakan sintaks berikut:
```
grok
```
**bidang**
+ Wajib.
+ Bidang harus berupa bidang teks.
**pola**
+ Wajib.
+ Pola grok digunakan untuk mengekstrak bidang baru dari bidang teks yang diberikan.
+ Jika nama bidang baru sudah ada, itu akan menggantikan bidang asli.
**Pola Grok**
Pola grok digunakan untuk mencocokkan bidang teks dari setiap dokumen untuk mengekstrak bidang baru.
**Contoh 1: Buat bidang baru**
Contoh ini menunjukkan cara membuat bidang baru `host` untuk setiap dokumen. `host`akan menjadi nama host setelah `@` di `email` lapangan. Mengurai bidang null akan mengembalikan string kosong.
```
os> source=accounts | grok email '.+@%{HOSTNAME:host}' | fields email, host ;
fetched rows / total rows = 4/4
+-------------------------+-------------+
| email | host |
|-------------------------+-------------|
| jane_doe@example.com | example.com |
| arnav_desai@example.net | example.net |
| null | |
| juan_li@example.org | example.org |
+-------------------------+-------------+
```
**Contoh 2: Ganti bidang yang ada**
Contoh ini menunjukkan cara mengganti `address` bidang yang ada dengan nomor jalan dihapus.
```
os> source=accounts | grok address '%{NUMBER} %{GREEDYDATA:address}' | fields address ;
fetched rows / total rows = 4/4
+------------------+
| address |
|------------------|
| Example Lane |
| Any Street |
| Main Street |
| Example Court |
+------------------+
```
**Contoh 3: Menggunakan grok untuk mengurai log**
Contoh ini menunjukkan cara menggunakan grok untuk mengurai log mentah.
```
os> source=apache | grok message '%{COMMONAPACHELOG}' | fields COMMONAPACHELOG, timestamp, response, bytes ;
fetched rows / total rows = 4/4
+-----------------------------------------------------------------------------------------------------------------------------+----------------------------+------------+---------+
| COMMONAPACHELOG | timestamp | response | bytes |
|-----------------------------------------------------------------------------------------------------------------------------+----------------------------+------------+---------|
| 177.95.8.74 - upton5450 [28/Sep/2022:10:15:57 -0700] "HEAD /e-business/mindshare HTTP/1.0" 404 19927 | 28/Sep/2022:10:15:57 -0700 | 404 | 19927 |
| 127.45.152.6 - pouros8756 [28/Sep/2022:10:15:57 -0700] "GET /architectures/convergence/niches/mindshare HTTP/1.0" 100 28722 | 28/Sep/2022:10:15:57 -0700 | 100 | 28722 |
| *************** - - [28/Sep/2022:10:15:57 -0700] "PATCH /strategize/out-of-the-box HTTP/1.0" 401 27439 | 28/Sep/2022:10:15:57 -0700 | 401 | 27439 |
| ************** - - [28/Sep/2022:10:15:57 -0700] "POST /users HTTP/1.1" 301 9481 | 28/Sep/2022:10:15:57 -0700 | 301 | 9481 |
+-----------------------------------------------------------------------------------------------------------------------------+----------------------------+------------+---------+
```
**Batasan**
Perintah grok memiliki batasan yang sama dengan perintah parse.
#### perintah kepala
**catatan**
Untuk melihat integrasi sumber AWS data mana yang mendukung perintah PPL ini, lihat. [Commands](#supported-ppl-commands)
Gunakan `head` perintah untuk mengembalikan nomor N pertama dari hasil yang ditentukan setelah offset opsional dalam urutan pencarian.
**Sintaksis**
Gunakan sintaks berikut:
```
head [] [from ]
```
****
+ Bilangan bulat opsional.
+ Jumlah hasil yang akan dikembalikan.
+ Default: 10
****
+ Integer setelah opsional`from`.
+ Jumlah hasil yang harus dilewati.
+ Default: 0
**Contoh 1: Dapatkan 10 hasil pertama**
Contoh ini menunjukkan cara mengambil maksimal 10 hasil dari indeks akun.
Kueri PPL:
```
os> source=accounts | fields firstname, age | head;
fetched rows / total rows = 4/4
+-------------+-------+
| firstname | age |
|-------------+-------|
| Jane | 32 |
| John | 36 |
| Jorge | 28 |
| Juan | 33 |
+-------------+-------+
```
**Contoh 2: Dapatkan hasil N pertama**
Contoh menunjukkan hasil N pertama dari indeks akun.
Kueri PPL:
```
os> source=accounts | fields firstname, age | head 3;
fetched rows / total rows = 3/3
+-------------+-------+
| firstname | age |
|-------------+-------|
| Jane | 32 |
| John | 36 |
| Jorge | 28 |
+-------------+-------+
```
**Contoh 3: Dapatkan hasil N pertama setelah offset M**
Contoh ini menunjukkan cara mengambil hasil N pertama setelah melewatkan hasil M dari indeks akun.
Kueri PPL:
```
os> source=accounts | fields firstname, age | head 3 from 1;
fetched rows / total rows = 3/3
+-------------+-------+
| firstname | age |
|-------------+-------|
| John | 36 |
| Jorge | 28 |
| Juan | 33 |
+-------------+-------+
```
#### bergabung dengan perintah
**catatan**
Untuk melihat integrasi sumber AWS data mana yang mendukung perintah PPL ini, lihat. [Commands](#supported-ppl-commands)
Perintah join memungkinkan Anda untuk menggabungkan data dari berbagai sumber berdasarkan bidang umum, memungkinkan Anda untuk melakukan analisis kompleks dan mendapatkan wawasan yang lebih dalam dari kumpulan data terdistribusi Anda
**Skema**
Setidaknya ada dua indeks, `otel-v1-apm-span-*` (besar) dan `otel-v1-apm-service-map` (kecil).
Bidang yang relevan dari indeks:
**`otel-v1-apm-span-*`**
+ TraceID - Pengidentifikasi unik untuk jejak. Semua rentang dari jejak yang sama berbagi TraceID yang sama.
+ spanID - Pengidentifikasi unik untuk rentang dalam jejak, ditetapkan saat rentang dibuat.
+ parentSpanId - SpanID dari rentang induk rentang ini. Jika ini adalah rentang root, maka bidang ini harus kosong.
+ durationInNanos - Perbedaan nanodetik antara StartTime dan EndTime. (ini ada `latency` di UI)
+ ServiceName - Sumber daya dari mana rentang berasal.
+ TraceGroup - Nama rentang akar jejak.
**`otel-v1-apm-service-map`**
+ ServiceName - Nama layanan yang memancarkan rentang.
+ destination.domain - ServiceName dari layanan yang dipanggil oleh klien ini.
+ destination.resource - Nama rentang (API, operasi, dan sebagainya) dipanggil oleh klien ini.
+ target.domain - ServiceName dari layanan yang dipanggil oleh klien.
+ target.resource - Nama rentang (API, operasi, dan sebagainya) dipanggil oleh klien.
+ traceGroupName - Nama rentang tingkat atas yang memulai rantai permintaan.
**Persyaratan**
Support **join** untuk menghitung hal-hal berikut:
Untuk setiap layanan, gabungkan indeks rentang pada indeks peta layanan untuk menghitung metrik di bawah berbagai jenis filter.
Kueri sampel ini menghitung latensi saat difilter oleh grup pelacakan `client_cancel_order` untuk layanan. `order`
```
SELECT avg(durationInNanos)
FROM `otel-v1-apm-span-000001` t1
WHERE t1.serviceName = `order`
AND ((t1.name in
(SELECT target.resource
FROM `otel-v1-apm-service-map`
WHERE serviceName = `order`
AND traceGroupName = `client_cancel_order`)
AND t1.parentSpanId != NULL)
OR (t1.parentSpanId = NULL
AND t1.name = `client_cancel_order`))
AND t1.traceId in
(SELECT traceId
FROM `otel-v1-apm-span-000001`
WHERE serviceName = `order`)
```
**Migrasi ke PPL**
Sintaks dari perintah join
```
SEARCH source=
|
| [joinType] JOIN
[leftAlias]
ON joinCriteria
|
```
**Menulis ulang**
```
SEARCH source=otel-v1-apm-span-000001
| WHERE serviceName = 'order'
| JOIN left=t1 right=t2
ON t1.traceId = t2.traceId AND t2.serviceName = 'order'
otel-v1-apm-span-000001 -- self inner join
| EVAL s_name = t1.name -- rename to avoid ambiguous
| EVAL s_parentSpanId = t1.parentSpanId -- RENAME command would be better when it is supported
| EVAL s_durationInNanos = t1.durationInNanos
| FIELDS s_name, s_parentSpanId, s_durationInNanos -- reduce colunms in join
| LEFT JOIN left=s1 right=t3
ON s_name = t3.target.resource AND t3.serviceName = 'order' AND t3.traceGroupName = 'client_cancel_order'
otel-v1-apm-service-map
| WHERE (s_parentSpanId IS NOT NULL OR (s_parentSpanId IS NULL AND s_name = 'client_cancel_order'))
| STATS avg(s_durationInNanos) -- no need to add alias if there is no ambiguous
```
**JoinType**
+ Sintaks: `INNER | LEFT OUTER | CROSS`
+ Opsional
+ Jenis bergabung untuk tampil. Defaultnya adalah `INNER` jika tidak ditentukan.
**KiriAlias**
+ Sintaks: `left = `
+ Opsional
+ Alias subquery untuk digunakan dengan sisi gabungan kiri, untuk menghindari penamaan ambigu.
**JoinCriteria**
+ Sintaks: ``
+ Diperlukan
+ Sintaks dimulai dengan`ON`. Itu bisa berupa ekspresi perbandingan apa pun. Umumnya, kriteria bergabung terlihat seperti`.=.`.
Sebagai contoh: `l.id = r.id`. Jika kriteria gabungan berisi beberapa kondisi, Anda dapat menentukan `AND` dan `OR` operator antara setiap ekspresi perbandingan. Misalnya, `l.id = r.id AND l.email = r.email AND (r.age > 65 OR r.age < 18)`.
**Lebih banyak contoh**
Migrasi dari kueri SQL (TPC-H Q13):
```
SELECT c_count, COUNT(*) AS custdist
FROM
( SELECT c_custkey, COUNT(o_orderkey) c_count
FROM customer LEFT OUTER JOIN orders ON c_custkey = o_custkey
AND o_comment NOT LIKE '%unusual%packages%'
GROUP BY c_custkey
) AS c_orders
GROUP BY c_count
ORDER BY custdist DESC, c_count DESC;
```
Ditulis ulang oleh kueri bergabung PPL:
```
SEARCH source=customer
| FIELDS c_custkey
| LEFT OUTER JOIN
ON c_custkey = o_custkey AND o_comment NOT LIKE '%unusual%packages%'
orders
| STATS count(o_orderkey) AS c_count BY c_custkey
| STATS count() AS custdist BY c_count
| SORT - custdist, - c_count
```
Batasan: sub pencarian tidak didukung di sisi kanan gabungan.
Jika sub pencarian didukung, Anda dapat menulis ulang kueri PPL di atas sebagai berikut:
```
SEARCH source=customer
| FIELDS c_custkey
| LEFT OUTER JOIN
ON c_custkey = o_custkey
[
SEARCH source=orders
| WHERE o_comment NOT LIKE '%unusual%packages%'
| FIELDS o_orderkey, o_custkey
]
| STATS count(o_orderkey) AS c_count BY c_custkey
| STATS count() AS custdist BY c_count
| SORT - custdist, - c_count
```
#### perintah pencarian
**catatan**
Untuk melihat integrasi sumber AWS data mana yang mendukung perintah PPL ini, lihat. [Commands](#supported-ppl-commands)
Gunakan `lookup` perintah untuk memperkaya data pencarian Anda dengan menambahkan atau mengganti data dari indeks pencarian (tabel dimensi). Perintah ini memungkinkan Anda untuk memperluas bidang indeks dengan nilai dari tabel dimensi. Anda juga dapat menggunakannya untuk menambahkan atau mengganti nilai saat kondisi pencarian terpenuhi. `lookup`Perintah ini lebih cocok daripada `Join` perintah untuk memperkaya data sumber dengan dataset statis.
**Sintaksis**
Gunakan sintaks berikut:
```
SEARCH source=
|
| LOOKUP ( [AS ])...
[(REPLACE | APPEND) ( [AS ])...]
|
```
**LookuPindex**
+ Wajib.
+ Nama indeks pencarian (tabel dimensi).
**lookupMappingField**
+ Wajib.
+ Kunci pemetaan dalam indeks pencarian, analog dengan kunci gabungan dari tabel kanan. Anda dapat menentukan beberapa bidang, dipisahkan dengan koma.
**sourceMappingField**
+ Tidak wajib.
+ Default: < lookupMappingField >.
+ Kunci pemetaan dari kueri sumber, analog dengan kunci gabungan dari sisi kiri.
**InputField**
+ Tidak wajib.
+ Default: Semua bidang indeks pencarian tempat nilai yang cocok ditemukan.
+ Bidang dalam indeks pencarian di mana nilai yang cocok diterapkan ke output hasil. Anda dapat menentukan beberapa bidang, dipisahkan dengan koma.
**OutputField**
+ Tidak wajib.
+ Default: ``.
+ Bidang dalam output. Anda dapat menentukan beberapa bidang output. Jika Anda menentukan nama bidang yang ada dari kueri sumber, nilainya akan diganti atau ditambahkan dengan nilai yang cocok dari InputField. Jika Anda menentukan nama bidang baru, itu akan ditambahkan ke hasil.
**GANTI \| TAMBAHKAN**
+ Tidak wajib.
+ Default: GANTI
+ Menentukan bagaimana menangani nilai yang cocok. Jika Anda menentukan REPLACE, nilai yang cocok di bidang menimpa nilai dalam hasil. Jika Anda menentukan`APPEND`, nilai yang cocok di bidang hanya ditambahkan ke nilai yang hilang dalam hasil.
**Penggunaan**
+ LOOKUP id AS cid GANTI email SEBAGAI email
+ Cari nama GANTI email AS email
+ LOOKUP id AS cid, nama APPEND alamat, email AS email
+ ID PENCARIAN
**Contoh**
Lihat contoh berikut.
```
SEARCH source=
| WHERE orderType = 'Cancelled'
| LOOKUP account_list, mkt_id AS mkt_code REPLACE amount, account_name AS name
| STATS count(mkt_code), avg(amount) BY name
```
```
SEARCH source=
| DEDUP market_id
| EVAL category=replace(category, "-", ".")
| EVAL category=ltrim(category, "dvp.")
| LOOKUP bounce_category category AS category APPEND classification
```
```
SEARCH source=
| LOOKUP bounce_category category
```
#### perintah parse
`parse`Perintah mem-parsing bidang teks dengan ekspresi reguler dan menambahkan hasilnya ke hasil pencarian.
**catatan**
Untuk melihat integrasi sumber AWS data mana yang mendukung perintah PPL ini, lihat. [Commands](#supported-ppl-commands)
**Sintaksis**
Gunakan sintaks berikut:
```
parse
```
**`field`**
+ Wajib.
+ Bidang harus berupa bidang teks.
**`pattern`**
+ String wajib.
+ Ini adalah pola ekspresi reguler yang digunakan untuk mengekstrak bidang baru dari bidang teks yang diberikan.
+ Jika nama bidang baru sudah ada, itu akan menggantikan bidang asli.
**Ekspresi reguler**
Pola ekspresi reguler digunakan untuk mencocokkan seluruh bidang teks dari setiap dokumen dengan mesin regex Java. Setiap grup tangkap bernama dalam ekspresi akan menjadi `STRING` bidang baru.
**Contoh 1: Buat bidang baru**
Contoh menunjukkan cara membuat bidang baru `host` untuk setiap dokumen. `host`akan menjadi nama host setelah `@` di `email` lapangan. Mengurai bidang null akan mengembalikan string kosong.
Kueri PPL:
```
os> source=accounts | parse email '.+@(?.+)' | fields email, host ;
fetched rows / total rows = 4/4
+-----------------------+-------------+
| email | host |
|-----------------------+-------------|
| jane_doe@example.com | example.com |
| john_doe@example.net | example.net |
| null | |
| juan_li@example.org | example.org |
+-----------------------+-------------+
```
**Contoh 2: Ganti bidang yang ada**
Contoh menunjukkan cara mengganti `address` bidang yang ada dengan nomor jalan dihapus.
Kueri PPL:
```
os> source=accounts | parse address '\d+ (?.+)' | fields address ;
fetched rows / total rows = 4/4
+------------------+
| address |
|------------------|
| Example Lane |
| Example Street |
| Example Avenue |
| Example Court |
+------------------+
```
**Contoh 3: Filter dan urutkan berdasarkan bidang yang diuraikan**
Contoh menunjukkan cara mengurutkan nomor jalan yang lebih tinggi dari 500 di `address` lapangan.
Kueri PPL:
```
os> source=accounts | parse address '(?\d+) (?.+)' | where cast(streetNumber as int) > 500 | sort num(streetNumber) | fields streetNumber, street ;
fetched rows / total rows = 3/3
+----------------+----------------+
| streetNumber | street |
|----------------+----------------|
| *** | Example Street |
| *** | Example Avenue |
| 880 | Example Lane |
+----------------+----------------+
```
**Batasan**
Ada beberapa batasan dengan perintah parse:
+ Bidang yang ditentukan oleh parse tidak dapat diuraikan lagi.
Perintah berikut tidak akan berfungsi:
```
source=accounts | parse address '\d+ (?.+)' | parse street '\w+ (?\w+)'
```
+ Bidang yang ditentukan oleh parse tidak dapat diganti dengan perintah lain.
`where`tidak akan cocok dengan dokumen apa pun karena `street` tidak dapat diganti:
```
source=accounts | parse address '\d+ (?.+)' | eval street='1' | where street='1' ;
```
+ Bidang teks yang digunakan oleh parse tidak dapat diganti.
`street`tidak akan berhasil diurai karena `address` diganti:
```
source=accounts | parse address '\d+ (?.+)' | eval address='1' ;
```
+ Bidang yang ditentukan oleh parse tidak dapat disaring atau diurutkan setelah menggunakannya dalam perintah. `stats`
`where`dalam perintah berikut tidak akan berfungsi:
```
source=accounts | parse email '.+@(?.+)' | stats avg(age) by host | where host=pyrami.com ;
```
#### pola perintah
**catatan**
Untuk melihat integrasi sumber AWS data mana yang mendukung perintah PPL ini, lihat. [Commands](#supported-ppl-commands)
`patterns`Perintah mengekstrak pola log dari bidang teks dan menambahkan hasil ke hasil pencarian. Mengelompokkan log berdasarkan polanya memudahkan pengumpulan statistik dari volume besar data log untuk analisis dan pemecahan masalah.
**Sintaksis**
Gunakan sintaks berikut:
```
patterns [new_field=] [pattern=]
```
**new-field-name**
+ String opsional.
+ Ini adalah nama bidang baru untuk pola yang diekstraksi.
+ Nilai default-nya `patterns_field`.
+ Jika nama sudah ada, itu akan menggantikan bidang asli.
**pola**
+ String opsional.
+ Ini adalah pola regex karakter yang harus disaring dari bidang teks.
+ Jika tidak ada, pola default adalah karakter alfanumerik (). `[a-zA-Z\d]`
**bidang**
+ Wajib.
+ Bidang harus berupa bidang teks.
**Contoh 1: Buat bidang baru**
Contoh ini menunjukkan cara menggunakan ekstrak tanda baca `email` untuk setiap dokumen. Mengurai bidang null akan mengembalikan string kosong.
Kueri PPL:
```
os> source=accounts | patterns email | fields email, patterns_field ;
fetched rows / total rows = 4/4
+-----------------------+------------------+
| email | patterns_field |
|-----------------------+------------------|
| jane_doe@example.com | @. |
| john_doe@example.net | @. |
| null | |
| juan_li@example.org | @. |
+-----------------------+------------------+
```
**Contoh 2: Ekstrak pola log**
Contoh menunjukkan cara mengekstrak tanda baca dari bidang log mentah menggunakan pola default.
Kueri PPL:
```
os> source=apache | patterns message | fields message, patterns_field ;
fetched rows / total rows = 4/4
+-----------------------------------------------------------------------------------------------------------------------------+---------------------------------+
| message | patterns_field |
|-----------------------------------------------------------------------------------------------------------------------------+---------------------------------|
| 177.95.8.74 - upton5450 [28/Sep/2022:10:15:57 -0700] "HEAD /e-business/mindshare HTTP/1.0" 404 19927 | ... - [//::: -] " /-/ /." |
| ************ - pouros8756 [28/Sep/2022:10:15:57 -0700] "GET /architectures/convergence/niches/mindshare HTTP/1.0" 100 28722 | ... - [//::: -] " //// /." |
| *************** - - [28/Sep/2022:10:15:57 -0700] "PATCH /strategize/out-of-the-box HTTP/1.0" 401 27439 | ... - - [//::: -] " //--- /." |
| ************** - - [28/Sep/2022:10:15:57 -0700] "POST /users HTTP/1.1" 301 9481 | ... - - [//::: -] " / /." |
+-----------------------------------------------------------------------------------------------------------------------------+---------------------------------+
```
**Contoh 3: Ekstrak pola log dengan pola regex khusus**
Contoh menunjukkan cara mengekstrak tanda baca dari bidang log mentah menggunakan pola yang ditentukan pengguna.
Kueri PPL:
```
os> source=apache | patterns new_field='no_numbers' pattern='[0-9]' message | fields message, no_numbers ;
fetched rows / total rows = 4/4
+-----------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------+
| message | no_numbers |
|-----------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------|
| 177.95.8.74 - upton5450 [28/Sep/2022:10:15:57 -0700] "HEAD /e-business/mindshare HTTP/1.0" 404 19927 | ... - upton [/Sep/::: -] "HEAD /e-business/mindshare HTTP/." |
| 127.45.152.6 - pouros8756 [28/Sep/2022:10:15:57 -0700] "GET /architectures/convergence/niches/mindshare HTTP/1.0" 100 28722 | ... - pouros [/Sep/::: -] "GET /architectures/convergence/niches/mindshare HTTP/." |
| *************** - - [28/Sep/2022:10:15:57 -0700] "PATCH /strategize/out-of-the-box HTTP/1.0" 401 27439 | ... - - [/Sep/::: -] "PATCH /strategize/out-of-the-box HTTP/." |
| ************** - - [28/Sep/2022:10:15:57 -0700] "POST /users HTTP/1.1" 301 9481 | ... - - [/Sep/::: -] "POST /users HTTP/." |
+-----------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------+
```
**Batasan**
Perintah pattern memiliki batasan yang sama dengan perintah parse.
#### perintah langka
**catatan**
Untuk melihat integrasi sumber AWS data mana yang mendukung perintah PPL ini, lihat. [Commands](#supported-ppl-commands)
Gunakan `rare` perintah untuk menemukan tupel nilai yang paling tidak umum dari semua bidang dalam daftar bidang.
**catatan**
Maksimal 10 hasil dikembalikan untuk setiap tupel nilai yang berbeda dari bidang kelompok-menurut.
**Sintaksis**
Gunakan sintaks berikut:
```
rare [N] [by-clause] rare_approx [N] [by-clause]
```
**daftar lapangan**
+ Wajib.
+ Daftar nama bidang yang dibatasi koma.
**oleh-klausa**
+ Tidak wajib.
+ Satu atau lebih bidang untuk mengelompokkan hasil berdasarkan.
**T**
+ Jumlah hasil yang akan dikembalikan.
+ Default: 10
**jarang\_approx**
+ Perkiraan hitungan bidang langka (n) dengan menggunakan estimasi [kardinalitas dengan algoritma HyperLogLog \+\+](https://spark.apache.org/docs/latest/sql-ref-functions-builtin.html).
**Contoh 1: Temukan nilai yang paling tidak umum di bidang**
Contoh ini menemukan jenis kelamin yang paling tidak umum dari semua akun.
Kueri PPL:
```
os> source=accounts | rare gender;
os> source=accounts | rare_approx 10 gender;
os> source=accounts | rare_approx gender;
fetched rows / total rows = 2/2
+----------+
| gender |
|----------|
| F |
| M |
+----------+
```
**Contoh 2: Temukan nilai yang paling tidak umum yang diatur berdasarkan jenis kelamin**
Contoh ini menemukan usia paling tidak umum dari semua grup akun berdasarkan jenis kelamin.
Kueri PPL:
```
os> source=accounts | rare 5 age by gender;
os> source=accounts | rare_approx 5 age by gender;
fetched rows / total rows = 4/4
+----------+-------+
| gender | age |
|----------+-------|
| F | 28 |
| M | 32 |
| M | 33 |
| M | 36 |
+----------+-------+
```
#### ganti nama perintah
Gunakan `rename` perintah untuk mengubah nama satu atau lebih bidang di hasil pencarian.
**catatan**
Untuk melihat integrasi sumber AWS data mana yang mendukung perintah PPL ini, lihat. [Commands](#supported-ppl-commands)
**Sintaksis**
Gunakan sintaks berikut:
```
rename AS ["," AS ]...
```
**bidang sumber**
+ Wajib.
+ Ini adalah nama bidang yang ingin Anda ganti namanya.
**bidang target**
+ Wajib.
+ Ini adalah nama yang ingin Anda ganti namanya.
**Contoh 1: Ganti nama satu bidang**
Contoh ini menunjukkan cara mengganti nama satu bidang.
Kueri PPL:
```
os> source=accounts | rename account_number as an | fields an;
fetched rows / total rows = 4/4
+------+
| an |
|------|
| 1 |
| 6 |
| 13 |
| 18 |
+------+
```
**Contoh 2: Ganti nama beberapa bidang**
Contoh ini menunjukkan cara mengganti nama beberapa bidang.
Kueri PPL:
```
os> source=accounts | rename account_number as an, employer as emp | fields an, emp;
fetched rows / total rows = 4/4
+------+---------+
| an | emp |
|------+---------|
| 1 | Pyrami |
| 6 | Netagy |
| 13 | Quility |
| 18 | null |
+------+---------+
```
**Batasan**
+ Mengganti bidang yang ada tidak didukung:
```
source=accounts | grok address '%{NUMBER} %{GREEDYDATA:address}' | fields address
```
#### perintah pencarian
**catatan**
Untuk melihat integrasi sumber AWS data mana yang mendukung perintah PPL ini, lihat. [Commands](#supported-ppl-commands)
Gunakan `search` perintah untuk mengambil dokumen dari indeks. `search`Perintah hanya dapat digunakan sebagai perintah pertama dalam kueri PPL.
**Sintaksis**
Gunakan sintaks berikut:
```
search source=[:] [boolean-expression]
```
**pencarian**
+ Tidak wajib.
+ Cari kata kunci, yang dapat dihilangkan.
**indeks**
+ Wajib.
+ Perintah pencarian harus menentukan indeks mana yang akan ditanyakan.
+ Nama indeks dapat diawali oleh `:` untuk pencarian lintas cluster.
**ekspresi bool**
+ Tidak wajib.
+ Ekspresi apa pun yang mengevaluasi nilai boolean.
**Contoh 1: Ambil semua data**
Contoh menunjukkan mengambil semua dokumen dari indeks akun.
Kueri PPL:
```
os> source=accounts;
+------------------+-------------+----------------------+-----------+----------+--------+----------------+---------+-------+-----------------------+------------+
| account_number | firstname | address | balance | gender | city | employer | state | age | email | lastname |
|------------------+-------------+----------------------+-----------+----------+--------+----------------+---------+-------+-----------------------+------------|
| 1 | Jorge | *** Any Lane | 39225 | M | Brogan | ExampleCorp | IL | 32 | jane_doe@example.com | Souza |
| 6 | John | *** Example Street | 5686 | M | Dante | AnyCorp | TN | 36 | john_doe@example.com | Doe |
| 13 | Jane | *** Any Street | ***** | F | Nogal | ExampleCompany | VA | 28 | null | Doe |
| 18 | Juan | *** Example Court | 4180 | M | Orick | null | MD | 33 | juan_li@example.org | Li |
+------------------+-------------+----------------------+-----------+----------+--------+----------------+---------+-------+-----------------------+------------+
```
**Contoh 2: Ambil data dengan kondisi**
Contoh menunjukkan mengambil semua dokumen dari indeks akun dengan.
Kueri PPL:
```
os> SEARCH source=accounts account_number=1 or gender="F";
+------------------+-------------+--------------------+-----------+----------+--------+----------------+---------+-------+-------------------------+------------+
| account_number | firstname | address | balance | gender | city | employer | state | age | email - | lastname |
|------------------+-------------+--------------------+-----------+----------+--------+----------------+---------+-------+-------------------------+------------|
| 1 | Jorge | *** Any Lane | ***** | M | Brogan | ExampleCorp | IL | 32 | jorge_souza@example.com | Souza |
| 13 | Jane | *** Any Street | ***** | F | Nogal | ExampleCompany | VA | 28 | null | Doe |
+------------------+-------------+--------------------+-----------+----------+--------+-----------------+---------+-------+------------------------+------------+
```
#### perintah urutkan
Gunakan `sort` perintah untuk mengurutkan hasil pencarian berdasarkan bidang tertentu.
**catatan**
Untuk melihat integrasi sumber AWS data mana yang mendukung perintah PPL ini, lihat. [Commands](#supported-ppl-commands)
**Sintaksis**
Gunakan sintaks berikut:
```
sort <[+|-] sort-field>...
```
**[\+\|-]**
+ Tidak wajib.
+ Nilai tambah [\+] adalah singkatan dari urutan naik dengan NULL/MISSING nilai terlebih dahulu.
+ Minus [-] adalah singkatan dari urutan menurun dengan NULL/MISSING nilai terakhir.
+ Default: Urutan menaik dengan NULL/MISSING nilai terlebih dahulu.
**bidang sortir**
+ Wajib.
+ Bidang yang digunakan untuk menyortir.
**Contoh 1: Urutkan berdasarkan satu bidang**
Contoh menunjukkan cara mengurutkan dokumen dengan bidang usia dalam urutan menaik.
Kueri PPL:
```
os> source=accounts | sort age | fields account_number, age;
fetched rows / total rows = 4/4
+------------------+-------+
| account_number | age |
|------------------+-------|
| 13 | 28 |
| 1 | 32 |
| 18 | 33 |
| 6 | 36 |
+------------------+-------+
```
**Contoh 2: Urutkan berdasarkan satu bidang dan kembalikan semua hasil**
Contoh menunjukkan cara mengurutkan dokumen dengan bidang usia dalam urutan menaik.
Kueri PPL:
```
os> source=accounts | sort age | fields account_number, age;
fetched rows / total rows = 4/4
+------------------+-------+
| account_number | age |
|------------------+-------|
| 13 | 28 |
| 1 | 32 |
| 18 | 33 |
| 6 | 36 |
+------------------+-------+
```
**Contoh 3: Urutkan berdasarkan satu bidang dalam urutan menurun**
Contoh menunjukkan cara mengurutkan dokumen dengan bidang usia dalam urutan menurun.
Kueri PPL:
```
os> source=accounts | sort - age | fields account_number, age;
fetched rows / total rows = 4/4
+------------------+-------+
| account_number | age |
|------------------+-------|
| 6 | 36 |
| 18 | 33 |
| 1 | 32 |
| 13 | 28 |
+------------------+-------+
```
**Contoh 4: Urutkan berdasarkan beberapa bidang**
Contoh menunjukkan cara mengurutkan dokumen dengan bidang gender dalam urutan menaik dan bidang usia dalam urutan menurun.
Kueri PPL:
```
os> source=accounts | sort + gender, - age | fields account_number, gender, age;
fetched rows / total rows = 4/4
+------------------+----------+-------+
| account_number | gender | age |
|------------------+----------+-------|
| 13 | F | 28 |
| 6 | M | 36 |
| 18 | M | 33 |
| 1 | M | 32 |
+------------------+----------+-------+
```
**Contoh 5: Urutkan berdasarkan bidang termasuk nilai null**
Contoh menunjukkan cara mengurutkan bidang pemberi kerja dengan opsi default (urutan naik dan null terlebih dahulu). Hasilnya menunjukkan bahwa nilai null berada di baris pertama.
Kueri PPL:
```
os> source=accounts | sort employer | fields employer;
fetched rows / total rows = 4/4
+------------+
| employer |
|------------|
| null |
| AnyCompany |
| AnyCorp |
| AnyOrgty |
+------------+
```
#### perintah statistik
Gunakan `stats` perintah untuk menghitung agregasi dari hasil pencarian.
**catatan**
Untuk melihat integrasi sumber AWS data mana yang mendukung perintah PPL ini, lihat. [Commands](#supported-ppl-commands)
**Penanganan nilai NULL/MISSING**
**Penanganan nilai NULL/MISSING**
| Fungsi | NULL | HILANG |
| --- | --- | --- |
| COUNT | Tidak dihitung | Tidak dihitung |
| JUMLAH | Abaikan | Abaikan |
| AVG | Abaikan | Abaikan |
| MAX | Abaikan | Abaikan |
| MIN | Abaikan | Abaikan |
**Sintaksis**
Gunakan sintaks berikut:
```
stats ... [by-clause]
```
**pengumpulan**
+ Wajib.
+ Fungsi agregasi diterapkan ke bidang.
**oleh-klausa**
+ Tidak wajib.
+ Sintaks: `by [span-expression,] [field,]...`
+ Menentukan bidang dan ekspresi untuk mengelompokkan hasil agregasi. Klausa demi memungkinkan Anda mengelompokkan hasil agregasi menggunakan bidang dan ekspresi. Anda dapat menggunakan fungsi skalar, fungsi agregasi, dan bahkan ekspresi rentang untuk membagi bidang tertentu menjadi bucket dengan interval yang sama.
+ Default: Jika tidak `` ditentukan, perintah stats mengembalikan satu baris yang mewakili agregasi atas seluruh set hasil.
**span-ekspresi**
+ Opsional, paling banyak satu.
+ Sintaks: `span(field_expr, interval_expr)`
+ Satuan ekspresi interval adalah unit alami secara default. Jika bidang adalah bidang tipe tanggal dan waktu, dan intervalnya dalam date/time satuan, Anda menentukan unit dalam ekspresi interval.
+ Misalnya, membelah `age` lapangan menjadi ember 10 tahun, sepertinya. `span(age, 10)` Untuk membagi bidang stempel waktu menjadi interval per jam, gunakan. `span(timestamp, 1h)`
**Unit waktu yang tersedia**
| Satuan interval rentang |
| --- |
| milidetik (ms) |
| kedua |
| menit (m, peka huruf besar/kecil) |
| jam (h) |
| hari (d) |
| minggu (w) |
| bulan (M, peka huruf besar/kecil) |
| kuartal (q) |
| tahun (y) |
**Fungsi agregasi**
**`COUNT`**
Mengembalikan hitungan jumlah expr dalam baris diambil oleh pernyataan SELECT.
Contoh:
```
os> source=accounts | stats count();
fetched rows / total rows = 1/1
+-----------+
| count() |
|-----------|
| 4 |
+-----------+
```
**`SUM`**
Gunakan `SUM(expr)` untuk mengembalikan jumlah expr.
Contoh
```
os> source=accounts | stats sum(age) by gender;
fetched rows / total rows = 2/2
+------------+----------+
| sum(age) | gender |
|------------+----------|
| 28 | F |
| 101 | M |
+------------+----------+
```
**`AVG`**
Gunakan `AVG(expr)` untuk mengembalikan nilai rata-rata expr.
Contoh
```
os> source=accounts | stats avg(age) by gender;
fetched rows / total rows = 2/2
+--------------------+----------+
| avg(age) | gender |
|--------------------+----------|
| 28.0 | F |
| 33.666666666666664 | M |
+--------------------+----------+
```
**`MAX`**
Gunakan `MAX(expr)` untuk mengembalikan nilai maksimum expr.
Contoh
```
os> source=accounts | stats max(age);
fetched rows / total rows = 1/1
+------------+
| max(age) |
|------------|
| 36 |
+------------+
```
**`MIN`**
Gunakan `MIN(expr)` untuk mengembalikan nilai minimum expr.
Contoh
```
os> source=accounts | stats min(age);
fetched rows / total rows = 1/1
+------------+
| min(age) |
|------------|
| 28 |
+------------+
```
**`STDDEV_SAMP`**
Gunakan `STDDEV_SAMP(expr)` untuk mengembalikan standar deviasi sampel expr.
Contoh:
```
os> source=accounts | stats stddev_samp(age);
fetched rows / total rows = 1/1
+--------------------+
| stddev_samp(age) |
|--------------------|
| 3.304037933599835 |
+--------------------+
```
**STDDEV\_POP**
Gunakan `STDDEV_POP(expr)` untuk mengembalikan standar deviasi populasi expr.
Contoh:
```
os> source=accounts | stats stddev_pop(age);
fetched rows / total rows = 1/1
+--------------------+
| stddev_pop(age) |
|--------------------|
| 2.**************** |
+--------------------+
```
**MENGAMBIL**
Gunakan `TAKE(field [, size])` untuk mengembalikan nilai asli bidang. Itu tidak menjamin urutan nilai.
**bidang**
+ Wajib.
+ Bidang harus berupa bidang teks.
**ukuran**
+ Bilangan bulat opsional.
+ Jumlah nilai harus dikembalikan.
+ Defaultnya adalah 10.
**Contoh**
```
os> source=accounts | stats take(firstname);
fetched rows / total rows = 1/1
+-----------------------------+
| take(firstname) |
|-----------------------------|
| [Jane, Mary, Nikki, Juan |
+-----------------------------+
```
**PERSENTIL atau PERCENTILE\_APPROX**
Gunakan `PERCENTILE(expr, percent)` atau `PERCENTILE_APPROX(expr, percent)` untuk mengembalikan nilai persentil perkiraan expr pada persentase yang ditentukan.
**persen**
+ Angka harus konstanta antara 0 dan 100.
**Contoh**
```
os> source=accounts | stats percentile(age, 90) by gender;
fetched rows / total rows = 2/2
+-----------------------+----------+
| percentile(age, 90) | gender |
|-----------------------+----------|
| 28 | F |
| 36 | M |
+-----------------------+----------+
```
**Contoh 1: Hitung jumlah peristiwa**
Contoh menunjukkan cara menghitung jumlah peristiwa di akun.
```
os> source=accounts | stats count();
fetched rows / total rows = 1/1
+-----------+
| count() |
|-----------|
| 4 |
+-----------+
```
**Contoh 2: Hitung rata-rata bidang**
Contoh menunjukkan cara menghitung usia rata-rata untuk semua akun.
```
os> source=accounts | stats avg(age);
fetched rows / total rows = 1/1
+------------+
| avg(age) |
|------------|
| 32.25 |
+------------+
```
**Contoh 3: Hitung rata-rata bidang menurut grup**
Contoh menunjukkan cara menghitung usia rata-rata untuk semua akun, dikelompokkan berdasarkan jenis kelamin.
```
os> source=accounts | stats avg(age) by gender;
fetched rows / total rows = 2/2
+--------------------+----------+
| avg(age) | gender |
|--------------------+----------|
| 28.0 | F |
| 33.666666666666664 | M |
+--------------------+----------+
```
**Contoh 4: Hitung rata-rata, jumlah, dan hitungan bidang menurut grup**
Contoh menunjukkan cara menghitung usia rata-rata, jumlah usia, dan jumlah peristiwa untuk semua akun, dikelompokkan berdasarkan jenis kelamin.
```
os> source=accounts | stats avg(age), sum(age), count() by gender;
fetched rows / total rows = 2/2
+--------------------+------------+-----------+----------+
| avg(age) | sum(age) | count() | gender |
|--------------------+------------+-----------+----------|
| 28.0 | 28 | 1 | F |
| 33.666666666666664 | 101 | 3 | M |
+--------------------+------------+-----------+----------+
```
**Contoh 5: Hitung maksimum bidang**
Contoh menghitung usia maksimum untuk semua akun.
```
os> source=accounts | stats max(age);
fetched rows / total rows = 1/1
+------------+
| max(age) |
|------------|
| 36 |
+------------+
```
**Contoh 6: Hitung maksimum dan minimum bidang menurut grup**
Contoh menghitung nilai usia maksimum dan minimum untuk semua akun, dikelompokkan berdasarkan jenis kelamin.
```
os> source=accounts | stats max(age), min(age) by gender;
fetched rows / total rows = 2/2
+------------+------------+----------+
| max(age) | min(age) | gender |
|------------+------------+----------|
| 28 | 28 | F |
| 36 | 32 | M |
+------------+------------+----------+
```
**Contoh 7: Hitung jumlah bidang yang berbeda**
Untuk mendapatkan hitungan nilai bidang yang berbeda, Anda dapat menggunakan fungsi `DISTINCT_COUNT` (atau`DC`) sebagai gantinya`COUNT`. Contoh menghitung hitungan dan hitungan yang berbeda dari bidang gender dari semua akun.
```
os> source=accounts | stats count(gender), distinct_count(gender);
fetched rows / total rows = 1/1
+-----------------+--------------------------+
| count(gender) | distinct_count(gender) |
|-----------------+--------------------------|
| 4 | 2 |
+-----------------+--------------------------+
```
**Contoh 8: Hitung hitungan dengan rentang**
Contohnya mendapat hitungan usia dengan interval 10 tahun.
```
os> source=accounts | stats count(age) by span(age, 10) as age_span
fetched rows / total rows = 2/2
+--------------+------------+
| count(age) | age_span |
|--------------+------------|
| 1 | 20 |
| 3 | 30 |
+--------------+------------+
```
**Contoh 9: Hitung hitungan berdasarkan jenis kelamin dan rentang**
Contoh ini menghitung catatan yang dikelompokkan berdasarkan jenis kelamin dan rentang usia 5 tahun.
```
os> source=accounts | stats count() as cnt by span(age, 5) as age_span, gender
fetched rows / total rows = 3/3
+-------+------------+----------+
| cnt | age_span | gender |
|-------+------------+----------|
| 1 | 25 | F |
| 2 | 30 | M |
| 1 | 35 | M |
+-------+------------+----------+
```
Ekspresi span selalu muncul sebagai kunci pengelompokan pertama, terlepas dari urutan yang ditentukan dalam perintah.
```
os> source=accounts | stats count() as cnt by gender, span(age, 5) as age_span
fetched rows / total rows = 3/3
+-------+------------+----------+
| cnt | age_span | gender |
|-------+------------+----------|
| 1 | 25 | F |
| 2 | 30 | M |
| 1 | 35 | M |
+-------+------------+----------+
```
**Contoh 10: Hitung hitungan dan dapatkan daftar email berdasarkan jenis kelamin dan rentang**
Contoh mendapatkan hitungan usia dengan interval 10 tahun dan kelompok berdasarkan jenis kelamin, selain itu untuk setiap baris mendapatkan daftar paling banyak 5 email.
```
os> source=accounts | stats count() as cnt, take(email, 5) by span(age, 5) as age_span, gender
fetched rows / total rows = 3/3
+-------+----------------------------------------------------+------------+----------+
| cnt | take(email, 5) | age_span | gender |
|-------+----------------------------------------------------+------------+----------|
| 1 | [] | 25 | F |
| 2 | [janedoe@anycompany.com,juanli@examplecompany.org] | 30 | M |
| 1 | [marymajor@examplecorp.com] | 35 | M |
+-------+----------------------------------------------------+------------+----------+
```
**Contoh 11: Hitung persentil suatu bidang**
Contoh menunjukkan bagaimana menghitung persentil usia 90 dari semua akun.
```
os> source=accounts | stats percentile(age, 90);
fetched rows / total rows = 1/1
+-----------------------+
| percentile(age, 90) |
|-----------------------|
| 36 |
+-----------------------+
```
**Contoh 12: Hitung persentil bidang berdasarkan grup**
Contoh menunjukkan bagaimana menghitung persentil usia 90 dari semua grup akun berdasarkan jenis kelamin.
```
os> source=accounts | stats percentile(age, 90) by gender;
fetched rows / total rows = 2/2
+-----------------------+----------+
| percentile(age, 90) | gender |
|-----------------------+----------|
| 28 | F |
| 36 | M |
+-----------------------+----------+
```
**Contoh 13: Hitung persentil berdasarkan jenis kelamin dan rentang**
Contohnya mendapatkan persentil usia 90 dengan interval 10 tahun dan kelompok berdasarkan jenis kelamin.
```
os> source=accounts | stats percentile(age, 90) as p90 by span(age, 10) as age_span, gender
fetched rows / total rows = 2/2
+-------+------------+----------+
| p90 | age_span | gender |
|-------+------------+----------|
| 28 | 20 | F |
| 36 | 30 | M |
+-------+------------+----------+
```
```
- `source = table | stats avg(a) `
- `source = table | where a < 50 | stats avg(c) `
- `source = table | stats max(c) by b`
- `source = table | stats count(c) by b | head 5`
- `source = table | stats distinct_count(c)`
- `source = table | stats stddev_samp(c)`
- `source = table | stats stddev_pop(c)`
- `source = table | stats percentile(c, 90)`
- `source = table | stats percentile_approx(c, 99)`
```
**Agregasi dengan rentang**
```
- `source = table | stats count(a) by span(a, 10) as a_span`
- `source = table | stats sum(age) by span(age, 5) as age_span | head 2`
- `source = table | stats avg(age) by span(age, 20) as age_span, country | sort - age_span | head 2`
```
**Agregasi dengan rentang jendela waktu (fungsi jendela jatuh)**
```
- `source = table | stats sum(productsAmount) by span(transactionDate, 1d) as age_date | sort age_date`
- `source = table | stats sum(productsAmount) by span(transactionDate, 1w) as age_date, productId`
```
**Kelompok agregasi berdasarkan berbagai tingkatan**
```
- `source = table | stats avg(age) as avg_state_age by country, state | stats avg(avg_state_age) as avg_country_age by country`
- `source = table | stats avg(age) as avg_city_age by country, state, city | eval new_avg_city_age = avg_city_age - 1 | stats avg(new_avg_city_age) as avg_state_age by country, state | where avg_state_age > 18 | stats avg(avg_state_age) as avg_adult_country_age by country`
```
#### perintah subquery
**catatan**
Untuk melihat integrasi sumber AWS data mana yang mendukung perintah PPL ini, lihat. [Commands](#supported-ppl-commands)
Gunakan `subquery` perintah untuk melakukan kueri bersarang yang kompleks dalam pernyataan Piped Processing Language (PPL) Anda.
```
source=logs | where field in [ subquery source=events | where condition | fields field ]
```
Dalam contoh ini, pencarian utama (`source=logs`) difilter oleh hasil dari subquery (`source=events`).
Perintah subquery mendukung beberapa tingkat bersarang untuk analisis data yang kompleks.
**Contoh Subquery Bersarang**
```
source=logs | where id in [ subquery source=users | where user in [ subquery source=actions | where action="login" | fields user] | fields uid ]
```
**InSubquery Pemakaian**
+ `source = outer | where a in [ source = inner | fields b ]`
+ `source = outer | where (a) in [ source = inner | fields b ]`
+ `source = outer | where (a,b,c) in [ source = inner | fields d,e,f ]`
+ `source = outer | where a not in [ source = inner | fields b ]`
+ `source = outer | where (a) not in [ source = inner | fields b ]`
+ `source = outer | where (a,b,c) not in [ source = inner | fields d,e,f ]`
+ `source = outer a in [ source = inner | fields b ]`(pemfilteran pencarian dengan subquery)
+ `source = outer a not in [ source = inner | fields b ]`(pemfilteran pencarian dengan subquery)
+ `source = outer | where a in [ source = inner1 | where b not in [ source = inner2 | fields c ] | fields b ]`(bersarang)
+ `source = table1 | inner join left = l right = r on l.a = r.a AND r.a in [ source = inner | fields d ] | fields l.a, r.a, b, c`(sebagai filter gabungan)
**Contoh Migrasi SQL dengan PPL In-subquery**
TPC-H Q4 (dalam subquery dengan agregasi)
```
select
o_orderpriority,
count(*) as order_count
from
orders
where
o_orderdate >= date '1993-07-01'
and o_orderdate < date '1993-07-01' + interval '3' month
and o_orderkey in (
select
l_orderkey
from
lineitem
where l_commitdate < l_receiptdate
)
group by
o_orderpriority
order by
o_orderpriority
```
Ditulis ulang oleh kueri PPL InSubquery :
```
source = orders
| where o_orderdate >= "1993-07-01" and o_orderdate < "1993-10-01" and o_orderkey IN
[ source = lineitem
| where l_commitdate < l_receiptdate
| fields l_orderkey
]
| stats count(1) as order_count by o_orderpriority
| sort o_orderpriority
| fields o_orderpriority, order_count
```
TPC-H Q20 (dalam subquery bersarang)
```
select
s_name,
s_address
from
supplier,
nation
where
s_suppkey in (
select
ps_suppkey
from
partsupp
where
ps_partkey in (
select
p_partkey
from
part
where
p_name like 'forest%'
)
)
and s_nationkey = n_nationkey
and n_name = 'CANADA'
order by
s_name
```
Ditulis ulang oleh kueri PPL InSubquery :
```
source = supplier
| where s_suppkey IN [
source = partsupp
| where ps_partkey IN [
source = part
| where like(p_name, "forest%")
| fields p_partkey
]
| fields ps_suppkey
]
| inner join left=l right=r on s_nationkey = n_nationkey and n_name = 'CANADA'
nation
| sort s_name
```
**ExistsSubquery penggunaan**
Asumsi:`a`, `b` adalah bidang luar tabel,`c`, `d` adalah bidang bagian dalam tabel,`e`, `f` adalah bidang bagian dalam tabel 2.
+ `source = outer | where exists [ source = inner | where a = c ]`
+ `source = outer | where not exists [ source = inner | where a = c ]`
+ `source = outer | where exists [ source = inner | where a = c and b = d ]`
+ `source = outer | where not exists [ source = inner | where a = c and b = d ]`
+ `source = outer exists [ source = inner | where a = c ]`(pemfilteran pencarian dengan subquery)
+ `source = outer not exists [ source = inner | where a = c ]`(pemfilteran pencarian dengan subquery)
+ `source = table as t1 exists [ source = table as t2 | where t1.a = t2.a ]`(alias tabel berguna dalam subquery yang ada)
+ `source = outer | where exists [ source = inner1 | where a = c and exists [ source = inner2 | where c = e ] ]`(bersarang)
+ `source = outer | where exists [ source = inner1 | where a = c | where exists [ source = inner2 | where c = e ] ]`(bersarang)
+ `source = outer | where exists [ source = inner | where c > 10 ]`(tidak berkorelasi ada)
+ `source = outer | where not exists [ source = inner | where c > 10 ]`(tidak berkorelasi ada)
+ `source = outer | where exists [ source = inner ] | eval l = "nonEmpty" | fields l`(khusus tidak berkorelasi ada)
**ScalarSubquery penggunaan**
Asumsi:`a`, `b` adalah bidang tabel luar,`c`, `d` adalah bidang bagian dalam tabel,`e`, `f` adalah bidang tabel bersarang
**Subquery skalar yang tidak berkorelasi**
Di Pilih:
+ `source = outer | eval m = [ source = inner | stats max(c) ] | fields m, a`
+ `source = outer | eval m = [ source = inner | stats max(c) ] + b | fields m, a`
Di mana:
+ `source = outer | where a > [ source = inner | stats min(c) ] | fields a`
Di Filter Pencarian:
+ `source = outer a > [ source = inner | stats min(c) ] | fields a`
**Subquery skalar berkorelasi**
Di Pilih:
+ `source = outer | eval m = [ source = inner | where outer.b = inner.d | stats max(c) ] | fields m, a`
+ `source = outer | eval m = [ source = inner | where b = d | stats max(c) ] | fields m, a`
+ `source = outer | eval m = [ source = inner | where outer.b > inner.d | stats max(c) ] | fields m, a`
Di mana:
+ `source = outer | where a = [ source = inner | where outer.b = inner.d | stats max(c) ]`
+ `source = outer | where a = [ source = inner | where b = d | stats max(c) ]`
+ `source = outer | where [ source = inner | where outer.b = inner.d OR inner.d = 1 | stats count() ] > 0 | fields a`
Di Filter Pencarian:
+ `source = outer a = [ source = inner | where b = d | stats max(c) ]`
+ `source = outer [ source = inner | where outer.b = inner.d OR inner.d = 1 | stats count() ] > 0 | fields a`
**Subkueri skalar bersarang**
+ `source = outer | where a = [ source = inner | stats max(c) | sort c ] OR b = [ source = inner | where c = 1 | stats min(d) | sort d ]`
+ `source = outer | where a = [ source = inner | where c = [ source = nested | stats max(e) by f | sort f ] | stats max(d) by c | sort c | head 1 ]`
**(Hubungan) Subquery**
`InSubquery`, `ExistsSubquery` dan `ScalarSubquery` semua ekspresi subquery. Tapi `RelationSubquery` bukan ekspresi subquery, itu adalah rencana subquery yang umum digunakan dalam Join atau From klausa.
+ `source = table1 | join left = l right = r [ source = table2 | where d > 10 | head 5 ]`(subquery di bergabung dengan sisi kanan)
+ `source = [ source = table1 | join left = l right = r [ source = table2 | where d > 10 | head 5 ] | stats count(a) by b ] as outer | head 1`
**Konteks Tambahan**
`InSubquery`,`ExistsSubquery`, dan `ScalarSubquery` merupakan ekspresi subquery yang biasa digunakan dalam `where` klausa dan filter pencarian.
Dimana perintah:
```
| where | ...
```
Filter pencarian:
```
search source=* | ...
```
Ekspresi subquery dapat digunakan dalam ekspresi boolean:
```
| where orders.order_id in [ source=returns | where return_reason="damaged" | field order_id ]
```
`orders.order_id in [ source=... ]`Itu adalah a``.
Secara umum, kami menamai klausa subquery semacam ini sebagai `InSubquery` ekspresi. Ini adalah sebuah``.
**Subquery dengan berbagai jenis bergabung**
Contoh menggunakan`ScalarSubquery`:
```
source=employees
| join source=sales on employees.employee_id = sales.employee_id
| where sales.sale_amount > [ source=targets | where target_met="true" | fields target_value ]
```
Tidak seperti InSubquery ExistsSubquery,, dan ScalarSubquery, a RelationSubquery bukan ekspresi subquery. Sebaliknya, ini adalah rencana subquery.
```
SEARCH source=customer
| FIELDS c_custkey
| LEFT OUTER JOIN left = c, right = o ON c.c_custkey = o.o_custkey
[
SEARCH source=orders
| WHERE o_comment NOT LIKE '%unusual%packages%'
| FIELDS o_orderkey, o_custkey
]
| STATS ...
```
#### perintah atas
**catatan**
Untuk melihat integrasi sumber AWS data mana yang mendukung perintah PPL ini, lihat. [Commands](#supported-ppl-commands)
Gunakan `top` perintah untuk menemukan tupel nilai yang paling umum dari semua bidang dalam daftar bidang.
**Sintaksis**
Gunakan sintaks berikut:
```
top [N] [by-clause] top_approx [N] [by-clause]
```
**T**
+ Jumlah hasil yang akan dikembalikan.
+ Default: 10
**daftar lapangan**
+ Wajib.
+ Daftar nama bidang yang dibatasi koma.
**oleh-klausa**
+ Tidak wajib.
+ Satu atau lebih bidang untuk mengelompokkan hasil berdasarkan.
**top\_approx**
+ Perkiraan hitungan (n) bidang teratas dengan menggunakan estimasi [kardinalitas dengan algoritma HyperLogLog \+\+](https://spark.apache.org/docs/latest/sql-ref-functions-builtin.html).
**Contoh 1: Temukan nilai yang paling umum di bidang**
Contoh menemukan jenis kelamin yang paling umum untuk semua akun.
Kueri PPL:
```
os> source=accounts | top gender;
os> source=accounts | top_approx gender;
fetched rows / total rows = 2/2
+----------+
| gender |
|----------|
| M |
| F |
+----------+
```
**Contoh 2: Temukan nilai yang paling umum di bidang (terbatas pada 1)**
Contoh menemukan jenis kelamin tunggal yang paling umum untuk semua akun.
Kueri PPL:
```
os> source=accounts | top_approx 1 gender;
fetched rows / total rows = 1/1
+----------+
| gender |
|----------|
| M |
+----------+
```
**Contoh 3: Temukan nilai yang paling umum, dikelompokkan berdasarkan jenis kelamin**
Contoh menemukan usia paling umum untuk semua akun, dikelompokkan berdasarkan jenis kelamin.
Kueri PPL:
```
os> source=accounts | top 1 age by gender;
os> source=accounts | top_approx 1 age by gender;
fetched rows / total rows = 2/2
+----------+-------+
| gender | age |
|----------+-------|
| F | 28 |
| M | 32 |
+----------+-------+
```
#### perintah trendline
**catatan**
Untuk melihat integrasi sumber AWS data mana yang mendukung perintah PPL ini, lihat. [Commands](#supported-ppl-commands)
Gunakan `trendline` perintah untuk menghitung rata-rata bergerak bidang.
**Sintaksis**
Gunakan sintaks berikut
```
TRENDLINE [sort <[+|-] sort-field>] SMA(number-of-datapoints, field) [AS alias] [SMA(number-of-datapoints, field) [AS alias]]...
```
**[\+\|-]**
+ Tidak wajib.
+ Nilai tambah [\+] adalah singkatan dari urutan naik dengan NULL/MISSING nilai terlebih dahulu.
+ Minus [-] adalah singkatan dari urutan menurun dengan NULL/MISSING nilai terakhir.
+ Default: Urutan menaik dengan NULL/MISSING nilai terlebih dahulu.
**bidang sortir**
+ Wajib saat menyortir digunakan.
+ Bidang yang digunakan untuk menyortir.
**number-of-datapoints**
+ Wajib.
+ Jumlah titik data yang menghitung rata-rata bergerak.
+ Harus lebih besar dari nol.
**bidang**
+ Wajib.
+ Nama bidang rata-rata bergerak harus dihitung.
**alias**
+ Tidak wajib.
+ Nama kolom yang dihasilkan berisi moving average.
Hanya tipe Simple Moving Average (SMA) yang didukung. Itu dihitung seperti ini:
```
f[i]: The value of field 'f' in the i-th data-point
n: The number of data-points in the moving window (period)
t: The current time index
SMA(t) = (1/n) * Σ(f[i]), where i = t-n+1 to t
```
**Contoh 1: Hitung rata-rata bergerak sederhana untuk rangkaian waktu suhu**
Contoh menghitung rata-rata bergerak sederhana di atas suhu menggunakan dua titik data.
Kueri PPL:
```
os> source=t | trendline sma(2, temperature) as temp_trend;
fetched rows / total rows = 5/5
+-----------+---------+--------------------+----------+
|temperature|device-id| timestamp|temp_trend|
+-----------+---------+--------------------+----------+
| 12| 1492|2023-04-06 17:07:...| NULL|
| 12| 1492|2023-04-06 17:07:...| 12.0|
| 13| 256|2023-04-06 17:07:...| 12.5|
| 14| 257|2023-04-06 17:07:...| 13.5|
| 15| 258|2023-04-06 17:07:...| 14.5|
+-----------+---------+--------------------+----------+
```
**Contoh 2: Hitung rata-rata bergerak sederhana untuk rangkaian waktu suhu dengan penyortiran**
Contoh menghitung dua rata-rata bergerak sederhana di atas suhu menggunakan dua dan tiga titik data yang diurutkan turun berdasarkan device-id.
Kueri PPL:
```
os> source=t | trendline sort - device-id sma(2, temperature) as temp_trend_2 sma(3, temperature) as temp_trend_3;
fetched rows / total rows = 5/5
+-----------+---------+--------------------+------------+------------------+
|temperature|device-id| timestamp|temp_trend_2| temp_trend_3|
+-----------+---------+--------------------+------------+------------------+
| 15| 258|2023-04-06 17:07:...| NULL| NULL|
| 14| 257|2023-04-06 17:07:...| 14.5| NULL|
| 13| 256|2023-04-06 17:07:...| 13.5| 14.0|
| 12| 1492|2023-04-06 17:07:...| 12.5| 13.0|
| 12| 1492|2023-04-06 17:07:...| 12.0|12.333333333333334|
+-----------+---------+--------------------+------------+------------------+
```
#### Dimana perintah
**catatan**
Untuk melihat integrasi sumber AWS data mana yang mendukung perintah PPL ini, lihat. [Commands](#supported-ppl-commands)
`where`Perintah menggunakan bool-expression untuk memfilter hasil pencarian. Ini hanya mengembalikan hasil ketika bool-expression mengevaluasi ke true.
**Sintaksis**
Gunakan sintaks berikut:
```
where
```
**ekspresi bool**
+ Tidak wajib.
+ Ekspresi apa pun yang dapat dievaluasi ke nilai boolean.
**Contoh 1: Filter hasil set dengan kondisi**
Contoh menunjukkan cara mengambil dokumen dari indeks akun yang memenuhi kondisi tertentu.
Kueri PPL:
```
os> source=accounts | where account_number=1 or gender="F" | fields account_number, gender;
fetched rows / total rows = 2/2
+------------------+----------+
| account_number | gender |
|------------------+----------|
| 1 | M |
| 13 | F |
+------------------+----------+
```
**Contoh tambahan**
**Filter dengan kondisi logis**
+ `source = table | where c = 'test' AND a = 1 | fields a,b,c`
+ `source = table | where c != 'test' OR a > 1 | fields a,b,c | head 1`
+ `source = table | where c = 'test' NOT a > 1 | fields a,b,c`
+ `source = table | where a = 1 | fields a,b,c`
+ `source = table | where a >= 1 | fields a,b,c`
+ `source = table | where a < 1 | fields a,b,c`
+ `source = table | where b != 'test' | fields a,b,c`
+ `source = table | where c = 'test' | fields a,b,c | head 3`
+ `source = table | where ispresent(b)`
+ `source = table | where isnull(coalesce(a, b)) | fields a,b,c | head 3`
+ `source = table | where isempty(a)`
+ `source = table | where isblank(a)`
+ `source = table | where case(length(a) > 6, 'True' else 'False') = 'True'`
+ `source = table | where a between 1 and 4`- Catatan: Ini mengembalikan >= 1 dan <= 4, yaitu [1, 4]
+ `source = table | where b not between '2024-09-10' and '2025-09-10'`- Catatan: Ini mengembalikan b >= '\*\*\*\*\*\*\*\*\*\*' dan b <= '2025-09-10'
+ `source = table | where cidrmatch(ip, '***********/24')`
+ `source = table | where cidrmatch(ipv6, '2003:db8::/32')`
```
source = table | eval status_category =
case(a >= 200 AND a < 300, 'Success',
a >= 300 AND a < 400, 'Redirection',
a >= 400 AND a < 500, 'Client Error',
a >= 500, 'Server Error'
else 'Incorrect HTTP status code')
| where case(a >= 200 AND a < 300, 'Success',
a >= 300 AND a < 400, 'Redirection',
a >= 400 AND a < 500, 'Client Error',
a >= 500, 'Server Error'
else 'Incorrect HTTP status code'
) = 'Incorrect HTTP status code'
```
```
source = table
| eval factor = case(a > 15, a - 14, isnull(b), a - 7, a < 3, a + 1 else 1)
| where case(factor = 2, 'even', factor = 4, 'even', factor = 6, 'even', factor = 8, 'even' else 'odd') = 'even'
| stats count() by factor
```
#### ringkasan bidang
**catatan**
Untuk melihat integrasi sumber AWS data mana yang mendukung perintah PPL ini, lihat. [Commands](#supported-ppl-commands)
Gunakan `fieldsummary` perintah untuk menghitung statistik dasar untuk setiap bidang (hitungan, hitungan berbeda, min, maks, rata-rata, stddev, rata-rata) dan tentukan tipe data dari setiap bidang. Perintah ini dapat digunakan dengan pipa sebelumnya dan akan memperhitungkannya.
**Sintaksis**
Gunakan sintaksis berikut: Untuk kasus penggunaan CloudWatch Log, hanya satu bidang dalam kueri yang didukung.
```
... | fieldsummary (nulls=true/false)
```
**includefields**
+ Daftar semua kolom yang akan dikumpulkan dengan statistik ke dalam kumpulan hasil terpadu.
**Nulls**
+ Tidak wajib.
+ Jika disetel ke true, sertakan nilai null dalam perhitungan agregasi (ganti null dengan nol untuk nilai numerik).
**Contoh 1**
Kueri PPL:
```
os> source = t | where status_code != 200 | fieldsummary includefields= status_code nulls=true
+------------------+-------------+------------+------------+------------+------------+------------+------------+----------------|
| Fields | COUNT | COUNT_DISTINCT | MIN | MAX | AVG | MEAN | STDDEV | NUlls | TYPEOF |
|------------------+-------------+------------+------------+------------+------------+------------+------------+----------------|
| "status_code" | 2 | 2 | 301 | 403 | 352.0 | 352.0 | 72.12489168102785 | 0 | "int" |
+------------------+-------------+------------+------------+------------+------------+------------+------------+----------------|
```
**Contoh 2**
Kueri PPL:
```
os> source = t | fieldsummary includefields= id, status_code, request_path nulls=true
+------------------+-------------+------------+------------+------------+------------+------------+------------+----------------|
| Fields | COUNT | COUNT_DISTINCT | MIN | MAX | AVG | MEAN | STDDEV | NUlls | TYPEOF |
|------------------+-------------+------------+------------+------------+------------+------------+------------+----------------|
| "id" | 6 | 6 | 1 | 6 | 3.5 | 3.5 | 1.8708286933869707 | 0 | "int" |
+------------------+-------------+------------+------------+------------+------------+------------+------------+----------------|
| "status_code" | 4 | 3 | 200 | 403 | 184.0 | 184.0 | 161.16699413961905 | 2 | "int" |
+------------------+-------------+------------+------------+------------+------------+------------+------------+----------------|
| "request_path" | 2 | 2 | /about| /home | 0.0 | 0.0 | 0 | 2 |"string"|
+------------------+-------------+------------+------------+------------+------------+------------+------------+----------------|
```
#### memperluas perintah
**catatan**
Untuk melihat integrasi sumber AWS data mana yang mendukung fungsi PPL ini, lihat. [Fungsi](#supported-ppl-functions)
Gunakan `expand` perintah untuk meratakan bidang tipe Array atau Map, menghasilkan baris individual untuk setiap elemen atau pasangan kunci-nilai.
**Sintaksis**
Gunakan sintaks berikut:
```
expand [As alias]
```
**bidang**
+ Bidang yang akan diperluas (meledak).
+ Bidang harus dari jenis yang didukung.
**alias**
+ Tidak wajib.
+ Nama yang akan digunakan sebagai pengganti nama bidang asli.
**Pedoman penggunaan**
Perintah expand menghasilkan baris untuk setiap elemen dalam bidang array atau peta tertentu, di mana:
+ Elemen array menjadi baris individual.
+ Pasangan nilai kunci peta dipecah menjadi baris terpisah, dengan masing-masing nilai kunci direpresentasikan sebagai baris.
+ Ketika alias disediakan, nilai yang meledak diwakili di bawah alias, bukan nama bidang asli.
Anda dapat menggunakan perintah ini dalam kombinasi dengan perintah lain, seperti statistik, eval, dan parse, untuk memanipulasi atau mengekstrak data pasca-ekspansi.
**Contoh**
+ `source = table | expand employee | stats max(salary) as max by state, company `
+ `source = table | expand employee as worker | stats max(salary) as max by state, company `
+ `source = table | expand employee as worker | eval bonus = salary * 3 | fields worker, bonus`
+ `source = table | expand employee | parse description '(?.+@.+)' | fields employee, email`
+ `source = table | eval array=json_array(1, 2, 3) | expand array as uid | fields name, occupation, uid `
+ `source = table | expand multi_valueA as multiA | expand multi_valueB as multiB`
Anda dapat menggunakan perintah expand dalam kombinasi dengan perintah lain seperti eval, stats, dan banyak lagi. Menggunakan beberapa perintah memperluas akan membuat produk Cartesian dari semua elemen internal dalam setiap array komposit atau peta.
**Kueri push-down SQL yang efektif**
Perintah expand diterjemahkan ke dalam operasi SQL yang setara menggunakan LATERAL VIEW explode, memungkinkan ledakan array atau peta yang efisien pada tingkat kueri SQL.
```
SELECT customer exploded_productId
FROM table
LATERAL VIEW explode(productId) AS exploded_productId
```
Perintah explode menawarkan fungsionalitas berikut:
+ Ini adalah operasi kolom yang mengembalikan kolom baru.
+ Ini menciptakan baris baru untuk setiap elemen di kolom meledak.
+ Null internal diabaikan sebagai bagian dari bidang yang meledak (tidak ada baris created/exploded untuk null).
#### Fungsi PPL
**Topics**
+ [Fungsi kondisi PPL](#supported-ppl-condition-functions)
+ [Fungsi hash kriptografi PPL](#supported-ppl-cryptographic-functions)
+ [Fungsi tanggal dan waktu PPL](#supported-ppl-date-time-functions)
+ [Ekspresi PPL](#supported-ppl-expressions)
+ [Fungsi alamat IP PPL](#supported-ppl-ip-address-functions)
+ [Fungsi PPL JSON](#supported-ppl-json-functions)
+ [Fungsi PPL Lambda](#supported-ppl-lambda-functions)
+ [Fungsi matematika PPL](#supported-ppl-math-functions)
+ [Fungsi string PPL](#supported-ppl-string-functions)
+ [Fungsi konversi tipe PPL](#supported-ppl-type-conversion-functions)
##### Fungsi kondisi PPL
**catatan**
Untuk melihat integrasi sumber AWS data mana yang mendukung fungsi PPL ini, lihat. [Fungsi](#supported-ppl-functions)
##### ISNULL
**Deskripsi**: `isnull(field)` mengembalikan true jika bidang adalah null.
**Jenis argumen:**
+ Semua tipe data yang didukung.
**Jenis pengembalian:**
+ BOOLEAN
**Contoh:**
```
os> source=accounts | eval result = isnull(employer) | fields result, employer, firstname
fetched rows / total rows = 4/4
+----------+-------------+-------------+
| result | employer | firstname |
|----------+-------------+-------------|
| False | AnyCompany | Mary |
| False | ExampleCorp | Jane |
| False | ExampleOrg | Nikki |
| True | null | Juan |
+----------+-------------+-------------+
```
##### ISNOTNULL
**Deskripsi**: `isnotnull(field)` mengembalikan true jika bidang tidak null.
**Jenis argumen:**
+ Semua tipe data yang didukung.
**Jenis pengembalian:**
+ BOOLEAN
**Contoh:**
```
os> source=accounts | where not isnotnull(employer) | fields account_number, employer
fetched rows / total rows = 1/1
+------------------+------------+
| account_number | employer |
|------------------+------------|
| 18 | null |
+------------------+------------+
```
##### ADA
**Contoh:**
```
os> source=accounts | where exists(email) | fields account_number, email
fetched rows / total rows = 1/1
```
##### IFNULL
**Deskripsi**: `ifnull(field1, field2)` mengembalikan `field2` `field1` jika nol.
**Jenis argumen:**
+ Semua tipe data yang didukung.
+ Jika kedua parameter memiliki tipe yang berbeda, fungsi akan gagal pemeriksaan semantik.
**Jenis pengembalian:**
+ Setiap
**Contoh:**
```
os> source=accounts | eval result = ifnull(employer, 'default') | fields result, employer, firstname
fetched rows / total rows = 4/4
+------------+------------+-------------+
| result | employer | firstname |
|------------+------------+-------------|
| AnyCompany | AnyCompany | Mary |
| ExampleCorp| ExampleCorp| Jane |
| ExampleOrg | ExampleOrg | Nikki |
| default | null | Juan |
+------------+------------+-------------+
```
##### NULLIF
**Deskripsi**: `nullif(field1, field2)` kembalikan null jika dua parameter sama, jika tidak kembalikan bidang1.
**Jenis argumen:**
+ Semua tipe data yang didukung.
+ Jika kedua parameter memiliki tipe yang berbeda, fungsi akan gagal pemeriksaan semantik.
**Jenis pengembalian:**
+ Setiap
**Contoh:**
```
os> source=accounts | eval result = nullif(employer, 'AnyCompany') | fields result, employer, firstname
fetched rows / total rows = 4/4
+----------------+----------------+-------------+
| result | employer | firstname |
|----------------+----------------+-------------|
| null | AnyCompany | Mary |
| ExampleCorp | ExampleCorp | Jane |
| ExampleOrg | ExampleOrg | Nikki |
| null | null | Juan |
+----------------+----------------+-------------+
```
##### JIKA
**Deskripsi**: `if(condition, expr1, expr2)` mengembalikan `expr1` jika kondisi benar, jika tidak maka kembali`expr2`.
**Jenis argumen:**
+ Semua tipe data yang didukung.
+ Jika kedua parameter memiliki tipe yang berbeda, fungsi akan gagal pemeriksaan semantik.
**Jenis pengembalian:**
+ Setiap
**Contoh:**
```
os> source=accounts | eval result = if(true, firstname, lastname) | fields result, firstname, lastname
fetched rows / total rows = 4/4
+----------+-------------+----------+
| result | firstname | lastname |
|----------+-------------+----------|
| Jane | Jane | Doe |
| Mary | Mary | Major |
| Pat | Pat | Candella |
| Dale | Jorge | Souza |
+----------+-----------+------------+
os> source=accounts | eval result = if(false, firstname, lastname) | fields result, firstname, lastname
fetched rows / total rows = 4/4
+----------+-------------+------------+
| result | firstname | lastname |
|----------+-------------+------------|
| Doe | Jane | Doe |
| Major | Mary | Major |
| Candella | Pat | Candella |
| Souza | Jorge | Souza |
+----------+-------------+------------+
os> source=accounts | eval is_vip = if(age > 30 AND isnotnull(employer), true, false) | fields is_vip, firstname, lastname
fetched rows / total rows = 4/4
+----------+-------------+------------+
| is_vip | firstname | lastname |
|----------+-------------+------------|
| True | Jane | Doe |
| True | Mary | Major |
| False | Pat | Candella |
| False | Jorge | Souza |
+----------+-------------+------------+
```
##### Fungsi hash kriptografi PPL
**catatan**
Untuk melihat integrasi sumber AWS data mana yang mendukung fungsi PPL ini, lihat. [Fungsi](#supported-ppl-functions)
##### MD5
MD5 menghitung MD5 intisari dan mengembalikan nilai sebagai 32 karakter hex string.
**Pemakaian**: `md5('hello')`
**Jenis argumen:**
+ STRING
**Jenis pengembalian:**
+ STRING
**Contoh:**
```
os> source=people | eval `MD5('hello')` = MD5('hello') | fields `MD5('hello')`
fetched rows / total rows = 1/1
+----------------------------------+
| MD5('hello') |
|----------------------------------|
| <32 character hex string> |
+----------------------------------+
```
##### SHA1
SHA1 mengembalikan hasil hex string dari SHA-1.
**Pemakaian**: `sha1('hello')`
**Jenis argumen:**
+ STRING
**Jenis pengembalian:**
+ STRING
**Contoh:**
```
os> source=people | eval `SHA1('hello')` = SHA1('hello') | fields `SHA1('hello')`
fetched rows / total rows = 1/1
+------------------------------------------+
| SHA1('hello') |
|------------------------------------------|
| <40-character SHA-1 hash result> |
+------------------------------------------+
```
##### SHA2
SHA2 mengembalikan hasil hex string dari keluarga SHA-2 fungsi hash (SHA-224, SHA-256, SHA-384, dan SHA-512). NumBits menunjukkan panjang bit yang diinginkan dari hasil, yang harus memiliki nilai 224, 256, 384, 512
**Penggunaan:**
+ `sha2('hello',256)`
+ `sha2('hello',512)`
**Jenis argumen:**
+ STRING, BILANGAN BULAT
**Jenis pengembalian:**
+ STRING
**Contoh:**
```
os> source=people | eval `SHA2('hello',256)` = SHA2('hello',256) | fields `SHA2('hello',256)`
fetched rows / total rows = 1/1
+------------------------------------------------------------------+
| SHA2('hello',256) |
|------------------------------------------------------------------|
| <64-character SHA-256 hash result> |
+------------------------------------------------------------------+
os> source=people | eval `SHA2('hello',512)` = SHA2('hello',512) | fields `SHA2('hello',512)`
fetched rows / total rows = 1/1
+------------------------------------------------------------------+
| SHA2('hello',512) | |
|------------------------------------------------------------------|
| <128-character SHA-512 hash result> |
+------------------------------------------------------------------+
```
##### Fungsi tanggal dan waktu PPL
**catatan**
Untuk melihat integrasi sumber AWS data mana yang mendukung fungsi PPL ini, lihat. [Fungsi](#supported-ppl-functions)
##### `DAY`
**Penggunaan**: `DAY(date)` ekstrak hari dalam sebulan untuk tanggal, dalam kisaran 1 hingga 31.
**Jenis argumen**: STRING/DATE/TIMESTAMP
**Jenis pengembalian**: INTEGER
**Sinonim**:`DAYOFMONTH`, `DAY_OF_MONTH`
**Contoh:**
```
os> source=people | eval `DAY(DATE('2020-08-26'))` = DAY(DATE('2020-08-26')) | fields `DAY(DATE('2020-08-26'))`
fetched rows / total rows = 1/1
+---------------------------+
| DAY(DATE('2020-08-26')) |
|---------------------------|
| 26 |
+---------------------------+
```
##### `DAYOFMONTH`
**Penggunaan**: `DAYOFMONTH(date)` ekstrak hari dalam sebulan untuk tanggal, dalam kisaran 1 hingga 31.
**Jenis argumen**: STRING/DATE/TIMESTAMP
**Jenis pengembalian**: INTEGER
**Sinonim**:`DAY`, `DAY_OF_MONTH`
**Contoh:**
```
os> source=people | eval `DAYOFMONTH(DATE('2020-08-26'))` = DAYOFMONTH(DATE('2020-08-26')) | fields `DAYOFMONTH(DATE('2020-08-26'))`
fetched rows / total rows = 1/1
+----------------------------------+
| DAYOFMONTH(DATE('2020-08-26')) |
|----------------------------------|
| 26 |
+----------------------------------+
```
##### `DAY_OF_MONTH`
**Penggunaan**: `DAY_OF_MONTH(DATE)` ekstrak hari dalam sebulan untuk tanggal, dalam kisaran 1 hingga 31.
**Jenis argumen**: STRING/DATE/TIMESTAMP
**Jenis pengembalian**: INTEGER
**Sinonim**:`DAY`, `DAYOFMONTH`
**Contoh:**
```
os> source=people | eval `DAY_OF_MONTH(DATE('2020-08-26'))` = DAY_OF_MONTH(DATE('2020-08-26')) | fields `DAY_OF_MONTH(DATE('2020-08-26'))`
fetched rows / total rows = 1/1
+------------------------------------+
| DAY_OF_MONTH(DATE('2020-08-26')) |
|------------------------------------|
| 26 |
+------------------------------------+
```
##### `DAYOFWEEK`
**Penggunaan**: `DAYOFWEEK(DATE)` mengembalikan indeks hari kerja untuk tanggal (1 = Minggu, 2 = Senin,..., 7 = Sabtu).
**Jenis argumen**: STRING/DATE/TIMESTAMP
**Jenis pengembalian**: INTEGER
**Sinonim**: `DAY_OF_WEEK`
**Contoh:**
```
os> source=people | eval `DAYOFWEEK(DATE('2020-08-26'))` = DAYOFWEEK(DATE('2020-08-26')) | fields `DAYOFWEEK(DATE('2020-08-26'))`
fetched rows / total rows = 1/1
+---------------------------------+
| DAYOFWEEK(DATE('2020-08-26')) |
|---------------------------------|
| 4 |
+---------------------------------+
```
##### `DAY_OF_WEEK`
**Penggunaan**: `DAY_OF_WEEK(DATE)` mengembalikan indeks hari kerja untuk tanggal (1 = Minggu, 2 = Senin,..., 7 = Sabtu).
**Jenis argumen**: STRING/DATE/TIMESTAMP
**Jenis pengembalian**: INTEGER
**Sinonim**: `DAYOFWEEK`
**Contoh:**
```
os> source=people | eval `DAY_OF_WEEK(DATE('2020-08-26'))` = DAY_OF_WEEK(DATE('2020-08-26')) | fields `DAY_OF_WEEK(DATE('2020-08-26'))`
fetched rows / total rows = 1/1
+-----------------------------------+
| DAY_OF_WEEK(DATE('2020-08-26')) |
|-----------------------------------|
| 4 |
+-----------------------------------+
```
##### `DAYOFYEAR`
**Penggunaan**: `DAYOFYEAR(DATE)` mengembalikan hari dalam setahun untuk tanggal, dalam kisaran 1 hingga 366.
**Jenis argumen**: STRING/DATE/TIMESTAMP
**Jenis pengembalian**: INTEGER
**Sinonim**: `DAY_OF_YEAR`
**Contoh:**
```
os> source=people | eval `DAYOFYEAR(DATE('2020-08-26'))` = DAYOFYEAR(DATE('2020-08-26')) | fields `DAYOFYEAR(DATE('2020-08-26'))`
fetched rows / total rows = 1/1
+---------------------------------+
| DAYOFYEAR(DATE('2020-08-26')) |
|---------------------------------|
| 239 |
+---------------------------------+
```
##### `DAY_OF_YEAR`
**Penggunaan**: `DAY_OF_YEAR(DATE)` mengembalikan hari dalam setahun untuk tanggal, dalam kisaran 1 hingga 366.
**Jenis argumen**: STRING/DATE/TIMESTAMP
**Jenis pengembalian**: INTEGER
**Sinonim**: `DAYOFYEAR`
**Contoh:**
```
os> source=people | eval `DAY_OF_YEAR(DATE('2020-08-26'))` = DAY_OF_YEAR(DATE('2020-08-26')) | fields `DAY_OF_YEAR(DATE('2020-08-26'))`
fetched rows / total rows = 1/1
+-----------------------------------+
| DAY_OF_YEAR(DATE('2020-08-26')) |
|-----------------------------------|
| 239 |
+-----------------------------------+
```
##### `DAYNAME`
**Penggunaan**: `DAYNAME(DATE)` mengembalikan nama hari kerja untuk tanggal, termasuk Senin, Selasa, Rabu, Kamis, Jumat, Sabtu dan Minggu.
**Jenis argumen**: STRING/DATE/TIMESTAMP
**Jenis pengembalian**: STRING
**Contoh:**
```
os> source=people | eval `DAYNAME(DATE('2020-08-26'))` = DAYNAME(DATE('2020-08-26')) | fields `DAYNAME(DATE('2020-08-26'))`
fetched rows / total rows = 1/1
+-------------------------------+
| DAYNAME(DATE('2020-08-26')) |
|-------------------------------|
| Wednesday |
+-------------------------------+
```
##### `FROM_UNIXTIME`
**Penggunaan**: `FROM_UNIXTIME` mengembalikan representasi argumen yang diberikan sebagai cap waktu atau nilai string karakter. Fungsi ini melakukan konversi terbalik dari `UNIX_TIMESTAMP` fungsi.
Jika Anda memberikan argumen kedua, `FROM_UNIXTIME` gunakan untuk memformat hasil yang mirip dengan `DATE_FORMAT` fungsi.
Jika stempel waktu berada di luar kisaran 1970-01-01 00:00:00 hingga 3001-01-18 23:59:59.999 999 (0 hingga 32536771199.999999 waktu epoch), fungsi kembali. `NULL`
**Jenis argumen**: DOUBLE, STRING
**Peta tipe pengembalian**:
GANDA -> STEMPEL WAKTU
GANDA, STRING -> STRING
**Contoh:**
```
os> source=people | eval `FROM_UNIXTIME(1220249547)` = FROM_UNIXTIME(1220249547) | fields `FROM_UNIXTIME(1220249547)`
fetched rows / total rows = 1/1
+-----------------------------+
| FROM_UNIXTIME(1220249547) |
|-----------------------------|
| 2008-09-01 06:12:27 |
+-----------------------------+
os> source=people | eval `FROM_UNIXTIME(1220249547, 'HH:mm:ss')` = FROM_UNIXTIME(1220249547, 'HH:mm:ss') | fields `FROM_UNIXTIME(1220249547, 'HH:mm:ss')`
fetched rows / total rows = 1/1
+-----------------------------------------+
| FROM_UNIXTIME(1220249547, 'HH:mm:ss') |
|-----------------------------------------|
| 06:12:27 |
+-----------------------------------------+
```
##### `HOUR`
**Penggunaan**: `HOUR(TIME)` mengekstrak nilai jam untuk waktu.
Tidak seperti waktu standar hari, nilai waktu dalam fungsi ini dapat memiliki rentang yang lebih besar dari 23. Akibatnya, nilai pengembalian `HOUR(TIME)` bisa lebih besar dari 23.
**Jenis argumen**: STRING/TIME/TIMESTAMP
**Jenis pengembalian**: INTEGER
**Sinonim**: `HOUR_OF_DAY`
**Contoh:**
```
os> source=people | eval `HOUR(TIME('01:02:03'))` = HOUR(TIME('01:02:03')) | fields `HOUR(TIME('01:02:03'))`
fetched rows / total rows = 1/1
+--------------------------+
| HOUR(TIME('01:02:03')) |
|--------------------------|
| 1 |
+--------------------------+
```
##### `HOUR_OF_DAY`
**Penggunaan**: `HOUR_OF_DAY(TIME)` mengekstrak nilai jam dari waktu yang diberikan.
Tidak seperti waktu standar hari, nilai waktu dalam fungsi ini dapat memiliki rentang yang lebih besar dari 23. Akibatnya, nilai pengembalian `HOUR_OF_DAY(TIME)` bisa lebih besar dari 23.
**Jenis argumen**: STRING/TIME/TIMESTAMP
**Jenis pengembalian**: INTEGER
**Sinonim**: `HOUR`
**Contoh:**
```
os> source=people | eval `HOUR_OF_DAY(TIME('01:02:03'))` = HOUR_OF_DAY(TIME('01:02:03')) | fields `HOUR_OF_DAY(TIME('01:02:03'))`
fetched rows / total rows = 1/1
+---------------------------------+
| HOUR_OF_DAY(TIME('01:02:03')) |
|---------------------------------|
| 1 |
+---------------------------------+
```
##### `LAST_DAY`
**Penggunaan**: `LAST_DAY` mengembalikan hari terakhir bulan sebagai nilai DATE untuk argumen tanggal yang diberikan.
**Jenis argumen**: DATE/STRING/TIMESTAMP/TIME
**Jenis pengembalian**: TANGGAL
**Contoh:**
```
os> source=people | eval `last_day('2023-02-06')` = last_day('2023-02-06') | fields `last_day('2023-02-06')`
fetched rows / total rows = 1/1
+--------------------------+
| last_day('2023-02-06') |
|--------------------------|
| 2023-02-28 |
+--------------------------+
```
##### `LOCALTIMESTAMP`
**Penggunaan**: `LOCALTIMESTAMP()` adalah sinonim untuk`NOW()`.
**Contoh:**
```
> source=people | eval `LOCALTIMESTAMP()` = LOCALTIMESTAMP() | fields `LOCALTIMESTAMP()`
fetched rows / total rows = 1/1
+---------------------+
| LOCALTIMESTAMP() |
|---------------------|
| 2022-08-02 15:54:19 |
+---------------------+
```
##### `LOCALTIME`
**Penggunaan**: `LOCALTIME()` adalah sinonim untuk. `NOW()`
**Contoh:**
```
> source=people | eval `LOCALTIME()` = LOCALTIME() | fields `LOCALTIME()`
fetched rows / total rows = 1/1
+---------------------+
| LOCALTIME() |
|---------------------|
| 2022-08-02 15:54:19 |
+---------------------+
```
##### `MAKE_DATE`
**Penggunaan**: `MAKE_DATE` mengembalikan nilai tanggal berdasarkan nilai tahun, bulan, dan hari yang diberikan. Semua argumen dibulatkan ke bilangan bulat.
**Spesifikasi**: 1. MAKE\_DATE (INTEGER, INTEGER, INTEGER) -> TANGGAL
**Jenis argumen**: INTEGER, INTEGER, INTEGER
**Jenis pengembalian**: TANGGAL
**Contoh:**
```
os> source=people | eval `MAKE_DATE(1945, 5, 9)` = MAKEDATE(1945, 5, 9) | fields `MAKEDATE(1945, 5, 9)`
fetched rows / total rows = 1/1
+------------------------+
| MAKEDATE(1945, 5, 9) |
|------------------------|
| 1945-05-09 |
+------------------------+
```
##### `MINUTE`
**Penggunaan**: `MINUTE(TIME)` mengembalikan komponen menit dari waktu yang diberikan, sebagai bilangan bulat dalam kisaran 0 hingga 59.
**Jenis argumen**: STRING/TIME/TIMESTAMP
**Jenis pengembalian**: INTEGER
**Sinonim**: `MINUTE_OF_HOUR`
**Contoh:**
```
os> source=people | eval `MINUTE(TIME('01:02:03'))` = MINUTE(TIME('01:02:03')) | fields `MINUTE(TIME('01:02:03'))`
fetched rows / total rows = 1/1
+----------------------------+
| MINUTE(TIME('01:02:03')) |
|----------------------------|
| 2 |
+----------------------------+
```
##### `MINUTE_OF_HOUR`
**Penggunaan**: `MINUTE_OF_HOUR(TIME)` mengembalikan komponen menit dari waktu yang diberikan, sebagai bilangan bulat dalam kisaran 0 hingga 59.
**Jenis argumen**: STRING/TIME/TIMESTAMP
**Jenis pengembalian**: INTEGER
**Sinonim**: `MINUTE`
**Contoh:**
```
os> source=people | eval `MINUTE_OF_HOUR(TIME('01:02:03'))` = MINUTE_OF_HOUR(TIME('01:02:03')) | fields `MINUTE_OF_HOUR(TIME('01:02:03'))`
fetched rows / total rows = 1/1
+------------------------------------+
| MINUTE_OF_HOUR(TIME('01:02:03')) |
|------------------------------------|
| 2 |
+------------------------------------+
```
##### `MONTH`
**Penggunaan**: `MONTH(DATE)` mengembalikan bulan dari tanggal yang diberikan sebagai bilangan bulat, dalam rentang 1 hingga 12 (di mana 1 mewakili Januari dan 12 mewakili Desember).
**Jenis argumen**: STRING/DATE/TIMESTAMP
**Jenis pengembalian**: INTEGER
**Sinonim**: `MONTH_OF_YEAR`
**Contoh:**
```
os> source=people | eval `MONTH(DATE('2020-08-26'))` = MONTH(DATE('2020-08-26')) | fields `MONTH(DATE('2020-08-26'))`
fetched rows / total rows = 1/1
+-----------------------------+
| MONTH(DATE('2020-08-26')) |
|-----------------------------|
| 8 |
+-----------------------------+
```
##### `MONTHNAME`
**Penggunaan**: `MONTHNAME(DATE)` mengembalikan bulan dari tanggal yang diberikan sebagai bilangan bulat, dalam rentang 1 hingga 12 (di mana 1 mewakili Januari dan 12 mewakili Desember).
**Jenis argumen**: STRING/DATE/TIMESTAMP
**Jenis pengembalian**: INTEGER
**Sinonim**: `MONTH_OF_YEAR`
**Contoh:**
```
os> source=people | eval `MONTHNAME(DATE('2020-08-26'))` = MONTHNAME(DATE('2020-08-26')) | fields `MONTHNAME(DATE('2020-08-26'))`
fetched rows / total rows = 1/1
+---------------------------------+
| MONTHNAME(DATE('2020-08-26')) |
|---------------------------------|
| August |
+---------------------------------+
```
##### `MONTH_OF_YEAR`
**Penggunaan**: `MONTH_OF_YEAR(DATE)` mengembalikan bulan dari tanggal yang diberikan sebagai bilangan bulat, dalam rentang 1 hingga 12 (di mana 1 mewakili Januari dan 12 mewakili Desember).
**Jenis argumen**: STRING/DATE/TIMESTAMP
**Jenis pengembalian**: INTEGER
**Sinonim**: `MONTH`
**Contoh:**
```
os> source=people | eval `MONTH_OF_YEAR(DATE('2020-08-26'))` = MONTH_OF_YEAR(DATE('2020-08-26')) | fields `MONTH_OF_YEAR(DATE('2020-08-26'))`
fetched rows / total rows = 1/1
+-------------------------------------+
| MONTH_OF_YEAR(DATE('2020-08-26')) |
|-------------------------------------|
| 8 |
+-------------------------------------+
```
##### `NOW`
**Penggunaan**: `NOW` mengembalikan tanggal dan waktu saat ini sebagai `TIMESTAMP` nilai dalam format YYYY-MM-DD 'hh:mm: ss'. Nilai dinyatakan dalam zona waktu cluster.
**catatan**
`NOW()`mengembalikan waktu konstan yang menunjukkan kapan pernyataan mulai mengeksekusi. Ini berbeda dari`SYSDATE()`, yang mengembalikan waktu eksekusi yang tepat.
**Jenis pengembalian**: TIMESTAMP
**Spesifikasi**: SEKARANG () -> TIMESTAMP
**Contoh:**
```
os> source=people | eval `value_1` = NOW(), `value_2` = NOW() | fields `value_1`, `value_2`
fetched rows / total rows = 1/1
+---------------------+---------------------+
| value_1 | value_2 |
|---------------------+---------------------|
| 2022-08-02 15:39:05 | 2022-08-02 15:39:05 |
+---------------------+---------------------+
```
##### `QUARTER`
**Penggunaan**: `QUARTER(DATE)` mengembalikan kuartal tahun untuk tanggal yang diberikan sebagai bilangan bulat, dalam kisaran 1 sampai 4.
**Jenis argumen**: STRING/DATE/TIMESTAMP
**Jenis pengembalian**: INTEGER
**Contoh:**
```
os> source=people | eval `QUARTER(DATE('2020-08-26'))` = QUARTER(DATE('2020-08-26')) | fields `QUARTER(DATE('2020-08-26'))`
fetched rows / total rows = 1/1
+-------------------------------+
| QUARTER(DATE('2020-08-26')) |
|-------------------------------|
| 3 |
+-------------------------------+
```
##### `SECOND`
**Penggunaan**: `SECOND(TIME)` mengembalikan komponen kedua dari waktu yang diberikan sebagai bilangan bulat, dalam kisaran 0 hingga 59.
**Jenis argumen**: STRING/TIME/TIMESTAMP
**Jenis pengembalian**: INTEGER
**Sinonim**: `SECOND_OF_MINUTE`
**Contoh:**
```
os> source=people | eval `SECOND(TIME('01:02:03'))` = SECOND(TIME('01:02:03')) | fields `SECOND(TIME('01:02:03'))`
fetched rows / total rows = 1/1
+----------------------------+
| SECOND(TIME('01:02:03')) |
|----------------------------|
| 3 |
+----------------------------+
```
##### `SECOND_OF_MINUTE`
**Penggunaan**: `SECOND_OF_MINUTE(TIME)` mengembalikan komponen kedua dari waktu yang diberikan sebagai bilangan bulat, dalam kisaran 0 hingga 59.
**Jenis argumen**: STRING/TIME/TIMESTAMP
**Jenis pengembalian**: INTEGER
**Sinonim**: `SECOND`
**Contoh:**
```
os> source=people | eval `SECOND_OF_MINUTE(TIME('01:02:03'))` = SECOND_OF_MINUTE(TIME('01:02:03')) | fields `SECOND_OF_MINUTE(TIME('01:02:03'))`
fetched rows / total rows = 1/1
+--------------------------------------+
| SECOND_OF_MINUTE(TIME('01:02:03')) |
|--------------------------------------|
| 3 |
+--------------------------------------+
```
##### `SUBDATE`
**Penggunaan**: `SUBDATE(DATE, DAYS)` mengurangi argumen kedua (seperti `DATE` atau`DAYS`) dari tanggal yang diberikan.
**Jenis argumen**: TANGGAL/TIMESTAMP, PANJANG
**Peta tipe pengembalian**: (TANGGAL, PANJANG) -> TANGGAL
**Antonim**: `ADDDATE`
**Contoh:**
```
os> source=people | eval `'2008-01-02' - 31d` = SUBDATE(DATE('2008-01-02'), 31), `'2020-08-26' - 1` = SUBDATE(DATE('2020-08-26'), 1), `ts '2020-08-26 01:01:01' - 1` = SUBDATE(TIMESTAMP('2020-08-26 01:01:01'), 1) | fields `'2008-01-02' - 31d`, `'2020-08-26' - 1`, `ts '2020-08-26 01:01:01' - 1`
fetched rows / total rows = 1/1
+----------------------+--------------------+--------------------------------+
| '2008-01-02' - 31d | '2020-08-26' - 1 | ts '2020-08-26 01:01:01' - 1 |
|----------------------+--------------------+--------------------------------|
| 2007-12-02 00:00:00 | 2020-08-25 | 2020-08-25 01:01:01 |
+----------------------+--------------------+--------------------------------+
```
##### `SYSDATE`
**Penggunaan**: `SYSDATE()` mengembalikan tanggal dan waktu saat ini sebagai `TIMESTAMP` nilai dalam format YYYY-MM-DD 'hh:mm:ss.nnnnnn'.
`SYSDATE()`mengembalikan waktu yang tepat di mana ia mengeksekusi. Ini berbeda dari NOW (), yang mengembalikan waktu konstan yang menunjukkan kapan pernyataan mulai dijalankan.
**Jenis argumen opsional**: INTEGER (0 sampai 6) - Menentukan jumlah digit untuk detik pecahan dalam nilai kembali.
**Jenis pengembalian**: TIMESTAMP
**Contoh:**
```
os> source=people | eval `SYSDATE()` = SYSDATE() | fields `SYSDATE()`
fetched rows / total rows = 1/1
+----------------------------+
| SYSDATE() |
|----------------------------|
| 2022-08-02 15:39:05.123456 |
+----------------------------+
```
##### `TIMESTAMP`
**Penggunaan**: `TIMESTAMP(EXPR)` membangun tipe timestamp dengan string input `expr` sebagai stempel waktu.
Dengan satu argumen, `TIMESTAMP(expr)` buat stempel waktu dari input. Jika `expr` adalah string, itu ditafsirkan sebagai stempel waktu. Untuk argumen non-string, fungsi cast `expr` ke stempel waktu menggunakan zona waktu UTC. `expr`Kapan `TIME` nilai, fungsi tersebut menerapkan tanggal hari ini sebelum casting.
Saat digunakan dengan dua argumen, `TIMESTAMP(expr1, expr2)` tambahkan ekspresi waktu (`expr2`) ke ekspresi tanggal atau timestamp (`expr1`) dan mengembalikan hasilnya sebagai nilai stempel waktu.
**Jenis argumen**: STRING/DATE/TIME/TIMESTAMP
**Peta tipe pengembalian**:
(STRING/DATE/TIME/TIMESTAMP) -> STEMPEL WAKTU
(STRING/DATE/TIME/TIMESTAMP, STRING/DATE/TIME/TIMESTAMP) -> STEMPEL WAKTU
**Contoh:**
```
os> source=people | eval `TIMESTAMP('2020-08-26 13:49:00')` = TIMESTAMP('2020-08-26 13:49:00'), `TIMESTAMP('2020-08-26 13:49:00', TIME('12:15:42'))` = TIMESTAMP('2020-08-26 13:49:00', TIME('12:15:42')) | fields `TIMESTAMP('2020-08-26 13:49:00')`, `TIMESTAMP('2020-08-26 13:49:00', TIME('12:15:42'))`
fetched rows / total rows = 1/1
+------------------------------------+------------------------------------------------------+
| TIMESTAMP('2020-08-26 13:49:00') | TIMESTAMP('2020-08-26 13:49:00', TIME('12:15:42')) |
|------------------------------------+------------------------------------------------------|
| 2020-08-26 13:49:00 | 2020-08-27 02:04:42 |
+------------------------------------+------------------------------------------------------+
```
##### `UNIX_TIMESTAMP`
**Penggunaan**: `UNIX_TIMESTAMP` mengubah argumen tanggal tertentu ke waktu Unix (detik sejak Epoch, yang dimulai pada awal 1970). Jika tidak ada argumen yang disediakan, ia mengembalikan waktu Unix saat ini.
Argumen tanggal dapat berupa`DATE`, `TIMESTAMP` string, atau angka dalam salah satu format ini:`YYMMDD`,`YYMMDDhhmmss`,`YYYYMMDD`, atau`YYYYMMDDhhmmss`. Jika argumen menyertakan komponen waktu, itu mungkin secara opsional termasuk detik pecahan.
Jika argumen dalam format yang tidak valid atau berada di luar kisaran 1970-01-01 00:00:00 hingga 3001-01-18 23:59:59.999 999 (0 hingga 32536771199.999999 dalam waktu epoch), fungsi akan kembali. `NULL`
Fungsi menerima`DATE`,`TIMESTAMP`, atau `DOUBLE` sebagai tipe argumen, atau tidak ada argumen. Itu selalu mengembalikan `DOUBLE` nilai yang mewakili stempel waktu Unix.
Untuk konversi terbalik, Anda dapat menggunakan fungsi FROM\_UNIXTIME.
**Jenis argumen**:/DOUBLE/DATE/TIMESTAMP
**Jenis pengembalian**: DOUBLE
**Contoh:**
```
os> source=people | eval `UNIX_TIMESTAMP(double)` = UNIX_TIMESTAMP(20771122143845), `UNIX_TIMESTAMP(timestamp)` = UNIX_TIMESTAMP(TIMESTAMP('1996-11-15 17:05:42')) | fields `UNIX_TIMESTAMP(double)`, `UNIX_TIMESTAMP(timestamp)`
fetched rows / total rows = 1/1
+--------------------------+-----------------------------+
| UNIX_TIMESTAMP(double) | UNIX_TIMESTAMP(timestamp) |
|--------------------------+-----------------------------|
| 3404817525.0 | 848077542.0 |
+--------------------------+-----------------------------+
```
##### `WEEK`
**Penggunaan**: `WEEK(DATE)` mengembalikan nomor minggu untuk tanggal tertentu.
**Jenis argumen**: DATE/TIMESTAMP/STRING
**Jenis pengembalian**: INTEGER
**Sinonim**: `WEEK_OF_YEAR`
**Contoh:**
```
os> source=people | eval `WEEK(DATE('2008-02-20'))` = WEEK(DATE('2008-02-20')) | fields `WEEK(DATE('2008-02-20'))`
fetched rows / total rows = 1/1
+----------------------------+
| WEEK(DATE('2008-02-20')) |
|----------------------------|
| 8 |
+----------------------------+
```
##### `WEEKDAY`
**Penggunaan**: `WEEKDAY(DATE)` mengembalikan indeks hari kerja untuk tanggal (0 = Senin, 1 = Selasa,..., 6 = Minggu).
Ini mirip dengan `dayofweek` fungsi, tetapi mengembalikan indeks yang berbeda untuk setiap hari.
**Jenis argumen**: STRING/DATE/TIME/TIMESTAMP
**Jenis pengembalian**: INTEGER
**Contoh:**
```
os> source=people | eval `weekday(DATE('2020-08-26'))` = weekday(DATE('2020-08-26')) | eval `weekday(DATE('2020-08-27'))` = weekday(DATE('2020-08-27')) | fields `weekday(DATE('2020-08-26'))`, `weekday(DATE('2020-08-27'))`
fetched rows / total rows = 1/1
+-------------------------------+-------------------------------+
| weekday(DATE('2020-08-26')) | weekday(DATE('2020-08-27')) |
|-------------------------------+-------------------------------|
| 2 | 3 |
+-------------------------------+-------------------------------+
```
##### `WEEK_OF_YEAR`
**Penggunaan**: `WEEK_OF_YEAR(DATE)` mengembalikan nomor minggu untuk tanggal yang diberikan.
**Jenis argumen**: DATE/TIMESTAMP/STRING
**Jenis pengembalian**: INTEGER
**Sinonim**: `WEEK`
**Contoh:**
```
os> source=people | eval `WEEK_OF_YEAR(DATE('2008-02-20'))` = WEEK(DATE('2008-02-20'))| fields `WEEK_OF_YEAR(DATE('2008-02-20'))`
fetched rows / total rows = 1/1
+------------------------------------+
| WEEK_OF_YEAR(DATE('2008-02-20')) |
|------------------------------------|
| 8 |
+------------------------------------+
```
##### `YEAR`
**Penggunaan**: `YEAR(DATE)` mengembalikan tahun untuk tanggal, dalam kisaran 1000 hingga 9999, atau 0 untuk tanggal “nol”.
**Jenis argumen**: STRING/DATE/TIMESTAMP
**Jenis pengembalian**: INTEGER
**Contoh:**
```
os> source=people | eval `YEAR(DATE('2020-08-26'))` = YEAR(DATE('2020-08-26')) | fields `YEAR(DATE('2020-08-26'))`
fetched rows / total rows = 1/1
+----------------------------+
| YEAR(DATE('2020-08-26')) |
|----------------------------|
| 2020 |
+----------------------------+
```
##### `DATE_ADD`
**Penggunaan**: `DATE_ADD(date, INTERVAL expr unit)` menambahkan interval yang ditentukan ke tanggal yang diberikan.
**Jenis argumen**: TANGGAL, INTERVAL
**Jenis pengembalian**: TANGGAL
**Antonim**: `DATE_SUB`
**Contoh:**
```
os> source=people | eval `'2020-08-26' + 1d` = DATE_ADD(DATE('2020-08-26'), INTERVAL 1 DAY) | fields `'2020-08-26' + 1d`
fetched rows / total rows = 1/1
+---------------------+
| '2020-08-26' + 1d |
|---------------------|
| 2020-08-27 |
+---------------------+
```
##### `DATE_SUB`
**Penggunaan**: `DATE_SUB(date, INTERVAL expr unit)` mengurangi interval expr dari tanggal.
**Jenis argumen**: TANGGAL, INTERVAL
**Jenis pengembalian**: TANGGAL
**Antonim**: `DATE_ADD`
**Contoh:**
```
os> source=people | eval `'2008-01-02' - 31d` = DATE_SUB(DATE('2008-01-02'), INTERVAL 31 DAY) | fields `'2008-01-02' - 31d`
fetched rows / total rows = 1/1
+---------------------+
| '2008-01-02' - 31d |
|---------------------|
| 2007-12-02 |
+---------------------+
```
##### `TIMESTAMPADD`
**Penggunaan**: Mengembalikan `TIMESTAMP` nilai setelah menambahkan interval waktu tertentu ke tanggal tertentu.
**Argumen**:
+ INTERVAL: INTERVAL (DETIK, MENIT, JAM, HARI, MINGGU, BULAN, KUARTAL, TAHUN)
+ bilangan bulat: bilangan bulat
+ tanggal: DATE, TIMESTAMP, atau STRING
Jika Anda memberikan argumen `STRING` as the date, formatlah sebagai valid`TIMESTAMP`. Fungsi secara otomatis mengkonversi `DATE` argumen ke a`TIMESTAMP`.
**Contoh:**
```
os> source=people | eval `TIMESTAMPADD(DAY, 17, '2000-01-01 00:00:00')` = TIMESTAMPADD(DAY, 17, '2000-01-01 00:00:00') | eval `TIMESTAMPADD(QUARTER, -1, '2000-01-01 00:00:00')` = TIMESTAMPADD(QUARTER, -1, '2000-01-01 00:00:00') | fields `TIMESTAMPADD(DAY, 17, '2000-01-01 00:00:00')`, `TIMESTAMPADD(QUARTER, -1, '2000-01-01 00:00:00')`
fetched rows / total rows = 1/1
+----------------------------------------------+--------------------------------------------------+
| TIMESTAMPADD(DAY, 17, '2000-01-01 00:00:00') | TIMESTAMPADD(QUARTER, -1, '2000-01-01 00:00:00') |
|----------------------------------------------+--------------------------------------------------|
| 2000-01-18 00:00:00 | 1999-10-01 00:00:00 |
+----------------------------------------------+--------------------------------------------------+
```
##### `TIMESTAMPDIFF`
**Penggunaan**: `TIMESTAMPDIFF(interval, start, end)` mengembalikan perbedaan antara awal dan akhir date/times dalam satuan interval tertentu.
**Argumen**:
+ INTERVAL: INTERVAL (DETIK, MENIT, JAM, HARI, MINGGU, BULAN, KUARTAL, TAHUN)
+ mulai: DATE, TIMESTAMP, atau STRING
+ akhir: TANGGAL, TIMESTAMP, atau STRING
Fungsi secara otomatis mengkonversi argumen `TIMESTAMP` bila sesuai. Format `STRING` argumen sebagai valid `TIMESTAMP` s.
**Contoh:**
```
os> source=people | eval `TIMESTAMPDIFF(YEAR, '1997-01-01 00:00:00', '2001-03-06 00:00:00')` = TIMESTAMPDIFF(YEAR, '1997-01-01 00:00:00', '2001-03-06 00:00:00') | eval `TIMESTAMPDIFF(SECOND, timestamp('1997-01-01 00:00:23'), timestamp('1997-01-01 00:00:00'))` = TIMESTAMPDIFF(SECOND, timestamp('1997-01-01 00:00:23'), timestamp('1997-01-01 00:00:00')) | fields `TIMESTAMPDIFF(YEAR, '1997-01-01 00:00:00', '2001-03-06 00:00:00')`, `TIMESTAMPDIFF(SECOND, timestamp('1997-01-01 00:00:23'), timestamp('1997-01-01 00:00:00'))`
fetched rows / total rows = 1/1
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------+
| TIMESTAMPDIFF(YEAR, '1997-01-01 00:00:00', '2001-03-06 00:00:00') | TIMESTAMPDIFF(SECOND, timestamp('1997-01-01 00:00:23'), timestamp('1997-01-01 00:00:00')) |
|-------------------------------------------------------------------+-------------------------------------------------------------------------------------------|
| 4 | -23 |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------+
```
##### `UTC_TIMESTAMP`
**Penggunaan**: `UTC_TIMESTAMP` mengembalikan stempel waktu UTC saat ini sebagai nilai dalam 'YYYY-MM-DD hh:mm: ss'.
**Jenis pengembalian**: TIMESTAMP
**Spesifikasi**: UTC\_TIMESTAMP () -> TIMESTAMP
**Contoh:**
```
> source=people | eval `UTC_TIMESTAMP()` = UTC_TIMESTAMP() | fields `UTC_TIMESTAMP()`
fetched rows / total rows = 1/1
+---------------------+
| UTC_TIMESTAMP() |
|---------------------|
| 2022-10-03 17:54:28 |
+---------------------+
```
##### `CURRENT_TIMEZONE`
**Penggunaan**: `CURRENT_TIMEZONE` mengembalikan zona waktu lokal saat ini.
**Jenis pengembalian**: STRING
**Contoh:**
```
> source=people | eval `CURRENT_TIMEZONE()` = CURRENT_TIMEZONE() | fields `CURRENT_TIMEZONE()`
fetched rows / total rows = 1/1
+------------------------+
| CURRENT_TIMEZONE() |
|------------------------|
| America/Chicago |
+------------------------+
```
##### Ekspresi PPL
**catatan**
Untuk melihat integrasi sumber AWS data mana yang mendukung fungsi PPL ini, lihat. [Fungsi](#supported-ppl-functions)
Ekspresi, terutama ekspresi nilai, mengembalikan nilai skalar. Ekspresi memiliki tipe dan bentuk yang berbeda. Misalnya, ada nilai literal sebagai ekspresi atom dan ekspresi aritmatika, predikat, dan fungsi yang dibangun di atasnya. Anda dapat menggunakan ekspresi dalam klausa yang berbeda, seperti menggunakan ekspresi aritmatika dalam dan perintah. `Filter` `Stats`
**Operator**
Ekspresi aritmatika adalah ekspresi yang dibentuk oleh literal numerik dan operator aritmatika biner sebagai berikut:
1. `+`: Tambahkan.
1. `-`: Kurangi.
1. `*`: Lipat gandakan.
1. `/`: Divide (Untuk bilangan bulat, hasilnya adalah bilangan bulat dengan bagian fraksional dibuang)
1. `%`: Modulo (Gunakan dengan bilangan bulat saja; hasilnya adalah sisa pembagian)
**Diutamakan**
Gunakan tanda kurung untuk mengontrol prioritas operator aritmatika. Jika tidak, operator dengan prioritas lebih tinggi dilakukan terlebih dahulu.
**Jenis konversi**
Konversi tipe implisit dilakukan saat mencari tanda tangan operator. Misalnya, bilangan bulat bilangan `+` real cocok dengan tanda tangan `+(double,double)` yang menghasilkan bilangan real. Aturan ini juga berlaku untuk panggilan fungsi.
Contoh untuk berbagai jenis ekspresi aritmatika:
```
os> source=accounts | where age > (25 + 5) | fields age ;
fetched rows / total rows = 3/3
+-------+
| age |
|-------|
| 32 |
| 36 |
| 33 |
+-------+
```
**Operator predikat**
Operator predikat adalah ekspresi yang mengevaluasi menjadi benar. Perbandingan `MISSING` dan `NULL` nilai mengikuti aturan ini:
+ `MISSING`Nilai hanya sama dengan `MISSING` nilai dan kurang dari nilai lainnya.
+ `NULL`Nilai sama dengan `NULL` nilai, lebih besar dari `MISSING` nilai, tetapi kurang dari semua nilai lainnya.
**Operator**
**Operator predikat**
| Nama | Deskripsi |
| --- | --- |
| > | Lebih besar dari operator |
| >= | Operator yang lebih besar dari atau sama |
| < | Kurang dari operator |
| \!= | Operator tidak sama |
| <= | Operator kurang dari atau sama |
| = | Operator yang sama |
| LIKE | Pencocokan pola sederhana |
| IN | Tes nilai NULL |
| AND | DAN operator |
| OR | ATAU operator |
| XOR | Operator XOR |
| NOT | BUKAN tes nilai NULL |
Anda dapat membandingkan datetimes. Saat membandingkan jenis datetime yang berbeda (misalnya `DATE` dan`TIME`), keduanya mengonversi ke. `DATETIME` Aturan berikut berlaku untuk konversi:
+ `TIME`berlaku untuk tanggal hari ini.
+ `DATE`ditafsirkan pada tengah malam.
**Operator predikat dasar**
Contoh untuk operator perbandingan:
```
os> source=accounts | where age > 33 | fields age ;
fetched rows / total rows = 1/1
+-------+
| age |
|-------|
| 36 |
+-------+
```
**`IN`**
Contoh bidang uji `IN` operator dalam daftar nilai:
```
os> source=accounts | where age in (32, 33) | fields age ;
fetched rows / total rows = 2/2
+-------+
| age |
|-------|
| 32 |
| 33 |
+-------+
```
**`OR`**
Contoh `OR` operator:
```
os> source=accounts | where age = 32 OR age = 33 | fields age ;
fetched rows / total rows = 2/2
+-------+
| age |
|-------|
| 32 |
| 33 |
+-------+
```
**`NOT`**
Contoh `NOT` operator:
```
os> source=accounts | where age not in (32, 33) | fields age ;
fetched rows / total rows = 2/2
+-------+
| age |
|-------|
| 36 |
| 28 |
+-------+
```
##### Fungsi alamat IP PPL
**catatan**
Untuk melihat integrasi sumber AWS data mana yang mendukung fungsi PPL ini, lihat. [Fungsi](#supported-ppl-functions)
##### `CIDRMATCH`
**Penggunaan**: `CIDRMATCH(ip, cidr)` memeriksa apakah alamat IP yang ditentukan berada dalam kisaran cidr yang diberikan.
**Jenis argumen:**
+ STRING, STRING
+ Jenis pengembalian: BOOLEAN
**Contoh:**
```
os> source=ips | where cidrmatch(ip, '***********/24') | fields ip
fetched rows / total rows = 1/1
+--------------+
| ip |
|--------------|
| *********** |
+--------------+
os> source=ipsv6 | where cidrmatch(ip, '2003:db8::/32') | fields ip
fetched rows / total rows = 1/1
+-----------------------------------------+
| ip |
|-----------------------------------------|
| 2003:0db8:****:****:****:****:****:0000 |
+-----------------------------------------+
```
**catatan**
`ip`dapat berupa IPv6 alamat IPv4 atau alamat.
`cidr`bisa berupa IPv6 blok IPv4 atau blok.
`ip`dan `cidr` harus keduanya IPv4 atau keduanya IPv6.
`ip`dan keduanya `cidr` harus valid dan tidak kosong/non-null.
##### Fungsi PPL JSON
**catatan**
Untuk melihat integrasi sumber AWS data mana yang mendukung fungsi PPL ini, lihat. [Fungsi](#supported-ppl-functions)
##### `JSON`
**Penggunaan**: `json(value)` mengevaluasi apakah string dapat diurai sebagai format JSON. Fungsi mengembalikan string asli jika JSON valid, atau null jika tidak valid.
**Jenis argumen**: STRING
**Jenis pengembalian**: STRING/NULL. Ekspresi STRING dari format objek JSON yang valid.
**Contoh:**
```
os> source=people | eval `valid_json()` = json('[1,2,3,{"f1":1,"f2":[5,6]},4]') | fields valid_json
fetched rows / total rows = 1/1
+---------------------------------+
| valid_json |
+---------------------------------+
| [1,2,3,{"f1":1,"f2":[5,6]},4] |
+---------------------------------+
os> source=people | eval `invalid_json()` = json('{"invalid": "json"') | fields invalid_json
fetched rows / total rows = 1/1
+----------------+
| invalid_json |
+----------------+
| null |
+----------------+
```
##### `JSON_OBJECT`
**Penggunaan**: `json_object(, [, , ]...)` mengembalikan objek JSON dari anggota pasangan kunci-nilai.
**Jenis argumen:**
+ A harus STRING.
+ A dapat berupa tipe data apa saja.
**Jenis pengembalian**: JSON\_OBJECT. StructType Ekspresi objek JSON yang valid.
**Contoh:**
```
os> source=people | eval result = json_object('key', 123.45) | fields result
fetched rows / total rows = 1/1
+------------------+
| result |
+------------------+
| {"key":123.45} |
+------------------+
os> source=people | eval result = json_object('outer', json_object('inner', 123.45)) | fields result
fetched rows / total rows = 1/1
+------------------------------+
| result |
+------------------------------+
| {"outer":{"inner":123.45}} |
+------------------------------+
```
##### `JSON_ARRAY`
**Penggunaan**: `json_array(...)` membuat JSON ARRAY menggunakan daftar nilai.
**Jenis argumen**: A `` dapat berupa segala jenis nilai seperti string, angka, atau boolean.
**Jenis pengembalian**: ARRAY. Array dari setiap tipe data yang didukung untuk array JSON yang valid.
**Contoh:**
```
os> source=people | eval `json_array` = json_array(1, 2, 0, -1, 1.1, -0.11)
fetched rows / total rows = 1/1
+------------------------------+
| json_array |
+------------------------------+
| [1.0,2.0,0.0,-1.0,1.1,-0.11] |
+------------------------------+
os> source=people | eval `json_array_object` = json_object("array", json_array(1, 2, 0, -1, 1.1, -0.11))
fetched rows / total rows = 1/1
+----------------------------------------+
| json_array_object |
+----------------------------------------+
| {"array":[1.0,2.0,0.0,-1.0,1.1,-0.11]} |
+----------------------------------------+
```
##### `TO_JSON_STRING`
**Penggunaan**: `to_json_string(jsonObject)` mengembalikan string JSON dengan nilai objek json yang diberikan.
**Jenis argumen: JSON\_OBJECT**
**Jenis pengembalian**: STRING
**Contoh:**
```
os> source=people | eval `json_string` = to_json_string(json_array(1, 2, 0, -1, 1.1, -0.11)) | fields json_string
fetched rows / total rows = 1/1
+--------------------------------+
| json_string |
+--------------------------------+
| [1.0,2.0,0.0,-1.0,1.1,-0.11] |
+--------------------------------+
os> source=people | eval `json_string` = to_json_string(json_object('key', 123.45)) | fields json_string
fetched rows / total rows = 1/1
+-----------------+
| json_string |
+-----------------+
| {'key', 123.45} |
+-----------------+
```
##### `ARRAY_LENGTH`
**Penggunaan**: `array_length(jsonArray)` mengembalikan jumlah elemen dalam array terluar.
**Jenis argumen**: ARRAY. Sebuah objek ARRAY atau JSON\_ARRAY.
**Jenis pengembalian**: INTEGER
**Contoh:**
```
os> source=people | eval `json_array` = json_array_length(json_array(1,2,3,4)), `empty_array` = json_array_length(json_array())
fetched rows / total rows = 1/1
+--------------+---------------+
| json_array | empty_array |
+--------------+---------------+
| 4 | 0 |
+--------------+---------------+
```
##### `JSON_EXTRACT`
**Penggunaan**: `json_extract(jsonStr, path)` mengekstrak objek JSON dari string JSON berdasarkan jalur JSON yang ditentukan. Fungsi mengembalikan null jika input JSON string tidak valid.
**Jenis argumen**: STRING, STRING
**Jenis pengembalian**: STRING
+ Ekspresi STRING dari format objek JSON yang valid.
+ `NULL`dikembalikan jika JSON tidak valid.
**Contoh:**
```
os> source=people | eval `json_extract('{"a":"b"}', '$.a')` = json_extract('{"a":"b"}', '$a')
fetched rows / total rows = 1/1
+----------------------------------+
| json_extract('{"a":"b"}', 'a') |
+----------------------------------+
| b |
+----------------------------------+
os> source=people | eval `json_extract('{"a":[{"b":1},{"b":2}]}', '$.a[1].b')` = json_extract('{"a":[{"b":1},{"b":2}]}', '$.a[1].b')
fetched rows / total rows = 1/1
+-----------------------------------------------------------+
| json_extract('{"a":[{"b":1.0},{"b":2.0}]}', '$.a[1].b') |
+-----------------------------------------------------------+
| 2.0 |
+-----------------------------------------------------------+
os> source=people | eval `json_extract('{"a":[{"b":1},{"b":2}]}', '$.a[*].b')` = json_extract('{"a":[{"b":1},{"b":2}]}', '$.a[*].b')
fetched rows / total rows = 1/1
+-----------------------------------------------------------+
| json_extract('{"a":[{"b":1.0},{"b":2.0}]}', '$.a[*].b') |
+-----------------------------------------------------------+
| [1.0,2.0] |
+-----------------------------------------------------------+
os> source=people | eval `invalid_json` = json_extract('{"invalid": "json"')
fetched rows / total rows = 1/1
+----------------+
| invalid_json |
+----------------+
| null |
+----------------+
```
##### `JSON_KEYS`
**Penggunaan**: `json_keys(jsonStr)` mengembalikan semua kunci dari objek JSON terluar sebagai array.
**Jenis argumen**: STRING. Ekspresi STRING dari format objek JSON yang valid.
**Jenis pengembalian**: ARRAY [STRING]. Fungsi mengembalikan `NULL` untuk string JSON valid lainnya, string kosong, atau JSON tidak valid.
**Contoh:**
```
os> source=people | eval `keys` = json_keys('{"f1":"abc","f2":{"f3":"a","f4":"b"}}')
fetched rows / total rows = 1/1
+------------+
| keus |
+------------+
| [f1, f2] |
+------------+
os> source=people | eval `keys` = json_keys('[1,2,3,{"f1":1,"f2":[5,6]},4]')
fetched rows / total rows = 1/1
+--------+
| keys |
+--------+
| null |
+--------+
```
##### `JSON_VALID`
**Penggunaan**: `json_valid(jsonStr)` mengevaluasi apakah string JSON menggunakan sintaks JSON yang valid dan mengembalikan TRUE atau FALSE.
**Jenis argumen**: STRING
**Jenis pengembalian**: BOOLEAN
**Contoh:**
```
os> source=people | eval `valid_json` = json_valid('[1,2,3,4]'), `invalid_json` = json_valid('{"invalid": "json"') | feilds `valid_json`, `invalid_json`
fetched rows / total rows = 1/1
+--------------+----------------+
| valid_json | invalid_json |
+--------------+----------------+
| True | False |
+--------------+----------------+
os> source=accounts | where json_valid('[1,2,3,4]') and isnull(email) | fields account_number, email
fetched rows / total rows = 1/1
+------------------+---------+
| account_number | email |
|------------------+---------|
| 13 | null |
+------------------+---------+
```
##### Fungsi PPL Lambda
**catatan**
Untuk melihat integrasi sumber AWS data mana yang mendukung fungsi PPL ini, lihat. [Fungsi](#supported-ppl-functions)
##### `EXISTS`
**Penggunaan**: `exists(array, lambda)` mengevaluasi apakah predikat Lambda berlaku untuk satu atau lebih elemen dalam array.
**Jenis argumen**: ARRAY, LAMBDA
**Jenis pengembalian**: BOOLEAN. Mengembalikan `TRUE` jika setidaknya satu elemen dalam array memenuhi predikat Lambda, jika tidak. `FALSE`
**Contoh:**
```
os> source=people | eval array = json_array(1, -1, 2), result = exists(array, x -> x > 0) | fields result
fetched rows / total rows = 1/1
+-----------+
| result |
+-----------+
| true |
+-----------+
os> source=people | eval array = json_array(-1, -3, -2), result = exists(array, x -> x > 0) | fields result
fetched rows / total rows = 1/1
+-----------+
| result |
+-----------+
| false |
+-----------+
```
##### `FILTER`
**Penggunaan**: `filter(array, lambda)` memfilter array input menggunakan fungsi Lambda yang diberikan.
**Jenis argumen**: ARRAY, LAMBDA
**Jenis pengembalian**: ARRAY. ARRAY yang berisi semua elemen dalam array input yang memenuhi predikat lambda.
**Contoh:**
```
os> source=people | eval array = json_array(1, -1, 2), result = filter(array, x -> x > 0) | fields result
fetched rows / total rows = 1/1
+-----------+
| result |
+-----------+
| [1, 2] |
+-----------+
os> source=people | eval array = json_array(-1, -3, -2), result = filter(array, x -> x > 0) | fields result
fetched rows / total rows = 1/1
+-----------+
| result |
+-----------+
| [] |
+-----------+
```
##### `TRANSFORM`
**Penggunaan**: `transform(array, lambda)` mengubah elemen dalam array menggunakan fungsi transformasi Lambda. Argumen kedua menyiratkan indeks elemen jika menggunakan fungsi Lambda biner. Ini mirip dengan pemrograman fungsional. `map`
**Jenis argumen**: ARRAY, LAMBDA
**Jenis pengembalian**: ARRAY. ARRAY yang berisi hasil penerapan fungsi transformasi lambda ke setiap elemen dalam array input.
**Contoh:**
```
os> source=people | eval array = json_array(1, 2, 3), result = transform(array, x -> x + 1) | fields result
fetched rows / total rows = 1/1
+--------------+
| result |
+--------------+
| [2, 3, 4] |
+--------------+
os> source=people | eval array = json_array(1, 2, 3), result = transform(array, (x, i) -> x + i) | fields result
fetched rows / total rows = 1/1
+--------------+
| result |
+--------------+
| [1, 3, 5] |
+--------------+
```
##### `REDUCE`
**Penggunaan**: `reduce(array, start, merge_lambda, finish_lambda)` mengurangi array ke nilai tunggal dengan menerapkan fungsi lambda. Fungsi ini menerapkan merge\_lambda ke nilai awal dan semua elemen array, kemudian menerapkan ke hasilnya`finish_lambda`.
**Jenis argumen**: ARRAY, APAPUN, LAMBDA, LAMBDA
**Jenis pengembalian**: APA SAJA. Hasil akhir dari penerapan fungsi Lambda ke nilai awal dan array input.
**Contoh:**
```
os> source=people | eval array = json_array(1, 2, 3), result = reduce(array, 0, (acc, x) -> acc + x) | fields result
fetched rows / total rows = 1/1
+-----------+
| result |
+-----------+
| 6 |
+-----------+
os> source=people | eval array = json_array(1, 2, 3), result = reduce(array, 10, (acc, x) -> acc + x) | fields result
fetched rows / total rows = 1/1
+-----------+
| result |
+-----------+
| 16 |
+-----------+
os> source=people | eval array = json_array(1, 2, 3), result = reduce(array, 0, (acc, x) -> acc + x, acc -> acc * 10) | fields result
fetched rows / total rows = 1/1
+-----------+
| result |
+-----------+
| 60 |
+-----------+
```
##### Fungsi matematika PPL
**catatan**
Untuk melihat integrasi sumber AWS data mana yang mendukung fungsi PPL ini, lihat. [Fungsi](#supported-ppl-functions)
##### `ABS`
**Penggunaan**: `ABS(x) ` menghitung nilai absolut x.
**Jenis argumen:** INTEGER/LONG/FLOAT/DOUBLE
**Jenis pengembalian:** INTEGER/LONG/FLOAT/DOUBLE
**Contoh:**
```
os> source=people | eval `ABS(-1)` = ABS(-1) | fields `ABS(-1)`
fetched rows / total rows = 1/1
+-----------+
| ABS(-1) |
|-----------|
| 1 |
+-----------+
```
##### `ACOS`
**Penggunaan**: `ACOS(x)` menghitung busur kosinus x. Ia kembali `NULL` jika x tidak dalam kisaran -1 hingga 1.
**Jenis argumen**: INTEGER/LONG/FLOAT/DOUBLE
**Jenis pengembalian**: DOUBLE
**Contoh:**
```
os> source=people | eval `ACOS(0)` = ACOS(0) | fields `ACOS(0)`
fetched rows / total rows = 1/1
+--------------------+
| ACOS(0) |
|--------------------|
| 1.5707963267948966 |
+--------------------+
```
##### `ASIN`
**Penggunaan**: `asin(x)` menghitung sinus busur x. Ia kembali `NULL` jika x tidak dalam kisaran -1 hingga 1.
**Jenis argumen**: INTEGER/LONG/FLOAT/DOUBLE
**Jenis pengembalian**: DOUBLE
**Contoh:**
```
os> source=people | eval `ASIN(0)` = ASIN(0) | fields `ASIN(0)`
fetched rows / total rows = 1/1
+-----------+
| ASIN(0) |
|-----------|
| 0.0 |
+-----------+
```
##### `ATAN`
**Penggunaan**: `ATAN(x)` menghitung tangen busur dari x. `atan(y, x)` menghitung tangen busur dari y/x, kecuali bahwa tanda-tanda kedua argumen menentukan kuadran hasil.
**Jenis argumen**: INTEGER/LONG/FLOAT/DOUBLE
**Jenis pengembalian**: DOUBLE
**Contoh:**
```
os> source=people | eval `ATAN(2)` = ATAN(2), `ATAN(2, 3)` = ATAN(2, 3) | fields `ATAN(2)`, `ATAN(2, 3)`
fetched rows / total rows = 1/1
+--------------------+--------------------+
| ATAN(2) | ATAN(2, 3) |
|--------------------+--------------------|
| 1.1071487177940904 | 0.5880026035475675 |
+--------------------+--------------------+
```
##### `ATAN2`
**Penggunaan**: `ATAN2(y, x)` menghitung tangen busur dari y/x, kecuali bahwa tanda-tanda kedua argumen menentukan kuadran hasil.
**Jenis argumen**: INTEGER/LONG/FLOAT/DOUBLE
**Jenis pengembalian**: DOUBLE
**Contoh:**
```
os> source=people | eval `ATAN2(2, 3)` = ATAN2(2, 3) | fields `ATAN2(2, 3)`
fetched rows / total rows = 1/1
+--------------------+
| ATAN2(2, 3) |
|--------------------|
| 0.5880026035475675 |
+--------------------+
```
##### `CBRT`
**Penggunaan**: `CBRT` menghitung akar kubus dari suatu angka.
**Jenis argumen**: INTEGER/LONG/FLOAT/DOUBLE
**Jenis pengembalian**: DOUBLE:
INTEGER/LONG/FLOAT/DOUBLE-> GANDA
**Contoh:**
```
opensearchsql> source=location | eval `CBRT(8)` = CBRT(8), `CBRT(9.261)` = CBRT(9.261), `CBRT(-27)` = CBRT(-27) | fields `CBRT(8)`, `CBRT(9.261)`, `CBRT(-27)`;
fetched rows / total rows = 2/2
+-----------+---------------+-------------+
| CBRT(8) | CBRT(9.261) | CBRT(-27) |
|-----------+---------------+-------------|
| 2.0 | 2.1 | -3.0 |
| 2.0 | 2.1 | -3.0 |
+-----------+---------------+-------------+
```
##### `CEIL`
**Penggunaan**: Sebuah alias untuk `CEILING` fungsi. `CEILING(T)`mengambil plafon nilai T.
**Batasan**: `CEILING` hanya berfungsi seperti yang diharapkan ketika IEEE 754 tipe ganda menampilkan desimal saat disimpan.
**Jenis argumen**: INTEGER/LONG/FLOAT/DOUBLE
**Jenis pengembalian**: PANJANG
**Contoh:**
```
os> source=people | eval `CEILING(0)` = CEILING(0), `CEILING(50.00005)` = CEILING(50.00005), `CEILING(-50.00005)` = CEILING(-50.00005) | fields `CEILING(0)`, `CEILING(50.00005)`, `CEILING(-50.00005)`
fetched rows / total rows = 1/1
+--------------+---------------------+----------------------+
| CEILING(0) | CEILING(50.00005) | CEILING(-50.00005) |
|--------------+---------------------+----------------------|
| 0 | 51 | -50 |
+--------------+---------------------+----------------------+
os> source=people | eval `CEILING(3147483647.12345)` = CEILING(3147483647.12345), `CEILING(113147483647.12345)` = CEILING(113147483647.12345), `CEILING(3147483647.00001)` = CEILING(3147483647.00001) | fields `CEILING(3147483647.12345)`, `CEILING(113147483647.12345)`, `CEILING(3147483647.00001)`
fetched rows / total rows = 1/1
+-----------------------------+-------------------------------+-----------------------------+
| CEILING(3147483647.12345) | CEILING(113147483647.12345) | CEILING(3147483647.00001) |
|-----------------------------+-------------------------------+-----------------------------|
| 3147483648 | 113147483648 | 3147483648 |
+-----------------------------+-------------------------------+-----------------------------+
```
##### `CONV`
**Penggunaan**: `CONV(x, a, b)` mengubah angka x dari basis ke basis b.
**Jenis argumen**: x: STRING, a: INTEGER, b: INTEGER
**Jenis pengembalian**: STRING
**Contoh:**
```
os> source=people | eval `CONV('12', 10, 16)` = CONV('12', 10, 16), `CONV('2C', 16, 10)` = CONV('2C', 16, 10), `CONV(12, 10, 2)` = CONV(12, 10, 2), `CONV(1111, 2, 10)` = CONV(1111, 2, 10) | fields `CONV('12', 10, 16)`, `CONV('2C', 16, 10)`, `CONV(12, 10, 2)`, `CONV(1111, 2, 10)`
fetched rows / total rows = 1/1
+----------------------+----------------------+-------------------+---------------------+
| CONV('12', 10, 16) | CONV('2C', 16, 10) | CONV(12, 10, 2) | CONV(1111, 2, 10) |
|----------------------+----------------------+-------------------+---------------------|
| c | 44 | 1100 | 15 |
+----------------------+----------------------+-------------------+---------------------+
```
##### `COS`
**Penggunaan**: `COS(x)` menghitung kosinus x, di mana x diberikan dalam radian.
**Jenis argumen**: INTEGER/LONG/FLOAT/DOUBLE
**Jenis pengembalian:** DOUBLE
**Contoh:**
```
os> source=people | eval `COS(0)` = COS(0) | fields `COS(0)`
fetched rows / total rows = 1/1
+----------+
| COS(0) |
|----------|
| 1.0 |
+----------+
```
##### `COT`
**Penggunaan**: `COT(x)` menghitung kotangen x. Ia mengembalikan out-of-range kesalahan jika x sama dengan 0.
**Jenis argumen**: INTEGER/LONG/FLOAT/DOUBLE
**Jenis pengembalian**: DOUBLE
**Contoh:**
```
os> source=people | eval `COT(1)` = COT(1) | fields `COT(1)`
fetched rows / total rows = 1/1
+--------------------+
| COT(1) |
|--------------------|
| 0.6420926159343306 |
+--------------------+
```
##### `CRC32`
**Penggunaan**: `CRC32` menghitung nilai pemeriksaan redundansi siklik dan mengembalikan nilai unsigned 32-bit.
**Jenis argumen**: STRING
**Jenis pengembalian**: PANJANG
**Contoh:**
```
os> source=people | eval `CRC32('MySQL')` = CRC32('MySQL') | fields `CRC32('MySQL')`
fetched rows / total rows = 1/1
+------------------+
| CRC32('MySQL') |
|------------------|
| 3259397556 |
+------------------+
```
##### `DEGREES`
**Penggunaan**: `DEGREES(x)` mengkonversi x dari radian ke derajat.
**Jenis argumen**: INTEGER/LONG/FLOAT/DOUBLE
**Jenis pengembalian**: DOUBLE
**Contoh:**
```
os> source=people | eval `DEGREES(1.57)` = DEGREES(1.57) | fields `DEGREES(1.57)`
fetched rows / total rows = 1/1
+-------------------+
| DEGREES(1.57) |
|-------------------|
| 89.95437383553924 |
+-------------------+
```
##### `E`
**Penggunaan**: `E()` mengembalikan nomor Euler.
**Jenis pengembalian**: DOUBLE
**Contoh:**
```
os> source=people | eval `E()` = E() | fields `E()`
fetched rows / total rows = 1/1
+-------------------+
| E() |
|-------------------|
| 2.718281828459045 |
+-------------------+
```
##### `EXP`
**Penggunaan**: `EXP(x)` mengembalikan e dinaikkan ke kekuatan x.
**Jenis argumen**: INTEGER/LONG/FLOAT/DOUBLE
**Jenis pengembalian**: DOUBLE
**Contoh:**
```
os> source=people | eval `EXP(2)` = EXP(2) | fields `EXP(2)`
fetched rows / total rows = 1/1
+------------------+
| EXP(2) |
|------------------|
| 7.38905609893065 |
+------------------+
```
##### `FLOOR`
**Penggunaan**: `FLOOR(T)` mengambil lantai nilai T.
**Batasan**: `FLOOR` hanya berfungsi seperti yang diharapkan ketika IEEE 754 tipe ganda menampilkan desimal saat disimpan.
**Jenis argumen**: INTEGER/LONG/FLOAT/DOUBLE
**Jenis pengembalian**: PANJANG
**Contoh:**
```
os> source=people | eval `FLOOR(0)` = FLOOR(0), `FLOOR(50.00005)` = FLOOR(50.00005), `FLOOR(-50.00005)` = FLOOR(-50.00005) | fields `FLOOR(0)`, `FLOOR(50.00005)`, `FLOOR(-50.00005)`
fetched rows / total rows = 1/1
+------------+-------------------+--------------------+
| FLOOR(0) | FLOOR(50.00005) | FLOOR(-50.00005) |
|------------+-------------------+--------------------|
| 0 | 50 | -51 |
+------------+-------------------+--------------------+
os> source=people | eval `FLOOR(3147483647.12345)` = FLOOR(3147483647.12345), `FLOOR(113147483647.12345)` = FLOOR(113147483647.12345), `FLOOR(3147483647.00001)` = FLOOR(3147483647.00001) | fields `FLOOR(3147483647.12345)`, `FLOOR(113147483647.12345)`, `FLOOR(3147483647.00001)`
fetched rows / total rows = 1/1
+---------------------------+-----------------------------+---------------------------+
| FLOOR(3147483647.12345) | FLOOR(113147483647.12345) | FLOOR(3147483647.00001) |
|---------------------------+-----------------------------+---------------------------|
| 3147483647 | 113147483647 | 3147483647 |
+---------------------------+-----------------------------+---------------------------+
os> source=people | eval `FLOOR(282474973688888.022)` = FLOOR(282474973688888.022), `FLOOR(9223372036854775807.022)` = FLOOR(9223372036854775807.022), `FLOOR(9223372036854775807.0000001)` = FLOOR(9223372036854775807.0000001) | fields `FLOOR(282474973688888.022)`, `FLOOR(9223372036854775807.022)`, `FLOOR(9223372036854775807.0000001)`
fetched rows / total rows = 1/1
+------------------------------+----------------------------------+--------------------------------------+
| FLOOR(282474973688888.022) | FLOOR(9223372036854775807.022) | FLOOR(9223372036854775807.0000001) |
|------------------------------+----------------------------------+--------------------------------------|
| 282474973688888 | 9223372036854775807 | 9223372036854775807 |
+------------------------------+----------------------------------+--------------------------------------+
```
##### `LN`
**Penggunaan**: `LN(x)` mengembalikan logaritma natural dari x.
**Jenis argumen**: INTEGER/LONG/FLOAT/DOUBLE
**Jenis pengembalian**: DOUBLE
**Contoh:**
```
os> source=people | eval `LN(2)` = LN(2) | fields `LN(2)`
fetched rows / total rows = 1/1
+--------------------+
| LN(2) |
|--------------------|
| 0.6931471805599453 |
+--------------------+
```
##### `LOG`
**Penggunaan**: `LOG(x)` mengembalikan logaritma natural dari x yang merupakan basis e logaritma dari x. log (B, x) setara dengan log (x) /log (B).
**Jenis argumen**: INTEGER/LONG/FLOAT/DOUBLE
**Jenis pengembalian**: DOUBLE
**Contoh:**
```
os> source=people | eval `LOG(2)` = LOG(2), `LOG(2, 8)` = LOG(2, 8) | fields `LOG(2)`, `LOG(2, 8)`
fetched rows / total rows = 1/1
+--------------------+-------------+
| LOG(2) | LOG(2, 8) |
|--------------------+-------------|
| 0.6931471805599453 | 3.0 |
+--------------------+-------------+
```
##### `LOG2`
**Penggunaan**: `LOG2(x)` setara dengan`log(x)`/`log(2)`.
**Jenis argumen**: INTEGER/LONG/FLOAT/DOUBLE
**Jenis pengembalian**: DOUBLE
**Contoh:**
```
os> source=people | eval `LOG2(8)` = LOG2(8) | fields `LOG2(8)`
fetched rows / total rows = 1/1
+-----------+
| LOG2(8) |
|-----------|
| 3.0 |
+-----------+
```
##### `LOG10`
**Penggunaan**: `LOG10(x)` setara dengan`log(x)`/`log(10)`.
**Jenis argumen**: INTEGER/LONG/FLOAT/DOUBLE
**Jenis pengembalian**: DOUBLE
**Contoh:**
```
os> source=people | eval `LOG10(100)` = LOG10(100) | fields `LOG10(100)`
fetched rows / total rows = 1/1
+--------------+
| LOG10(100) |
|--------------|
| 2.0 |
+--------------+
```
##### `MOD`
**Penggunaan**: `MOD(n, m)` menghitung sisa angka n dibagi dengan m.
**Jenis argumen**: INTEGER/LONG/FLOAT/DOUBLE
**Tipe pengembalian**: Tipe yang lebih luas antara tipe n dan m jika m adalah nilai bukan nol. Jika m sama dengan 0, maka kembali NULL.
**Contoh:**
```
os> source=people | eval `MOD(3, 2)` = MOD(3, 2), `MOD(3.1, 2)` = MOD(3.1, 2) | fields `MOD(3, 2)`, `MOD(3.1, 2)`
fetched rows / total rows = 1/1
+-------------+---------------+
| MOD(3, 2) | MOD(3.1, 2) |
|-------------+---------------|
| 1 | 1.1 |
+-------------+---------------+
```
##### `PI`
**Penggunaan**: `PI() ` mengembalikan pi konstan.
**Jenis pengembalian**: DOUBLE
**Contoh:**
```
os> source=people | eval `PI()` = PI() | fields `PI()`
fetched rows / total rows = 1/1
+-------------------+
| PI() |
|-------------------|
| 3.141592653589793 |
+-------------------+
```
##### `POW`
**Penggunaan**: `POW(x, y)` menghitung nilai x dinaikkan ke kekuatan y. Masukan yang buruk mengembalikan `NULL` hasil.
**Jenis argumen**: INTEGER/LONG/FLOAT/DOUBLE
**Jenis pengembalian**: DOUBLE
**Sinonim**: `POWER(_, _)`
**Contoh:**
```
os> source=people | eval `POW(3, 2)` = POW(3, 2), `POW(-3, 2)` = POW(-3, 2), `POW(3, -2)` = POW(3, -2) | fields `POW(3, 2)`, `POW(-3, 2)`, `POW(3, -2)`
fetched rows / total rows = 1/1
+-------------+--------------+--------------------+
| POW(3, 2) | POW(-3, 2) | POW(3, -2) |
|-------------+--------------+--------------------|
| 9.0 | 9.0 | 0.1111111111111111 |
+-------------+--------------+--------------------+
```
##### DAYA
**Penggunaan**: `POWER(x, y)` menghitung nilai x dinaikkan ke kekuatan y. Masukan yang buruk mengembalikan `NULL` hasil.
**Jenis argumen**: INTEGER/LONG/FLOAT/DOUBLE
**Jenis pengembalian**: DOUBLE
**Sinonim**: `POW(_, _)`
**Contoh:**
```
os> source=people | eval `POWER(3, 2)` = POWER(3, 2), `POWER(-3, 2)` = POWER(-3, 2), `POWER(3, -2)` = POWER(3, -2) | fields `POWER(3, 2)`, `POWER(-3, 2)`, `POWER(3, -2)`
fetched rows / total rows = 1/1
+---------------+----------------+--------------------+
| POWER(3, 2) | POWER(-3, 2) | POWER(3, -2) |
|---------------+----------------+--------------------|
| 9.0 | 9.0 | 0.1111111111111111 |
+---------------+----------------+--------------------+
```
##### `RADIANS`
**Penggunaan**: `RADIANS(x)` mengkonversi x dari derajat ke radian.
**Jenis argumen**: INTEGER/LONG/FLOAT/DOUBLE
**Jenis pengembalian**: DOUBLE
**Contoh:**
```
os> source=people | eval `RADIANS(90)` = RADIANS(90) | fields `RADIANS(90)`
fetched rows / total rows = 1/1
+--------------------+
| RADIANS(90) |
|--------------------|
| 1.5707963267948966 |
+--------------------+
```
##### `RAND`
**Penggunaan**:`RAND()`/`RAND(N)`mengembalikan nilai floating-point acak dalam kisaran 0 <= nilai < 1.0. Jika Anda menentukan bilangan bulat N, fungsi menginisialisasi benih sebelum eksekusi. Salah satu implikasi dari perilaku ini adalah bahwa dengan argumen N yang identik, `rand(N)` mengembalikan nilai yang sama setiap kali, menghasilkan urutan nilai kolom yang dapat diulang.
**Jenis argumen**: INTEGER
**Jenis pengembalian**: FLOAT
**Contoh:**
```
os> source=people | eval `RAND(3)` = RAND(3) | fields `RAND(3)`
fetched rows / total rows = 1/1
+------------+
| RAND(3) |
|------------|
| 0.73105735 |
+------------+
```
##### `ROUND`
**Penggunaan**: `ROUND(x, d)` membulatkan argumen x ke d tempat desimal. Jika Anda tidak menentukan d, defaultnya adalah 0.
**Jenis argumen**: INTEGER/LONG/FLOAT/DOUBLE
**Peta tipe pengembalian**:
+ (INTEGER/PANJANG [, INTEGER]) -> PANJANG
+ (MENGAPUNG/GANDA [, BILANGAN BULAT]) -> PANJANG
**Contoh:**
```
os> source=people | eval `ROUND(12.34)` = ROUND(12.34), `ROUND(12.34, 1)` = ROUND(12.34, 1), `ROUND(12.34, -1)` = ROUND(12.34, -1), `ROUND(12, 1)` = ROUND(12, 1) | fields `ROUND(12.34)`, `ROUND(12.34, 1)`, `ROUND(12.34, -1)`, `ROUND(12, 1)`
fetched rows / total rows = 1/1
+----------------+-------------------+--------------------+----------------+
| ROUND(12.34) | ROUND(12.34, 1) | ROUND(12.34, -1) | ROUND(12, 1) |
|----------------+-------------------+--------------------+----------------|
| 12.0 | 12.3 | 10.0 | 12 |
+----------------+-------------------+--------------------+----------------+
```
##### `SIGN`
**Penggunaan**: `SIGN` mengembalikan tanda argumen sebagai -1, 0, atau 1, tergantung pada apakah jumlahnya negatif, nol, atau positif.
**Jenis argumen**: INTEGER/LONG/FLOAT/DOUBLE
**Jenis pengembalian:** INTEGER
**Contoh:**
```
os> source=people | eval `SIGN(1)` = SIGN(1), `SIGN(0)` = SIGN(0), `SIGN(-1.1)` = SIGN(-1.1) | fields `SIGN(1)`, `SIGN(0)`, `SIGN(-1.1)`
fetched rows / total rows = 1/1
+-----------+-----------+--------------+
| SIGN(1) | SIGN(0) | SIGN(-1.1) |
|-----------+-----------+--------------|
| 1 | 0 | -1 |
+-----------+-----------+--------------+
```
##### `SIN`
**Penggunaan**: `sin(x)` menghitung sinus x, di mana x diberikan dalam radian.
**Jenis argumen:** INTEGER/LONG/FLOAT/DOUBLE
**Jenis pengembalian:** DOUBLE
**Contoh:**
```
os> source=people | eval `SIN(0)` = SIN(0) | fields `SIN(0)`
fetched rows / total rows = 1/1
+----------+
| SIN(0) |
|----------|
| 0.0 |
+----------+
```
##### `SQRT`
**Penggunaan**: `SQRT` menghitung akar kuadrat dari angka non-negatif.
**Jenis argumen:** INTEGER/LONG/FLOAT/DOUBLE
**Peta tipe pengembalian:**
+ (Non-negatif) INTEGER/LONG/FLOAT/DOUBLE -> GANDA
+ (Negatif) INTEGER/LONG/FLOAT/DOUBLE -> NULL
**Contoh:**
```
os> source=people | eval `SQRT(4)` = SQRT(4), `SQRT(4.41)` = SQRT(4.41) | fields `SQRT(4)`, `SQRT(4.41)`
fetched rows / total rows = 1/1
+-----------+--------------+
| SQRT(4) | SQRT(4.41) |
|-----------+--------------|
| 2.0 | 2.1 |
+-----------+--------------+
```
##### Fungsi string PPL
**catatan**
Untuk melihat integrasi sumber AWS data mana yang mendukung fungsi PPL ini, lihat. [Fungsi](#supported-ppl-functions)
##### `CONCAT`
**Penggunaan**: `CONCAT(str1, str2, ...., str_9)` menambahkan hingga 9 string bersama-sama.
**Jenis argumen:**
+ STRING, STRING,..., STRING
+ Jenis pengembalian: STRING
**Contoh:**
```
os> source=people | eval `CONCAT('hello', 'world')` = CONCAT('hello', 'world'), `CONCAT('hello ', 'whole ', 'world', '!')` = CONCAT('hello ', 'whole ', 'world', '!') | fields `CONCAT('hello', 'world')`, `CONCAT('hello ', 'whole ', 'world', '!')`
fetched rows / total rows = 1/1
+----------------------------+--------------------------------------------+
| CONCAT('hello', 'world') | CONCAT('hello ', 'whole ', 'world', '!') |
|----------------------------+--------------------------------------------|
| helloworld | hello whole world! |
+----------------------------+--------------------------------------------+
```
##### `CONCAT_WS`
**Penggunaan**: `CONCAT_WS(sep, str1, str2)` menggabungkan dua atau lebih string menggunakan pemisah tertentu di antara mereka.
**Jenis argumen:**
+ STRING, STRING,..., STRING
+ Jenis pengembalian: STRING
**Contoh:**
```
os> source=people | eval `CONCAT_WS(',', 'hello', 'world')` = CONCAT_WS(',', 'hello', 'world') | fields `CONCAT_WS(',', 'hello', 'world')`
fetched rows / total rows = 1/1
+------------------------------------+
| CONCAT_WS(',', 'hello', 'world') |
|------------------------------------|
| hello,world |
+------------------------------------+
```
##### `LENGTH`
**Penggunaan**: `length(str)` mengembalikan panjang string input diukur dalam byte.
**Jenis argumen:**
+ STRING
+ Jenis pengembalian: INTEGER
**Contoh:**
```
os> source=people | eval `LENGTH('helloworld')` = LENGTH('helloworld') | fields `LENGTH('helloworld')`
fetched rows / total rows = 1/1
+------------------------+
| LENGTH('helloworld') |
|------------------------|
| 10 |
+------------------------+
```
##### `LOWER`
**Penggunaan**: `lower(string)` mengkonversi string input ke huruf kecil.
**Jenis argumen:**
+ STRING
+ Jenis pengembalian: STRING
**Contoh:**
```
os> source=people | eval `LOWER('helloworld')` = LOWER('helloworld'), `LOWER('HELLOWORLD')` = LOWER('HELLOWORLD') | fields `LOWER('helloworld')`, `LOWER('HELLOWORLD')`
fetched rows / total rows = 1/1
+-----------------------+-----------------------+
| LOWER('helloworld') | LOWER('HELLOWORLD') |
|-----------------------+-----------------------|
| helloworld | helloworld |
+-----------------------+-----------------------+
```
##### `LTRIM`
**Penggunaan**: `ltrim(str)` menghapus karakter spasi terkemuka dari string input.
**Jenis argumen:**
+ STRING
+ Jenis pengembalian: STRING
**Contoh:**
```
os> source=people | eval `LTRIM(' hello')` = LTRIM(' hello'), `LTRIM('hello ')` = LTRIM('hello ') | fields `LTRIM(' hello')`, `LTRIM('hello ')`
fetched rows / total rows = 1/1
+---------------------+---------------------+
| LTRIM(' hello') | LTRIM('hello ') |
|---------------------+---------------------|
| hello | hello |
+---------------------+---------------------+
```
##### `POSITION`
**Penggunaan**: `POSITION(substr IN str)` mengembalikan posisi kejadian pertama substring dalam string. Ia mengembalikan 0 jika substring tidak dalam string. Ia mengembalikan NULL jika argumen adalah NULL.
**Jenis argumen:**
+ STRING, STRING
+ Kembalikan tipe INTEGER
**Contoh:**
```
os> source=people | eval `POSITION('world' IN 'helloworld')` = POSITION('world' IN 'helloworld'), `POSITION('invalid' IN 'helloworld')`= POSITION('invalid' IN 'helloworld') | fields `POSITION('world' IN 'helloworld')`, `POSITION('invalid' IN 'helloworld')`
fetched rows / total rows = 1/1
+-------------------------------------+---------------------------------------+
| POSITION('world' IN 'helloworld') | POSITION('invalid' IN 'helloworld') |
|-------------------------------------+---------------------------------------|
| 6 | 0 |
+-------------------------------------+---------------------------------------+
```
##### `REVERSE`
**Penggunaan**: `REVERSE(str)` mengembalikan string terbalik dari string input.
**Jenis argumen:**
+ STRING
+ Jenis pengembalian: STRING
**Contoh:**
```
os> source=people | eval `REVERSE('abcde')` = REVERSE('abcde') | fields `REVERSE('abcde')`
fetched rows / total rows = 1/1
+--------------------+
| REVERSE('abcde') |
|--------------------|
| edcba |
+--------------------+
```
##### `RIGHT`
**Penggunaan**: `right(str, len)` mengembalikan karakter paling kanan dari string input. Ia mengembalikan 0 jika substring tidak dalam string. Ia mengembalikan NULL jika argumen adalah NULL.
**Jenis argumen:**
+ STRING, BILANGAN BULAT
+ Jenis pengembalian: STRING
**Contoh:**
```
os> source=people | eval `RIGHT('helloworld', 5)` = RIGHT('helloworld', 5), `RIGHT('HELLOWORLD', 0)` = RIGHT('HELLOWORLD', 0) | fields `RIGHT('helloworld', 5)`, `RIGHT('HELLOWORLD', 0)`
fetched rows / total rows = 1/1
+--------------------------+--------------------------+
| RIGHT('helloworld', 5) | RIGHT('HELLOWORLD', 0) |
|--------------------------+--------------------------|
| world | |
+--------------------------+--------------------------+
```
##### `RTRIM`
**Penggunaan**: `rtrim(str)` memangkas karakter spasi trailing dari string input.
**Jenis argumen:**
+ STRING
+ Jenis pengembalian: **STRING**
**Contoh:**
```
os> source=people | eval `RTRIM(' hello')` = RTRIM(' hello'), `RTRIM('hello ')` = RTRIM('hello ') | fields `RTRIM(' hello')`, `RTRIM('hello ')`
fetched rows / total rows = 1/1
+---------------------+---------------------+
| RTRIM(' hello') | RTRIM('hello ') |
|---------------------+---------------------|
| hello | hello |
+---------------------+---------------------+
```
##### `SUBSTRING`
**Penggunaan**: `substring(str, start)` atau `substring(str, start, length)` mengembalikan substring dari string input. Dengan tidak ada panjang yang ditentukan, ia mengembalikan seluruh string dari posisi awal.
**Jenis argumen:**
+ STRING, BILANGAN BULAT, BILANGAN BULAT
+ Jenis pengembalian: STRING
**Contoh:**
```
os> source=people | eval `SUBSTRING('helloworld', 5)` = SUBSTRING('helloworld', 5), `SUBSTRING('helloworld', 5, 3)` = SUBSTRING('helloworld', 5, 3) | fields `SUBSTRING('helloworld', 5)`, `SUBSTRING('helloworld', 5, 3)`
fetched rows / total rows = 1/1
+------------------------------+---------------------------------+
| SUBSTRING('helloworld', 5) | SUBSTRING('helloworld', 5, 3) |
|------------------------------+---------------------------------|
| oworld | owo |
+------------------------------+---------------------------------+
```
##### `TRIM`
**Penggunaan**: `trim(string)` menghapus spasi depan dan belakang dari string input.
**Jenis argumen:**
+ STRING
+ Jenis pengembalian: **STRING**
**Contoh:**
```
os> source=people | eval `TRIM(' hello')` = TRIM(' hello'), `TRIM('hello ')` = TRIM('hello ') | fields `TRIM(' hello')`, `TRIM('hello ')`
fetched rows / total rows = 1/1
+--------------------+--------------------+
| TRIM(' hello') | TRIM('hello ') |
|--------------------+--------------------|
| hello | hello |
+--------------------+--------------------+
```
##### `UPPER`
**Penggunaan**: `upper(string)` mengkonversi string input ke huruf besar.
**Jenis argumen:**
+ STRING
+ Jenis pengembalian: STRING
**Contoh:**
```
os> source=people | eval `UPPER('helloworld')` = UPPER('helloworld'), `UPPER('HELLOWORLD')` = UPPER('HELLOWORLD') | fields `UPPER('helloworld')`, `UPPER('HELLOWORLD')`
fetched rows / total rows = 1/1
+-----------------------+-----------------------+
| UPPER('helloworld') | UPPER('HELLOWORLD') |
|-----------------------+-----------------------|
| HELLOWORLD | HELLOWORLD |
+-----------------------+-----------------------+
```
##### Fungsi konversi tipe PPL
**catatan**
Untuk melihat integrasi sumber AWS data mana yang mendukung fungsi PPL ini, lihat. [Fungsi](#supported-ppl-functions)
##### `TRIM`
**Penggunaan**: `cast(expr as dateType)` melemparkan `expr` ke `dataType` dan mengembalikan nilai. `dataType`
Aturan konversi berikut berlaku:
**Ketik aturan konversi**
| Src/Target | STRING | ANGKA | BOOLEAN | TIMESTAMP | DATE | TIME |
| --- | --- | --- | --- | --- | --- | --- |
| STRING | | Catatan1 | Catatan1 | STEMPEL WAKTU () | TANGGAL () | WAKTU () |
| ANGKA | Catatan1 | | v\! =0 | N/A | N/A | N/A |
| BOOLEAN | Catatan1 | v? 1:0 | | N/A | N/A | N/A |
| TIMESTAMP | Catatan1 | N/A | N/A | | TANGGAL () | WAKTU () |
| DATE | Catatan1 | N/A | N/A | N/A | | N/A |
| TIME | Catatan1 | N/A | N/A | N/A | N/A | |
**Contoh cast ke string:**
```
os> source=people | eval `cbool` = CAST(true as string), `cint` = CAST(1 as string), `cdate` = CAST(CAST('2012-08-07' as date) as string) | fields `cbool`, `cint`, `cdate`
fetched rows / total rows = 1/1
+---------+--------+------------+
| cbool | cint | cdate |
|---------+--------+------------|
| true | 1 | 2012-08-07 |
+---------+--------+------------+
```
**Contoh lemparkan ke nomor:**
```
os> source=people | eval `cbool` = CAST(true as int), `cstring` = CAST('1' as int) | fields `cbool`, `cstring`
fetched rows / total rows = 1/1
+---------+-----------+
| cbool | cstring |
|---------+-----------|
| 1 | 1 |
+---------+-----------+
```
**Contoh Cast to Date:**
```
os> source=people | eval `cdate` = CAST('2012-08-07' as date), `ctime` = CAST('01:01:01' as time), `ctimestamp` = CAST('2012-08-07 01:01:01' as timestamp) | fields `cdate`, `ctime`, `ctimestamp`
fetched rows / total rows = 1/1
+------------+----------+---------------------+
| cdate | ctime | ctimestamp |
|------------+----------+---------------------|
| 2012-08-07 | 01:01:01 | 2012-08-07 01:01:01 |
+------------+----------+---------------------+
```
**Contoh pemeran berantai:**
```
os> source=people | eval `cbool` = CAST(CAST(true as string) as boolean) | fields `cbool`
fetched rows / total rows = 1/1
+---------+
| cbool |
|---------|
| True |
+---------+
```