Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris. # Perintah dan OpenSearch fungsi SQL yang didukung Tabel referensi berikut menunjukkan perintah SQL mana yang didukung di OpenSearch Discover untuk kueri data di Amazon S3, Security Lake, CloudWatch atau Log, dan perintah SQL mana yang didukung dalam Wawasan Log. CloudWatch Sintaks SQL yang didukung dalam Wawasan CloudWatch Log dan yang didukung di OpenSearch Discover untuk kueri CloudWatch Log adalah sama, dan direferensikan sebagai CloudWatch Log dalam tabel berikut. **catatan** OpenSearch juga memiliki dukungan SQL untuk kueri data yang dicerna OpenSearch dan disimpan dalam indeks. Dialek SQL ini berbeda dari SQL yang digunakan dalam query langsung dan disebut sebagai [OpenSearch SQL](https://opensearch.org/docs/latest/search-plugins/sql/sql/index/) pada indeks. **Topics** + [Commands](#supported-sql-data-retrieval) + [Fungsi](#supported-sql-functions) + [Pembatasan SQL umum](#general-sql-restrictions) + [Informasi tambahan untuk pengguna CloudWatch Log Insights menggunakan OpenSearch SQL](#supported-sql-for-multi-log-queries) ## Commands **catatan** Di kolom perintah contoh, ganti sesuai `` kebutuhan tergantung pada sumber data yang Anda kueri. Contoh perintah: `SELECT Body , Operation FROM ` Jika Anda menanyakan Amazon S3 atau Security Lake, gunakan: `SELECT Body , Operation FROM table_name` Jika Anda menanyakan CloudWatch Log, gunakan: `SELECT Body , Operation FROM `LogGroupA`` | Perintah | Deskripsi | CloudWatch Log | Amazon S3 | Danau Keamanan | Perintah contoh | | --- | --- | --- | --- | --- | --- | | [Klausa SELECT](#supported-sql-select) | Menampilkan nilai yang diproyeksikan. | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | 
SELECT 
    method,
    status 
FROM
| | [Klausa WHERE](#supported-sql-where) | Memfilter peristiwa log berdasarkan kriteria bidang yang disediakan. | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | 
SELECT 
    * 
FROM 
    
WHERE 
    status = 100
| | [Klausa GROUP BY](#supported-sql-group-by) | Grup mencatat peristiwa berdasarkan kategori dan menemukan rata-rata berdasarkan statistik. | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | 
SELECT 
    method,
    status,
    COUNT(*) AS request_count,
    SUM(bytes) AS total_bytes 
FROM 
     
GROUP BY 
    method, 
    status
| | [Klausa HAVING](#supported-sql-having) | Memfilter hasil berdasarkan kondisi pengelompokan. | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | 
SELECT 
    method,
    status,
    COUNT(*) AS request_count,
    SUM(bytes) AS total_bytes 
FROM 
     
GROUP BY 
    method,
    status
HAVING 
    COUNT(*) > 5
| | [Klausa ORDER BY](#supported-sql-order-by) | Memesan hasil berdasarkan bidang dalam klausa pesanan. Anda dapat mengurutkan dalam urutan menurun atau naik. | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | 
SELECT 
    * 
FROM 
     
ORDER BY 
    status DESC
| | [Klausa JOIN](#supported-sql-join) ( `INNER` \$1 `CROSS` \$1 `LEFT` `OUTER` ) | Bergabung dengan hasil untuk dua tabel berdasarkan bidang umum. | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung (harus menggunakan `Inner` dan `Left Outer` kata kunci untuk bergabung; Hanya satu operasi JOIN yang didukung dalam pernyataan SELECT) | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung (harus menggunakan kata kunci Inner, Left Outer, dan Cross untuk bergabung) | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung (harus menggunakan kata kunci Inner, Left Outer, dan Cross untuk bergabung) | 
SELECT 
    A.Body,
    B.Timestamp
FROM 
     AS A 
INNER JOIN 
     AS B 
    ON A.`requestId` = B.`requestId`
| | [Klausa LIMIT](#supported-sql-limit) | Membatasi hasil ke baris N pertama. | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | 
SELECT 
    * 
FROM 
     
LIMIT 
    10
| | [Klausul KASUS](#supported-sql-case) | Mengevaluasi kondisi dan mengembalikan nilai ketika kondisi pertama terpenuhi. | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | 
SELECT
    method,
    status,
    CASE
        WHEN status BETWEEN 100 AND 199 THEN 'Informational'
        WHEN status BETWEEN 200 AND 299 THEN 'Success'
        WHEN status BETWEEN 300 AND 399 THEN 'Redirection'
        WHEN status BETWEEN 400 AND 499 THEN 'Client Error'
        WHEN status BETWEEN 500 AND 599 THEN 'Server Error'
        ELSE 'Unknown Status'
    END AS status_category,
    CASE method
        WHEN 'GET' THEN 'Read Operation'
        WHEN 'POST' THEN 'Create Operation'
        WHEN 'PUT' THEN 'Update Operation'
        WHEN 'PATCH' THEN 'Partial Update Operation'
        WHEN 'DELETE' THEN 'Delete Operation'
        ELSE 'Other Operation'
    END AS operation_type,
    bytes,
    datetime
FROM
| | [Ekspresi tabel umum](#supported-sql-cte) | Membuat set hasil sementara bernama dalam pernyataan SELECT, INSERT, UPDATE, DELETE, atau MERGE. | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/negative_icon.svg)Tidak didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | 
WITH RequestStats AS (
    SELECT 
        method,
        status,
        bytes,
        COUNT(*) AS request_count
    FROM 
        tableName
    GROUP BY 
        method,
        status,
        bytes
)
SELECT 
    method,
    status,
    bytes,
    request_count 
FROM 
    RequestStats 
WHERE 
    bytes > 1000
| | [EXPLAIN](#supported-sql-explain) | Menampilkan rencana eksekusi pernyataan SQL tanpa benar-benar mengeksekusinya. | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/negative_icon.svg)Tidak didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | 
EXPLAIN
SELECT 
    k,
    SUM(v)
FROM 
    VALUES 
        (1, 2),
        (1, 3) AS t(k, v)
GROUP BY 
    k
| | [Klausa SUBQUERY LATERAL](#supported-sql-lateral-subquery) | Mengizinkan subquery dalam klausa FROM untuk referensi kolom dari item sebelumnya dalam klausa FROM yang sama. | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/negative_icon.svg)Tidak didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | 
 SELECT 
    * 
FROM 
    tableName
LATERAL (
    SELECT 
        * 
    FROM 
        t2 
    WHERE 
        t1.c1 = t2.c1
)
| | [Klausa TAMPILAN LATERAL](#supported-sql-lateral-view) | Menghasilkan tabel virtual dengan menerapkan fungsi penghasil tabel ke setiap baris tabel dasar. | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/negative_icon.svg)Tidak didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | 
SELECT 
    * 
FROM 
    tableName
LATERAL VIEW 
    EXPLODE(ARRAY(30, 60)) tableName AS c_age
LATERAL VIEW 
    EXPLODE(ARRAY(40, 80)) AS d_age
| | [Seperti predikat](#supported-sql-like-predicate) | Cocokkan string dengan pola menggunakan karakter wildcard. | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | 
 SELECT 
    method,
    status,
    request,
    host 
FROM 
     
WHERE 
    method LIKE 'D%'
| | [MENGIMBANGI](#supported-sql-offset) | Menentukan jumlah baris untuk dilewati sebelum mulai mengembalikan baris dari query. | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung saat digunakan bersama dengan LIMIT klausa dalam kueri. Contoh:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/supported-directquery-sql.html) | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | 
 SELECT 
    method,
    status,
    bytes,
    datetime 
FROM 
     
ORDER BY 
    datetime
OFFSET 
    10
| | [Klausul PIVOT](#supported-sql-pivot) | Mengubah baris menjadi kolom, memutar data dari format berbasis baris ke format berbasis kolom. | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/negative_icon.svg)Tidak didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | 
SELECT 
    * 
FROM 
    (
        SELECT 
            method,
            status,
            bytes
        FROM 
            
    ) AS SourceTable 
PIVOT 
(
    SUM(bytes) 
    FOR method IN ('GET', 'POST', 'PATCH', 'PUT', 'DELETE')
) AS PivotTable
| | [Tetapkan operator](#supported-sql-set) | Menggabungkan hasil dari dua atau lebih pernyataan SELECT (misalnya, UNION, INTERSECT, KECUALI). | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | 
SELECT 
    method,
    status,
    bytes
FROM 
    
WHERE 
    status = '416'

UNION

SELECT 
    method,
    status,
    bytes
FROM 
    
WHERE 
    bytes > 20000
| | [URUTKAN BERDASARKAN klausa](#supported-sql-sort-by) | Menentukan urutan di mana untuk mengembalikan hasil query. | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | 
SELECT 
    method,
    status,
    bytes
FROM 
    
SORT BY 
    bytes DESC
| | [UNPIVOT](#supported-sql-unpivot) | Mengubah kolom menjadi baris, memutar data dari format berbasis kolom ke format berbasis baris. | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/negative_icon.svg)Tidak didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | 
 SELECT 
    status,
    REPLACE(method, '_bytes', '') AS request_method,
    bytes,
    datetime 
FROM 
    PivotedData 
UNPIVOT 
(
    bytes 
    FOR method IN 
    (
        GET_bytes,
        POST_bytes,
        PATCH_bytes,
        PUT_bytes,
        DELETE_bytes
    )
) AS UnpivotedData
| ## Fungsi **catatan** Di kolom perintah contoh, ganti sesuai `` kebutuhan tergantung pada sumber data yang Anda kueri. Contoh perintah: `SELECT Body , Operation FROM ` Jika Anda menanyakan Amazon S3 atau Security Lake, gunakan: `SELECT Body , Operation FROM table_name` Jika Anda menanyakan CloudWatch Log, gunakan: `SELECT Body , Operation FROM `LogGroupA`` | Tersedia Tata Bahasa SQL | Deskripsi | CloudWatch Log | Amazon S3 | Danau Keamanan | Perintah contoh | | --- | --- | --- | --- | --- | --- | | [Fungsi string](#supported-sql-string) | Fungsi bawaan yang dapat memanipulasi dan mengubah string dan data teks dalam kueri SQL. Misalnya, mengonversi kasus, menggabungkan string, mengekstraksi bagian, dan membersihkan teks. | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | 
SELECT 
    UPPER(method) AS upper_method,
    LOWER(host) AS lower_host 
FROM
| | [Fungsi tanggal dan waktu](#supported-sql-date-time) | Fungsi bawaan untuk menangani dan mengubah data tanggal dan stempel waktu dalam kueri. ****Misalnya, **date\$1add, date\$1format****, datediff, dan current\$1date**.**** | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | 
SELECT 
    TO_TIMESTAMP(datetime) AS timestamp,
    TIMESTAMP_SECONDS(UNIX_TIMESTAMP(datetime)) AS from_seconds,
    UNIX_TIMESTAMP(datetime) AS to_unix,
    FROM_UTC_TIMESTAMP(datetime, 'PST') AS to_pst,
    TO_UTC_TIMESTAMP(datetime, 'EST') AS from_est 
FROM
| | [Fungsi agregat](#supported-sql-aggregate) | Fungsi bawaan yang melakukan perhitungan pada beberapa baris untuk menghasilkan nilai ringkasan tunggal. Misalnya, **jumlah**, **hitung**, **rata-rata**, **maks**, dan **min**. | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | 
SELECT 
    COUNT(*) AS total_records,
    COUNT(DISTINCT method) AS unique_methods,
    SUM(bytes) AS total_bytes,
    AVG(bytes) AS avg_bytes,
    MIN(bytes) AS min_bytes,
    MAX(bytes) AS max_bytes 
FROM
| | [Fungsi kondisional](#supported-sql-conditional) | Fungsi bawaan yang melakukan tindakan berdasarkan kondisi tertentu, atau yang mengevaluasi ekspresi secara kondisional. Misalnya, **CASE** dan **IF**. | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | 
SELECT 
    CASE 
        WHEN method = 'GET' AND bytes < 1000 THEN 'Small Read'
        WHEN method = 'POST' AND bytes > 10000 THEN 'Large Write'
        WHEN status >= 400 OR bytes = 0 THEN 'Problem'
        ELSE 'Normal'
    END AS request_type 
FROM
| | [Fungsi JSON](#supported-sql-json) | Fungsi bawaan untuk mengurai, mengekstrak, memodifikasi, dan menanyakan data berformat JSON dalam kueri SQL (misalnya, from\$1json, to\$1json, get\$1json\$1object, json\$1tuple) yang memungkinkan manipulasi struktur JSON dalam kumpulan data. | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | 
SELECT 
    FROM_JSON(
        @message, 
        'STRUCT<
            host: STRING,
            user-identifier: STRING,
            datetime: STRING,
            method: STRING,
            status: INT,
            bytes: INT
        >'
    ) AS parsed_json 
FROM
| | [Fungsi array](#supported-sql-array) | Fungsi bawaan untuk bekerja dengan kolom tipe array dalam kueri SQL, memungkinkan operasi seperti mengakses, memodifikasi, dan menganalisis data array (misalnya, size, explode, array\$1contains). | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | 
SELECT 
    scores,
    size(scores) AS length,
    array_contains(scores, 90) AS has_90 
FROM
| | [Fungsi jendela](#supported-sql-window) | Fungsi bawaan yang melakukan perhitungan di serangkaian baris tertentu yang terkait dengan baris (jendela) saat ini, memungkinkan operasi seperti peringkat, total berjalan, dan rata-rata bergerak (misalnya, ROW\$1NUMBER, RANK, LAG, LEAD) | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | 
 SELECT 
    field1,
    field2,
    RANK() OVER (ORDER BY field2 DESC) AS field2Rank 
FROM
| | [Fungsi konversi](#supported-sql-conversion) | Fungsi bawaan untuk mengonversi data dari satu jenis ke jenis lainnya dalam kueri SQL, memungkinkan transformasi tipe data dan konversi format (misalnya, CAST, TO\$1DATE, TO\$1TIMESTAMP, BINARY) | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | 
SELECT 
    CAST('123' AS INT) AS converted_number,
    CAST(123 AS STRING) AS converted_string 
FROM
| | [Fungsi predikat](#supported-sql-predicate) | Fungsi bawaan yang mengevaluasi kondisi dan mengembalikan nilai boolean (benar/salah) berdasarkan kriteria atau pola yang ditentukan (misalnya, IN, LIKE, BETWEEN, IS NULL, EXISTS) | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | 
SELECT 
    * 
FROM 
     
WHERE 
    id BETWEEN 50000 AND 75000
| | [Fungsi peta](#supported-sql-map) | Menerapkan fungsi tertentu untuk setiap elemen dalam koleksi, mengubah data menjadi satu set nilai baru. | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/negative_icon.svg)Tidak didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | 
SELECT 
    MAP_FILTER(
        MAP(
            'method', method,
            'status', CAST(status AS STRING),
            'bytes', CAST(bytes AS STRING)
        ),
        (k, v) -> k IN ('method', 'status') AND v != 'null'
    ) AS filtered_map 
FROM 
     
WHERE 
    status = 100
| | [Fungsi matematika](#supported-sql-math) | Melakukan operasi matematika pada data numerik, seperti menghitung rata-rata, jumlah, atau nilai trigonometri. | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | 
SELECT 
    bytes,
    bytes + 1000 AS added,
    bytes - 1000 AS subtracted,
    bytes * 2 AS doubled,
    bytes / 1024 AS kilobytes,
    bytes % 1000 AS remainder 
FROM
| | [Fungsi grup multi-log](#multi-log-queries) | Memungkinkan pengguna untuk menentukan beberapa grup log dalam pernyataan SQL SELECT | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | Tidak berlaku | Tidak berlaku | 
SELECT 
    lg1.Column1,
    lg1.Column2 
FROM 
    `logGroups(logGroupIdentifier: ['LogGroup1', 'LogGroup2'])` AS lg1 
WHERE 
    lg1.Column3 = "Success"
| | [Fungsi generator](#supported-sql-generator) | Membuat objek iterator yang menghasilkan urutan nilai, memungkinkan penggunaan memori yang efisien dalam kumpulan data besar. | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/negative_icon.svg)Tidak didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | ![\[alt text not found\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/success_icon.svg)Didukung | 
SELECT 
    explode(array(10, 20))
| ## Pembatasan SQL umum Pembatasan berikut berlaku saat menggunakan OpenSearch SQL dengan CloudWatch Log, Amazon S3, dan Security Lake. 1. Anda hanya dapat menggunakan satu operasi JOIN dalam pernyataan SELECT. 1. Hanya satu tingkat subkueri bersarang yang didukung. 1. Beberapa kueri pernyataan yang dipisahkan oleh titik dua tidak didukung. 1. Kueri yang berisi nama bidang yang identik tetapi berbeda hanya dalam kasus (seperti field1 dan FIELD1) tidak didukung. Misalnya, kueri berikut tidak didukung: ``` Select AWSAccountId, awsaccountid from LogGroup ``` Namun, kueri berikut adalah karena nama bidang (@logStream) identik di kedua grup log: ``` Select a.`@logStream`, b.`@logStream` from Table A INNER Join Table B on a.id = b.id ``` 1. Fungsi dan ekspresi harus beroperasi pada nama bidang dan menjadi bagian dari pernyataan SELECT dengan grup log yang ditentukan dalam klausa FROM. Misalnya, kueri ini tidak didukung: ``` SELECT cos(10) FROM LogGroup ``` Kueri ini didukung: ``` SELECT cos(field1) FROM LogGroup ``` ## Informasi tambahan untuk pengguna CloudWatch Log Insights menggunakan OpenSearch SQL CloudWatch Log mendukung kueri OpenSearch SQL di konsol Logs Insights, API, dan CLI. Ini mendukung sebagian besar perintah, termasuk SELECT, FROM, WHERE, GROUP BY, HAVING, JOINS, dan query bersarang, bersama dengan JSON, matematika, string, dan fungsi bersyarat. Namun, CloudWatch Log hanya mendukung operasi baca, sehingga tidak mengizinkan pernyataan DDL atau DHTML. Lihat tabel di bagian sebelumnya untuk daftar lengkap perintah dan fungsi yang didukung. ### Fungsi grup multi-log CloudWatch Logs Insights mendukung kemampuan untuk menanyakan beberapa grup log. Untuk mengatasi kasus penggunaan ini di SQL, Anda dapat menggunakan `logGroups` perintah. Perintah ini khusus untuk kueri data di Wawasan CloudWatch Log yang melibatkan satu atau beberapa grup log. Gunakan sintaks ini untuk menanyakan beberapa grup log dengan menentukannya dalam perintah, alih-alih menulis kueri untuk masing-masing grup log dan menggabungkannya dengan `UNION` perintah. Sintaksis: ``` `logGroups( logGroupIdentifier: ['LogGroup1','LogGroup2', ...'LogGroupn'] ) ``` Dalam sintaks ini, Anda dapat menentukan hingga 50 grup log dalam `logGroupIndentifier` parameter. Untuk mereferensikan grup log di akun pemantauan, gunakan ARNs alih-alih `LogGroup` nama. Contoh kueri: ``` SELECT LG1.Column1, LG1.Column2 from `logGroups( logGroupIdentifier: ['LogGroup1', 'LogGroup2'] )` as LG1 WHERE LG1.Column1 = 'ABC' ``` Sintaks berikut yang melibatkan beberapa grup log setelah `FROM` pernyataan tidak didukung saat menanyakan CloudWatch Log: ``` SELECT Column1, Column2 FROM 'LogGroup1', 'LogGroup2', ...'LogGroupn' WHERE Column1 = 'ABC' ``` ### Pembatasan Saat Anda menggunakan perintah SQL atau PPL, lampirkan bidang tertentu di backticks untuk menanyakannya. Backticks diperlukan untuk bidang dengan karakter khusus (non-alfabet dan non-numerik). Misalnya, lampirkan`@message`, `Operation.Export,` dan `Test::Field` di backticks. Anda tidak perlu melampirkan kolom dengan nama abjad murni di backticks. Contoh kueri dengan bidang sederhana: ``` SELECT SessionToken, Operation, StartTime FROM `LogGroup-A` LIMIT 1000; ``` Kueri yang sama dengan backticks ditambahkan: ``` SELECT `SessionToken`, `Operation`, `StartTime` FROM `LogGroup-A` LIMIT 1000; ``` Untuk pembatasan umum tambahan yang tidak spesifik untuk CloudWatch Log, lihat[Pembatasan SQL umum](#general-sql-restrictions). ### Contoh kueri dan kuota **catatan** Berikut ini berlaku untuk pengguna CloudWatch Log Insights dan OpenSearch pengguna yang melakukan kueri data CloudWatch . Untuk contoh kueri SQL yang dapat Anda gunakan di CloudWatch Log, lihat **Kueri tersimpan dan contoh** di konsol Amazon CloudWatch Logs Insights untuk contoh. 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). ### Perintah SQL **Topics** + [Fungsi string](#supported-sql-string) + [Fungsi tanggal dan waktu](#supported-sql-date-time) + [Fungsi agregat](#supported-sql-aggregate) + [Fungsi kondisional](#supported-sql-conditional) + [Fungsi JSON](#supported-sql-json) + [Fungsi array](#supported-sql-array) + [Fungsi jendela](#supported-sql-window) + [Fungsi konversi](#supported-sql-conversion) + [Fungsi predikat](#supported-sql-predicate) + [Fungsi peta](#supported-sql-map) + [Fungsi matematika](#supported-sql-math) + [Fungsi generator](#supported-sql-generator) + [Klausa SELECT](#supported-sql-select) + [Klausa WHERE](#supported-sql-where) + [Klausa GROUP BY](#supported-sql-group-by) + [Klausa HAVING](#supported-sql-having) + [Klausa ORDER BY](#supported-sql-order-by) + [Klausa JOIN](#supported-sql-join) + [Klausa LIMIT](#supported-sql-limit) + [Klausul KASUS](#supported-sql-case) + [Ekspresi tabel umum](#supported-sql-cte) + [EXPLAIN](#supported-sql-explain) + [Klausa SUBQUERY LATERAL](#supported-sql-lateral-subquery) + [Klausa TAMPILAN LATERAL](#supported-sql-lateral-view) + [Seperti predikat](#supported-sql-like-predicate) + [MENGIMBANGI](#supported-sql-offset) + [Klausul PIVOT](#supported-sql-pivot) + [Tetapkan operator](#supported-sql-set) + [URUTKAN BERDASARKAN klausa](#supported-sql-sort-by) + [UNPIVOT](#supported-sql-unpivot) #### Fungsi string **catatan** Untuk melihat integrasi sumber AWS data mana yang mendukung perintah SQL ini, lihat. [Perintah dan OpenSearch fungsi SQL yang didukung](#supported-directquery-sql) **** | Fungsi | Deskripsi | | --- | --- | | ascii (str) | Mengembalikan nilai numerik dari karakter pertama. str | | base64 (tempat sampah) | Mengkonversi argumen dari biner bin ke string dasar 64. | | bit\$1length (expr) | Mengembalikan panjang bit data string atau jumlah bit data biner. | | btrim (str) | Menghapus karakter ruang depan dan belakang daristr. | | btrim (str, TrimStr) | Hapus trimStr karakter utama dan belakang daristr. | | char (expr) | Mengembalikan karakter ASCII memiliki biner setara dengan. expr Jika n lebih besar dari 256 hasilnya setara dengan chr (n% 256) | | char\$1length (expr) | Mengembalikan panjang karakter data string atau jumlah byte data biner. Panjang data string mencakup spasi trailing. Panjang data biner termasuk nol biner. | | character\$1length (expr) | Mengembalikan panjang karakter data string atau jumlah byte data biner. Panjang data string mencakup spasi trailing. Panjang data biner termasuk nol biner. | | chr (expr) | Mengembalikan karakter ASCII memiliki biner setara dengan. expr Jika n lebih besar dari 256 hasilnya setara dengan chr (n% 256) | | concat\$1ws (sep [, str \$1 larik (str)] \$1) | Mengembalikan rangkaian string dipisahkan olehsep, melewatkan nilai-nilai null. | | berisi (kiri, kanan) | Mengembalikan boolean. Nilai adalah Benar jika kanan ditemukan di dalam kiri. Mengembalikan NULL jika ekspresi input adalah NULL. Jika tidak, mengembalikan False. Baik kiri atau kanan harus dari tipe STRING atau BINARY. | | decode (bin, charset) | Mendekode argumen pertama menggunakan set karakter argumen kedua. | | decode (expr, pencarian, hasil [, pencarian, hasil]... [, default]) | Membandingkan expr dengan setiap nilai pencarian secara berurutan. Jika expr sama dengan nilai pencarian, decode mengembalikan hasil yang sesuai. Jika tidak ada kecocokan yang ditemukan, maka ia mengembalikan default. Jika default dihilangkan, ia mengembalikan null. | | elt (n, masukan1, masukan2,...) | Mengembalikan input n -th, misalnya, kembali input2 ketika n 2. | | menyandikan (str, charset) | Mengkodekan argumen pertama menggunakan set karakter argumen kedua. | | endswith (kiri, kanan) | Mengembalikan boolean. Nilai adalah Benar jika kiri berakhir dengan kanan. Mengembalikan NULL jika ekspresi input adalah NULL. Jika tidak, mengembalikan False. Baik kiri atau kanan harus dari tipe STRING atau BINARY. | | find\$1in\$1set (str, str\$1array) | Mengembalikan indeks (1-based) dari string yang diberikan (str) dalam daftar yang dibatasi koma (). str\$1array Mengembalikan 0, jika string tidak ditemukan atau jika string yang diberikan (str) berisi koma. | | format\$1number (expr1, expr2) | Memformat angka expr1 seperti '\$1, \$1\$1\$1, \$1\$1\$1.\$1\$1', dibulatkan ke tempat desimal. expr2 Jika expr2 0, hasilnya tidak memiliki titik desimal atau bagian pecahan. expr2juga menerima format yang ditentukan pengguna. Ini seharusnya berfungsi seperti FORMAT MySQL. | | format\$1string (strfmt, obj,...) | Mengembalikan string diformat dari string format printf-style. | | initcap (str) | Kembali str dengan huruf pertama dari setiap kata dalam huruf besar. Semua huruf lainnya dalam huruf kecil. Kata-kata dibatasi oleh ruang putih. | | instr (str, substr) | Mengembalikan indeks (1-based) dari kejadian pertama substr instr. | | lcase (str) | Kembali str dengan semua karakter diubah menjadi huruf kecil. | | kiri (str, len) | Mengembalikan karakter paling kiri len (lenbisa tipe string) dari stringstr, jika len kurang atau sama dari 0 hasilnya adalah string kosong. | | len (expr) | Mengembalikan panjang karakter data string atau jumlah byte data biner. Panjang data string mencakup spasi trailing. Panjang data biner termasuk nol biner. | | panjang (expr) | Mengembalikan panjang karakter data string atau jumlah byte data biner. Panjang data string mencakup spasi trailing. Panjang data biner termasuk nol biner. | | levenshtein (str1, str2 [, ambang batas]) | Mengembalikan jarak Levenshtein antara dua string yang diberikan. Jika ambang batas diatur dan jarak lebih dari itu, kembalikan -1. | | menemukan (substr, str [, pos]) | Mengembalikan posisi kejadian pertama substr di posisi str setelahpos. Nilai yang diberikan pos dan dikembalikan berbasis 1. | | lebih rendah (str) | Kembali str dengan semua karakter diubah menjadi huruf kecil. | | lpad (str, len [, pad]) | Kembalistr, empuk kiri dengan pad panjang. len Jika str lebih panjang darilen, nilai kembali disingkat menjadi len karakter atau byte. Jika tidak pad ditentukan, str akan empuk ke kiri dengan karakter spasi jika itu adalah string karakter, dan dengan nol jika itu adalah urutan byte. | | ltrim (str) | Menghapus karakter spasi terkemuka daristr. | | luhn\$1check (str) | Memeriksa bahwa string digit valid sesuai dengan algoritma Luhn. Fungsi checksum ini banyak diterapkan pada nomor kartu kredit dan nomor identifikasi pemerintah untuk membedakan nomor yang valid dari nomor yang salah ketik dan salah. | | topeng (masukan [, UpperChar, LowerChar, DigitChar, OtherChar]) | menutupi nilai string yang diberikan. Fungsi ini menggantikan karakter dengan 'X' atau 'x', dan angka dengan 'n'. Ini dapat berguna untuk membuat salinan tabel dengan informasi sensitif dihapus. | | octet\$1length (expr) | Mengembalikan panjang byte data string atau jumlah byte data biner. | | overlay (masukan, ganti, pos [, len]) | Ganti input dengan replace yang dimulai pada pos dan panjangnyalen. | | posisi (substr, str [, pos]) | Mengembalikan posisi kejadian pertama substr di posisi str setelahpos. Nilai yang diberikan pos dan dikembalikan berbasis 1. | | printf (strfmt, obj,...) | Mengembalikan string diformat dari string format printf-style. | | regexp\$1count (str, regexp) | Mengembalikan hitungan berapa kali pola ekspresi reguler regexp dicocokkan dalam stringstr. | | regexp\$1extract (str, regexp [, idx]) | Ekstrak string pertama str yang cocok dengan regexp ekspresi dan sesuai dengan indeks grup regex. | | regexp\$1extract\$1all (str, regexp [, idx]) | Ekstrak semua string str yang cocok dengan regexp ekspresi dan sesuai dengan indeks grup regex. | | regexp\$1instr (str, regexp) | Mencari string untuk ekspresi reguler dan mengembalikan integer yang menunjukkan posisi awal substring yang cocok. Posisi berbasis 1, bukan berbasis 0. Jika tidak ada kecocokan yang ditemukan, mengembalikan 0. | | regexp\$1replace (str, regexp, rep [, posisi]) | Mengganti semua substring dari kecocokan str itu denganregexp. rep | | regexp\$1substr (str, regexp) | Mengembalikan substring yang cocok dengan ekspresi reguler regexp dalam stringstr. Jika ekspresi reguler tidak ditemukan, hasilnya adalah nol. | | ulangi (str, n) | Mengembalikan string yang mengulangi nilai string yang diberikan n kali. | | ganti (str, cari [, ganti]) | Menggantikan semua kejadian dengan. search replace | | kanan (str, len) | Mengembalikan karakter paling kanan len (lenbisa tipe string) dari stringstr, jika len kurang atau sama dari 0 hasilnya adalah string kosong. | | rpad (str, len [, pad]) | Kembalistr, empuk kanan pad dengan panjang. len Jika str lebih panjang darilen, nilai kembali disingkat menjadi len karakter. Jika tidak pad ditentukan, str akan empuk ke kanan dengan karakter spasi jika itu adalah string karakter, dan dengan nol jika itu adalah string biner. | | rtrim (str) | Menghapus karakter spasi trailing daristr. | | kalimat (str [, lang, country]) | Terbagi str menjadi array array kata. | | soundex (str) | Mengembalikan kode Soundex dari string. | | ruang (n) | Mengembalikan string yang terdiri dari n spasi. | | split (str, regex, batas) | Membagi str sekitar kejadian yang cocok regex dan mengembalikan array dengan panjang paling banyak limit | | split\$1part (str, pembatas, partNum) | Membagi str dengan pembatas dan mengembalikan bagian yang diminta dari split (berbasis 1). Jika ada masukan nol, mengembalikan null. jika partNum berada di luar jangkauan bagian terpisah, mengembalikan string kosong. Jika partNum 0, melempar kesalahan. Jika partNum negatif, bagian-bagiannya dihitung mundur dari ujung string. Jika string kosong, tidak str terbelah. delimiter | | startswith (kiri, kanan) | Mengembalikan boolean. Nilai True jika kiri dimulai dengan kanan. Mengembalikan NULL jika ekspresi input adalah NULL. Jika tidak, mengembalikan False. Baik kiri atau kanan harus dari tipe STRING atau BINARY. | | substr (str, pos [, len]) | Mengembalikan substring str yang dimulai pada pos dan panjangnyalen, atau irisan array byte yang dimulai pada pos dan panjangnyalen. | | substr (str DARI pos [UNTUK len]]) | Mengembalikan substring str yang dimulai pada pos dan panjangnyalen, atau irisan array byte yang dimulai pada pos dan panjangnyalen. | | substring (str, pos [, len]) | Mengembalikan substring str yang dimulai pada pos dan panjangnyalen, atau irisan array byte yang dimulai pada pos dan panjangnyalen. | | substring (str DARI pos [UNTUK len]]) | Mengembalikan substring str yang dimulai pada pos dan panjangnyalen, atau irisan array byte yang dimulai pada pos dan panjangnyalen. | | substring\$1index (str, delim, hitung) | Mengembalikan substring dari str sebelum count terjadinya pembatas. delim Jika count positif, semuanya di sebelah kiri pembatas akhir (dihitung dari kiri) dikembalikan. Jika count negatif, semuanya di sebelah kanan pembatas akhir (menghitung dari kanan) dikembalikan. Fungsi substring\$1index melakukan kecocokan peka huruf besar/kecil saat mencari. delim | | to\$1binary (str [, fmt]) | Mengkonversi input str ke nilai biner berdasarkan yang disediakanfmt. fmtbisa berupa string case-insensitive literal dari “hex”, “utf-8", “utf8", atau “base64". Secara default, format biner untuk konversi adalah “hex” jika fmt dihilangkan. Fungsi mengembalikan NULL jika setidaknya salah satu parameter input adalah NULL. | | to\$1char (NumberExpr, FormatExpr) | Konversi numberExpr ke string berdasarkan fileformatExpr. Melempar pengecualian jika konversi gagal. Format dapat terdiri dari karakter berikut, case insensitive: '0' atau '9': Menentukan digit yang diharapkan antara 0 dan 9. Urutan 0 atau 9 dalam format string cocok dengan urutan digit dalam nilai input, menghasilkan string hasil dengan panjang yang sama dengan urutan yang sesuai dalam string format. String hasil dilapisi kiri dengan nol jika urutan 0/9 terdiri lebih banyak digit daripada bagian yang cocok dari nilai desimal, dimulai dengan 0, dan sebelum titik desimal. Jika tidak, itu dilapisi dengan spasi. '.' atau 'D': Menentukan posisi titik desimal (opsional, hanya diperbolehkan sekali). ',' atau 'G': Menentukan posisi pengelompokan (ribuan) pemisah (,). Harus ada 0 atau 9 di kiri dan kanan setiap pemisah pengelompokan. ' | | to\$1number (expr, fmt) | Ubah string 'expr' ke angka berdasarkan format string 'fmt'. Melempar pengecualian jika konversi gagal. Format dapat terdiri dari karakter berikut, case insensitive: '0' atau '9': Menentukan digit yang diharapkan antara 0 dan 9. Urutan 0 atau 9 dalam format string cocok dengan urutan digit dalam string input. Jika urutan 0/9 dimulai dengan 0 dan sebelum titik desimal, itu hanya dapat mencocokkan urutan digit dengan ukuran yang sama. Jika tidak, jika urutan dimulai dengan 9 atau setelah titik desimal, itu dapat cocok dengan urutan digit yang memiliki ukuran yang sama atau lebih kecil. '.' atau 'D': Menentukan posisi titik desimal (opsional, hanya diperbolehkan sekali). ',' atau 'G': Menentukan posisi pengelompokan (ribuan) pemisah (,). Harus ada 0 atau 9 di kiri dan kanan setiap pemisah pengelompokan. 'expr' harus cocok dengan pemisah pengelompokan yang relevan dengan ukuran nomor. ' | | to\$1varchar (NumberExpr, FormatExpr) | Konversi numberExpr ke string berdasarkan fileformatExpr. Melempar pengecualian jika konversi gagal. Format dapat terdiri dari karakter berikut, case insensitive: '0' atau '9': Menentukan digit yang diharapkan antara 0 dan 9. Urutan 0 atau 9 dalam format string cocok dengan urutan digit dalam nilai input, menghasilkan string hasil dengan panjang yang sama dengan urutan yang sesuai dalam string format. String hasil dilapisi kiri dengan nol jika urutan 0/9 terdiri lebih banyak digit daripada bagian yang cocok dari nilai desimal, dimulai dengan 0, dan sebelum titik desimal. Jika tidak, itu dilapisi dengan spasi. '.' atau 'D': Menentukan posisi titik desimal (opsional, hanya diperbolehkan sekali). ',' atau 'G': Menentukan posisi pengelompokan (ribuan) pemisah (,). Harus ada 0 atau 9 di kiri dan kanan setiap pemisah pengelompokan. ' | | terjemahkan (masukan, dari, ke) | Menerjemahkan input string dengan mengganti karakter yang ada dalam from string dengan karakter yang sesuai dalam to string. | | memangkas (str) | Menghapus karakter ruang depan dan belakang daristr. | | trim (KEDUANYA DARI str) | Menghapus karakter ruang depan dan belakang daristr. | | trim (MEMIMPIN DARI str) | Menghapus karakter spasi terkemuka daristr. | | trim (TERTINGGAL DARI str) | Menghapus karakter spasi trailing daristr. | | trim (TrimStr DARI str) | Hapus trimStr karakter utama dan belakang daristr. | | trim (KEDUA TrimStr DARI str) | Hapus trimStr karakter utama dan belakang daristr. | | trim (MEMIMPIN TrimStr DARI str) | Hapus trimStr karakter utama daristr. | | trim (TRAILING TrimStr DARI str) | Hapus trimStr karakter trailing daristr. | | try\$1to\$1binary (str [, fmt]) | Ini adalah versi khusus to\$1binary yang melakukan operasi yang sama, tetapi mengembalikan nilai NULL alih-alih menimbulkan kesalahan jika konversi tidak dapat dilakukan. | | try\$1to\$1number (expr, fmt) | Mengkonversi string 'expr' ke angka berdasarkan format fmt string. Mengembalikan NULL jika string 'expr' tidak cocok dengan format yang diharapkan. Formatnya mengikuti semantik yang sama dengan fungsi to\$1number. | | ucase (str) | Kembali str dengan semua karakter diubah menjadi huruf besar. | | unbase64 (str) | Mengkonversi argumen dari string dasar 64 str ke biner. | | atas (str) | Kembali str dengan semua karakter diubah menjadi huruf besar. | **Contoh** ``` -- ascii SELECT ascii('222'); +----------+ |ascii(222)| +----------+ | 50| +----------+ SELECT ascii(2); +--------+ |ascii(2)| +--------+ | 50| +--------+ -- base64 SELECT base64('Feathers'); +-----------------+ |base64(Feathers)| +-----------------+ | RmVhdGhlcnM=| +-----------------+ SELECT base64(x'537061726b2053514c'); +-----------------------------+ |base64(X'537061726B2053514C')| +-----------------------------+ | U3BhcmsgU1FM| +-----------------------------+ -- bit_length SELECT bit_length('Feathers'); +---------------------+ |bit_length(Feathers)| +---------------------+ | 64| +---------------------+ SELECT bit_length(x'537061726b2053514c'); +---------------------------------+ |bit_length(X'537061726B2053514C')| +---------------------------------+ | 72| +---------------------------------+ -- btrim SELECT btrim(' Feathers '); +----------------------+ |btrim( Feathers )| +----------------------+ | Feathers| +----------------------+ SELECT btrim(encode(' Feathers ', 'utf-8')); +-------------------------------------+ |btrim(encode( Feathers , utf-8))| +-------------------------------------+ | Feathers| +-------------------------------------+ SELECT btrim('Feathers', 'Fe'); +---------------------+ |btrim(Alphabet, Al)| +---------------------+ | athers| +---------------------+ SELECT btrim(encode('Feathers', 'utf-8'), encode('Al', 'utf-8')); +---------------------------------------------------+ |btrim(encode(Feathers, utf-8), encode(Al, utf-8))| +---------------------------------------------------+ | athers| +---------------------------------------------------+ -- char SELECT char(65); +--------+ |char(65)| +--------+ | A| +--------+ -- char_length SELECT char_length('Feathers '); +-----------------------+ |char_length(Feathers )| +-----------------------+ | 9 | +-----------------------+ SELECT char_length(x'537061726b2053514c'); +----------------------------------+ |char_length(X'537061726B2053514C')| +----------------------------------+ | 9| +----------------------------------+ SELECT CHAR_LENGTH('Feathers '); +-----------------------+ |char_length(Feathers )| +-----------------------+ | 9| +-----------------------+ SELECT CHARACTER_LENGTH('Feathers '); +----------------------------+ |character_length(Feathers )| +----------------------------+ | 9| +----------------------------+ -- character_length SELECT character_length('Feathers '); +----------------------------+ |character_length(Feathers )| +----------------------------+ | 9| +----------------------------+ SELECT character_length(x'537061726b2053514c'); +---------------------------------------+ |character_length(X'537061726B2053514C')| +---------------------------------------+ | 9| +---------------------------------------+ SELECT CHAR_LENGTH('Feathers '); +-----------------------+ |char_length(Feathers )| +-----------------------+ | 9| +-----------------------+ SELECT CHARACTER_LENGTH('Feathers '); +----------------------------+ |character_length(Feathers )| +----------------------------+ | 9| +----------------------------+ -- chr SELECT chr(65); +-------+ |chr(65)| +-------+ | A| +-------+ -- concat_ws SELECT concat_ws(' ', 'Fea', 'thers'); +------------------------+ |concat_ws( , Fea, thers)| +------------------------+ | Feathers| +------------------------+ SELECT concat_ws('s'); +------------+ |concat_ws(s)| +------------+ | | +------------+ SELECT concat_ws('/', 'foo', null, 'bar'); +----------------------------+ |concat_ws(/, foo, NULL, bar)| +----------------------------+ | foo/bar| +----------------------------+ SELECT concat_ws(null, 'Fea', 'thers'); +---------------------------+ |concat_ws(NULL, Fea, thers)| +---------------------------+ | NULL| +---------------------------+ -- contains SELECT contains('Feathers', 'Fea'); +--------------------------+ |contains(Feathers, Fea)| +--------------------------+ | true| +--------------------------+ SELECT contains('Feathers', 'SQL'); +--------------------------+ |contains(Feathers, SQL)| +--------------------------+ | false| +--------------------------+ SELECT contains('Feathers', null); +-------------------------+ |contains(Feathers, NULL)| +-------------------------+ | NULL| +-------------------------+ SELECT contains(x'537061726b2053514c', x'537061726b'); +----------------------------------------------+ |contains(X'537061726B2053514C', X'537061726B')| +----------------------------------------------+ | true| +----------------------------------------------+ -- decode SELECT decode(encode('abc', 'utf-8'), 'utf-8'); +---------------------------------+ |decode(encode(abc, utf-8), utf-8)| +---------------------------------+ | abc| +---------------------------------+ SELECT decode(2, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic'); +----------------------------------------------------------------------------------+ |decode(2, 1, Southlake, 2, San Francisco, 3, New Jersey, 4, Seattle, Non domestic)| +----------------------------------------------------------------------------------+ | San Francisco| +----------------------------------------------------------------------------------+ SELECT decode(6, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic'); +----------------------------------------------------------------------------------+ |decode(6, 1, Southlake, 2, San Francisco, 3, New Jersey, 4, Seattle, Non domestic)| +----------------------------------------------------------------------------------+ | Non domestic| +----------------------------------------------------------------------------------+ SELECT decode(6, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle'); +--------------------------------------------------------------------+ |decode(6, 1, Southlake, 2, San Francisco, 3, New Jersey, 4, Seattle)| +--------------------------------------------------------------------+ | NULL| +--------------------------------------------------------------------+ SELECT decode(null, 6, 'Fea', NULL, 'thers', 4, 'rock'); +-------------------------------------------+ |decode(NULL, 6, Fea, NULL, thers, 4, rock)| +-------------------------------------------+ | thers| +-------------------------------------------+ -- elt SELECT elt(1, 'scala', 'java'); +-------------------+ |elt(1, scala, java)| +-------------------+ | scala| +-------------------+ SELECT elt(2, 'a', 1); +------------+ |elt(2, a, 1)| +------------+ | 1| +------------+ -- encode SELECT encode('abc', 'utf-8'); +------------------+ |encode(abc, utf-8)| +------------------+ | [61 62 63]| +------------------+ -- endswith SELECT endswith('Feathers', 'ers'); +------------------------+ |endswith(Feathers, ers)| +------------------------+ | true| +------------------------+ SELECT endswith('Feathers', 'SQL'); +--------------------------+ |endswith(Feathers, SQL)| +--------------------------+ | false| +--------------------------+ SELECT endswith('Feathers', null); +-------------------------+ |endswith(Feathers, NULL)| +-------------------------+ | NULL| +-------------------------+ SELECT endswith(x'537061726b2053514c', x'537061726b'); +----------------------------------------------+ |endswith(X'537061726B2053514C', X'537061726B')| +----------------------------------------------+ | false| +----------------------------------------------+ SELECT endswith(x'537061726b2053514c', x'53514c'); +------------------------------------------+ |endswith(X'537061726B2053514C', X'53514C')| +------------------------------------------+ | true| +------------------------------------------+ -- find_in_set SELECT find_in_set('ab','abc,b,ab,c,def'); +-------------------------------+ |find_in_set(ab, abc,b,ab,c,def)| +-------------------------------+ | 3| +-------------------------------+ -- format_number SELECT format_number(12332.123456, 4); +------------------------------+ |format_number(12332.123456, 4)| +------------------------------+ | 12,332.1235| +------------------------------+ SELECT format_number(12332.123456, '##################.###'); +---------------------------------------------------+ |format_number(12332.123456, ##################.###)| +---------------------------------------------------+ | 12332.123| +---------------------------------------------------+ -- format_string SELECT format_string("Hello World %d %s", 100, "days"); +-------------------------------------------+ |format_string(Hello World %d %s, 100, days)| +-------------------------------------------+ | Hello World 100 days| +-------------------------------------------+ -- initcap SELECT initcap('Feathers'); +------------------+ |initcap(Feathers)| +------------------+ | Feathers| +------------------+ -- instr SELECT instr('Feathers', 'ers'); +--------------------+ |instr(Feathers, ers)| +--------------------+ | 6| +--------------------+ -- lcase SELECT lcase('Feathers'); +---------------+ |lcase(Feathers)| +---------------+ | feathers| +---------------+ -- left SELECT left('Feathers', 3); +------------------+ |left(Feathers, 3)| +------------------+ | Fea| +------------------+ SELECT left(encode('Feathers', 'utf-8'), 3); +---------------------------------+ |left(encode(Feathers, utf-8), 3)| +---------------------------------+ | [RmVh]| +---------------------------------+ -- len SELECT len('Feathers '); +---------------+ |len(Feathers )| +---------------+ | 9| +---------------+ SELECT len(x'537061726b2053514c'); +--------------------------+ |len(X'537061726B2053514C')| +--------------------------+ | 9| +--------------------------+ SELECT CHAR_LENGTH('Feathers '); +-----------------------+ |char_length(Feathers )| +-----------------------+ | 9| +-----------------------+ SELECT CHARACTER_LENGTH('Feathers '); +----------------------------+ |character_length(Feathers )| +----------------------------+ | 9| +----------------------------+ -- length SELECT length('Feathers '); +------------------+ |length(Feathers )| +------------------+ | 9| +------------------+ SELECT length(x'537061726b2053514c'); +-----------------------------+ |length(X'537061726B2053514C')| +-----------------------------+ | 9| +-----------------------------+ SELECT CHAR_LENGTH('Feathers '); +-----------------------+ |char_length(Feathers )| +-----------------------+ | 9| +-----------------------+ SELECT CHARACTER_LENGTH('Feathers '); +----------------------------+ |character_length(Feathers )| +----------------------------+ | 9| +----------------------------+ -- levenshtein SELECT levenshtein('kitten', 'sitting'); +----------------------------+ |levenshtein(kitten, sitting)| +----------------------------+ | 3| +----------------------------+ SELECT levenshtein('kitten', 'sitting', 2); +-------------------------------+ |levenshtein(kitten, sitting, 2)| +-------------------------------+ | -1| +-------------------------------+ -- locate SELECT locate('bar', 'foobarbar'); +-------------------------+ |locate(bar, foobarbar, 1)| +-------------------------+ | 4| +-------------------------+ SELECT locate('bar', 'foobarbar', 5); +-------------------------+ |locate(bar, foobarbar, 5)| +-------------------------+ | 7| +-------------------------+ SELECT POSITION('bar' IN 'foobarbar'); +-------------------------+ |locate(bar, foobarbar, 1)| +-------------------------+ | 4| +-------------------------+ -- lower SELECT lower('Feathers'); +---------------+ |lower(Feathers)| +---------------+ | feathers| +---------------+ -- lpad SELECT lpad('hi', 5, '??'); +---------------+ |lpad(hi, 5, ??)| +---------------+ | ???hi| +---------------+ SELECT lpad('hi', 1, '??'); +---------------+ |lpad(hi, 1, ??)| +---------------+ | h| +---------------+ SELECT lpad('hi', 5); +--------------+ |lpad(hi, 5, )| +--------------+ | hi| +--------------+ SELECT hex(lpad(unhex('aabb'), 5)); +--------------------------------+ |hex(lpad(unhex(aabb), 5, X'00'))| +--------------------------------+ | 000000AABB| +--------------------------------+ SELECT hex(lpad(unhex('aabb'), 5, unhex('1122'))); +--------------------------------------+ |hex(lpad(unhex(aabb), 5, unhex(1122)))| +--------------------------------------+ | 112211AABB| +--------------------------------------+ -- ltrim SELECT ltrim(' Feathers '); +----------------------+ |ltrim( Feathers )| +----------------------+ | Feathers | +----------------------+ -- luhn_check SELECT luhn_check('8112189876'); +----------------------+ |luhn_check(8112189876)| +----------------------+ | true| +----------------------+ SELECT luhn_check('79927398713'); +-----------------------+ |luhn_check(79927398713)| +-----------------------+ | true| +-----------------------+ SELECT luhn_check('79927398714'); +-----------------------+ |luhn_check(79927398714)| +-----------------------+ | false| +-----------------------+ -- mask SELECT mask('abcd-EFGH-8765-4321'); +----------------------------------------+ |mask(abcd-EFGH-8765-4321, X, x, n, NULL)| +----------------------------------------+ | xxxx-XXXX-nnnn-nnnn| +----------------------------------------+ SELECT mask('abcd-EFGH-8765-4321', 'Q'); +----------------------------------------+ |mask(abcd-EFGH-8765-4321, Q, x, n, NULL)| +----------------------------------------+ | xxxx-QQQQ-nnnn-nnnn| +----------------------------------------+ SELECT mask('AbCD123-@$#', 'Q', 'q'); +--------------------------------+ |mask(AbCD123-@$#, Q, q, n, NULL)| +--------------------------------+ | QqQQnnn-@$#| +--------------------------------+ SELECT mask('AbCD123-@$#'); +--------------------------------+ |mask(AbCD123-@$#, X, x, n, NULL)| +--------------------------------+ | XxXXnnn-@$#| +--------------------------------+ SELECT mask('AbCD123-@$#', 'Q'); +--------------------------------+ |mask(AbCD123-@$#, Q, x, n, NULL)| +--------------------------------+ | QxQQnnn-@$#| +--------------------------------+ SELECT mask('AbCD123-@$#', 'Q', 'q'); +--------------------------------+ |mask(AbCD123-@$#, Q, q, n, NULL)| +--------------------------------+ | QqQQnnn-@$#| +--------------------------------+ SELECT mask('AbCD123-@$#', 'Q', 'q', 'd'); +--------------------------------+ |mask(AbCD123-@$#, Q, q, d, NULL)| +--------------------------------+ | QqQQddd-@$#| +--------------------------------+ SELECT mask('AbCD123-@$#', 'Q', 'q', 'd', 'o'); +-----------------------------+ |mask(AbCD123-@$#, Q, q, d, o)| +-----------------------------+ | QqQQdddoooo| +-----------------------------+ SELECT mask('AbCD123-@$#', NULL, 'q', 'd', 'o'); +--------------------------------+ |mask(AbCD123-@$#, NULL, q, d, o)| +--------------------------------+ | AqCDdddoooo| +--------------------------------+ SELECT mask('AbCD123-@$#', NULL, NULL, 'd', 'o'); +-----------------------------------+ |mask(AbCD123-@$#, NULL, NULL, d, o)| +-----------------------------------+ | AbCDdddoooo| +-----------------------------------+ SELECT mask('AbCD123-@$#', NULL, NULL, NULL, 'o'); +--------------------------------------+ |mask(AbCD123-@$#, NULL, NULL, NULL, o)| +--------------------------------------+ | AbCD123oooo| +--------------------------------------+ SELECT mask(NULL, NULL, NULL, NULL, 'o'); +-------------------------------+ |mask(NULL, NULL, NULL, NULL, o)| +-------------------------------+ | NULL| +-------------------------------+ SELECT mask(NULL); +-------------------------+ |mask(NULL, X, x, n, NULL)| +-------------------------+ | NULL| +-------------------------+ SELECT mask('AbCD123-@$#', NULL, NULL, NULL, NULL); +-----------------------------------------+ |mask(AbCD123-@$#, NULL, NULL, NULL, NULL)| +-----------------------------------------+ | AbCD123-@$#| +-----------------------------------------+ -- octet_length SELECT octet_length('Feathers'); +-----------------------+ |octet_length(Feathers)| +-----------------------+ | 8| +-----------------------+ SELECT octet_length(x'537061726b2053514c'); +-----------------------------------+ |octet_length(X'537061726B2053514C')| +-----------------------------------+ | 9| +-----------------------------------+ -- overlay SELECT overlay('Feathers' PLACING '_' FROM 6); +----------------------------+ |overlay(Feathers, _, 6, -1)| +----------------------------+ | Feathe_ers| +----------------------------+ SELECT overlay('Feathers' PLACING 'ures' FROM 5); +-------------------------------+ |overlay(Feathers, ures, 5, -1)| +-------------------------------+ | Features | +-------------------------------+ -- position SELECT position('bar', 'foobarbar'); +---------------------------+ |position(bar, foobarbar, 1)| +---------------------------+ | 4| +---------------------------+ SELECT position('bar', 'foobarbar', 5); +---------------------------+ |position(bar, foobarbar, 5)| +---------------------------+ | 7| +---------------------------+ SELECT POSITION('bar' IN 'foobarbar'); +-------------------------+ |locate(bar, foobarbar, 1)| +-------------------------+ | 4| +-------------------------+ -- printf SELECT printf("Hello World %d %s", 100, "days"); +------------------------------------+ |printf(Hello World %d %s, 100, days)| +------------------------------------+ | Hello World 100 days| +------------------------------------+ -- regexp_count SELECT regexp_count('Steven Jones and Stephen Smith are the best players', 'Ste(v|ph)en'); +------------------------------------------------------------------------------+ |regexp_count(Steven Jones and Stephen Smith are the best players, Ste(v|ph)en)| +------------------------------------------------------------------------------+ | 2| +------------------------------------------------------------------------------+ SELECT regexp_count('abcdefghijklmnopqrstuvwxyz', '[a-z]{3}'); +--------------------------------------------------+ |regexp_count(abcdefghijklmnopqrstuvwxyz, [a-z]{3})| +--------------------------------------------------+ | 8| +--------------------------------------------------+ -- regexp_extract SELECT regexp_extract('100-200', '(\\d+)-(\\d+)', 1); +---------------------------------------+ |regexp_extract(100-200, (\d+)-(\d+), 1)| +---------------------------------------+ | 100| +---------------------------------------+ -- regexp_extract_all SELECT regexp_extract_all('100-200, 300-400', '(\\d+)-(\\d+)', 1); +----------------------------------------------------+ |regexp_extract_all(100-200, 300-400, (\d+)-(\d+), 1)| +----------------------------------------------------+ | [100, 300]| +----------------------------------------------------+ -- regexp_instr SELECT regexp_instr('user@opensearch.org', '@[^.]*'); +----------------------------------------------+ |regexp_instr(user@opensearch.org, @[^.]*, 0)| +----------------------------------------------+ | 5| +----------------------------------------------+ -- regexp_replace SELECT regexp_replace('100-200', '(\\d+)', 'num'); +--------------------------------------+ |regexp_replace(100-200, (\d+), num, 1)| +--------------------------------------+ | num-num| +--------------------------------------+ -- regexp_substr SELECT regexp_substr('Steven Jones and Stephen Smith are the best players', 'Ste(v|ph)en'); +-------------------------------------------------------------------------------+ |regexp_substr(Steven Jones and Stephen Smith are the best players, Ste(v|ph)en)| +-------------------------------------------------------------------------------+ | Steven| +-------------------------------------------------------------------------------+ SELECT regexp_substr('Steven Jones and Stephen Smith are the best players', 'Jeck'); +------------------------------------------------------------------------+ |regexp_substr(Steven Jones and Stephen Smith are the best players, Jeck)| +------------------------------------------------------------------------+ | NULL| +------------------------------------------------------------------------+ -- repeat SELECT repeat('123', 2); +--------------+ |repeat(123, 2)| +--------------+ | 123123| +--------------+ -- replace SELECT replace('ABCabc', 'abc', 'DEF'); +-------------------------+ |replace(ABCabc, abc, DEF)| +-------------------------+ | ABCDEF| +-------------------------+ -- right SELECT right('Feathers', 3); +-------------------+ |right(Feathers, 3)| +-------------------+ | ers| +-------------------+ -- rpad SELECT rpad('hi', 5, '??'); +---------------+ |rpad(hi, 5, ??)| +---------------+ | hi???| +---------------+ SELECT rpad('hi', 1, '??'); +---------------+ |rpad(hi, 1, ??)| +---------------+ | h| +---------------+ SELECT rpad('hi', 5); +--------------+ |rpad(hi, 5, )| +--------------+ | hi | +--------------+ SELECT hex(rpad(unhex('aabb'), 5)); +--------------------------------+ |hex(rpad(unhex(aabb), 5, X'00'))| +--------------------------------+ | AABB000000| +--------------------------------+ SELECT hex(rpad(unhex('aabb'), 5, unhex('1122'))); +--------------------------------------+ |hex(rpad(unhex(aabb), 5, unhex(1122)))| +--------------------------------------+ | AABB112211| +--------------------------------------+ -- rtrim SELECT rtrim(' Feathers '); +----------------------+ |rtrim( Feathers )| +----------------------+ | Feathers| +----------------------+ -- sentences SELECT sentences('Hi there! Good morning.'); +--------------------------------------+ |sentences(Hi there! Good morning., , )| +--------------------------------------+ | [[Hi, there], [Go...| +--------------------------------------+ -- soundex SELECT soundex('Miller'); +---------------+ |soundex(Miller)| +---------------+ | M460| +---------------+ -- space SELECT concat(space(2), '1'); +-------------------+ |concat(space(2), 1)| +-------------------+ | 1| +-------------------+ -- split SELECT split('oneAtwoBthreeC', '[ABC]'); +--------------------------------+ |split(oneAtwoBthreeC, [ABC], -1)| +--------------------------------+ | [one, two, three, ]| +--------------------------------+ SELECT split('oneAtwoBthreeC', '[ABC]', -1); +--------------------------------+ |split(oneAtwoBthreeC, [ABC], -1)| +--------------------------------+ | [one, two, three, ]| +--------------------------------+ SELECT split('oneAtwoBthreeC', '[ABC]', 2); +-------------------------------+ |split(oneAtwoBthreeC, [ABC], 2)| +-------------------------------+ | [one, twoBthreeC]| +-------------------------------+ -- split_part SELECT split_part('11.12.13', '.', 3); +--------------------------+ |split_part(11.12.13, ., 3)| +--------------------------+ | 13| +--------------------------+ -- startswith SELECT startswith('Feathers', 'Fea'); +----------------------------+ |startswith(Feathers, Fea)| +----------------------------+ | true| +----------------------------+ SELECT startswith('Feathers', 'SQL'); +--------------------------+ |startswith(Feathers, SQL)| +--------------------------+ | false| +--------------------------+ SELECT startswith('Feathers', null); +---------------------------+ |startswith(Feathers, NULL)| +---------------------------+ | NULL| +---------------------------+ SELECT startswith(x'537061726b2053514c', x'537061726b'); +------------------------------------------------+ |startswith(X'537061726B2053514C', X'537061726B')| +------------------------------------------------+ | true| +------------------------------------------------+ SELECT startswith(x'537061726b2053514c', x'53514c'); +--------------------------------------------+ |startswith(X'537061726B2053514C', X'53514C')| +--------------------------------------------+ | false| +--------------------------------------------+ -- substr SELECT substr('Feathers', 5); +--------------------------------+ |substr(Feathers, 5, 2147483647)| +--------------------------------+ | hers | +--------------------------------+ SELECT substr('Feathers', -3); +---------------------------------+ |substr(Feathers, -3, 2147483647)| +---------------------------------+ | ers| +---------------------------------+ SELECT substr('Feathers', 5, 1); +-----------------------+ |substr(Feathers, 5, 1)| +-----------------------+ | h| +-----------------------+ SELECT substr('Feathers' FROM 5); +-----------------------------------+ |substring(Feathers, 5, 2147483647)| +-----------------------------------+ | hers | +-----------------------------------+ SELECT substr('Feathers' FROM -3); +------------------------------------+ |substring(Feathers, -3, 2147483647)| +------------------------------------+ | ers| +------------------------------------+ SELECT substr('Feathers' FROM 5 FOR 1); +--------------------------+ |substring(Feathers, 5, 1)| +--------------------------+ | h| +--------------------------+ -- substring SELECT substring('Feathers', 5); +-----------------------------------+ |substring(Feathers, 5, 2147483647)| +-----------------------------------+ | hers | +-----------------------------------+ SELECT substring('Feathers', -3); +------------------------------------+ |substring(Feathers, -3, 2147483647)| +------------------------------------+ | ers| +------------------------------------+ SELECT substring('Feathers', 5, 1); +--------------------------+ |substring(Feathers, 5, 1)| +--------------------------+ | h| +--------------------------+ SELECT substring('Feathers' FROM 5); +-----------------------------------+ |substring(Feathers, 5, 2147483647)| +-----------------------------------+ | hers | +-----------------------------------+ SELECT substring('Feathers' FROM -3); +------------------------------------+ |substring(Feathers, -3, 2147483647)| +------------------------------------+ | ers| +------------------------------------+ SELECT substring('Feathers' FROM 5 FOR 1); +--------------------------+ |substring(Feathers, 5, 1)| +--------------------------+ | h| +--------------------------+ -- substring_index SELECT substring_index('www.apache.org', '.', 2); +-------------------------------------+ |substring_index(www.apache.org, ., 2)| +-------------------------------------+ | www.apache| +-------------------------------------+ -- to_binary SELECT to_binary('abc', 'utf-8'); +---------------------+ |to_binary(abc, utf-8)| +---------------------+ | [61 62 63]| +---------------------+ -- to_char SELECT to_char(454, '999'); +-----------------+ |to_char(454, 999)| +-----------------+ | 454| +-----------------+ SELECT to_char(454.00, '000D00'); +-----------------------+ |to_char(454.00, 000D00)| +-----------------------+ | 454.00| +-----------------------+ SELECT to_char(12454, '99G999'); +----------------------+ |to_char(12454, 99G999)| +----------------------+ | 12,454| +----------------------+ SELECT to_char(78.12, '$99.99'); +----------------------+ |to_char(78.12, $99.99)| +----------------------+ | $78.12| +----------------------+ SELECT to_char(-12454.8, '99G999D9S'); +----------------------------+ |to_char(-12454.8, 99G999D9S)| +----------------------------+ | 12,454.8-| +----------------------------+ -- to_number SELECT to_number('454', '999'); +-------------------+ |to_number(454, 999)| +-------------------+ | 454| +-------------------+ SELECT to_number('454.00', '000.00'); +-------------------------+ |to_number(454.00, 000.00)| +-------------------------+ | 454.00| +-------------------------+ SELECT to_number('12,454', '99,999'); +-------------------------+ |to_number(12,454, 99,999)| +-------------------------+ | 12454| +-------------------------+ SELECT to_number('$78.12', '$99.99'); +-------------------------+ |to_number($78.12, $99.99)| +-------------------------+ | 78.12| +-------------------------+ SELECT to_number('12,454.8-', '99,999.9S'); +-------------------------------+ |to_number(12,454.8-, 99,999.9S)| +-------------------------------+ | -12454.8| +-------------------------------+ -- to_varchar SELECT to_varchar(454, '999'); +-----------------+ |to_char(454, 999)| +-----------------+ | 454| +-----------------+ SELECT to_varchar(454.00, '000D00'); +-----------------------+ |to_char(454.00, 000D00)| +-----------------------+ | 454.00| +-----------------------+ SELECT to_varchar(12454, '99G999'); +----------------------+ |to_char(12454, 99G999)| +----------------------+ | 12,454| +----------------------+ SELECT to_varchar(78.12, '$99.99'); +----------------------+ |to_char(78.12, $99.99)| +----------------------+ | $78.12| +----------------------+ SELECT to_varchar(-12454.8, '99G999D9S'); +----------------------------+ |to_char(-12454.8, 99G999D9S)| +----------------------------+ | 12,454.8-| +----------------------------+ -- translate SELECT translate('AaBbCc', 'abc', '123'); +---------------------------+ |translate(AaBbCc, abc, 123)| +---------------------------+ | A1B2C3| +---------------------------+ -- try_to_binary SELECT try_to_binary('abc', 'utf-8'); +-------------------------+ |try_to_binary(abc, utf-8)| +-------------------------+ | [61 62 63]| +-------------------------+ select try_to_binary('a!', 'base64'); +-------------------------+ |try_to_binary(a!, base64)| +-------------------------+ | NULL| +-------------------------+ select try_to_binary('abc', 'invalidFormat'); +---------------------------------+ |try_to_binary(abc, invalidFormat)| +---------------------------------+ | NULL| +---------------------------------+ -- try_to_number SELECT try_to_number('454', '999'); +-----------------------+ |try_to_number(454, 999)| +-----------------------+ | 454| +-----------------------+ SELECT try_to_number('454.00', '000.00'); +-----------------------------+ |try_to_number(454.00, 000.00)| +-----------------------------+ | 454.00| +-----------------------------+ SELECT try_to_number('12,454', '99,999'); +-----------------------------+ |try_to_number(12,454, 99,999)| +-----------------------------+ | 12454| +-----------------------------+ SELECT try_to_number('$78.12', '$99.99'); +-----------------------------+ |try_to_number($78.12, $99.99)| +-----------------------------+ | 78.12| +-----------------------------+ SELECT try_to_number('12,454.8-', '99,999.9S'); +-----------------------------------+ |try_to_number(12,454.8-, 99,999.9S)| +-----------------------------------+ | -12454.8| +-----------------------------------+ -- ucase SELECT ucase('Feathers'); +---------------+ |ucase(Feathers)| +---------------+ | FEATHERS| +---------------+ -- unbase64 SELECT unbase64('U3BhcmsgU1FM'); +----------------------+ |unbase64(U3BhcmsgU1FM)| +----------------------+ | [53 70 61 72 6B 2...| +----------------------+ -- upper SELECT upper('Feathers'); +---------------+ |upper(Feathers)| +---------------+ | FEATHERS| +---------------+ ``` #### Fungsi tanggal dan waktu **catatan** Untuk melihat integrasi sumber AWS data mana yang mendukung perintah SQL ini, lihat. [Perintah dan OpenSearch fungsi SQL yang didukung](#supported-directquery-sql) **** | Fungsi | Deskripsi | | --- | --- | | add\$1months (start\$1date, num\$1months) | Mengembalikan tanggal yang num\$1months setelahnyastart\$1date. | | convert\$1timezone ([SourceTZ,] TargetTZ, Sourcets) | Mengkonversi stempel waktu tanpa zona waktu sourceTs dari zona waktu ke zona sourceTz waktu. targetTz | | curdate () | Mengembalikan tanggal saat ini pada awal evaluasi query. Semua panggilan curdate dalam kueri yang sama mengembalikan nilai yang sama. | | current\$1date () | Mengembalikan tanggal saat ini pada awal evaluasi query. Semua panggilan current\$1date dalam kueri yang sama mengembalikan nilai yang sama. | | current\$1date | Mengembalikan tanggal saat ini pada awal evaluasi query. | | current\$1timestamp () | Mengembalikan timestamp saat ini pada awal evaluasi query. Semua panggilan current\$1timestamp dalam kueri yang sama mengembalikan nilai yang sama. | | current\$1timestamp | Mengembalikan timestamp saat ini pada awal evaluasi query. | | current\$1timezone () | Mengembalikan zona waktu lokal sesi saat ini. | | date\$1add (start\$1date, num\$1days) | Mengembalikan tanggal yang num\$1days setelahnyastart\$1date. | | date\$1diff (EndDate, startDate) | Mengembalikan jumlah hari dari startDate keendDate. | | date\$1format (stempel waktu, fmt) | Mengkonversi timestamp ke nilai string dalam format yang ditentukan oleh format fmt tanggal. | | date\$1from\$1unix\$1date (hari) | Buat tanggal dari jumlah hari sejak 1970-01-01. | | date\$1part (bidang, sumber) | Ekstrak bagian dari sumber date/timestamp atau interval. | | date\$1sub (start\$1date, num\$1days) | Mengembalikan tanggal yang num\$1days sebelumnyastart\$1date. | | date\$1trunc (fmt, ts) | Mengembalikan stempel waktu ts terpotong ke unit yang ditentukan oleh model format. fmt | | dateadd (start\$1date, num\$1days) | Mengembalikan tanggal yang num\$1days setelahnyastart\$1date. | | datediff (EndDate, startDate) | Mengembalikan jumlah hari dari startDate keendDate. | | datepart (bidang, sumber) | Ekstrak bagian dari sumber date/timestamp atau interval. | | hari (tanggal) | Mengembalikan hari bulan tanggal/timestamp. | | dayofmonth (tanggal) | Mengembalikan hari bulan tanggal/timestamp. | | dayofweek (tanggal) | Mengembalikan hari dalam seminggu untuk date/timestamp (1 = Minggu, 2 = Senin,..., 7 = Sabtu). | | dayofyear (tanggal) | Mengembalikan hari tahun tanggal/timestamp. | | ekstrak (bidang DARI sumber) | Ekstrak bagian dari sumber date/timestamp atau interval. | | dari\$1unixtime (unix\$1time [, fmt]) | Pengembalian unix\$1time dalam yang ditentukanfmt. | | from\$1utc\$1timestamp (stempel waktu, zona waktu) | Diberikan stempel waktu seperti '2017-07-14 02:40:00.0 ', menafsirkannya sebagai waktu di UTC, dan menjadikan waktu itu sebagai stempel waktu di zona waktu yang diberikan. Misalnya, 'GMT\$11' akan menghasilkan '2017-07-14 03:40:00.0 '. | | jam (stempel waktu) | Mengembalikan komponen jam dari string/timestamp. | | last\$1day (tanggal) | Mengembalikan hari terakhir bulan yang menjadi tanggalnya. | | localtimestamp () | Mengembalikan timestamp saat ini tanpa zona waktu pada awal evaluasi query. Semua panggilan localtimestamp dalam kueri yang sama mengembalikan nilai yang sama. | | localtimestamp | Mengembalikan tanggal-waktu lokal saat ini di zona waktu sesi pada awal evaluasi kueri. | | make\$1date (tahun, bulan, hari) | Buat bidang tanggal dari tahun, bulan, dan hari. | | make\$1dt\$1interval ([hari [, jam [, menit [, detik]]]]) | Buat DayTimeIntervalType durasi dari hari, jam, menit dan detik. | | make\$1interval ([tahun [, bulan [, minggu [, hari [, jam [, menit [, detik]]]]]]) | Buat interval dari tahun, bulan, minggu, hari, jam, menit dan detik. | | make\$1timestamp (tahun, bulan, hari, jam, menit, detik [, zona waktu]) | Buat stempel waktu dari bidang tahun, bulan, hari, jam, min, detik, dan zona waktu. | | make\$1timestamp\$1ltz (tahun, bulan, hari, jam, menit, detik [, zona waktu]) | Buat stempel waktu saat ini dengan zona waktu lokal dari bidang tahun, bulan, hari, jam, menit, detik, dan zona waktu. | | make\$1timestamp\$1ntz (tahun, bulan, hari, jam, min, detik) | Buat bidang tanggal-waktu lokal dari bidang tahun, bulan, hari, jam, menit, detik. | | make\$1ym\$1interval ([tahun [, bulan]]) | Buat interval tahun-bulan dari tahun, bulan. | | menit (stempel waktu) | Mengembalikan komponen menit dari string/timestamp. | | bulan (tanggal) | Mengembalikan komponen bulan dari tanggal/timestamp. | | bulan\$1antara (stempel waktu1, stempel waktu2 [, roundOff]) | Jika timestamp1 lebih lambattimestamp2, maka hasilnya positif. Jika timestamp1 dan timestamp2 berada pada hari yang sama dalam bulan, atau keduanya adalah hari terakhir bulan, waktu dalam sehari akan diabaikan. Jika tidak, selisihnya dihitung berdasarkan 31 hari per bulan, dan dibulatkan menjadi 8 digit kecuali RoundOff = False. | | next\$1day (start\$1date, hari\$1of\$1week) | Mengembalikan tanggal pertama yang lebih lambat start\$1date dan dinamai seperti yang ditunjukkan. Fungsi mengembalikan NULL jika setidaknya salah satu parameter input adalah NULL. | | sekarang () | Mengembalikan timestamp saat ini pada awal evaluasi query. | | kuartal (tanggal) | Mengembalikan kuartal tahun untuk tanggal, dalam kisaran 1 hingga 4. | | kedua (stempel waktu) | Mengembalikan komponen kedua dari string/timestamp. | | session\$1window (time\$1column, gap\$1duration) | Menghasilkan jendela sesi yang diberi stempel waktu yang menentukan kolom dan durasi celah. Lihat 'Jenis jendela waktu' di dokumen panduan Streaming Terstruktur untuk penjelasan dan contoh terperinci. | | timestamp\$1micros (mikrodetik) | Membuat stempel waktu dari jumlah mikrodetik sejak zaman UTC. | | timestamp\$1millis (milidetik) | Membuat stempel waktu dari jumlah milidetik sejak zaman UTC. | | timestamp\$1seconds (detik) | Membuat stempel waktu dari jumlah detik (bisa fraksional) sejak zaman UTC. | | to\$1date (date\$1str [, fmt]) | date\$1strMem-parsing ekspresi dengan fmt ekspresi ke tanggal. Mengembalikan null dengan input tidak valid. Secara default, ini mengikuti aturan casting ke tanggal jika fmt dihilangkan. | | to\$1timestamp (timestamp\$1str [, fmt]) | Mem-parsing timestamp\$1str ekspresi dengan fmt ekspresi ke stempel waktu. Mengembalikan null dengan input tidak valid. Secara default, ini mengikuti aturan casting ke stempel waktu jika fmt dihilangkan. | | to\$1timestamp\$1ltz (timestamp\$1str [, fmt]) | Mem-parsing timestamp\$1str ekspresi dengan fmt ekspresi ke stempel waktu dengan zona waktu lokal. Mengembalikan null dengan input tidak valid. Secara default, ini mengikuti aturan casting ke stempel waktu jika fmt dihilangkan. | | to\$1timestamp\$1ntz (timestamp\$1str [, fmt]) | Mem-parsing timestamp\$1str ekspresi dengan fmt ekspresi ke stempel waktu tanpa zona waktu. Mengembalikan null dengan input tidak valid. Secara default, ini mengikuti aturan casting ke stempel waktu jika fmt dihilangkan. | | to\$1unix\$1timestamp (TimeExp [, fmt]) | Mengembalikan stempel waktu UNIX dari waktu yang diberikan. | | to\$1utc\$1timestamp (stempel waktu, zona waktu) | Diberikan stempel waktu seperti '2017-07-14 02:40:00.0 ', menafsirkannya sebagai waktu di zona waktu tertentu, dan menjadikan waktu itu sebagai stempel waktu di UTC. Misalnya, 'GMT\$11' akan menghasilkan '2017-07-14 01:40:00.0 '. | | batang (tanggal, fmt) | Kembali date dengan porsi waktu hari terpotong ke unit yang ditentukan oleh model format. fmt | | try\$1to\$1timestamp (stempel waktu [, fmt]) | Mem-parsing timestamp\$1str ekspresi dengan fmt ekspresi ke stempel waktu. | | unix\$1date (tanggal) | Mengembalikan jumlah hari sejak 1970-01-01. | | unix\$1micros (stempel waktu) | Mengembalikan jumlah mikrodetik sejak 1970-01-01 00:00:00 UTC. | | unix\$1millis (stempel waktu) | Mengembalikan jumlah milidetik sejak 1970-01-01 00:00:00 UTC. Memangkas tingkat presisi yang lebih tinggi. | | unix\$1seconds (stempel waktu) | Mengembalikan jumlah detik sejak 1970-01-01 00:00:00 UTC. Memangkas tingkat presisi yang lebih tinggi. | | unix\$1timestamp ([TimeExp [, fmt]]) | Mengembalikan stempel waktu UNIX dari waktu saat ini atau yang ditentukan. | | hari kerja (tanggal) | Mengembalikan hari dalam seminggu untuk date/timestamp (0 = Senin, 1 = Selasa,..., 6 = Minggu). | | weekofyear (tanggal) | Mengembalikan minggu tahun dari tanggal yang diberikan. Satu minggu dianggap dimulai pada hari Senin dan minggu 1 adalah minggu pertama dengan> 3 hari. | | jendela (time\$1column, window\$1duration [, slide\$1duration [, start\$1time]]) | Bucketize baris menjadi satu atau beberapa jendela waktu yang diberikan timestamp menentukan kolom. Jendela mulai inklusif tetapi ujung jendela eksklusif, misalnya 12:05 akan berada di jendela [12:05,12:10) tetapi tidak di [12:00,12:05). Windows dapat mendukung presisi mikrodetik. Windows dalam urutan bulan tidak didukung. Lihat 'Operasi Jendela pada Waktu Peristiwa' di dokumen panduan Streaming Terstruktur untuk penjelasan dan contoh terperinci. | | window\$1time (window\$1column) | Ekstrak nilai waktu dari kolom time/session jendela yang dapat digunakan untuk nilai waktu acara jendela. Waktu yang diekstraksi adalah (window.end - 1) yang mencerminkan fakta bahwa jendela agregasi memiliki batas atas eksklusif - [mulai, akhir) Lihat 'Operasi Jendela pada Waktu Peristiwa' di dokumen panduan Streaming Terstruktur untuk penjelasan dan contoh terperinci. | | tahun (tanggal) | Mengembalikan komponen tahun tanggal/timestamp. | **Contoh** ``` -- add_months SELECT add_months('2016-08-31', 1); +-------------------------+ |add_months(2016-08-31, 1)| +-------------------------+ | 2016-09-30| +-------------------------+ -- convert_timezone SELECT convert_timezone('Europe/Brussels', 'America/Los_Angeles', timestamp_ntz'2021-12-06 00:00:00'); +-------------------------------------------------------------------------------------------+ |convert_timezone(Europe/Brussels, America/Los_Angeles, TIMESTAMP_NTZ '2021-12-06 00:00:00')| +-------------------------------------------------------------------------------------------+ | 2021-12-05 15:00:00| +-------------------------------------------------------------------------------------------+ SELECT convert_timezone('Europe/Brussels', timestamp_ntz'2021-12-05 15:00:00'); +------------------------------------------------------------------------------------------+ |convert_timezone(current_timezone(), Europe/Brussels, TIMESTAMP_NTZ '2021-12-05 15:00:00')| +------------------------------------------------------------------------------------------+ | 2021-12-05 07:00:00| +------------------------------------------------------------------------------------------+ -- curdate SELECT curdate(); +--------------+ |current_date()| +--------------+ | 2024-02-24| +--------------+ -- current_date SELECT current_date(); +--------------+ |current_date()| +--------------+ | 2024-02-24| +--------------+ SELECT current_date; +--------------+ |current_date()| +--------------+ | 2024-02-24| +--------------+ -- current_timestamp SELECT current_timestamp(); +--------------------+ | current_timestamp()| +--------------------+ |2024-02-24 16:36:...| +--------------------+ SELECT current_timestamp; +--------------------+ | current_timestamp()| +--------------------+ |2024-02-24 16:36:...| +--------------------+ -- current_timezone SELECT current_timezone(); +------------------+ |current_timezone()| +------------------+ | Asia/Seoul| +------------------+ -- date_add SELECT date_add('2016-07-30', 1); +-----------------------+ |date_add(2016-07-30, 1)| +-----------------------+ | 2016-07-31| +-----------------------+ -- date_diff SELECT date_diff('2009-07-31', '2009-07-30'); +---------------------------------+ |date_diff(2009-07-31, 2009-07-30)| +---------------------------------+ | 1| +---------------------------------+ SELECT date_diff('2009-07-30', '2009-07-31'); +---------------------------------+ |date_diff(2009-07-30, 2009-07-31)| +---------------------------------+ | -1| +---------------------------------+ -- date_format SELECT date_format('2016-04-08', 'y'); +--------------------------+ |date_format(2016-04-08, y)| +--------------------------+ | 2016| +--------------------------+ -- date_from_unix_date SELECT date_from_unix_date(1); +----------------------+ |date_from_unix_date(1)| +----------------------+ | 1970-01-02| +----------------------+ -- date_part SELECT date_part('YEAR', TIMESTAMP '2019-08-12 01:00:00.123456'); +-------------------------------------------------------+ |date_part(YEAR, TIMESTAMP '2019-08-12 01:00:00.123456')| +-------------------------------------------------------+ | 2019| +-------------------------------------------------------+ SELECT date_part('week', timestamp'2019-08-12 01:00:00.123456'); +-------------------------------------------------------+ |date_part(week, TIMESTAMP '2019-08-12 01:00:00.123456')| +-------------------------------------------------------+ | 33| +-------------------------------------------------------+ SELECT date_part('doy', DATE'2019-08-12'); +---------------------------------+ |date_part(doy, DATE '2019-08-12')| +---------------------------------+ | 224| +---------------------------------+ SELECT date_part('SECONDS', timestamp'2019-10-01 00:00:01.000001'); +----------------------------------------------------------+ |date_part(SECONDS, TIMESTAMP '2019-10-01 00:00:01.000001')| +----------------------------------------------------------+ | 1.000001| +----------------------------------------------------------+ SELECT date_part('days', interval 5 days 3 hours 7 minutes); +-------------------------------------------------+ |date_part(days, INTERVAL '5 03:07' DAY TO MINUTE)| +-------------------------------------------------+ | 5| +-------------------------------------------------+ SELECT date_part('seconds', interval 5 hours 30 seconds 1 milliseconds 1 microseconds); +-------------------------------------------------------------+ |date_part(seconds, INTERVAL '05:00:30.001001' HOUR TO SECOND)| +-------------------------------------------------------------+ | 30.001001| +-------------------------------------------------------------+ SELECT date_part('MONTH', INTERVAL '2021-11' YEAR TO MONTH); +--------------------------------------------------+ |date_part(MONTH, INTERVAL '2021-11' YEAR TO MONTH)| +--------------------------------------------------+ | 11| +--------------------------------------------------+ SELECT date_part('MINUTE', INTERVAL '123 23:55:59.002001' DAY TO SECOND); +---------------------------------------------------------------+ |date_part(MINUTE, INTERVAL '123 23:55:59.002001' DAY TO SECOND)| +---------------------------------------------------------------+ | 55| +---------------------------------------------------------------+ -- date_sub SELECT date_sub('2016-07-30', 1); +-----------------------+ |date_sub(2016-07-30, 1)| +-----------------------+ | 2016-07-29| +-----------------------+ -- date_trunc SELECT date_trunc('YEAR', '2015-03-05T09:32:05.359'); +-----------------------------------------+ |date_trunc(YEAR, 2015-03-05T09:32:05.359)| +-----------------------------------------+ | 2015-01-01 00:00:00| +-----------------------------------------+ SELECT date_trunc('MM', '2015-03-05T09:32:05.359'); +---------------------------------------+ |date_trunc(MM, 2015-03-05T09:32:05.359)| +---------------------------------------+ | 2015-03-01 00:00:00| +---------------------------------------+ SELECT date_trunc('DD', '2015-03-05T09:32:05.359'); +---------------------------------------+ |date_trunc(DD, 2015-03-05T09:32:05.359)| +---------------------------------------+ | 2015-03-05 00:00:00| +---------------------------------------+ SELECT date_trunc('HOUR', '2015-03-05T09:32:05.359'); +-----------------------------------------+ |date_trunc(HOUR, 2015-03-05T09:32:05.359)| +-----------------------------------------+ | 2015-03-05 09:00:00| +-----------------------------------------+ SELECT date_trunc('MILLISECOND', '2015-03-05T09:32:05.123456'); +---------------------------------------------------+ |date_trunc(MILLISECOND, 2015-03-05T09:32:05.123456)| +---------------------------------------------------+ | 2015-03-05 09:32:...| +---------------------------------------------------+ -- dateadd SELECT dateadd('2016-07-30', 1); +-----------------------+ |date_add(2016-07-30, 1)| +-----------------------+ | 2016-07-31| +-----------------------+ -- datediff SELECT datediff('2009-07-31', '2009-07-30'); +--------------------------------+ |datediff(2009-07-31, 2009-07-30)| +--------------------------------+ | 1| +--------------------------------+ SELECT datediff('2009-07-30', '2009-07-31'); +--------------------------------+ |datediff(2009-07-30, 2009-07-31)| +--------------------------------+ | -1| +--------------------------------+ -- datepart SELECT datepart('YEAR', TIMESTAMP '2019-08-12 01:00:00.123456'); +----------------------------------------------------------+ |datepart(YEAR FROM TIMESTAMP '2019-08-12 01:00:00.123456')| +----------------------------------------------------------+ | 2019| +----------------------------------------------------------+ SELECT datepart('week', timestamp'2019-08-12 01:00:00.123456'); +----------------------------------------------------------+ |datepart(week FROM TIMESTAMP '2019-08-12 01:00:00.123456')| +----------------------------------------------------------+ | 33| +----------------------------------------------------------+ SELECT datepart('doy', DATE'2019-08-12'); +------------------------------------+ |datepart(doy FROM DATE '2019-08-12')| +------------------------------------+ | 224| +------------------------------------+ SELECT datepart('SECONDS', timestamp'2019-10-01 00:00:01.000001'); +-------------------------------------------------------------+ |datepart(SECONDS FROM TIMESTAMP '2019-10-01 00:00:01.000001')| +-------------------------------------------------------------+ | 1.000001| +-------------------------------------------------------------+ SELECT datepart('days', interval 5 days 3 hours 7 minutes); +----------------------------------------------------+ |datepart(days FROM INTERVAL '5 03:07' DAY TO MINUTE)| +----------------------------------------------------+ | 5| +----------------------------------------------------+ SELECT datepart('seconds', interval 5 hours 30 seconds 1 milliseconds 1 microseconds); +----------------------------------------------------------------+ |datepart(seconds FROM INTERVAL '05:00:30.001001' HOUR TO SECOND)| +----------------------------------------------------------------+ | 30.001001| +----------------------------------------------------------------+ SELECT datepart('MONTH', INTERVAL '2021-11' YEAR TO MONTH); +-----------------------------------------------------+ |datepart(MONTH FROM INTERVAL '2021-11' YEAR TO MONTH)| +-----------------------------------------------------+ | 11| +-----------------------------------------------------+ SELECT datepart('MINUTE', INTERVAL '123 23:55:59.002001' DAY TO SECOND); +------------------------------------------------------------------+ |datepart(MINUTE FROM INTERVAL '123 23:55:59.002001' DAY TO SECOND)| +------------------------------------------------------------------+ | 55| +------------------------------------------------------------------+ -- day SELECT day('2009-07-30'); +---------------+ |day(2009-07-30)| +---------------+ | 30| +---------------+ -- dayofmonth SELECT dayofmonth('2009-07-30'); +----------------------+ |dayofmonth(2009-07-30)| +----------------------+ | 30| +----------------------+ -- dayofweek SELECT dayofweek('2009-07-30'); +---------------------+ |dayofweek(2009-07-30)| +---------------------+ | 5| +---------------------+ -- dayofyear SELECT dayofyear('2016-04-09'); +---------------------+ |dayofyear(2016-04-09)| +---------------------+ | 100| +---------------------+ -- extract SELECT extract(YEAR FROM TIMESTAMP '2019-08-12 01:00:00.123456'); +---------------------------------------------------------+ |extract(YEAR FROM TIMESTAMP '2019-08-12 01:00:00.123456')| +---------------------------------------------------------+ | 2019| +---------------------------------------------------------+ SELECT extract(week FROM timestamp'2019-08-12 01:00:00.123456'); +---------------------------------------------------------+ |extract(week FROM TIMESTAMP '2019-08-12 01:00:00.123456')| +---------------------------------------------------------+ | 33| +---------------------------------------------------------+ SELECT extract(doy FROM DATE'2019-08-12'); +-----------------------------------+ |extract(doy FROM DATE '2019-08-12')| +-----------------------------------+ | 224| +-----------------------------------+ SELECT extract(SECONDS FROM timestamp'2019-10-01 00:00:01.000001'); +------------------------------------------------------------+ |extract(SECONDS FROM TIMESTAMP '2019-10-01 00:00:01.000001')| +------------------------------------------------------------+ | 1.000001| +------------------------------------------------------------+ SELECT extract(days FROM interval 5 days 3 hours 7 minutes); +---------------------------------------------------+ |extract(days FROM INTERVAL '5 03:07' DAY TO MINUTE)| +---------------------------------------------------+ | 5| +---------------------------------------------------+ SELECT extract(seconds FROM interval 5 hours 30 seconds 1 milliseconds 1 microseconds); +---------------------------------------------------------------+ |extract(seconds FROM INTERVAL '05:00:30.001001' HOUR TO SECOND)| +---------------------------------------------------------------+ | 30.001001| +---------------------------------------------------------------+ SELECT extract(MONTH FROM INTERVAL '2021-11' YEAR TO MONTH); +----------------------------------------------------+ |extract(MONTH FROM INTERVAL '2021-11' YEAR TO MONTH)| +----------------------------------------------------+ | 11| +----------------------------------------------------+ SELECT extract(MINUTE FROM INTERVAL '123 23:55:59.002001' DAY TO SECOND); +-----------------------------------------------------------------+ |extract(MINUTE FROM INTERVAL '123 23:55:59.002001' DAY TO SECOND)| +-----------------------------------------------------------------+ | 55| +-----------------------------------------------------------------+ -- from_unixtime SELECT from_unixtime(0, 'yyyy-MM-dd HH:mm:ss'); +-------------------------------------+ |from_unixtime(0, yyyy-MM-dd HH:mm:ss)| +-------------------------------------+ | 1970-01-01 09:00:00| +-------------------------------------+ SELECT from_unixtime(0); +-------------------------------------+ |from_unixtime(0, yyyy-MM-dd HH:mm:ss)| +-------------------------------------+ | 1970-01-01 09:00:00| +-------------------------------------+ -- from_utc_timestamp SELECT from_utc_timestamp('2016-08-31', 'Asia/Seoul'); +------------------------------------------+ |from_utc_timestamp(2016-08-31, Asia/Seoul)| +------------------------------------------+ | 2016-08-31 09:00:00| +------------------------------------------+ -- hour SELECT hour('2009-07-30 12:58:59'); +-------------------------+ |hour(2009-07-30 12:58:59)| +-------------------------+ | 12| +-------------------------+ -- last_day SELECT last_day('2009-01-12'); +--------------------+ |last_day(2009-01-12)| +--------------------+ | 2009-01-31| +--------------------+ -- localtimestamp SELECT localtimestamp(); +--------------------+ | localtimestamp()| +--------------------+ |2024-02-24 16:36:...| +--------------------+ -- make_date SELECT make_date(2013, 7, 15); +----------------------+ |make_date(2013, 7, 15)| +----------------------+ | 2013-07-15| +----------------------+ SELECT make_date(2019, 7, NULL); +------------------------+ |make_date(2019, 7, NULL)| +------------------------+ | NULL| +------------------------+ -- make_dt_interval SELECT make_dt_interval(1, 12, 30, 01.001001); +-------------------------------------+ |make_dt_interval(1, 12, 30, 1.001001)| +-------------------------------------+ | INTERVAL '1 12:30...| +-------------------------------------+ SELECT make_dt_interval(2); +-----------------------------------+ |make_dt_interval(2, 0, 0, 0.000000)| +-----------------------------------+ | INTERVAL '2 00:00...| +-----------------------------------+ SELECT make_dt_interval(100, null, 3); +----------------------------------------+ |make_dt_interval(100, NULL, 3, 0.000000)| +----------------------------------------+ | NULL| +----------------------------------------+ -- make_interval SELECT make_interval(100, 11, 1, 1, 12, 30, 01.001001); +----------------------------------------------+ |make_interval(100, 11, 1, 1, 12, 30, 1.001001)| +----------------------------------------------+ | 100 years 11 mont...| +----------------------------------------------+ SELECT make_interval(100, null, 3); +----------------------------------------------+ |make_interval(100, NULL, 3, 0, 0, 0, 0.000000)| +----------------------------------------------+ | NULL| +----------------------------------------------+ SELECT make_interval(0, 1, 0, 1, 0, 0, 100.000001); +-------------------------------------------+ |make_interval(0, 1, 0, 1, 0, 0, 100.000001)| +-------------------------------------------+ | 1 months 1 days 1...| +-------------------------------------------+ -- make_timestamp SELECT make_timestamp(2014, 12, 28, 6, 30, 45.887); +-------------------------------------------+ |make_timestamp(2014, 12, 28, 6, 30, 45.887)| +-------------------------------------------+ | 2014-12-28 06:30:...| +-------------------------------------------+ SELECT make_timestamp(2014, 12, 28, 6, 30, 45.887, 'CET'); +------------------------------------------------+ |make_timestamp(2014, 12, 28, 6, 30, 45.887, CET)| +------------------------------------------------+ | 2014-12-28 14:30:...| +------------------------------------------------+ SELECT make_timestamp(2019, 6, 30, 23, 59, 60); +---------------------------------------+ |make_timestamp(2019, 6, 30, 23, 59, 60)| +---------------------------------------+ | 2019-07-01 00:00:00| +---------------------------------------+ SELECT make_timestamp(2019, 6, 30, 23, 59, 1); +--------------------------------------+ |make_timestamp(2019, 6, 30, 23, 59, 1)| +--------------------------------------+ | 2019-06-30 23:59:01| +--------------------------------------+ SELECT make_timestamp(null, 7, 22, 15, 30, 0); +--------------------------------------+ |make_timestamp(NULL, 7, 22, 15, 30, 0)| +--------------------------------------+ | NULL| +--------------------------------------+ -- make_timestamp_ltz SELECT make_timestamp_ltz(2014, 12, 28, 6, 30, 45.887); +-----------------------------------------------+ |make_timestamp_ltz(2014, 12, 28, 6, 30, 45.887)| +-----------------------------------------------+ | 2014-12-28 06:30:...| +-----------------------------------------------+ SELECT make_timestamp_ltz(2014, 12, 28, 6, 30, 45.887, 'CET'); +----------------------------------------------------+ |make_timestamp_ltz(2014, 12, 28, 6, 30, 45.887, CET)| +----------------------------------------------------+ | 2014-12-28 14:30:...| +----------------------------------------------------+ SELECT make_timestamp_ltz(2019, 6, 30, 23, 59, 60); +-------------------------------------------+ |make_timestamp_ltz(2019, 6, 30, 23, 59, 60)| +-------------------------------------------+ | 2019-07-01 00:00:00| +-------------------------------------------+ SELECT make_timestamp_ltz(null, 7, 22, 15, 30, 0); +------------------------------------------+ |make_timestamp_ltz(NULL, 7, 22, 15, 30, 0)| +------------------------------------------+ | NULL| +------------------------------------------+ -- make_timestamp_ntz SELECT make_timestamp_ntz(2014, 12, 28, 6, 30, 45.887); +-----------------------------------------------+ |make_timestamp_ntz(2014, 12, 28, 6, 30, 45.887)| +-----------------------------------------------+ | 2014-12-28 06:30:...| +-----------------------------------------------+ SELECT make_timestamp_ntz(2019, 6, 30, 23, 59, 60); +-------------------------------------------+ |make_timestamp_ntz(2019, 6, 30, 23, 59, 60)| +-------------------------------------------+ | 2019-07-01 00:00:00| +-------------------------------------------+ SELECT make_timestamp_ntz(null, 7, 22, 15, 30, 0); +------------------------------------------+ |make_timestamp_ntz(NULL, 7, 22, 15, 30, 0)| +------------------------------------------+ | NULL| +------------------------------------------+ -- make_ym_interval SELECT make_ym_interval(1, 2); +----------------------+ |make_ym_interval(1, 2)| +----------------------+ | INTERVAL '1-2' YE...| +----------------------+ SELECT make_ym_interval(1, 0); +----------------------+ |make_ym_interval(1, 0)| +----------------------+ | INTERVAL '1-0' YE...| +----------------------+ SELECT make_ym_interval(-1, 1); +-----------------------+ |make_ym_interval(-1, 1)| +-----------------------+ | INTERVAL '-0-11' ...| +-----------------------+ SELECT make_ym_interval(2); +----------------------+ |make_ym_interval(2, 0)| +----------------------+ | INTERVAL '2-0' YE...| +----------------------+ -- minute SELECT minute('2009-07-30 12:58:59'); +---------------------------+ |minute(2009-07-30 12:58:59)| +---------------------------+ | 58| +---------------------------+ -- month SELECT month('2016-07-30'); +-----------------+ |month(2016-07-30)| +-----------------+ | 7| +-----------------+ -- months_between SELECT months_between('1997-02-28 10:30:00', '1996-10-30'); +-----------------------------------------------------+ |months_between(1997-02-28 10:30:00, 1996-10-30, true)| +-----------------------------------------------------+ | 3.94959677| +-----------------------------------------------------+ SELECT months_between('1997-02-28 10:30:00', '1996-10-30', false); +------------------------------------------------------+ |months_between(1997-02-28 10:30:00, 1996-10-30, false)| +------------------------------------------------------+ | 3.9495967741935485| +------------------------------------------------------+ -- next_day SELECT next_day('2015-01-14', 'TU'); +------------------------+ |next_day(2015-01-14, TU)| +------------------------+ | 2015-01-20| +------------------------+ -- now SELECT now(); +--------------------+ | now()| +--------------------+ |2024-02-24 16:36:...| +--------------------+ -- quarter SELECT quarter('2016-08-31'); +-------------------+ |quarter(2016-08-31)| +-------------------+ | 3| +-------------------+ -- second SELECT second('2009-07-30 12:58:59'); +---------------------------+ |second(2009-07-30 12:58:59)| +---------------------------+ | 59| +---------------------------+ -- session_window SELECT a, session_window.start, session_window.end, count(*) as cnt FROM VALUES ('A1', '2021-01-01 00:00:00'), ('A1', '2021-01-01 00:04:30'), ('A1', '2021-01-01 00:10:00'), ('A2', '2021-01-01 00:01:00') AS tab(a, b) GROUP by a, session_window(b, '5 minutes') ORDER BY a, start; +---+-------------------+-------------------+---+ | a| start| end|cnt| +---+-------------------+-------------------+---+ | A1|2021-01-01 00:00:00|2021-01-01 00:09:30| 2| | A1|2021-01-01 00:10:00|2021-01-01 00:15:00| 1| | A2|2021-01-01 00:01:00|2021-01-01 00:06:00| 1| +---+-------------------+-------------------+---+ SELECT a, session_window.start, session_window.end, count(*) as cnt FROM VALUES ('A1', '2021-01-01 00:00:00'), ('A1', '2021-01-01 00:04:30'), ('A1', '2021-01-01 00:10:00'), ('A2', '2021-01-01 00:01:00'), ('A2', '2021-01-01 00:04:30') AS tab(a, b) GROUP by a, session_window(b, CASE WHEN a = 'A1' THEN '5 minutes' WHEN a = 'A2' THEN '1 minute' ELSE '10 minutes' END) ORDER BY a, start; +---+-------------------+-------------------+---+ | a| start| end|cnt| +---+-------------------+-------------------+---+ | A1|2021-01-01 00:00:00|2021-01-01 00:09:30| 2| | A1|2021-01-01 00:10:00|2021-01-01 00:15:00| 1| | A2|2021-01-01 00:01:00|2021-01-01 00:02:00| 1| | A2|2021-01-01 00:04:30|2021-01-01 00:05:30| 1| +---+-------------------+-------------------+---+ -- timestamp_micros SELECT timestamp_micros(1230219000123123); +----------------------------------+ |timestamp_micros(1230219000123123)| +----------------------------------+ | 2008-12-26 00:30:...| +----------------------------------+ -- timestamp_millis SELECT timestamp_millis(1230219000123); +-------------------------------+ |timestamp_millis(1230219000123)| +-------------------------------+ | 2008-12-26 00:30:...| +-------------------------------+ -- timestamp_seconds SELECT timestamp_seconds(1230219000); +-----------------------------+ |timestamp_seconds(1230219000)| +-----------------------------+ | 2008-12-26 00:30:00| +-----------------------------+ SELECT timestamp_seconds(1230219000.123); +---------------------------------+ |timestamp_seconds(1230219000.123)| +---------------------------------+ | 2008-12-26 00:30:...| +---------------------------------+ -- to_date SELECT to_date('2009-07-30 04:17:52'); +----------------------------+ |to_date(2009-07-30 04:17:52)| +----------------------------+ | 2009-07-30| +----------------------------+ SELECT to_date('2016-12-31', 'yyyy-MM-dd'); +-------------------------------+ |to_date(2016-12-31, yyyy-MM-dd)| +-------------------------------+ | 2016-12-31| +-------------------------------+ -- to_timestamp SELECT to_timestamp('2016-12-31 00:12:00'); +---------------------------------+ |to_timestamp(2016-12-31 00:12:00)| +---------------------------------+ | 2016-12-31 00:12:00| +---------------------------------+ SELECT to_timestamp('2016-12-31', 'yyyy-MM-dd'); +------------------------------------+ |to_timestamp(2016-12-31, yyyy-MM-dd)| +------------------------------------+ | 2016-12-31 00:00:00| +------------------------------------+ -- to_timestamp_ltz SELECT to_timestamp_ltz('2016-12-31 00:12:00'); +-------------------------------------+ |to_timestamp_ltz(2016-12-31 00:12:00)| +-------------------------------------+ | 2016-12-31 00:12:00| +-------------------------------------+ SELECT to_timestamp_ltz('2016-12-31', 'yyyy-MM-dd'); +----------------------------------------+ |to_timestamp_ltz(2016-12-31, yyyy-MM-dd)| +----------------------------------------+ | 2016-12-31 00:00:00| +----------------------------------------+ -- to_timestamp_ntz SELECT to_timestamp_ntz('2016-12-31 00:12:00'); +-------------------------------------+ |to_timestamp_ntz(2016-12-31 00:12:00)| +-------------------------------------+ | 2016-12-31 00:12:00| +-------------------------------------+ SELECT to_timestamp_ntz('2016-12-31', 'yyyy-MM-dd'); +----------------------------------------+ |to_timestamp_ntz(2016-12-31, yyyy-MM-dd)| +----------------------------------------+ | 2016-12-31 00:00:00| +----------------------------------------+ -- to_unix_timestamp SELECT to_unix_timestamp('2016-04-08', 'yyyy-MM-dd'); +-----------------------------------------+ |to_unix_timestamp(2016-04-08, yyyy-MM-dd)| +-----------------------------------------+ | 1460041200| +-----------------------------------------+ -- to_utc_timestamp SELECT to_utc_timestamp('2016-08-31', 'Asia/Seoul'); +----------------------------------------+ |to_utc_timestamp(2016-08-31, Asia/Seoul)| +----------------------------------------+ | 2016-08-30 15:00:00| +----------------------------------------+ -- trunc SELECT trunc('2019-08-04', 'week'); +-----------------------+ |trunc(2019-08-04, week)| +-----------------------+ | 2019-07-29| +-----------------------+ SELECT trunc('2019-08-04', 'quarter'); +--------------------------+ |trunc(2019-08-04, quarter)| +--------------------------+ | 2019-07-01| +--------------------------+ SELECT trunc('2009-02-12', 'MM'); +---------------------+ |trunc(2009-02-12, MM)| +---------------------+ | 2009-02-01| +---------------------+ SELECT trunc('2015-10-27', 'YEAR'); +-----------------------+ |trunc(2015-10-27, YEAR)| +-----------------------+ | 2015-01-01| +-----------------------+ -- try_to_timestamp SELECT try_to_timestamp('2016-12-31 00:12:00'); +-------------------------------------+ |try_to_timestamp(2016-12-31 00:12:00)| +-------------------------------------+ | 2016-12-31 00:12:00| +-------------------------------------+ SELECT try_to_timestamp('2016-12-31', 'yyyy-MM-dd'); +----------------------------------------+ |try_to_timestamp(2016-12-31, yyyy-MM-dd)| +----------------------------------------+ | 2016-12-31 00:00:00| +----------------------------------------+ SELECT try_to_timestamp('foo', 'yyyy-MM-dd'); +---------------------------------+ |try_to_timestamp(foo, yyyy-MM-dd)| +---------------------------------+ | NULL| +---------------------------------+ -- unix_date SELECT unix_date(DATE("1970-01-02")); +---------------------+ |unix_date(1970-01-02)| +---------------------+ | 1| +---------------------+ -- unix_micros SELECT unix_micros(TIMESTAMP('1970-01-01 00:00:01Z')); +---------------------------------+ |unix_micros(1970-01-01 00:00:01Z)| +---------------------------------+ | 1000000| +---------------------------------+ -- unix_millis SELECT unix_millis(TIMESTAMP('1970-01-01 00:00:01Z')); +---------------------------------+ |unix_millis(1970-01-01 00:00:01Z)| +---------------------------------+ | 1000| +---------------------------------+ -- unix_seconds SELECT unix_seconds(TIMESTAMP('1970-01-01 00:00:01Z')); +----------------------------------+ |unix_seconds(1970-01-01 00:00:01Z)| +----------------------------------+ | 1| +----------------------------------+ -- unix_timestamp SELECT unix_timestamp(); +--------------------------------------------------------+ |unix_timestamp(current_timestamp(), yyyy-MM-dd HH:mm:ss)| +--------------------------------------------------------+ | 1708760216| +--------------------------------------------------------+ SELECT unix_timestamp('2016-04-08', 'yyyy-MM-dd'); +--------------------------------------+ |unix_timestamp(2016-04-08, yyyy-MM-dd)| +--------------------------------------+ | 1460041200| +--------------------------------------+ -- weekday SELECT weekday('2009-07-30'); +-------------------+ |weekday(2009-07-30)| +-------------------+ | 3| +-------------------+ -- weekofyear SELECT weekofyear('2008-02-20'); +----------------------+ |weekofyear(2008-02-20)| +----------------------+ | 8| +----------------------+ -- window SELECT a, window.start, window.end, count(*) as cnt FROM VALUES ('A1', '2021-01-01 00:00:00'), ('A1', '2021-01-01 00:04:30'), ('A1', '2021-01-01 00:06:00'), ('A2', '2021-01-01 00:01:00') AS tab(a, b) GROUP by a, window(b, '5 minutes') ORDER BY a, start; +---+-------------------+-------------------+---+ | a| start| end|cnt| +---+-------------------+-------------------+---+ | A1|2021-01-01 00:00:00|2021-01-01 00:05:00| 2| | A1|2021-01-01 00:05:00|2021-01-01 00:10:00| 1| | A2|2021-01-01 00:00:00|2021-01-01 00:05:00| 1| +---+-------------------+-------------------+---+ SELECT a, window.start, window.end, count(*) as cnt FROM VALUES ('A1', '2021-01-01 00:00:00'), ('A1', '2021-01-01 00:04:30'), ('A1', '2021-01-01 00:06:00'), ('A2', '2021-01-01 00:01:00') AS tab(a, b) GROUP by a, window(b, '10 minutes', '5 minutes') ORDER BY a, start; +---+-------------------+-------------------+---+ | a| start| end|cnt| +---+-------------------+-------------------+---+ | A1|2020-12-31 23:55:00|2021-01-01 00:05:00| 2| | A1|2021-01-01 00:00:00|2021-01-01 00:10:00| 3| | A1|2021-01-01 00:05:00|2021-01-01 00:15:00| 1| | A2|2020-12-31 23:55:00|2021-01-01 00:05:00| 1| | A2|2021-01-01 00:00:00|2021-01-01 00:10:00| 1| +---+-------------------+-------------------+---+ -- window_time SELECT a, window.start as start, window.end as end, window_time(window), cnt FROM (SELECT a, window, count(*) as cnt FROM VALUES ('A1', '2021-01-01 00:00:00'), ('A1', '2021-01-01 00:04:30'), ('A1', '2021-01-01 00:06:00'), ('A2', '2021-01-01 00:01:00') AS tab(a, b) GROUP by a, window(b, '5 minutes') ORDER BY a, window.start); +---+-------------------+-------------------+--------------------+---+ | a| start| end| window_time(window)|cnt| +---+-------------------+-------------------+--------------------+---+ | A1|2021-01-01 00:00:00|2021-01-01 00:05:00|2021-01-01 00:04:...| 2| | A1|2021-01-01 00:05:00|2021-01-01 00:10:00|2021-01-01 00:09:...| 1| | A2|2021-01-01 00:00:00|2021-01-01 00:05:00|2021-01-01 00:04:...| 1| +---+-------------------+-------------------+--------------------+---+ -- year SELECT year('2016-07-30'); +----------------+ |year(2016-07-30)| +----------------+ | 2016| +----------------+ ``` #### Fungsi agregat **catatan** Untuk melihat integrasi sumber AWS data mana yang mendukung perintah SQL ini, lihat. [Perintah dan OpenSearch fungsi SQL yang didukung](#supported-directquery-sql) Fungsi agregat beroperasi pada nilai lintas baris untuk melakukan perhitungan matematis seperti jumlah, rata-rata, penghitungan, minimum/maximum nilai, standar deviasi, dan estimasi, serta beberapa operasi non-matematika. **Sintaks** ``` aggregate_function(input1 [, input2, ...]) FILTER (WHERE boolean_expression) ``` **Parameter ** + `boolean_expression`- Menentukan ekspresi apa pun yang mengevaluasi untuk jenis hasil boolean. Dua atau lebih ekspresi dapat digabungkan bersama menggunakan operator logis (AND, OR). **Fungsi agregat yang diatur** Fungsi agregat ini menggunakan sintaks yang berbeda dari fungsi agregat lainnya sehingga untuk menentukan ekspresi (biasanya nama kolom) yang digunakan untuk mengurutkan nilai. **Sintaks** ``` { PERCENTILE_CONT | PERCENTILE_DISC }(percentile) WITHIN GROUP (ORDER BY { order_by_expression [ ASC | DESC ] [ NULLS { FIRST | LAST } ] [ , ... ] }) FILTER (WHERE boolean_expression) ``` **Parameter ** + `percentile`- Persentil nilai yang ingin Anda temukan. Persentil harus konstanta antara 0,0 dan 1,0. + `order_by_expression`- Ekspresi (biasanya nama kolom) yang digunakan untuk mengurutkan nilai sebelum menggabungkannya. + `boolean_expression`- Menentukan ekspresi apa pun yang mengevaluasi untuk jenis hasil boolean. Dua atau lebih ekspresi dapat digabungkan bersama menggunakan operator logis (AND, OR). **Contoh** ``` CREATE OR REPLACE TEMPORARY VIEW basic_pays AS SELECT * FROM VALUES ('Jane Doe','Accounting',8435), ('Akua Mansa','Accounting',9998), ('John Doe','Accounting',8992), ('Juan Li','Accounting',8870), ('Carlos Salazar','Accounting',11472), ('Arnav Desai','Accounting',6627), ('Saanvi Sarkar','IT',8113), ('Shirley Rodriguez','IT',5186), ('Nikki Wolf','Sales',9181), ('Alejandro Rosalez','Sales',9441), ('Nikhil Jayashankar','Sales',6660), ('Richard Roe','Sales',10563), ('Pat Candella','SCM',10449), ('Gerard Hernandez','SCM',6949), ('Pamela Castillo','SCM',11303), ('Paulo Santos','SCM',11798), ('Jorge Souza','SCM',10586) AS basic_pays(employee_name, department, salary); SELECT * FROM basic_pays; +-------------------+----------+------+ | employee_name |department|salary| +-------------------+----------+------+ | Arnav Desai |Accounting| 6627| | Jorge Souza | SCM| 10586| | Jane Doe |Accounting| 8435| | Nikhil Jayashankar| Sales| 6660| | Diego Vanauf | Sales| 10563| | Carlos Salazar |Accounting| 11472| | Gerard Hernandez | SCM| 6949| | John Doe |Accounting| 8992| | Nikki Wolf | Sales| 9181| | Paulo Santos | SCM| 11798| | Saanvi Sarkar | IT| 8113| | Shirley Rodriguez | IT| 5186| | Pat Candella | SCM| 10449| | Akua Mansa |Accounting| 9998| | Pamela Castillo | SCM| 11303| | Alejandro Rosalez | Sales| 9441| | Juan Li |Accounting| 8870| +-------------------+----------+------+ SELECT department, percentile_cont(0.25) WITHIN GROUP (ORDER BY salary) AS pc1, percentile_cont(0.25) WITHIN GROUP (ORDER BY salary) FILTER (WHERE employee_name LIKE '%Bo%') AS pc2, percentile_cont(0.25) WITHIN GROUP (ORDER BY salary DESC) AS pc3, percentile_cont(0.25) WITHIN GROUP (ORDER BY salary DESC) FILTER (WHERE employee_name LIKE '%Bo%') AS pc4, percentile_disc(0.25) WITHIN GROUP (ORDER BY salary) AS pd1, percentile_disc(0.25) WITHIN GROUP (ORDER BY salary) FILTER (WHERE employee_name LIKE '%Bo%') AS pd2, percentile_disc(0.25) WITHIN GROUP (ORDER BY salary DESC) AS pd3, percentile_disc(0.25) WITHIN GROUP (ORDER BY salary DESC) FILTER (WHERE employee_name LIKE '%Bo%') AS pd4 FROM basic_pays GROUP BY department ORDER BY department; +----------+-------+--------+-------+--------+-----+-----+-----+-----+ |department| pc1| pc2| pc3| pc4| pd1| pd2| pd3| pd4| +----------+-------+--------+-------+--------+-----+-----+-----+-----+ |Accounting|8543.75| 7838.25| 9746.5|10260.75| 8435| 6627| 9998|11472| | IT|5917.75| NULL|7381.25| NULL| 5186| NULL| 8113| NULL| | Sales|8550.75| NULL| 9721.5| NULL| 6660| NULL|10563| NULL| | SCM|10449.0|10786.25|11303.0|11460.75|10449|10449|11303|11798| +----------+-------+--------+-------+--------+-----+-----+-----+-----+ ``` #### Fungsi kondisional **catatan** Untuk melihat integrasi sumber AWS data mana yang mendukung perintah SQL ini, lihat. [Perintah dan OpenSearch fungsi SQL yang didukung](#supported-directquery-sql) **** | Fungsi | Deskripsi | | --- | --- | | menyatu (expr1, expr2,...) | Mengembalikan argumen non-null pertama jika ada. Jika tidak, null. | | jika (expr1, expr2, expr3) | Jika expr1 mengevaluasi ke true, maka returnexpr2; jika tidak kembaliexpr3. | | ifnull (expr1, expr2) | Mengembalikan expr2 expr1 jika nol, atau expr1 sebaliknya. | | nanvl (expr1, expr2) | Kembali expr1 jika bukan NaN, atau expr2 sebaliknya. | | nullif (expr1, expr2) | Mengembalikan null jika expr1 sama denganexpr2, atau expr1 sebaliknya. | | nvl (expr1, expr2) | Mengembalikan expr2 expr1 jika nol, atau expr1 sebaliknya. | | nvl2 (expr1, expr2, expr3) | Mengembalikan expr2 expr1 jika tidak null, atau expr3 sebaliknya. | | KASUS KETIKA expr1 KEMUDIAN expr2 [KETIKA expr3 KEMUDIAN expr4] \$1 [ELSE expr5] AKHIR | When expr1 = true, returnexpr2; else when expr3 = true, returnexpr4; else kembaliexpr5. | **Contoh** ``` -- coalesce SELECT coalesce(NULL, 1, NULL); +-----------------------+ |coalesce(NULL, 1, NULL)| +-----------------------+ | 1| +-----------------------+ -- if SELECT if(1 < 2, 'a', 'b'); +-------------------+ |(IF((1 < 2), a, b))| +-------------------+ | a| +-------------------+ -- ifnull SELECT ifnull(NULL, array('2')); +----------------------+ |ifnull(NULL, array(2))| +----------------------+ | [2]| +----------------------+ -- nanvl SELECT nanvl(cast('NaN' as double), 123); +-------------------------------+ |nanvl(CAST(NaN AS DOUBLE), 123)| +-------------------------------+ | 123.0| +-------------------------------+ -- nullif SELECT nullif(2, 2); +------------+ |nullif(2, 2)| +------------+ | NULL| +------------+ -- nvl SELECT nvl(NULL, array('2')); +-------------------+ |nvl(NULL, array(2))| +-------------------+ | [2]| +-------------------+ -- nvl2 SELECT nvl2(NULL, 2, 1); +----------------+ |nvl2(NULL, 2, 1)| +----------------+ | 1| +----------------+ -- when SELECT CASE WHEN 1 > 0 THEN 1 WHEN 2 > 0 THEN 2.0 ELSE 1.2 END; +-----------------------------------------------------------+ |CASE WHEN (1 > 0) THEN 1 WHEN (2 > 0) THEN 2.0 ELSE 1.2 END| +-----------------------------------------------------------+ | 1.0| +-----------------------------------------------------------+ SELECT CASE WHEN 1 < 0 THEN 1 WHEN 2 > 0 THEN 2.0 ELSE 1.2 END; +-----------------------------------------------------------+ |CASE WHEN (1 < 0) THEN 1 WHEN (2 > 0) THEN 2.0 ELSE 1.2 END| +-----------------------------------------------------------+ | 2.0| +-----------------------------------------------------------+ SELECT CASE WHEN 1 < 0 THEN 1 WHEN 2 < 0 THEN 2.0 END; +--------------------------------------------------+ |CASE WHEN (1 < 0) THEN 1 WHEN (2 < 0) THEN 2.0 END| +--------------------------------------------------+ | NULL| +--------------------------------------------------+ ``` #### Fungsi JSON **catatan** Untuk melihat integrasi sumber AWS data mana yang mendukung perintah SQL ini, lihat. [Perintah dan OpenSearch fungsi SQL yang didukung](#supported-directquery-sql) **** | Fungsi | Deskripsi | | --- | --- | | from\$1json (JsonStr, skema [, opsi]) | Mengembalikan nilai struct dengan `JsonStr` dan `schema` yang diberikan. | | get\$1json\$1object (json\$1txt, jalur) | Mengekstrak objek json dari `path`. | | json\$1array\$1length (JsonArray) | Mengembalikan jumlah elemen dalam array JSON terluar. | | json\$1object\$1keys (json\$1object) | Mengembalikan semua kunci dari objek JSON terluar sebagai array. | | json\$1tuple (JsonStr, p1, p2,..., pn) | Mengembalikan tuple seperti fungsi get\$1json\$1object, tetapi dibutuhkan beberapa nama. Semua parameter input dan jenis kolom output adalah string. | | schema\$1of\$1json (json [, opsi]) | Mengembalikan skema dalam format DDL string JSON. | | to\$1json (expr [, opsi]) | Mengembalikan string JSON dengan nilai struct yang diberikan | **Contoh** ``` -- from_json SELECT from_json('{"a":1, "b":0.8}', 'a INT, b DOUBLE'); +---------------------------+ | from_json({"a":1, "b":0.8}) | +---------------------------+ | {1, 0.8} | +---------------------------+ SELECT from_json('{"time":"26/08/2015"}', 'time Timestamp', map('timestampFormat', 'dd/MM/yyyy')); +--------------------------------+ | from_json({"time":"26/08/2015"}) | +--------------------------------+ | {2015-08-26 00:00... | +--------------------------------+ SELECT from_json('{"teacher": "Alice", "student": [{"name": "Bob", "rank": 1}, {"name": "Charlie", "rank": 2}]}', 'STRUCT>>'); +--------------------------------------------------------------------------------------------------------+ | from_json({"teacher": "Alice", "student": [{"name": "Bob", "rank": 1}, {"name": "Charlie", "rank": 2}]}) | +--------------------------------------------------------------------------------------------------------+ | {Alice, [{Bob, 1}... | +--------------------------------------------------------------------------------------------------------+ -- get_json_object SELECT get_json_object('{"a":"b"}', '$.a'); +-------------------------------+ | get_json_object({"a":"b"}, $.a) | +-------------------------------+ | b | +-------------------------------+ -- json_array_length SELECT json_array_length('[1,2,3,4]'); +----------------------------+ | json_array_length([1,2,3,4]) | +----------------------------+ | 4 | +----------------------------+ SELECT json_array_length('[1,2,3,{"f1":1,"f2":[5,6]},4]'); +------------------------------------------------+ | json_array_length([1,2,3,{"f1":1,"f2":[5,6]},4]) | +------------------------------------------------+ | 5 | +------------------------------------------------+ SELECT json_array_length('[1,2'); +-----------------------+ | json_array_length([1,2) | +-----------------------+ | NULL | +-----------------------+ -- json_object_keys SELECT json_object_keys('{}'); +--------------------+ | json_object_keys({}) | +--------------------+ | [] | +--------------------+ SELECT json_object_keys('{"key": "value"}'); +----------------------------------+ | json_object_keys({"key": "value"}) | +----------------------------------+ | [key] | +----------------------------------+ SELECT json_object_keys('{"f1":"abc","f2":{"f3":"a", "f4":"b"}}'); +--------------------------------------------------------+ | json_object_keys({"f1":"abc","f2":{"f3":"a", "f4":"b"}}) | +--------------------------------------------------------+ | [f1, f2] | +--------------------------------------------------------+ -- json_tuple SELECT json_tuple('{"a":1, "b":2}', 'a', 'b'); +---+---+ | c0| c1| +---+---+ | 1| 2| +---+---+ -- schema_of_json SELECT schema_of_json('[{"col":0}]'); +---------------------------+ | schema_of_json([{"col":0}]) | +---------------------------+ | ARRAY **catatan** Untuk melihat integrasi sumber AWS data mana yang mendukung perintah SQL ini, lihat. [Perintah dan OpenSearch fungsi SQL yang didukung](#supported-directquery-sql) **** | Fungsi | Deskripsi | | --- | --- | | array (expr,...) | Mengembalikan array dengan elemen yang diberikan. | | array\$1append (array, elemen) | Tambahkan elemen di akhir array diteruskan sebagai argumen pertama. Jenis elemen harus mirip dengan jenis elemen array. Elemen null juga ditambahkan ke dalam array. Tetapi jika array dilewatkan, adalah output NULL adalah NULL | | array\$1compact (array) | Menghapus nilai null dari array. | | array\$1contains (array, nilai) | Mengembalikan nilai true jika array berisi nilai. | | array\$1distinct (array) | Menghapus nilai duplikat dari array. | | array\$1except (array1, array2) | Mengembalikan array elemen dalam array1 tetapi tidak di array2, tanpa duplikat. | | array\$1insert (x, pos, val) | Menempatkan val ke pos indeks array x. Indeks array mulai dari 1. Indeks negatif maksimum adalah -1 dimana fungsi menyisipkan elemen baru setelah elemen terakhir saat ini. Indeks di atas ukuran array menambahkan array, atau menambahkan array jika indeks negatif, dengan elemen 'null'. | | array\$1berpotongan (array1, array2) | Mengembalikan array elemen di persimpangan array1 dan array2, tanpa duplikat. | | array\$1join (array, pembatas [, NullReplacement]) | Menggabungkan elemen-elemen dari array yang diberikan menggunakan pembatas dan string opsional untuk menggantikan nol. Jika tidak ada nilai yang ditetapkan untuk NullReplacement, nilai null apa pun disaring. | | array\$1max (array) | Mengembalikan nilai maksimum dalam array. NaN lebih besar dari elemen non-NaN untuk double/float tipe. Elemen NULL dilewati. | | array\$1min (larik) | Mengembalikan nilai minimum dalam array. NaN lebih besar dari elemen non-NaN untuk double/float tipe. Elemen NULL dilewati. | | array\$1position (array, elemen) | Mengembalikan indeks (1-based) dari elemen pencocokan pertama dari array selama, atau 0 jika tidak ada kecocokan ditemukan. | | array\$1prepend (array, elemen) | Tambahkan elemen di awal array diteruskan sebagai argumen pertama. Jenis elemen harus sama dengan jenis elemen array. Elemen null juga ditambahkan ke array. Tetapi jika array yang dilewatkan adalah output NULL adalah NULL | | array\$1remove (array, elemen) | Hapus semua elemen yang sama dengan elemen dari array. | | array\$1repeat (elemen, hitungan) | Mengembalikan array yang berisi jumlah elemen kali. | | array\$1union (array1, array2) | Mengembalikan array elemen dalam penyatuan array1 dan array2, tanpa duplikat. | | arrays\$1tumpang tindih (a1, a2) | Mengembalikan nilai true jika a1 berisi setidaknya elemen non-null hadir juga dalam a2. Jika array tidak memiliki elemen umum dan keduanya tidak kosong dan salah satunya berisi elemen null null dikembalikan, false sebaliknya. | | arrays\$1zip (a1, a2,...) | Mengembalikan array gabungan struct di mana N-th struct berisi semua nilai N-th dari array masukan. | | meratakan () arrayOfArrays | Mengubah array array menjadi array tunggal. | | dapatkan (array, indeks) | Mengembalikan elemen array pada indeks (0-based) yang diberikan. Jika indeks menunjuk di luar batas array, maka fungsi ini mengembalikan NULL. | | urutan (mulai, berhenti, langkah) | Menghasilkan array elemen dari awal hingga berhenti (inklusif), bertambah demi langkah. Jenis elemen yang dikembalikan sama dengan jenis ekspresi argumen. Jenis yang didukung adalah: byte, pendek, integer, panjang, tanggal, stempel waktu. Ekspresi start dan stop harus diselesaikan dengan tipe yang sama. Jika ekspresi start dan stop diselesaikan ke tipe 'date' atau 'stempel waktu' maka ekspresi langkah harus diselesaikan ke tipe 'interval' atau 'interval bulan' atau 'interval waktu', jika tidak ke tipe yang sama dengan ekspresi start dan stop. | | acak (array) | Mengembalikan permutasi acak dari array yang diberikan. | | irisan (x, mulai, panjang) | Subset array x mulai dari awal indeks (indeks array mulai dari 1, atau mulai dari akhir jika start negatif) dengan panjang yang ditentukan. | | sort\$1array (array [, ascendingOrder]) | Mengurutkan array input dalam urutan naik atau turun sesuai dengan urutan alami dari elemen array. NaN lebih besar dari elemen non-NaN untuk double/float tipe. Elemen nol akan ditempatkan di awal array yang dikembalikan dalam urutan menaik atau di akhir array yang dikembalikan dalam urutan menurun. | **Contoh** ``` -- array SELECT array(1, 2, 3); +--------------+ |array(1, 2, 3)| +--------------+ | [1, 2, 3]| +--------------+ -- array_append SELECT array_append(array('b', 'd', 'c', 'a'), 'd'); +----------------------------------+ |array_append(array(b, d, c, a), d)| +----------------------------------+ | [b, d, c, a, d]| +----------------------------------+ SELECT array_append(array(1, 2, 3, null), null); +----------------------------------------+ |array_append(array(1, 2, 3, NULL), NULL)| +----------------------------------------+ | [1, 2, 3, NULL, N...| +----------------------------------------+ SELECT array_append(CAST(null as Array), 2); +---------------------+ |array_append(NULL, 2)| +---------------------+ | NULL| +---------------------+ -- array_compact SELECT array_compact(array(1, 2, 3, null)); +-----------------------------------+ |array_compact(array(1, 2, 3, NULL))| +-----------------------------------+ | [1, 2, 3]| +-----------------------------------+ SELECT array_compact(array("a", "b", "c")); +-----------------------------+ |array_compact(array(a, b, c))| +-----------------------------+ | [a, b, c]| +-----------------------------+ -- array_contains SELECT array_contains(array(1, 2, 3), 2); +---------------------------------+ |array_contains(array(1, 2, 3), 2)| +---------------------------------+ | true| +---------------------------------+ -- array_distinct SELECT array_distinct(array(1, 2, 3, null, 3)); +---------------------------------------+ |array_distinct(array(1, 2, 3, NULL, 3))| +---------------------------------------+ | [1, 2, 3, NULL]| +---------------------------------------+ -- array_except SELECT array_except(array(1, 2, 3), array(1, 3, 5)); +--------------------------------------------+ |array_except(array(1, 2, 3), array(1, 3, 5))| +--------------------------------------------+ | [2]| +--------------------------------------------+ -- array_insert SELECT array_insert(array(1, 2, 3, 4), 5, 5); +-------------------------------------+ |array_insert(array(1, 2, 3, 4), 5, 5)| +-------------------------------------+ | [1, 2, 3, 4, 5]| +-------------------------------------+ SELECT array_insert(array(5, 4, 3, 2), -1, 1); +--------------------------------------+ |array_insert(array(5, 4, 3, 2), -1, 1)| +--------------------------------------+ | [5, 4, 3, 2, 1]| +--------------------------------------+ SELECT array_insert(array(5, 3, 2, 1), -4, 4); +--------------------------------------+ |array_insert(array(5, 3, 2, 1), -4, 4)| +--------------------------------------+ | [5, 4, 3, 2, 1]| +--------------------------------------+ -- array_intersect SELECT array_intersect(array(1, 2, 3), array(1, 3, 5)); +-----------------------------------------------+ |array_intersect(array(1, 2, 3), array(1, 3, 5))| +-----------------------------------------------+ | [1, 3]| +-----------------------------------------------+ -- array_join SELECT array_join(array('hello', 'world'), ' '); +----------------------------------+ |array_join(array(hello, world), )| +----------------------------------+ | hello world| +----------------------------------+ SELECT array_join(array('hello', null ,'world'), ' '); +----------------------------------------+ |array_join(array(hello, NULL, world), )| +----------------------------------------+ | hello world| +----------------------------------------+ SELECT array_join(array('hello', null ,'world'), ' ', ','); +-------------------------------------------+ |array_join(array(hello, NULL, world), , ,)| +-------------------------------------------+ | hello , world| +-------------------------------------------+ -- array_max SELECT array_max(array(1, 20, null, 3)); +--------------------------------+ |array_max(array(1, 20, NULL, 3))| +--------------------------------+ | 20| +--------------------------------+ -- array_min SELECT array_min(array(1, 20, null, 3)); +--------------------------------+ |array_min(array(1, 20, NULL, 3))| +--------------------------------+ | 1| +--------------------------------+ -- array_position SELECT array_position(array(312, 773, 708, 708), 708); +----------------------------------------------+ |array_position(array(312, 773, 708, 708), 708)| +----------------------------------------------+ | 3| +----------------------------------------------+ SELECT array_position(array(312, 773, 708, 708), 414); +----------------------------------------------+ |array_position(array(312, 773, 708, 708), 414)| +----------------------------------------------+ | 0| +----------------------------------------------+ -- array_prepend SELECT array_prepend(array('b', 'd', 'c', 'a'), 'd'); +-----------------------------------+ |array_prepend(array(b, d, c, a), d)| +-----------------------------------+ | [d, b, d, c, a]| +-----------------------------------+ SELECT array_prepend(array(1, 2, 3, null), null); +-----------------------------------------+ |array_prepend(array(1, 2, 3, NULL), NULL)| +-----------------------------------------+ | [NULL, 1, 2, 3, N...| +-----------------------------------------+ SELECT array_prepend(CAST(null as Array), 2); +----------------------+ |array_prepend(NULL, 2)| +----------------------+ | NULL| +----------------------+ -- array_remove SELECT array_remove(array(1, 2, 3, null, 3), 3); +----------------------------------------+ |array_remove(array(1, 2, 3, NULL, 3), 3)| +----------------------------------------+ | [1, 2, NULL]| +----------------------------------------+ -- array_repeat SELECT array_repeat('123', 2); +--------------------+ |array_repeat(123, 2)| +--------------------+ | [123, 123]| +--------------------+ -- array_union SELECT array_union(array(1, 2, 3), array(1, 3, 5)); +-------------------------------------------+ |array_union(array(1, 2, 3), array(1, 3, 5))| +-------------------------------------------+ | [1, 2, 3, 5]| +-------------------------------------------+ -- arrays_overlap SELECT arrays_overlap(array(1, 2, 3), array(3, 4, 5)); +----------------------------------------------+ |arrays_overlap(array(1, 2, 3), array(3, 4, 5))| +----------------------------------------------+ | true| +----------------------------------------------+ -- arrays_zip SELECT arrays_zip(array(1, 2, 3), array(2, 3, 4)); +------------------------------------------+ |arrays_zip(array(1, 2, 3), array(2, 3, 4))| +------------------------------------------+ | [{1, 2}, {2, 3}, ...| +------------------------------------------+ SELECT arrays_zip(array(1, 2), array(2, 3), array(3, 4)); +-------------------------------------------------+ |arrays_zip(array(1, 2), array(2, 3), array(3, 4))| +-------------------------------------------------+ | [{1, 2, 3}, {2, 3...| +-------------------------------------------------+ -- flatten SELECT flatten(array(array(1, 2), array(3, 4))); +----------------------------------------+ |flatten(array(array(1, 2), array(3, 4)))| +----------------------------------------+ | [1, 2, 3, 4]| +----------------------------------------+ -- get SELECT get(array(1, 2, 3), 0); +----------------------+ |get(array(1, 2, 3), 0)| +----------------------+ | 1| +----------------------+ SELECT get(array(1, 2, 3), 3); +----------------------+ |get(array(1, 2, 3), 3)| +----------------------+ | NULL| +----------------------+ SELECT get(array(1, 2, 3), -1); +-----------------------+ |get(array(1, 2, 3), -1)| +-----------------------+ | NULL| +-----------------------+ -- sequence SELECT sequence(1, 5); +---------------+ | sequence(1, 5)| +---------------+ |[1, 2, 3, 4, 5]| +---------------+ SELECT sequence(5, 1); +---------------+ | sequence(5, 1)| +---------------+ |[5, 4, 3, 2, 1]| +---------------+ SELECT sequence(to_date('2018-01-01'), to_date('2018-03-01'), interval 1 month); +----------------------------------------------------------------------+ |sequence(to_date(2018-01-01), to_date(2018-03-01), INTERVAL '1' MONTH)| +----------------------------------------------------------------------+ | [2018-01-01, 2018...| +----------------------------------------------------------------------+ SELECT sequence(to_date('2018-01-01'), to_date('2018-03-01'), interval '0-1' year to month); +--------------------------------------------------------------------------------+ |sequence(to_date(2018-01-01), to_date(2018-03-01), INTERVAL '0-1' YEAR TO MONTH)| +--------------------------------------------------------------------------------+ | [2018-01-01, 2018...| +--------------------------------------------------------------------------------+ -- shuffle SELECT shuffle(array(1, 20, 3, 5)); +---------------------------+ |shuffle(array(1, 20, 3, 5))| +---------------------------+ | [5, 1, 20, 3]| +---------------------------+ SELECT shuffle(array(1, 20, null, 3)); +------------------------------+ |shuffle(array(1, 20, NULL, 3))| +------------------------------+ | [1, NULL, 20, 3]| +------------------------------+ -- slice SELECT slice(array(1, 2, 3, 4), 2, 2); +------------------------------+ |slice(array(1, 2, 3, 4), 2, 2)| +------------------------------+ | [2, 3]| +------------------------------+ SELECT slice(array(1, 2, 3, 4), -2, 2); +-------------------------------+ |slice(array(1, 2, 3, 4), -2, 2)| +-------------------------------+ | [3, 4]| +-------------------------------+ -- sort_array SELECT sort_array(array('b', 'd', null, 'c', 'a'), true); +-----------------------------------------+ |sort_array(array(b, d, NULL, c, a), true)| +-----------------------------------------+ | [NULL, a, b, c, d]| +-----------------------------------------+ ``` #### Fungsi jendela **catatan** Untuk melihat integrasi sumber AWS data mana yang mendukung perintah SQL ini, lihat. [Perintah dan OpenSearch fungsi SQL yang didukung](#supported-directquery-sql) Fungsi jendela beroperasi pada sekelompok baris, disebut sebagai jendela, dan menghitung nilai kembali untuk setiap baris berdasarkan kelompok baris. Fungsi jendela berguna untuk memproses tugas seperti menghitung rata-rata bergerak, menghitung statistik kumulatif, atau mengakses nilai baris yang diberikan posisi relatif dari baris saat ini. **Sintaksis** ``` window_function [ nulls_option ] OVER ( [ { PARTITION | DISTRIBUTE } BY partition_col_name = partition_col_val ( [ , ... ] ) ] { ORDER | SORT } BY expression [ ASC | DESC ] [ NULLS { FIRST | LAST } ] [ , ... ] [ window_frame ] ) ``` **Parameter** + window\$1fungsi Fungsi peringkat Sintaks: `RANK | DENSE_RANK | PERCENT_RANK | NTILE | ROW_NUMBER ` Fungsi analitik Sintaks: `CUME_DIST | LAG | LEAD | NTH_VALUE | FIRST_VALUE | LAST_VALUE ` Fungsi agregat Sintaks: `MAX | MIN | COUNT | SUM | AVG | ... ` + `nulls_option`- Menentukan apakah atau tidak untuk melewatkan nilai-nilai null ketika mengevaluasi fungsi jendela. RESPECT NULLS berarti tidak melewatkan nilai nol, sedangkan IGNORE NULLS berarti melewatkan. Jika tidak ditentukan, defaultnya adalah RESPECT NULLS. Sintaks: `{ IGNORE | RESPECT } NULLS ` Catatan: `Only LAG` \$1 `LEAD` \$1 `NTH_VALUE` `FIRST_VALUE` \$1 \$1 `LAST_VALUE` dapat digunakan dengan`IGNORE NULLS`. + `window_frame`- Menentukan baris mana untuk memulai jendela dan di mana untuk mengakhirinya. Sintaks: `{ RANGE | ROWS } { frame_start | BETWEEN frame_start AND frame_end }` frame\$1start dan frame\$1end memiliki sintaks berikut: Sintaks: `UNBOUNDED PRECEDING | offset PRECEDING | CURRENT ROW | offset FOLLOWING | UNBOUNDED FOLLOWING ` offset: menentukan offset dari posisi baris saat ini. **Catatan** Jika frame\$1end dihilangkan, defaultnya ke CURRENT ROW. **Contoh** ``` CREATE TABLE employees (name STRING, dept STRING, salary INT, age INT); INSERT INTO employees VALUES ("Lisa", "Sales", 10000, 35); INSERT INTO employees VALUES ("Evan", "Sales", 32000, 38); INSERT INTO employees VALUES ("Fred", "Engineering", 21000, 28); INSERT INTO employees VALUES ("Alex", "Sales", 30000, 33); INSERT INTO employees VALUES ("Tom", "Engineering", 23000, 33); INSERT INTO employees VALUES ("Jane", "Marketing", 29000, 28); INSERT INTO employees VALUES ("Jeff", "Marketing", 35000, 38); INSERT INTO employees VALUES ("Paul", "Engineering", 29000, 23); INSERT INTO employees VALUES ("Chloe", "Engineering", 23000, 25); SELECT * FROM employees; +-----+-----------+------+-----+ | name| dept|salary| age| +-----+-----------+------+-----+ |Chloe|Engineering| 23000| 25| | Fred|Engineering| 21000| 28| | Paul|Engineering| 29000| 23| |Helen| Marketing| 29000| 40| | Tom|Engineering| 23000| 33| | Jane| Marketing| 29000| 28| | Jeff| Marketing| 35000| 38| | Evan| Sales| 32000| 38| | Lisa| Sales| 10000| 35| | Alex| Sales| 30000| 33| +-----+-----------+------+-----+ SELECT name, dept, salary, RANK() OVER (PARTITION BY dept ORDER BY salary) AS rank FROM employees; +-----+-----------+------+----+ | name| dept|salary|rank| +-----+-----------+------+----+ | Lisa| Sales| 10000| 1| | Alex| Sales| 30000| 2| | Evan| Sales| 32000| 3| | Fred|Engineering| 21000| 1| | Tom|Engineering| 23000| 2| |Chloe|Engineering| 23000| 2| | Paul|Engineering| 29000| 4| |Helen| Marketing| 29000| 1| | Jane| Marketing| 29000| 1| | Jeff| Marketing| 35000| 3| +-----+-----------+------+----+ SELECT name, dept, salary, DENSE_RANK() OVER (PARTITION BY dept ORDER BY salary ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS dense_rank FROM employees; +-----+-----------+------+----------+ | name| dept|salary|dense_rank| +-----+-----------+------+----------+ | Lisa| Sales| 10000| 1| | Alex| Sales| 30000| 2| | Evan| Sales| 32000| 3| | Fred|Engineering| 21000| 1| | Tom|Engineering| 23000| 2| |Chloe|Engineering| 23000| 2| | Paul|Engineering| 29000| 3| |Helen| Marketing| 29000| 1| | Jane| Marketing| 29000| 1| | Jeff| Marketing| 35000| 2| +-----+-----------+------+----------+ SELECT name, dept, age, CUME_DIST() OVER (PARTITION BY dept ORDER BY age RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS cume_dist FROM employees; +-----+-----------+------+------------------+ | name| dept|age | cume_dist| +-----+-----------+------+------------------+ | Alex| Sales| 33|0.3333333333333333| | Lisa| Sales| 35|0.6666666666666666| | Evan| Sales| 38| 1.0| | Paul|Engineering| 23| 0.25| |Chloe|Engineering| 25| 0.75| | Fred|Engineering| 28| 0.25| | Tom|Engineering| 33| 1.0| | Jane| Marketing| 28|0.3333333333333333| | Jeff| Marketing| 38|0.6666666666666666| |Helen| Marketing| 40| 1.0| +-----+-----------+------+------------------+ SELECT name, dept, salary, MIN(salary) OVER (PARTITION BY dept ORDER BY salary) AS min FROM employees; +-----+-----------+------+-----+ | name| dept|salary| min| +-----+-----------+------+-----+ | Lisa| Sales| 10000|10000| | Alex| Sales| 30000|10000| | Evan| Sales| 32000|10000| |Helen| Marketing| 29000|29000| | Jane| Marketing| 29000|29000| | Jeff| Marketing| 35000|29000| | Fred|Engineering| 21000|21000| | Tom|Engineering| 23000|21000| |Chloe|Engineering| 23000|21000| | Paul|Engineering| 29000|21000| +-----+-----------+------+-----+ SELECT name, salary, LAG(salary) OVER (PARTITION BY dept ORDER BY salary) AS lag, LEAD(salary, 1, 0) OVER (PARTITION BY dept ORDER BY salary) AS lead FROM employees; +-----+-----------+------+-----+-----+ | name| dept|salary| lag| lead| +-----+-----------+------+-----+-----+ | Lisa| Sales| 10000|NULL |30000| | Alex| Sales| 30000|10000|32000| | Evan| Sales| 32000|30000| 0| | Fred|Engineering| 21000| NULL|23000| |Chloe|Engineering| 23000|21000|23000| | Tom|Engineering| 23000|23000|29000| | Paul|Engineering| 29000|23000| 0| |Helen| Marketing| 29000| NULL|29000| | Jane| Marketing| 29000|29000|35000| | Jeff| Marketing| 35000|29000| 0| +-----+-----------+------+-----+-----+ SELECT id, v, LEAD(v, 0) IGNORE NULLS OVER w lead, LAG(v, 0) IGNORE NULLS OVER w lag, NTH_VALUE(v, 2) IGNORE NULLS OVER w nth_value, FIRST_VALUE(v) IGNORE NULLS OVER w first_value, LAST_VALUE(v) IGNORE NULLS OVER w last_value FROM test_ignore_null WINDOW w AS (ORDER BY id) ORDER BY id; +--+----+----+----+---------+-----------+----------+ |id| v|lead| lag|nth_value|first_value|last_value| +--+----+----+----+---------+-----------+----------+ | 0|NULL|NULL|NULL| NULL| NULL| NULL| | 1| x| x| x| NULL| x| x| | 2|NULL|NULL|NULL| NULL| x| x| | 3|NULL|NULL|NULL| NULL| x| x| | 4| y| y| y| y| x| y| | 5|NULL|NULL|NULL| y| x| y| | 6| z| z| z| y| x| z| | 7| v| v| v| y| x| v| | 8|NULL|NULL|NULL| y| x| v| +--+----+----+----+---------+-----------+----------+ ``` #### Fungsi konversi **catatan** Untuk melihat integrasi sumber AWS data mana yang mendukung perintah SQL ini, lihat. [Perintah dan OpenSearch fungsi SQL yang didukung](#supported-directquery-sql) **** | Fungsi | Deskripsi | | --- | --- | | bigint (expr) | Memberikan nilai `expr` ke tipe data target `bigint`. | | biner (expr) | Memberikan nilai `expr` ke tipe data target `binary`. | | boolean (expr) | Memberikan nilai `expr` ke tipe data target `boolean`. | | pemeran (tipe expr AS) | Memberikan nilai `expr` ke tipe data target `type`. | | tanggal (expr) | Memberikan nilai `expr` ke tipe data target `date`. | | desimal (expr) | Memberikan nilai `expr` ke tipe data target `desimal`. | | ganda (expr) | Memberikan nilai `expr` ke tipe data target `double`. | | mengapung (expr) | Memberikan nilai `expr` ke tipe data target `float`. | | int (expr) | Memberikan nilai `expr` ke tipe data target `int`. | | kecil (expr) | Memberikan nilai `expr` ke tipe data target `smallint`. | | string (expr) | Memberikan nilai `expr` ke tipe data target `string`. | | stempel waktu (expr) | Memberikan nilai `expr` ke tipe data target `timestamp`. | | tinyint (expr) | Memberikan nilai `expr` ke tipe data target `tinyint`. | **Contoh** ``` -- cast SELECT cast(field as int); +---------------+ |CAST(field AS INT)| +---------------+ | 10| +---------------+ ``` #### Fungsi predikat **catatan** Untuk melihat integrasi sumber AWS data mana yang mendukung perintah SQL ini, lihat. [Perintah dan OpenSearch fungsi SQL yang didukung](#supported-directquery-sql) **** | Fungsi | Deskripsi | | --- | --- | | \$1 expr | Logis tidak. | | expr1 expr2 | Mengembalikan hasil yang sama dengan operator EQUAL (=) untuk operan non-null, tetapi mengembalikan true jika keduanya null, false jika salah satu dari mereka adalah null. | | expr1 = expr2 | Mengembalikan nilai true jika `expr1` sama dengan `expr2`, atau false sebaliknya. | | expr1 == expr2 | Mengembalikan nilai true jika `expr1` sama dengan `expr2`, atau false sebaliknya. | | expr1 > expr2 | Mengembalikan nilai true jika `expr1` lebih besar dari `expr2`. | | expr1 >= expr2 | Mengembalikan nilai true jika `expr1` lebih besar dari atau sama dengan `expr2`. | | expr1 dan expr2 | Logis DAN. | | pola str ilike [ESCAPE escape] | Mengembalikan nilai true jika str cocok dengan `pattern` dengan `escape` case-insensitive, null jika ada argumen null, false jika tidak. | | expr1 di (expr2, expr3,...) | Mengembalikan nilai true jika `expr` sama dengan valN apapun. | | isnan (expr) | Mengembalikan nilai true jika `expr` adalah NaN, atau false sebaliknya. | | isnotnull (expr) | Mengembalikan nilai true jika `expr` tidak null, atau false sebaliknya. | | isnull (expr) | Mengembalikan nilai true jika `expr` adalah null, atau false sebaliknya. | | str seperti pola [ESCAPE escape] | Mengembalikan nilai true jika str cocok dengan `pattern` dengan `escape`, null jika ada argumen null, false jika tidak. | | tidak expr | Logis tidak. | | expr1 atau expr2 | Logis ATAU. | | regexp (str, regexp) | Mengembalikan nilai true jika `str` cocok dengan `regexp`, atau false sebaliknya. | | regexp\$1like (str, regexp) | Mengembalikan nilai true jika `str` cocok dengan `regexp`, atau false sebaliknya. | | rlike (str, regexp) | Mengembalikan nilai true jika `str` cocok dengan `regexp`, atau false sebaliknya. | **Contoh** ``` -- ! SELECT ! true; +----------+ |(NOT true)| +----------+ | false| +----------+ SELECT ! false; +-----------+ |(NOT false)| +-----------+ | true| +-----------+ SELECT ! NULL; +----------+ |(NOT NULL)| +----------+ | NULL| +----------+ -- < SELECT to_date('2009-07-30 04:17:52') < to_date('2009-07-30 04:17:52'); +-------------------------------------------------------------+ |(to_date(2009-07-30 04:17:52) < to_date(2009-07-30 04:17:52))| +-------------------------------------------------------------+ | false| +-------------------------------------------------------------+ SELECT to_date('2009-07-30 04:17:52') < to_date('2009-08-01 04:17:52'); +-------------------------------------------------------------+ |(to_date(2009-07-30 04:17:52) < to_date(2009-08-01 04:17:52))| +-------------------------------------------------------------+ | true| +-------------------------------------------------------------+ SELECT 1 < NULL; +----------+ |(1 < NULL)| +----------+ | NULL| +----------+ -- <= SELECT 2 <= 2; +--------+ |(2 <= 2)| +--------+ | true| +--------+ SELECT 1.0 <= '1'; +----------+ |(1.0 <= 1)| +----------+ | true| +----------+ SELECT to_date('2009-07-30 04:17:52') <= to_date('2009-07-30 04:17:52'); +--------------------------------------------------------------+ |(to_date(2009-07-30 04:17:52) <= to_date(2009-07-30 04:17:52))| +--------------------------------------------------------------+ | true| +--------------------------------------------------------------+ SELECT to_date('2009-07-30 04:17:52') <= to_date('2009-08-01 04:17:52'); +--------------------------------------------------------------+ |(to_date(2009-07-30 04:17:52) <= to_date(2009-08-01 04:17:52))| +--------------------------------------------------------------+ | true| +--------------------------------------------------------------+ SELECT 1 <= NULL; +-----------+ |(1 <= NULL)| +-----------+ | NULL| +-----------+ -- <=> SELECT 2 <=> 2; +---------+ |(2 <=> 2)| +---------+ | true| +---------+ SELECT 1 <=> '1'; +---------+ |(1 <=> 1)| +---------+ | true| +---------+ SELECT true <=> NULL; +---------------+ |(true <=> NULL)| +---------------+ | false| +---------------+ SELECT NULL <=> NULL; +---------------+ |(NULL <=> NULL)| +---------------+ | true| +---------------+ -- = SELECT 2 = 2; +-------+ |(2 = 2)| +-------+ | true| +-------+ SELECT 1 = '1'; +-------+ |(1 = 1)| +-------+ | true| +-------+ SELECT true = NULL; +-------------+ |(true = NULL)| +-------------+ | NULL| +-------------+ SELECT NULL = NULL; +-------------+ |(NULL = NULL)| +-------------+ | NULL| +-------------+ -- == SELECT 2 == 2; +-------+ |(2 = 2)| +-------+ | true| +-------+ SELECT 1 == '1'; +-------+ |(1 = 1)| +-------+ | true| +-------+ SELECT true == NULL; +-------------+ |(true = NULL)| +-------------+ | NULL| +-------------+ SELECT NULL == NULL; +-------------+ |(NULL = NULL)| +-------------+ | NULL| +-------------+ -- > SELECT 2 > 1; +-------+ |(2 > 1)| +-------+ | true| +-------+ SELECT 2 > 1.1; +-------+ |(2 > 1)| +-------+ | true| +-------+ SELECT to_date('2009-07-30 04:17:52') > to_date('2009-07-30 04:17:52'); +-------------------------------------------------------------+ |(to_date(2009-07-30 04:17:52) > to_date(2009-07-30 04:17:52))| +-------------------------------------------------------------+ | false| +-------------------------------------------------------------+ SELECT to_date('2009-07-30 04:17:52') > to_date('2009-08-01 04:17:52'); +-------------------------------------------------------------+ |(to_date(2009-07-30 04:17:52) > to_date(2009-08-01 04:17:52))| +-------------------------------------------------------------+ | false| +-------------------------------------------------------------+ SELECT 1 > NULL; +----------+ |(1 > NULL)| +----------+ | NULL| +----------+ -- >= SELECT 2 >= 1; +--------+ |(2 >= 1)| +--------+ | true| +--------+ SELECT 2.0 >= '2.1'; +------------+ |(2.0 >= 2.1)| +------------+ | false| +------------+ SELECT to_date('2009-07-30 04:17:52') >= to_date('2009-07-30 04:17:52'); +--------------------------------------------------------------+ |(to_date(2009-07-30 04:17:52) >= to_date(2009-07-30 04:17:52))| +--------------------------------------------------------------+ | true| +--------------------------------------------------------------+ SELECT to_date('2009-07-30 04:17:52') >= to_date('2009-08-01 04:17:52'); +--------------------------------------------------------------+ |(to_date(2009-07-30 04:17:52) >= to_date(2009-08-01 04:17:52))| +--------------------------------------------------------------+ | false| +--------------------------------------------------------------+ SELECT 1 >= NULL; +-----------+ |(1 >= NULL)| +-----------+ | NULL| +-----------+ -- and SELECT true and true; +---------------+ |(true AND true)| +---------------+ | true| +---------------+ SELECT true and false; +----------------+ |(true AND false)| +----------------+ | false| +----------------+ SELECT true and NULL; +---------------+ |(true AND NULL)| +---------------+ | NULL| +---------------+ SELECT false and NULL; +----------------+ |(false AND NULL)| +----------------+ | false| +----------------+ -- ilike SELECT ilike('Wagon', '_Agon'); +-------------------+ |ilike(Wagon, _Agon)| +-------------------+ | true| +-------------------+ SELECT '%SystemDrive%\Users\John' ilike '\%SystemDrive\%\\users%'; +--------------------------------------------------------+ |ilike(%SystemDrive%\Users\John, \%SystemDrive\%\\users%)| +--------------------------------------------------------+ | true| +--------------------------------------------------------+ SELECT '%SystemDrive%\\USERS\\John' ilike '\%SystemDrive\%\\\\Users%'; +--------------------------------------------------------+ |ilike(%SystemDrive%\USERS\John, \%SystemDrive\%\\Users%)| +--------------------------------------------------------+ | true| +--------------------------------------------------------+ SELECT '%SystemDrive%/Users/John' ilike '/%SYSTEMDrive/%//Users%' ESCAPE '/'; +--------------------------------------------------------+ |ilike(%SystemDrive%/Users/John, /%SYSTEMDrive/%//Users%)| +--------------------------------------------------------+ | true| +--------------------------------------------------------+ -- in SELECT 1 in(1, 2, 3); +----------------+ |(1 IN (1, 2, 3))| +----------------+ | true| +----------------+ SELECT 1 in(2, 3, 4); +----------------+ |(1 IN (2, 3, 4))| +----------------+ | false| +----------------+ SELECT named_struct('a', 1, 'b', 2) in(named_struct('a', 1, 'b', 1), named_struct('a', 1, 'b', 3)); +----------------------------------------------------------------------------------+ |(named_struct(a, 1, b, 2) IN (named_struct(a, 1, b, 1), named_struct(a, 1, b, 3)))| +----------------------------------------------------------------------------------+ | false| +----------------------------------------------------------------------------------+ SELECT named_struct('a', 1, 'b', 2) in(named_struct('a', 1, 'b', 2), named_struct('a', 1, 'b', 3)); +----------------------------------------------------------------------------------+ |(named_struct(a, 1, b, 2) IN (named_struct(a, 1, b, 2), named_struct(a, 1, b, 3)))| +----------------------------------------------------------------------------------+ | true| +----------------------------------------------------------------------------------+ -- isnan SELECT isnan(cast('NaN' as double)); +--------------------------+ |isnan(CAST(NaN AS DOUBLE))| +--------------------------+ | true| +--------------------------+ -- isnotnull SELECT isnotnull(1); +---------------+ |(1 IS NOT NULL)| +---------------+ | true| +---------------+ -- isnull SELECT isnull(1); +-----------+ |(1 IS NULL)| +-----------+ | false| +-----------+ -- like SELECT like('Wagon', '_Agon'); +----------------+ |Wagon LIKE _Agon| +----------------+ | true| +----------------+ -- not SELECT not true; +----------+ |(NOT true)| +----------+ | false| +----------+ SELECT not false; +-----------+ |(NOT false)| +-----------+ | true| +-----------+ SELECT not NULL; +----------+ |(NOT NULL)| +----------+ | NULL| +----------+ -- or SELECT true or false; +---------------+ |(true OR false)| +---------------+ | true| +---------------+ SELECT false or false; +----------------+ |(false OR false)| +----------------+ | false| +----------------+ SELECT true or NULL; +--------------+ |(true OR NULL)| +--------------+ | true| +--------------+ SELECT false or NULL; +---------------+ |(false OR NULL)| +---------------+ | NULL| +---------------+ ``` #### Fungsi peta **catatan** Untuk melihat integrasi sumber AWS data mana yang mendukung perintah SQL ini, lihat. [Perintah dan OpenSearch fungsi SQL yang didukung](#supported-directquery-sql) **** | Fungsi | Deskripsi | | --- | --- | | element\$1at (array, indeks) | Mengembalikan elemen array pada indeks (1-based) yang diberikan. | | element\$1at (peta, kunci) | Mengembalikan nilai untuk kunci yang diberikan. Fungsi mengembalikan NULL jika kunci tidak terkandung dalam peta. | | peta (key0, value0, key1, value1,...) | Membuat peta dengan key/value pasangan yang diberikan. | | map\$1concat (peta,...) | Mengembalikan gabungan semua peta yang diberikan | | map\$1contains\$1key (peta, kunci) | Mengembalikan nilai true jika peta berisi kunci. | | map\$1entries (peta) | Mengembalikan array tidak berurutan dari semua entri dalam peta yang diberikan. | | map\$1from\$1arrays (kunci, nilai) | Membuat peta dengan sepasang key/value array yang diberikan. Semua elemen dalam kunci tidak boleh null | | map\$1from\$1entries () arrayOfEntries | Mengembalikan peta yang dibuat dari array yang diberikan dari entri. | | map\$1keys (peta) | Mengembalikan array tidak berurutan yang berisi kunci peta. | | map\$1values (peta) | Mengembalikan array tidak berurutan yang berisi nilai-nilai peta. | | str\$1to\$1map (teks [, PairDelim [,]]) keyValueDelim | Membuat peta setelah membagi teks menjadi pasangan kunci/nilai menggunakan pembatas. Pembatas default adalah ',' untuk `pairDelim` dan ':' untuk ``. keyValueDelim Baik `pairDelim` dan `keyValueDelim` diperlakukan sebagai ekspresi reguler. | | try\$1element\$1at (array, indeks) | Mengembalikan elemen array pada indeks (1-based) yang diberikan. Jika Index adalah 0, sistem akan melempar kesalahan. Jika indeks < 0, mengakses elemen dari yang terakhir ke yang pertama. Fungsi selalu mengembalikan NULL jika indeks melebihi panjang array. | | try\$1element\$1at (peta, kunci) | Mengembalikan nilai untuk kunci yang diberikan. Fungsi selalu mengembalikan NULL jika kunci tidak terkandung dalam peta. | **Contoh** ``` -- element_at SELECT element_at(array(1, 2, 3), 2); +-----------------------------+ |element_at(array(1, 2, 3), 2)| +-----------------------------+ | 2| +-----------------------------+ SELECT element_at(map(1, 'a', 2, 'b'), 2); +------------------------------+ |element_at(map(1, a, 2, b), 2)| +------------------------------+ | b| +------------------------------+ -- map SELECT map(1.0, '2', 3.0, '4'); +--------------------+ | map(1.0, 2, 3.0, 4)| +--------------------+ |{1.0 -> 2, 3.0 -> 4}| +--------------------+ -- map_concat SELECT map_concat(map(1, 'a', 2, 'b'), map(3, 'c')); +--------------------------------------+ |map_concat(map(1, a, 2, b), map(3, c))| +--------------------------------------+ | {1 -> a, 2 -> b, ...| +--------------------------------------+ -- map_contains_key SELECT map_contains_key(map(1, 'a', 2, 'b'), 1); +------------------------------------+ |map_contains_key(map(1, a, 2, b), 1)| +------------------------------------+ | true| +------------------------------------+ SELECT map_contains_key(map(1, 'a', 2, 'b'), 3); +------------------------------------+ |map_contains_key(map(1, a, 2, b), 3)| +------------------------------------+ | false| +------------------------------------+ -- map_entries SELECT map_entries(map(1, 'a', 2, 'b')); +----------------------------+ |map_entries(map(1, a, 2, b))| +----------------------------+ | [{1, a}, {2, b}]| +----------------------------+ -- map_from_arrays SELECT map_from_arrays(array(1.0, 3.0), array('2', '4')); +---------------------------------------------+ |map_from_arrays(array(1.0, 3.0), array(2, 4))| +---------------------------------------------+ | {1.0 -> 2, 3.0 -> 4}| +---------------------------------------------+ -- map_from_entries SELECT map_from_entries(array(struct(1, 'a'), struct(2, 'b'))); +---------------------------------------------------+ |map_from_entries(array(struct(1, a), struct(2, b)))| +---------------------------------------------------+ | {1 -> a, 2 -> b}| +---------------------------------------------------+ -- map_keys SELECT map_keys(map(1, 'a', 2, 'b')); +-------------------------+ |map_keys(map(1, a, 2, b))| +-------------------------+ | [1, 2]| +-------------------------+ -- map_values SELECT map_values(map(1, 'a', 2, 'b')); +---------------------------+ |map_values(map(1, a, 2, b))| +---------------------------+ | [a, b]| +---------------------------+ -- str_to_map SELECT str_to_map('a:1,b:2,c:3', ',', ':'); +-----------------------------+ |str_to_map(a:1,b:2,c:3, ,, :)| +-----------------------------+ | {a -> 1, b -> 2, ...| +-----------------------------+ SELECT str_to_map('a'); +-------------------+ |str_to_map(a, ,, :)| +-------------------+ | {a -> NULL}| +-------------------+ -- try_element_at SELECT try_element_at(array(1, 2, 3), 2); +---------------------------------+ |try_element_at(array(1, 2, 3), 2)| +---------------------------------+ | 2| +---------------------------------+ SELECT try_element_at(map(1, 'a', 2, 'b'), 2); +----------------------------------+ |try_element_at(map(1, a, 2, b), 2)| +----------------------------------+ | b| +----------------------------------+ ``` #### Fungsi matematika **catatan** Untuk melihat integrasi sumber AWS data mana yang mendukung perintah SQL ini, lihat. [Perintah dan OpenSearch fungsi SQL yang didukung](#supported-directquery-sql) **** | Fungsi | Deskripsi | | --- | --- | | expr1% expr2 | Mengembalikan sisanya setelah `expr1`/`expr2`. | | expr1 \$1 expr2 | Mengembalikan `expr1`\$1`expr2`. | | expr1 \$1 expr2 | Mengembalikan `expr1`\$1`expr2`. | | expr1 - expr2 | Mengembalikan `expr1`-`expr2`. | | expr1/expr2 | Mengembalikan `expr1`/`expr2`. Itu selalu melakukan divisi floating point. | | abs (expr) | Mengembalikan nilai absolut dari nilai numerik atau interval. | | acos (expr) | Mengembalikan cosinus terbalik (alias arc cosinus) dari `expr`, seolah-olah dihitung oleh `java.lang.math.acos`. | | acosh (expr) | Mengembalikan kosinus hiperbolik terbalik dari `expr`. | | asin (expr) | Mengembalikan sinus terbalik (alias arc sinus) arc sin dari `expr`, seolah-olah dihitung oleh `java.lang.math.asin`. | | asinh (expr) | Mengembalikan sinus hiperbolik terbalik dari `expr`. | | atan (expr) | Mengembalikan tangen terbalik (alias busur tangen) dari `expr`, seolah-olah dihitung oleh `java.lang.math.atan` | | atan2 (ExprY, ExprX) | Mengembalikan sudut dalam radian antara sumbu x positif dari sebuah bidang dan titik yang diberikan oleh koordinat (`exprx`, `Expry`), seolah-olah dihitung oleh `java.lang.math.atan2`. | | atanh (expr) | Mengembalikan singgung hiperbolik terbalik dari `expr`. | | bin (expr) | Mengembalikan representasi string dari nilai panjang `expr` diwakili dalam biner. | | bround (expr, d) | Mengembalikan `expr` dibulatkan ke tempat desimal `d` menggunakan mode pembulatan HALF\$1EVEN. | | cbrt (expr) | Mengembalikan akar kubus dari `expr`. | | ceil (expr [, skala]) | Mengembalikan angka terkecil setelah pembulatan yang tidak lebih kecil dari `expr`. Parameter `scale` opsional dapat ditentukan untuk mengontrol perilaku pembulatan. | | langit-langit (expr [, skala]) | Mengembalikan angka terkecil setelah pembulatan yang tidak lebih kecil dari `expr`. Parameter `scale` opsional dapat ditentukan untuk mengontrol perilaku pembulatan. | | conv (jumlah, dari\$1base, to\$1base) | Ubah `num` dari`from\$1base` menjadi `to\$1base`. | | cos (expr) | Mengembalikan cosinus dari `expr`, seolah-olah dihitung oleh `java.lang.math.cos`. | | cosh (expr) | Mengembalikan kosinus hiperbolik `expr`, seolah-olah dihitung oleh `java.lang.math.cosh`. | | dipan (expr) | Mengembalikan kotangen dari `expr`, seolah-olah dihitung oleh `1/java.lang.math.tan`. | | csc (expr) | Mengembalikan cosecant dari `expr`, seolah-olah dihitung oleh `1/java.lang.math.sin`. | | derajat (expr) | Mengubah radian ke derajat. | | expr1 div expr2 | Bagilah `expr1` dengan `expr2`. Ia mengembalikan NULL jika operan adalah NULL atau `expr2` adalah 0. Hasilnya dilemparkan ke panjang. | | e () | Mengembalikan nomor Euler, e. | | exp (expr) | Mengembalikan e ke kekuatan `expr`. | | expm1 (expr) - Mengembalikan exp (`expr`) | 1 | | faktorial (expr) | Mengembalikan faktorial dari `expr`. `expr` adalah [0.. 20]. Jika tidak, null. | | lantai (expr [, skala]) | Mengembalikan angka terbesar setelah pembulatan ke bawah yang tidak lebih besar dari `expr`. Parameter `scale` opsional dapat ditentukan untuk mengontrol perilaku pembulatan. | | terbesar (expr,...) | Mengembalikan nilai terbesar dari semua parameter, melewatkan nilai null. | | hex (expr) | Mengkonversi `expr` ke heksadesimal. | | hypot (expr1, expr2) | Mengembalikan sqrt (`expr1`\$1\$12 \$1 `expr2`\$1\$12). | | paling sedikit (expr,...) | Mengembalikan nilai terkecil dari semua parameter, melewatkan nilai null. | | ln (expr) | Mengembalikan logaritma natural (basis e) dari `expr`. | | log (dasar, expr) | Mengembalikan logaritma dari `expr` dengan `base`. | | log10 (expr) | Mengembalikan logaritma `expr` dengan basis 10. | | log1p (expr) | Mengembalikan log (1 \$1 `expr`). | | log2 (expr) | Mengembalikan logaritma `expr` dengan basis 2. | | expr1 mod expr2 | Mengembalikan sisanya setelah `expr1`/`expr2`. | | negatif (expr) | Mengembalikan nilai negasi dari `expr`. | | pi () | Mengembalikan pi. | | pmod (expr1, expr2) | Mengembalikan nilai positif dari `expr1` mod `expr2`. | | positif (expr) | Mengembalikan nilai `expr`. | | pow (expr1, expr2) | Meningkatkan `expr1` ke kekuatan `expr2`. | | kekuatan (expr1, expr2) | Meningkatkan `expr1` ke kekuatan `expr2`. | | radian (expr) | Mengubah derajat menjadi radian. | | rand ([biji]) | Mengembalikan nilai acak dengan independen dan terdistribusi identik (i.i.id.) nilai terdistribusi seragam di [0, 1). | | randn ([benih]) | Mengembalikan nilai acak dengan nilai independen dan terdistribusi identik (i.i.d.) diambil dari distribusi normal standar. | | acak ([benih]) | Mengembalikan nilai acak dengan independen dan terdistribusi identik (i.i.id.) nilai terdistribusi seragam di [0, 1). | | kulit (expr) | Mengembalikan nilai ganda yang paling dekat nilainya dengan argumen dan sama dengan bilangan bulat matematika. | | bulat (expr, d) | Mengembalikan `expr` dibulatkan ke tempat desimal `d` menggunakan mode pembulatan HALF\$1UP. | | detik (expr) | Mengembalikan secant dari `expr`, seolah-olah dihitung oleh `1/java.lang.math.cos`. | | shiftleft (basis, expr) | Pergeseran kiri Bitwise. | | tanda (expr) | Mengembalikan -1.0, 0.0 atau 1.0 sebagai `expr` negatif, 0 atau positif. | | signum (expr) | Mengembalikan -1.0, 0.0 atau 1.0 sebagai `expr` negatif, 0 atau positif. | | dosa (expr) | Mengembalikan sinus dari `expr`, seolah-olah dihitung oleh `java.lang.math.sin`. | | sinh (expr) | Mengembalikan sinus hiperbolik dari `expr`, seolah-olah dihitung oleh `java.lang.math.sinh`. | | sqrt (expr) | Mengembalikan akar kuadrat dari `expr`. | | tan (expr) | Mengembalikan tangen dari `expr`, seolah-olah dihitung oleh `java.lang.math.tan`. | | tanh (expr) | Mengembalikan tangen hiperbolik dari `expr`, seolah-olah dihitung oleh `java.lang.math.tanh`. | | try\$1add (expr1, expr2) | Mengembalikan jumlah `expr1`dan `expr2` dan hasilnya adalah null pada overflow. Jenis input yang dapat diterima sama dengan operator `\$1`. | | try\$1divide (dividen, pembagi) | Mengembalikan `dividen`/`divisor`. Itu selalu melakukan divisi floating point. Hasilnya selalu nol jika `expr2` adalah 0. Dividen harus berupa numerik atau interval. `pembagi` harus berupa numerik. | | try\$1multiply (expr1, expr2) | Mengembalikan `expr1`\$1`expr2` dan hasilnya adalah null pada overflow. Jenis input yang dapat diterima sama dengan operator `\$1`. | | try\$1kurangi (expr1, expr2) | Mengembalikan `expr1`-`expr2` dan hasilnya adalah null pada overflow. Jenis input yang dapat diterima sama dengan operator `-`. | | unhex (expr) | Mengkonversi heksadesimal `expr` menjadi biner. | | width\$1bucket (nilai, min\$1value, max\$1value, num\$1bucket) | Mengembalikan nomor bucket yang `value` akan ditetapkan dalam histogram equiwidth dengan bucket `num\$1bucket`, dalam rentang `min\$1value` hingga `max\$1value`.” | **Contoh** ``` -- % SELECT 2 % 1.8; +---------+ |(2 % 1.8)| +---------+ | 0.2| +---------+ SELECT MOD(2, 1.8); +-----------+ |mod(2, 1.8)| +-----------+ | 0.2| +-----------+ -- * SELECT 2 * 3; +-------+ |(2 * 3)| +-------+ | 6| +-------+ -- + SELECT 1 + 2; +-------+ |(1 + 2)| +-------+ | 3| +-------+ -- - SELECT 2 - 1; +-------+ |(2 - 1)| +-------+ | 1| +-------+ -- / SELECT 3 / 2; +-------+ |(3 / 2)| +-------+ | 1.5| +-------+ SELECT 2L / 2L; +-------+ |(2 / 2)| +-------+ | 1.0| +-------+ -- abs SELECT abs(-1); +-------+ |abs(-1)| +-------+ | 1| +-------+ SELECT abs(INTERVAL -'1-1' YEAR TO MONTH); +----------------------------------+ |abs(INTERVAL '-1-1' YEAR TO MONTH)| +----------------------------------+ | INTERVAL '1-1' YE...| +----------------------------------+ -- acos SELECT acos(1); +-------+ |ACOS(1)| +-------+ | 0.0| +-------+ SELECT acos(2); +-------+ |ACOS(2)| +-------+ | NaN| +-------+ -- acosh SELECT acosh(1); +--------+ |ACOSH(1)| +--------+ | 0.0| +--------+ SELECT acosh(0); +--------+ |ACOSH(0)| +--------+ | NaN| +--------+ -- asin SELECT asin(0); +-------+ |ASIN(0)| +-------+ | 0.0| +-------+ SELECT asin(2); +-------+ |ASIN(2)| +-------+ | NaN| +-------+ -- asinh SELECT asinh(0); +--------+ |ASINH(0)| +--------+ | 0.0| +--------+ -- atan SELECT atan(0); +-------+ |ATAN(0)| +-------+ | 0.0| +-------+ -- atan2 SELECT atan2(0, 0); +-----------+ |ATAN2(0, 0)| +-----------+ | 0.0| +-----------+ -- atanh SELECT atanh(0); +--------+ |ATANH(0)| +--------+ | 0.0| +--------+ SELECT atanh(2); +--------+ |ATANH(2)| +--------+ | NaN| +--------+ -- bin SELECT bin(13); +-------+ |bin(13)| +-------+ | 1101| +-------+ SELECT bin(-13); +--------------------+ | bin(-13)| +--------------------+ |11111111111111111...| +--------------------+ SELECT bin(13.3); +---------+ |bin(13.3)| +---------+ | 1101| +---------+ -- bround SELECT bround(2.5, 0); +--------------+ |bround(2.5, 0)| +--------------+ | 2| +--------------+ SELECT bround(25, -1); +--------------+ |bround(25, -1)| +--------------+ | 20| +--------------+ -- cbrt SELECT cbrt(27.0); +----------+ |CBRT(27.0)| +----------+ | 3.0| +----------+ -- ceil SELECT ceil(-0.1); +----------+ |CEIL(-0.1)| +----------+ | 0| +----------+ SELECT ceil(5); +-------+ |CEIL(5)| +-------+ | 5| +-------+ SELECT ceil(3.1411, 3); +---------------+ |ceil(3.1411, 3)| +---------------+ | 3.142| +---------------+ SELECT ceil(3.1411, -3); +----------------+ |ceil(3.1411, -3)| +----------------+ | 1000| +----------------+ -- ceiling SELECT ceiling(-0.1); +-------------+ |ceiling(-0.1)| +-------------+ | 0| +-------------+ SELECT ceiling(5); +----------+ |ceiling(5)| +----------+ | 5| +----------+ SELECT ceiling(3.1411, 3); +------------------+ |ceiling(3.1411, 3)| +------------------+ | 3.142| +------------------+ SELECT ceiling(3.1411, -3); +-------------------+ |ceiling(3.1411, -3)| +-------------------+ | 1000| +-------------------+ -- conv SELECT conv('100', 2, 10); +----------------+ |conv(100, 2, 10)| +----------------+ | 4| +----------------+ SELECT conv(-10, 16, -10); +------------------+ |conv(-10, 16, -10)| +------------------+ | -16| +------------------+ -- cos SELECT cos(0); +------+ |COS(0)| +------+ | 1.0| +------+ -- cosh SELECT cosh(0); +-------+ |COSH(0)| +-------+ | 1.0| +-------+ -- cot SELECT cot(1); +------------------+ | COT(1)| +------------------+ |0.6420926159343306| +------------------+ -- csc SELECT csc(1); +------------------+ | CSC(1)| +------------------+ |1.1883951057781212| +------------------+ -- degrees SELECT degrees(3.141592653589793); +--------------------------+ |DEGREES(3.141592653589793)| +--------------------------+ | 180.0| +--------------------------+ -- div SELECT 3 div 2; +---------+ |(3 div 2)| +---------+ | 1| +---------+ SELECT INTERVAL '1-1' YEAR TO MONTH div INTERVAL '-1' MONTH; +------------------------------------------------------+ |(INTERVAL '1-1' YEAR TO MONTH div INTERVAL '-1' MONTH)| +------------------------------------------------------+ | -13| +------------------------------------------------------+ -- e SELECT e(); +-----------------+ | E()| +-----------------+ |2.718281828459045| +-----------------+ -- exp SELECT exp(0); +------+ |EXP(0)| +------+ | 1.0| +------+ -- expm1 SELECT expm1(0); +--------+ |EXPM1(0)| +--------+ | 0.0| +--------+ -- factorial SELECT factorial(5); +------------+ |factorial(5)| +------------+ | 120| +------------+ -- floor SELECT floor(-0.1); +-----------+ |FLOOR(-0.1)| +-----------+ | -1| +-----------+ SELECT floor(5); +--------+ |FLOOR(5)| +--------+ | 5| +--------+ SELECT floor(3.1411, 3); +----------------+ |floor(3.1411, 3)| +----------------+ | 3.141| +----------------+ SELECT floor(3.1411, -3); +-----------------+ |floor(3.1411, -3)| +-----------------+ | 0| +-----------------+ -- greatest SELECT greatest(10, 9, 2, 4, 3); +------------------------+ |greatest(10, 9, 2, 4, 3)| +------------------------+ | 10| +------------------------+ -- hex SELECT hex(17); +-------+ |hex(17)| +-------+ | 11| +-------+ SELECT hex('SQL'); +------------------+ | hex(SQL)| +------------------+ |53514C| +------------------+ -- hypot SELECT hypot(3, 4); +-----------+ |HYPOT(3, 4)| +-----------+ | 5.0| +-----------+ -- least SELECT least(10, 9, 2, 4, 3); +---------------------+ |least(10, 9, 2, 4, 3)| +---------------------+ | 2| +---------------------+ -- ln SELECT ln(1); +-----+ |ln(1)| +-----+ | 0.0| +-----+ -- log SELECT log(10, 100); +------------+ |LOG(10, 100)| +------------+ | 2.0| +------------+ -- log10 SELECT log10(10); +---------+ |LOG10(10)| +---------+ | 1.0| +---------+ -- log1p SELECT log1p(0); +--------+ |LOG1P(0)| +--------+ | 0.0| +--------+ -- log2 SELECT log2(2); +-------+ |LOG2(2)| +-------+ | 1.0| +-------+ -- mod SELECT 2 % 1.8; +---------+ |(2 % 1.8)| +---------+ | 0.2| +---------+ SELECT MOD(2, 1.8); +-----------+ |mod(2, 1.8)| +-----------+ | 0.2| +-----------+ -- negative SELECT negative(1); +-----------+ |negative(1)| +-----------+ | -1| +-----------+ -- pi SELECT pi(); +-----------------+ | PI()| +-----------------+ |3.141592653589793| +-----------------+ -- pmod SELECT pmod(10, 3); +-----------+ |pmod(10, 3)| +-----------+ | 1| +-----------+ SELECT pmod(-10, 3); +------------+ |pmod(-10, 3)| +------------+ | 2| +------------+ -- positive SELECT positive(1); +-----+ |(+ 1)| +-----+ | 1| +-----+ -- pow SELECT pow(2, 3); +---------+ |pow(2, 3)| +---------+ | 8.0| +---------+ -- power SELECT power(2, 3); +-----------+ |POWER(2, 3)| +-----------+ | 8.0| +-----------+ -- radians SELECT radians(180); +-----------------+ | RADIANS(180)| +-----------------+ |3.141592653589793| +-----------------+ -- rand SELECT rand(); +------------------+ | rand()| +------------------+ |0.7211420708112387| +------------------+ SELECT rand(0); +------------------+ | rand(0)| +------------------+ |0.7604953758285915| +------------------+ SELECT rand(null); +------------------+ | rand(NULL)| +------------------+ |0.7604953758285915| +------------------+ -- randn SELECT randn(); +-------------------+ | randn()| +-------------------+ |-0.8175603217732732| +-------------------+ SELECT randn(0); +------------------+ | randn(0)| +------------------+ |1.6034991609278433| +------------------+ SELECT randn(null); +------------------+ | randn(NULL)| +------------------+ |1.6034991609278433| +------------------+ -- random SELECT random(); +-----------------+ | rand()| +-----------------+ |0.394205008255365| +-----------------+ SELECT random(0); +------------------+ | rand(0)| +------------------+ |0.7604953758285915| +------------------+ SELECT random(null); +------------------+ | rand(NULL)| +------------------+ |0.7604953758285915| +------------------+ -- rint SELECT rint(12.3456); +-------------+ |rint(12.3456)| +-------------+ | 12.0| +-------------+ -- round SELECT round(2.5, 0); +-------------+ |round(2.5, 0)| +-------------+ | 3| +-------------+ -- sec SELECT sec(0); +------+ |SEC(0)| +------+ | 1.0| +------+ -- shiftleft SELECT shiftleft(2, 1); +---------------+ |shiftleft(2, 1)| +---------------+ | 4| +---------------+ -- sign SELECT sign(40); +--------+ |sign(40)| +--------+ | 1.0| +--------+ SELECT sign(INTERVAL -'100' YEAR); +--------------------------+ |sign(INTERVAL '-100' YEAR)| +--------------------------+ | -1.0| +--------------------------+ -- signum SELECT signum(40); +----------+ |SIGNUM(40)| +----------+ | 1.0| +----------+ SELECT signum(INTERVAL -'100' YEAR); +----------------------------+ |SIGNUM(INTERVAL '-100' YEAR)| +----------------------------+ | -1.0| +----------------------------+ -- sin SELECT sin(0); +------+ |SIN(0)| +------+ | 0.0| +------+ -- sinh SELECT sinh(0); +-------+ |SINH(0)| +-------+ | 0.0| +-------+ -- sqrt SELECT sqrt(4); +-------+ |SQRT(4)| +-------+ | 2.0| +-------+ -- tan SELECT tan(0); +------+ |TAN(0)| +------+ | 0.0| +------+ -- tanh SELECT tanh(0); +-------+ |TANH(0)| +-------+ | 0.0| +-------+ -- try_add SELECT try_add(1, 2); +-------------+ |try_add(1, 2)| +-------------+ | 3| +-------------+ SELECT try_add(2147483647, 1); +----------------------+ |try_add(2147483647, 1)| +----------------------+ | NULL| +----------------------+ SELECT try_add(date'2021-01-01', 1); +-----------------------------+ |try_add(DATE '2021-01-01', 1)| +-----------------------------+ | 2021-01-02| +-----------------------------+ SELECT try_add(date'2021-01-01', interval 1 year); +---------------------------------------------+ |try_add(DATE '2021-01-01', INTERVAL '1' YEAR)| +---------------------------------------------+ | 2022-01-01| +---------------------------------------------+ SELECT try_add(timestamp'2021-01-01 00:00:00', interval 1 day); +----------------------------------------------------------+ |try_add(TIMESTAMP '2021-01-01 00:00:00', INTERVAL '1' DAY)| +----------------------------------------------------------+ | 2021-01-02 00:00:00| +----------------------------------------------------------+ SELECT try_add(interval 1 year, interval 2 year); +---------------------------------------------+ |try_add(INTERVAL '1' YEAR, INTERVAL '2' YEAR)| +---------------------------------------------+ | INTERVAL '3' YEAR| +---------------------------------------------+ -- try_divide SELECT try_divide(3, 2); +----------------+ |try_divide(3, 2)| +----------------+ | 1.5| +----------------+ SELECT try_divide(2L, 2L); +----------------+ |try_divide(2, 2)| +----------------+ | 1.0| +----------------+ SELECT try_divide(1, 0); +----------------+ |try_divide(1, 0)| +----------------+ | NULL| +----------------+ SELECT try_divide(interval 2 month, 2); +---------------------------------+ |try_divide(INTERVAL '2' MONTH, 2)| +---------------------------------+ | INTERVAL '0-1' YE...| +---------------------------------+ SELECT try_divide(interval 2 month, 0); +---------------------------------+ |try_divide(INTERVAL '2' MONTH, 0)| +---------------------------------+ | NULL| +---------------------------------+ -- try_multiply SELECT try_multiply(2, 3); +------------------+ |try_multiply(2, 3)| +------------------+ | 6| +------------------+ SELECT try_multiply(-2147483648, 10); +-----------------------------+ |try_multiply(-2147483648, 10)| +-----------------------------+ | NULL| +-----------------------------+ SELECT try_multiply(interval 2 year, 3); +----------------------------------+ |try_multiply(INTERVAL '2' YEAR, 3)| +----------------------------------+ | INTERVAL '6-0' YE...| +----------------------------------+ -- try_subtract SELECT try_subtract(2, 1); +------------------+ |try_subtract(2, 1)| +------------------+ | 1| +------------------+ SELECT try_subtract(-2147483648, 1); +----------------------------+ |try_subtract(-2147483648, 1)| +----------------------------+ | NULL| +----------------------------+ SELECT try_subtract(date'2021-01-02', 1); +----------------------------------+ |try_subtract(DATE '2021-01-02', 1)| +----------------------------------+ | 2021-01-01| +----------------------------------+ SELECT try_subtract(date'2021-01-01', interval 1 year); +--------------------------------------------------+ |try_subtract(DATE '2021-01-01', INTERVAL '1' YEAR)| +--------------------------------------------------+ | 2020-01-01| +--------------------------------------------------+ SELECT try_subtract(timestamp'2021-01-02 00:00:00', interval 1 day); +---------------------------------------------------------------+ |try_subtract(TIMESTAMP '2021-01-02 00:00:00', INTERVAL '1' DAY)| +---------------------------------------------------------------+ | 2021-01-01 00:00:00| +---------------------------------------------------------------+ SELECT try_subtract(interval 2 year, interval 1 year); +--------------------------------------------------+ |try_subtract(INTERVAL '2' YEAR, INTERVAL '1' YEAR)| +--------------------------------------------------+ | INTERVAL '1' YEAR| +--------------------------------------------------+ -- unhex SELECT decode(unhex('53514C'), 'UTF-8'); +----------------------------------------+ |decode(unhex(53514C), UTF-8)| +----------------------------------------+ | SQL| +----------------------------------------+ -- width_bucket SELECT width_bucket(5.3, 0.2, 10.6, 5); +-------------------------------+ |width_bucket(5.3, 0.2, 10.6, 5)| +-------------------------------+ | 3| +-------------------------------+ SELECT width_bucket(-2.1, 1.3, 3.4, 3); +-------------------------------+ |width_bucket(-2.1, 1.3, 3.4, 3)| +-------------------------------+ | 0| +-------------------------------+ SELECT width_bucket(8.1, 0.0, 5.7, 4); +------------------------------+ |width_bucket(8.1, 0.0, 5.7, 4)| +------------------------------+ | 5| +------------------------------+ SELECT width_bucket(-0.9, 5.2, 0.5, 2); +-------------------------------+ |width_bucket(-0.9, 5.2, 0.5, 2)| +-------------------------------+ | 3| +-------------------------------+ SELECT width_bucket(INTERVAL '0' YEAR, INTERVAL '0' YEAR, INTERVAL '10' YEAR, 10); +--------------------------------------------------------------------------+ |width_bucket(INTERVAL '0' YEAR, INTERVAL '0' YEAR, INTERVAL '10' YEAR, 10)| +--------------------------------------------------------------------------+ | 1| +--------------------------------------------------------------------------+ SELECT width_bucket(INTERVAL '1' YEAR, INTERVAL '0' YEAR, INTERVAL '10' YEAR, 10); +--------------------------------------------------------------------------+ |width_bucket(INTERVAL '1' YEAR, INTERVAL '0' YEAR, INTERVAL '10' YEAR, 10)| +--------------------------------------------------------------------------+ | 2| +--------------------------------------------------------------------------+ SELECT width_bucket(INTERVAL '0' DAY, INTERVAL '0' DAY, INTERVAL '10' DAY, 10); +-----------------------------------------------------------------------+ |width_bucket(INTERVAL '0' DAY, INTERVAL '0' DAY, INTERVAL '10' DAY, 10)| +-----------------------------------------------------------------------+ | 1| +-----------------------------------------------------------------------+ SELECT width_bucket(INTERVAL '1' DAY, INTERVAL '0' DAY, INTERVAL '10' DAY, 10); +-----------------------------------------------------------------------+ |width_bucket(INTERVAL '1' DAY, INTERVAL '0' DAY, INTERVAL '10' DAY, 10)| +-----------------------------------------------------------------------+ | 2| +-----------------------------------------------------------------------+ ``` #### Fungsi generator **catatan** Untuk melihat integrasi sumber AWS data mana yang mendukung fungsi SQL ini, lihat. [Perintah dan OpenSearch fungsi SQL yang didukung](#supported-directquery-sql) **** | Fungsi | Deskripsi | | --- | --- | | meledak (expr) | Memisahkan elemen array `expr` menjadi beberapa baris, atau elemen peta `expr` menjadi beberapa baris dan kolom. Kecuali ditentukan lain, menggunakan nama kolom default `col` untuk elemen array atau `key` dan `value` untuk elemen peta. | | explode\$1outer (expr) | Memisahkan elemen array `expr` menjadi beberapa baris, atau elemen peta `expr` menjadi beberapa baris dan kolom. Kecuali ditentukan lain, menggunakan nama kolom default `col` untuk elemen array atau `key` dan `value` untuk elemen peta. | | sebaris (expr) | Meledak array struct ke dalam tabel. Menggunakan nama kolom col1, col2, dll secara default kecuali ditentukan lain. | | inline\$1outer (expr) | Meledak array struct ke dalam tabel. Menggunakan nama kolom col1, col2, dll secara default kecuali ditentukan lain. | | posexplode (expr) | Memisahkan elemen array `expr` menjadi beberapa baris dengan posisi, atau elemen peta `expr` menjadi beberapa baris dan kolom dengan posisi. Kecuali ditentukan lain, gunakan nama kolom `pos` untuk posisi, `col` untuk elemen array atau `key` dan `value` untuk elemen peta. | | posexplode\$1outer (expr) | Memisahkan elemen array `expr` menjadi beberapa baris dengan posisi, atau elemen peta `expr` menjadi beberapa baris dan kolom dengan posisi. Kecuali ditentukan lain, gunakan nama kolom `pos` untuk posisi, `col` untuk elemen array atau `key` dan `value` untuk elemen peta. | | tumpukan (n, expr1,..., exprk) | Memisahkan `expr1`,..., `exprk` menjadi baris `n`. Menggunakan nama kolom col0, col1, dll secara default kecuali ditentukan lain. | **Contoh** ``` -- explode SELECT explode(array(10, 20)); +---+ |col| +---+ | 10| | 20| +---+ SELECT explode(collection => array(10, 20)); +---+ |col| +---+ | 10| | 20| +---+ SELECT * FROM explode(collection => array(10, 20)); +---+ |col| +---+ | 10| | 20| +---+ -- explode_outer SELECT explode_outer(array(10, 20)); +---+ |col| +---+ | 10| | 20| +---+ SELECT explode_outer(collection => array(10, 20)); +---+ |col| +---+ | 10| | 20| +---+ SELECT * FROM explode_outer(collection => array(10, 20)); +---+ |col| +---+ | 10| | 20| +---+ -- inline SELECT inline(array(struct(1, 'a'), struct(2, 'b'))); +----+----+ |col1|col2| +----+----+ | 1| a| | 2| b| +----+----+ -- inline_outer SELECT inline_outer(array(struct(1, 'a'), struct(2, 'b'))); +----+----+ |col1|col2| +----+----+ | 1| a| | 2| b| +----+----+ -- posexplode SELECT posexplode(array(10,20)); +---+---+ |pos|col| +---+---+ | 0| 10| | 1| 20| +---+---+ SELECT * FROM posexplode(array(10,20)); +---+---+ |pos|col| +---+---+ | 0| 10| | 1| 20| +---+---+ -- posexplode_outer SELECT posexplode_outer(array(10,20)); +---+---+ |pos|col| +---+---+ | 0| 10| | 1| 20| +---+---+ SELECT * FROM posexplode_outer(array(10,20)); +---+---+ |pos|col| +---+---+ | 0| 10| | 1| 20| +---+---+ -- stack SELECT stack(2, 1, 2, 3); +----+----+ |col0|col1| +----+----+ | 1| 2| | 3|NULL| +----+----+ ``` #### Klausa SELECT **catatan** Untuk melihat integrasi sumber AWS data mana yang mendukung perintah SQL ini, lihat. [Perintah dan OpenSearch fungsi SQL yang didukung](#supported-directquery-sql) OpenSearch SQL mendukung `SELECT` pernyataan yang digunakan untuk mengambil set hasil dari satu atau lebih tabel. Bagian berikut menjelaskan keseluruhan sintaks query dan konstruksi yang berbeda dari query. **Sintaksis** ``` select_statement [ { UNION | INTERSECT | EXCEPT } [ ALL | DISTINCT ] select_statement, ... ] [ ORDER BY { expression [ ASC | DESC ] [ NULLS { FIRST | LAST } ] [ , ... ] } ] [ SORT BY { expression [ ASC | DESC ] [ NULLS { FIRST | LAST } ] [ , ... ] } ] [ WINDOW { named_window [ , WINDOW named_window, ... ] } ] [ LIMIT { ALL | expression } ] ``` Sementara `select_statement` didefinisikan sebagai: ``` SELECT [ ALL | DISTINCT ] { [ [ named_expression ] [ , ... ] ] } FROM { from_item [ , ... ] } [ PIVOT clause ] [ UNPIVOT clause ] [ LATERAL VIEW clause ] [ ... ] [ WHERE boolean_expression ] [ GROUP BY expression [ , ... ] ] [ HAVING boolean_expression ] ``` **Parameter** + **SEMUA** Memilih semua baris yang cocok dari relasi dan diaktifkan secara default. + **BERBEDA** Memilih semua baris yang cocok dari relasi setelah menghapus duplikat dalam hasil. + **named\$1expression** Ekspresi dengan nama yang ditetapkan. Secara umum, ini menunjukkan ekspresi kolom. Sintaks: `expression [[AS] alias]` + **dari\$1item** Hubungan tabel Bergabunglah dengan relasi Hubungan pivot Hubungan unpivot Fungsi nilai tabel Tabel sebaris `[ LATERAL ] ( Subquery )` + **PIVOT** `PIVOT`Klausul ini digunakan untuk perspektif data. Anda bisa mendapatkan nilai agregat berdasarkan nilai kolom tertentu. + **UNPIVOT** `UNPIVOT`Klausa mengubah kolom menjadi baris. Ini adalah kebalikan dari`PIVOT`, kecuali untuk agregasi nilai. + **TAMPILAN LATERAL** `LATERAL VIEW`Klausul ini digunakan bersama dengan fungsi generator seperti`EXPLODE`, yang akan menghasilkan tabel virtual yang berisi satu atau lebih baris. `LATERAL VIEW`akan menerapkan baris ke setiap baris keluaran asli. + **DIMANA** Memfilter hasil `FROM` klausa berdasarkan predikat yang disediakan. + **GRUP OLEH** Menentukan ekspresi yang digunakan untuk mengelompokkan baris. Ini digunakan bersama dengan fungsi agregat (`MIN`,,,, `MAX` `COUNT` `SUM``AVG`, dan sebagainya) untuk mengelompokkan baris berdasarkan ekspresi pengelompokan dan nilai agregat di setiap grup. Ketika `FILTER` klausa dilampirkan ke fungsi agregat, hanya baris yang cocok yang diteruskan ke fungsi itu. + **MEMILIKI** Menentukan predikat dimana baris yang dihasilkan oleh `GROUP BY` disaring. `HAVING`Klausa ini digunakan untuk memfilter baris setelah pengelompokan dilakukan. Jika `HAVING` ditentukan tanpa`GROUP BY`, ini menunjukkan ekspresi `GROUP BY` tanpa pengelompokan (agregat global). + **MEMESAN OLEH** Menentukan urutan baris set hasil lengkap dari query. Baris output diurutkan di seluruh partisi. Parameter ini saling eksklusif dengan `SORT BY` dan `DISTRIBUTE BY` dan tidak dapat ditentukan bersama. + **URUTKAN BERDASARKAN** Menentukan urutan dimana baris diurutkan dalam setiap partisi. Parameter ini saling eksklusif dengan `ORDER BY` dan tidak dapat ditentukan bersama. + **MEMBATASI** Menentukan jumlah maksimum baris yang dapat dikembalikan oleh pernyataan atau subquery. Klausa ini sebagian besar digunakan dalam hubungannya dengan `ORDER BY` untuk menghasilkan hasil deterministik. + **boolean\$1expression** Menentukan ekspresi apa pun yang mengevaluasi untuk jenis hasil boolean. Dua atau lebih ekspresi dapat digabungkan bersama menggunakan operator logis (`AND`,`OR`). + **ekspresi** Menentukan kombinasi dari satu atau lebih nilai, operator, dan fungsi SQL yang mengevaluasi nilai. + **named\$1window** Menentukan alias untuk satu atau lebih spesifikasi jendela sumber. Spesifikasi jendela sumber dapat direferensikan dalam definisi janda dalam kueri. #### Klausa WHERE **catatan** Untuk melihat integrasi sumber AWS data mana yang mendukung perintah SQL ini, lihat. [Perintah dan OpenSearch fungsi SQL yang didukung](#supported-directquery-sql) `WHERE`Klausa ini digunakan untuk membatasi hasil `FROM` klausa kueri atau subquery berdasarkan kondisi yang ditentukan. **Sintaksis** ``` WHERE boolean_expression ``` **Parameter** + **boolean\$1expression** Menentukan ekspresi apa pun yang mengevaluasi untuk jenis hasil boolean. Dua atau lebih ekspresi dapat digabungkan bersama menggunakan operator logis (`AND`,`OR`). **Contoh** ``` CREATE TABLE person (id INT, name STRING, age INT); INSERT INTO person VALUES (100, 'John', 30), (200, 'Mary', NULL), (300, 'Mike', 80), (400, 'Dan', 50); -- Comparison operator in `WHERE` clause. SELECT * FROM person WHERE id > 200 ORDER BY id; +---+----+---+ | id|name|age| +---+----+---+ |300|Mike| 80| |400| Dan| 50| +---+----+---+ -- Comparison and logical operators in `WHERE` clause. SELECT * FROM person WHERE id = 200 OR id = 300 ORDER BY id; +---+----+----+ | id|name| age| +---+----+----+ |200|Mary|null| |300|Mike| 80| +---+----+----+ -- IS NULL expression in `WHERE` clause. SELECT * FROM person WHERE id > 300 OR age IS NULL ORDER BY id; +---+----+----+ | id|name| age| +---+----+----+ |200|Mary|null| |400| Dan| 50| +---+----+----+ -- Function expression in `WHERE` clause. SELECT * FROM person WHERE length(name) > 3 ORDER BY id; +---+----+----+ | id|name| age| +---+----+----+ |100|John| 30| |200|Mary|null| |300|Mike| 80| +---+----+----+ -- `BETWEEN` expression in `WHERE` clause. SELECT * FROM person WHERE id BETWEEN 200 AND 300 ORDER BY id; +---+----+----+ | id|name| age| +---+----+----+ |200|Mary|null| |300|Mike| 80| +---+----+----+ -- Scalar Subquery in `WHERE` clause. SELECT * FROM person WHERE age > (SELECT avg(age) FROM person); +---+----+---+ | id|name|age| +---+----+---+ |300|Mike| 80| +---+----+---+ -- Correlated Subquery in `WHERE` clause. SELECT id FROM person WHERE exists (SELECT id FROM person where id = 200); +---+----+----+ |id |name|age | +---+----+----+ |200|Mary|null| +---+----+----+ ``` #### Klausa GROUP BY **catatan** Untuk melihat integrasi sumber AWS data mana yang mendukung perintah SQL ini, lihat. [Perintah dan OpenSearch fungsi SQL yang didukung](#supported-directquery-sql) `GROUP BY`Klausa ini digunakan untuk mengelompokkan baris berdasarkan sekumpulan ekspresi pengelompokan tertentu dan menghitung agregasi pada kelompok baris berdasarkan satu atau lebih fungsi agregat yang ditentukan. Sistem ini juga melakukan beberapa agregasi untuk catatan input yang sama yang ditetapkan melalui`GROUPING SETS`,`CUBE`, `ROLLUP` klausa. Ekspresi pengelompokan dan agregasi lanjutan dapat dicampur dalam `GROUP BY` klausa dan bersarang dalam klausa. `GROUPING SETS ` Lihat detail lebih lanjut di `Mixed/Nested Grouping Analytics ` bagian ini. Ketika `FILTER` klausa dilampirkan ke fungsi agregat, hanya baris yang cocok yang diteruskan ke fungsi itu. **Sintaksis** ``` GROUP BY group_expression [ , group_expression [ , ... ] ] [ WITH { ROLLUP | CUBE } ] GROUP BY { group_expression | { ROLLUP | CUBE | GROUPING SETS } (grouping_set [ , ...]) } [ , ... ] ``` Sedangkan fungsi agregat didefinisikan sebagai: ``` aggregate_name ( [ DISTINCT ] expression [ , ... ] ) [ FILTER ( WHERE boolean_expression ) ] ``` **Parameter** + **group\$1expression** Menentukan kriteria berdasarkan baris yang dikelompokkan bersama. Pengelompokan baris dilakukan berdasarkan nilai hasil ekspresi pengelompokan. Ekspresi pengelompokan mungkin nama kolom seperti`GROUP BY a`, posisi kolom seperti`GROUP BY 0`, atau ekspresi seperti`GROUP BY a + b`. + **pengelompokan\$1set** Kumpulan pengelompokan ditentukan oleh nol atau lebih ekspresi dipisahkan koma dalam tanda kurung. Ketika kumpulan pengelompokan hanya memiliki satu elemen, tanda kurung dapat dihilangkan. Misalnya, `GROUPING SETS ((a), (b))` sama dengan `GROUPING SETS (a, b)`. Sintaks: `{ ( [ expression [ , ... ] ] ) | expression }` + **SET PENGELOMPOKAN** Kelompokkan baris untuk setiap kumpulan pengelompokan yang ditentukan setelahnya`GROUPING SETS`. Misalnya, `GROUP BY GROUPING SETS ((warehouse), (product))` secara semantik setara dengan penyatuan hasil dan. `GROUP BY warehouse` `GROUP BY product` Klausa ini adalah singkatan untuk UNION ALL di mana setiap kaki `UNION ALL` operator melakukan agregasi dari setiap kumpulan pengelompokan yang ditentukan dalam klausa. `GROUPING SETS` Demikian pula, `GROUP BY GROUPING SETS ((warehouse, product), (product), ())` secara semantik setara dengan penyatuan hasil `GROUP BY warehouse, product, GROUP BY product` dan agregat global. + **ROLLUP** Menentukan beberapa tingkat agregasi dalam satu pernyataan. Klausa ini digunakan untuk menghitung agregasi berdasarkan beberapa kumpulan pengelompokan. `ROLLUP`adalah singkatan untuk. `GROUPING SETS` Misalnya, `GROUP BY warehouse, product WITH ROLLUP or GROUP BY ROLLUP(warehouse, product)` setara dengan `GROUP BY GROUPING SETS((warehouse, product), (warehouse), ())`. `GROUP BY ROLLUP(warehouse, product, (warehouse, location))` sama dengan `GROUP BY GROUPING SETS((warehouse, product, location), (warehouse, product), (warehouse), ())`. Elemen N dari spesifikasi ROLLUP menghasilkan N\$11 GROUPING SETS. + **KUBUS** Klausa CUBE digunakan untuk melakukan agregasi berdasarkan kombinasi kolom pengelompokan yang ditentukan dalam klausa GROUP BY. CUBE adalah singkatan dari GROUPING SETS. Misalnya, `GROUP BY warehouse, product WITH CUBE or GROUP BY CUBE(warehouse, product)` setara dengan `GROUP BY GROUPING SETS((warehouse, product), (warehouse), (product), ())`. `GROUP BY CUBE(warehouse, product, (warehouse, location))` sama dengan `GROUP BY GROUPING SETS((warehouse, product, location), (warehouse, product), (warehouse, location), (product, warehouse, location), (warehouse), (product), (warehouse, product), ())`. Elemen N dari `CUBE` spesifikasi menghasilkan `GROUPING SETS` 2^N. + **Analisis Pengelompokan Campuran/Bersarang** Sebuah `GROUP BY` klausa dapat mencakup beberapa group\$1expressions dan beberapa. `CUBE|ROLLUP|GROUPING SETS` `GROUPING SETS`juga dapat memiliki `CUBE|ROLLUP|GROUPING SETS` klausa bersarang, seperti`GROUPING SETS(ROLLUP(warehouse, location)`,,. `CUBE(warehouse, location))` `GROUPING SETS(warehouse, GROUPING SETS(location, GROUPING SETS(ROLLUP(warehouse, location),` `CUBE(warehouse, location))))` `CUBE|ROLLUP`hanyalah gula sintaks untuk`GROUPING SETS`. Lihat bagian di atas untuk cara `CUBE|ROLLUP` menerjemahkannya`GROUPING SETS`. `group_expression`dapat diperlakukan sebagai kelompok tunggal `GROUPING SETS` dalam konteks ini. Untuk beberapa `GROUPING SETS` dalam `GROUP BY` klausa, kami menghasilkan satu `GROUPING SETS` dengan melakukan produk silang dari aslinya. `GROUPING SETS` Untuk bersarang `GROUPING SETS` di `GROUPING SETS` klausa, kita cukup mengambil set pengelompokannya dan menghapusnya. Misalnya, `GROUP BY warehouse, GROUPING SETS((product), ()), GROUPING SETS((location, size), (location), (size), ()) and GROUP BY warehouse, ROLLUP(product), CUBE(location, size)` setara dengan `GROUP BY GROUPING SETS( (warehouse, product, location, size), (warehouse, product, location), (warehouse, product, size), (warehouse, product), (warehouse, location, size), (warehouse, location), (warehouse, size), (warehouse))`. `GROUP BY GROUPING SETS(GROUPING SETS(warehouse), GROUPING SETS((warehouse, product)))` sama dengan `GROUP BY GROUPING SETS((warehouse), (warehouse, product))`. + **aggregate\$1name** Menentukan nama fungsi agregat (`MIN`,,`MAX`,`COUNT`, `SUM``AVG`, dan sebagainya). + **BERBEDA** Menghapus duplikat di baris input sebelum diteruskan ke fungsi agregat. + **FILTER** Memfilter baris input yang `boolean_expression` dalam `WHERE` klausa mengevaluasi ke true diteruskan ke fungsi agregat; baris lainnya dibuang. **Contoh** ``` CREATE TABLE dealer (id INT, city STRING, car_model STRING, quantity INT); INSERT INTO dealer VALUES (100, 'Fremont', 'Honda Civic', 10), (100, 'Fremont', 'Honda Accord', 15), (100, 'Fremont', 'Honda CRV', 7), (200, 'Dublin', 'Honda Civic', 20), (200, 'Dublin', 'Honda Accord', 10), (200, 'Dublin', 'Honda CRV', 3), (300, 'San Jose', 'Honda Civic', 5), (300, 'San Jose', 'Honda Accord', 8); -- Sum of quantity per dealership. Group by `id`. SELECT id, sum(quantity) FROM dealer GROUP BY id ORDER BY id; +---+-------------+ | id|sum(quantity)| +---+-------------+ |100| 32| |200| 33| |300| 13| +---+-------------+ -- Use column position in GROUP by clause. SELECT id, sum(quantity) FROM dealer GROUP BY 1 ORDER BY 1; +---+-------------+ | id|sum(quantity)| +---+-------------+ |100| 32| |200| 33| |300| 13| +---+-------------+ -- Multiple aggregations. -- 1. Sum of quantity per dealership. -- 2. Max quantity per dealership. SELECT id, sum(quantity) AS sum, max(quantity) AS max FROM dealer GROUP BY id ORDER BY id; +---+---+---+ | id|sum|max| +---+---+---+ |100| 32| 15| |200| 33| 20| |300| 13| 8| +---+---+---+ -- Count the number of distinct dealer cities per car_model. SELECT car_model, count(DISTINCT city) AS count FROM dealer GROUP BY car_model; +------------+-----+ | car_model|count| +------------+-----+ | Honda Civic| 3| | Honda CRV| 2| |Honda Accord| 3| +------------+-----+ -- Sum of only 'Honda Civic' and 'Honda CRV' quantities per dealership. SELECT id, sum(quantity) FILTER ( WHERE car_model IN ('Honda Civic', 'Honda CRV') ) AS `sum(quantity)` FROM dealer GROUP BY id ORDER BY id; +---+-------------+ | id|sum(quantity)| +---+-------------+ |100| 17| |200| 23| |300| 5| +---+-------------+ -- Aggregations using multiple sets of grouping columns in a single statement. -- Following performs aggregations based on four sets of grouping columns. -- 1. city, car_model -- 2. city -- 3. car_model -- 4. Empty grouping set. Returns quantities for all city and car models. SELECT city, car_model, sum(quantity) AS sum FROM dealer GROUP BY GROUPING SETS ((city, car_model), (city), (car_model), ()) ORDER BY city; +---------+------------+---+ | city| car_model|sum| +---------+------------+---+ | null| null| 78| | null| HondaAccord| 33| | null| HondaCRV| 10| | null| HondaCivic| 35| | Dublin| null| 33| | Dublin| HondaAccord| 10| | Dublin| HondaCRV| 3| | Dublin| HondaCivic| 20| | Fremont| null| 32| | Fremont| HondaAccord| 15| | Fremont| HondaCRV| 7| | Fremont| HondaCivic| 10| | San Jose| null| 13| | San Jose| HondaAccord| 8| | San Jose| HondaCivic| 5| +---------+------------+---+ -- Group by processing with `ROLLUP` clause. -- Equivalent GROUP BY GROUPING SETS ((city, car_model), (city), ()) SELECT city, car_model, sum(quantity) AS sum FROM dealer GROUP BY city, car_model WITH ROLLUP ORDER BY city, car_model; +---------+------------+---+ | city| car_model|sum| +---------+------------+---+ | null| null| 78| | Dublin| null| 33| | Dublin| HondaAccord| 10| | Dublin| HondaCRV| 3| | Dublin| HondaCivic| 20| | Fremont| null| 32| | Fremont| HondaAccord| 15| | Fremont| HondaCRV| 7| | Fremont| HondaCivic| 10| | San Jose| null| 13| | San Jose| HondaAccord| 8| | San Jose| HondaCivic| 5| +---------+------------+---+ -- Group by processing with `CUBE` clause. -- Equivalent GROUP BY GROUPING SETS ((city, car_model), (city), (car_model), ()) SELECT city, car_model, sum(quantity) AS sum FROM dealer GROUP BY city, car_model WITH CUBE ORDER BY city, car_model; +---------+------------+---+ | city| car_model|sum| +---------+------------+---+ | null| null| 78| | null| HondaAccord| 33| | null| HondaCRV| 10| | null| HondaCivic| 35| | Dublin| null| 33| | Dublin| HondaAccord| 10| | Dublin| HondaCRV| 3| | Dublin| HondaCivic| 20| | Fremont| null| 32| | Fremont| HondaAccord| 15| | Fremont| HondaCRV| 7| | Fremont| HondaCivic| 10| | San Jose| null| 13| | San Jose| HondaAccord| 8| | San Jose| HondaCivic| 5| +---------+------------+---+ --Prepare data for ignore nulls example CREATE TABLE person (id INT, name STRING, age INT); INSERT INTO person VALUES (100, 'Mary', NULL), (200, 'John', 30), (300, 'Mike', 80), (400, 'Dan', 50); --Select the first row in column age SELECT FIRST(age) FROM person; +--------------------+ | first(age, false) | +--------------------+ | NULL | +--------------------+ --Get the first row in column `age` ignore nulls,last row in column `id` and sum of column `id`. SELECT FIRST(age IGNORE NULLS), LAST(id), SUM(id) FROM person; +-------------------+------------------+----------+ | first(age, true) | last(id, false) | sum(id) | +-------------------+------------------+----------+ | 30 | 400 | 1000 | +-------------------+------------------+----------+ ``` #### Klausa HAVING **catatan** Untuk melihat integrasi sumber AWS data mana yang mendukung perintah SQL ini, lihat. [Perintah dan OpenSearch fungsi SQL yang didukung](#supported-directquery-sql) `HAVING`Klausul ini digunakan untuk menyaring hasil yang dihasilkan `GROUP BY` berdasarkan kondisi yang ditentukan. Ini sering digunakan bersama dengan `GROUP BY` klausa. **Sintaksis** ``` HAVING boolean_expression ``` **Parameter** + **boolean\$1expression** Menentukan ekspresi apa pun yang mengevaluasi untuk jenis hasil boolean. Dua atau lebih ekspresi dapat digabungkan bersama menggunakan operator logis (`AND`,`OR`). **Catatan** Ekspresi yang ditentukan dalam `HAVING` klausa hanya dapat merujuk ke: 1. Konstanta 1. Ekspresi yang muncul di `GROUP BY` 1. Fungsi agregat **Contoh** ``` CREATE TABLE dealer (id INT, city STRING, car_model STRING, quantity INT); INSERT INTO dealer VALUES (100, 'Fremont', 'Honda Civic', 10), (100, 'Fremont', 'Honda Accord', 15), (100, 'Fremont', 'Honda CRV', 7), (200, 'Dublin', 'Honda Civic', 20), (200, 'Dublin', 'Honda Accord', 10), (200, 'Dublin', 'Honda CRV', 3), (300, 'San Jose', 'Honda Civic', 5), (300, 'San Jose', 'Honda Accord', 8); -- `HAVING` clause referring to column in `GROUP BY`. SELECT city, sum(quantity) AS sum FROM dealer GROUP BY city HAVING city = 'Fremont'; +-------+---+ | city|sum| +-------+---+ |Fremont| 32| +-------+---+ -- `HAVING` clause referring to aggregate function. SELECT city, sum(quantity) AS sum FROM dealer GROUP BY city HAVING sum(quantity) > 15; +-------+---+ | city|sum| +-------+---+ | Dublin| 33| |Fremont| 32| +-------+---+ -- `HAVING` clause referring to aggregate function by its alias. SELECT city, sum(quantity) AS sum FROM dealer GROUP BY city HAVING sum > 15; +-------+---+ | city|sum| +-------+---+ | Dublin| 33| |Fremont| 32| +-------+---+ -- `HAVING` clause referring to a different aggregate function than what is present in -- `SELECT` list. SELECT city, sum(quantity) AS sum FROM dealer GROUP BY city HAVING max(quantity) > 15; +------+---+ | city|sum| +------+---+ |Dublin| 33| +------+---+ -- `HAVING` clause referring to constant expression. SELECT city, sum(quantity) AS sum FROM dealer GROUP BY city HAVING 1 > 0 ORDER BY city; +--------+---+ | city|sum| +--------+---+ | Dublin| 33| | Fremont| 32| |San Jose| 13| +--------+---+ -- `HAVING` clause without a `GROUP BY` clause. SELECT sum(quantity) AS sum FROM dealer HAVING sum(quantity) > 10; +---+ |sum| +---+ | 78| +---+ ``` #### Klausa ORDER BY **catatan** Untuk melihat integrasi sumber AWS data mana yang mendukung perintah SQL ini, lihat. [Perintah dan OpenSearch fungsi SQL yang didukung](#supported-directquery-sql) `ORDER BY`Klausa ini digunakan untuk mengembalikan baris hasil dengan cara yang diurutkan dalam urutan yang ditentukan pengguna. Berbeda dengan klausa SORT BY, klausa ini menjamin urutan total dalam output. **Sintaksis** ``` ORDER BY { expression [ sort_direction | nulls_sort_order ] [ , ... ] } ``` **Parameter** + **MEMESAN OLEH** Menentukan daftar koma dipisahkan ekspresi bersama dengan parameter opsional `sort_direction` dan `nulls_sort_order` yang digunakan untuk mengurutkan baris. + **sort\$1direction** Secara opsional menentukan apakah akan mengurutkan baris dalam urutan naik atau turun. Nilai yang valid untuk arah pengurutan adalah `ASC` untuk naik dan `DESC` turun. Jika arah pengurutan tidak ditentukan secara eksplisit, maka secara default baris diurutkan naik. Sintaks: `[ ASC | DESC ] ` + **nulls\$1sort\$1order** Opsional menentukan apakah `NULL` nilai-nilai dikembalikan nilai-nilai before/after non-Null. Jika null\$1sort\$1order tidak ditentukan, maka urutkan terlebih dahulu jika urutan `NULLs` sortir adalah `ASC` dan NULLS sort\$1order terakhir jika urutan pengurutan adalah. `DESC` 1. Jika `NULLS FIRST` ditentukan, maka nilai NULL dikembalikan terlebih dahulu terlepas dari urutan pengurutan. 2. Jika `NULLS LAST` ditentukan, maka nilai NULL dikembalikan terakhir terlepas dari urutan pengurutan. Sintaks: `[ NULLS { FIRST | LAST } ]` **Contoh** ``` CREATE TABLE person (id INT, name STRING, age INT); INSERT INTO person VALUES (100, 'John', 30), (200, 'Mary', NULL), (300, 'Mike', 80), (400, 'Jerry', NULL), (500, 'Dan', 50); -- Sort rows by age. By default rows are sorted in ascending manner with NULL FIRST. SELECT name, age FROM person ORDER BY age; +-----+----+ | name| age| +-----+----+ |Jerry|null| | Mary|null| | John| 30| | Dan| 50| | Mike| 80| +-----+----+ -- Sort rows in ascending manner keeping null values to be last. SELECT name, age FROM person ORDER BY age NULLS LAST; +-----+----+ | name| age| +-----+----+ | John| 30| | Dan| 50| | Mike| 80| | Mary|null| |Jerry|null| +-----+----+ -- Sort rows by age in descending manner, which defaults to NULL LAST. SELECT name, age FROM person ORDER BY age DESC; +-----+----+ | name| age| +-----+----+ | Mike| 80| | Dan| 50| | John| 30| |Jerry|null| | Mary|null| +-----+----+ -- Sort rows in ascending manner keeping null values to be first. SELECT name, age FROM person ORDER BY age DESC NULLS FIRST; +-----+----+ | name| age| +-----+----+ |Jerry|null| | Mary|null| | Mike| 80| | Dan| 50| | John| 30| +-----+----+ -- Sort rows based on more than one column with each column having different -- sort direction. SELECT * FROM person ORDER BY name ASC, age DESC; +---+-----+----+ | id| name| age| +---+-----+----+ |500| Dan| 50| |400|Jerry|null| |100| John| 30| |200| Mary|null| |300| Mike| 80| +---+-----+----+ ``` #### Klausa JOIN **catatan** Untuk melihat integrasi sumber AWS data mana yang mendukung perintah SQL ini, lihat. [Perintah dan OpenSearch fungsi SQL yang didukung](#supported-directquery-sql) SQL join digunakan untuk menggabungkan baris dari dua relasi berdasarkan kriteria join. Bagian berikut menjelaskan keseluruhan sintaks gabungan dan berbagai jenis gabungan bersama dengan contoh. **Sintaksis** ``` relation INNER JOIN relation [ join_criteria ] ``` **Parameter** + **hubungan** Menentukan hubungan yang akan bergabung. + **join\$1type** Menentukan jenis bergabung. Sintaks: `INNER | CROSS | LEFT OUTER` + **join\$1criteria** Menentukan bagaimana baris dari satu relasi akan digabungkan dengan baris relasi lain. Sintaks: `ON boolean_expression | USING ( column_name [ , ... ] ) ` + **boolean\$1expression** Menentukan ekspresi dengan tipe kembali boolean. **Bergabunglah dengan tipe** + **Gabung Batin** Gabungan batin perlu ditentukan secara eksplisit. Ini memilih baris yang memiliki nilai yang cocok di kedua hubungan. Sintaks: `relation INNER JOIN relation [ join_criteria ] ` + **Bergabung Kiri** Gabungan kiri mengembalikan semua nilai dari relasi kiri dan nilai yang cocok dari relasi kanan, atau menambahkan NULL jika tidak ada kecocokan. Ini juga disebut sebagai gabungan luar kiri. Sintaks: `relation LEFT OUTER JOIN relation [ join_criteria ]` + **Cross Bergabung** Gabungan silang mengembalikan produk Cartesian dari dua hubungan. Sintaks: `relation CROSS JOIN relation [ join_criteria ]` **Contoh** ``` -- Use employee and department tables to demonstrate different type of joins. SELECT * FROM employee; +---+-----+------+ | id| name|deptno| +---+-----+------+ |105|Chloe| 5| |103| Paul| 3| |101| John| 1| |102| Lisa| 2| |104| Evan| 4| |106| Amy| 6| +---+-----+------+ SELECT * FROM department; +------+-----------+ |deptno| deptname| +------+-----------+ | 3|Engineering| | 2| Sales| | 1| Marketing| +------+-----------+ -- Use employee and department tables to demonstrate inner join. SELECT id, name, employee.deptno, deptname FROM employee INNER JOIN department ON employee.deptno = department.deptno; +---+-----+------+-----------| | id| name|deptno| deptname| +---+-----+------+-----------| |103| Paul| 3|Engineering| |101| John| 1| Marketing| |102| Lisa| 2| Sales| +---+-----+------+-----------| -- Use employee and department tables to demonstrate left join. SELECT id, name, employee.deptno, deptname FROM employee LEFT JOIN department ON employee.deptno = department.deptno; +---+-----+------+-----------| | id| name|deptno| deptname| +---+-----+------+-----------| |105|Chloe| 5| NULL| |103| Paul| 3|Engineering| |101| John| 1| Marketing| |102| Lisa| 2| Sales| |104| Evan| 4| NULL| |106| Amy| 6| NULL| +---+-----+------+-----------| -- Use employee and department tables to demonstrate cross join. SELECT id, name, employee.deptno, deptname FROM employee CROSS JOIN department; +---+-----+------+-----------| | id| name|deptno| deptname| +---+-----+------+-----------| |105|Chloe| 5|Engineering| |105|Chloe| 5| Marketing| |105|Chloe| 5| Sales| |103| Paul| 3|Engineering| |103| Paul| 3| Marketing| |103| Paul| 3| Sales| |101| John| 1|Engineering| |101| John| 1| Marketing| |101| John| 1| Sales| |102| Lisa| 2|Engineering| |102| Lisa| 2| Marketing| |102| Lisa| 2| Sales| |104| Evan| 4|Engineering| |104| Evan| 4| Marketing| |104| Evan| 4| Sales| |106| Amy| 4|Engineering| |106| Amy| 4| Marketing| |106| Amy| 4| Sales| +---+-----+------+-----------| ``` #### Klausa LIMIT **catatan** Untuk melihat integrasi sumber AWS data mana yang mendukung perintah SQL ini, lihat. [Perintah dan OpenSearch fungsi SQL yang didukung](#supported-directquery-sql) `LIMIT`Klausa ini digunakan untuk membatasi jumlah baris yang dikembalikan oleh pernyataan. `SELECT` Secara umum, klausa ini digunakan bersama dengan `ORDER BY` untuk memastikan bahwa hasilnya deterministik. **Sintaksis** ``` LIMIT { ALL | integer_expression } ``` **Parameter** + **SEMUA** Jika ditentukan, query mengembalikan semua baris. Dengan kata lain, tidak ada batasan yang diterapkan jika opsi ini ditentukan. + **integer\$1expression** Menentukan ekspresi dilipat yang mengembalikan integer. **Contoh** ``` CREATE TABLE person (name STRING, age INT); INSERT INTO person VALUES ('Jane Doe', 25), ('Pat C', 18), ('Nikki W', 16), ('John D', 25), ('Juan L', 18), ('Jorge S', 16); -- Select the first two rows. SELECT name, age FROM person ORDER BY name LIMIT 2; +-------+---+ | name|age| +-------+---+ | Pat C| 18| |Jorge S| 16| +------+---+ -- Specifying ALL option on LIMIT returns all the rows. SELECT name, age FROM person ORDER BY name LIMIT ALL; +--------+---+ | name|age| +--------+---+ | Pat C| 18| | Jorge S| 16| | Juan L| 18| | John D| 25| | Nikki W| 16| |Jane Doe| 25| +--------+---+ -- A function expression as an input to LIMIT. SELECT name, age FROM person ORDER BY name LIMIT length('OPENSEARCH'); +-------+---+ | name|age| +-------+---+ | Pat C| 18| |Jorge S| 16| | Juan L| 18| | John D| 25| |Nikki W| 16| +-------+---+ ``` #### Klausul KASUS **catatan** Untuk melihat integrasi sumber AWS data mana yang mendukung perintah SQL ini, lihat. [Perintah dan OpenSearch fungsi SQL yang didukung](#supported-directquery-sql) `CASE`Klausa menggunakan aturan untuk mengembalikan hasil tertentu berdasarkan kondisi yang ditentukan, mirip dengan pernyataan if/else dalam bahasa pemrograman lainnya. **Sintaksis** ``` CASE [ expression ] { WHEN boolean_expression THEN then_expression } [ ... ] [ ELSE else_expression ] END ``` **Parameter** + **boolean\$1expression** Menentukan ekspresi apa pun yang mengevaluasi untuk jenis hasil boolean. Dua atau lebih ekspresi dapat digabungkan bersama menggunakan operator logis (`AND`,`OR`). + **then\$1expression** Menentukan ekspresi kemudian berdasarkan kondisi boolean\$1expression. `then_expression`dan semua `else_expression` harus tipe yang sama atau dapat dipaksakan untuk tipe umum. + **else\$1expression** Menentukan ekspresi default. `then_expression`dan semua ` else_expression` harus tipe yang sama atau dapat dipaksakan untuk tipe umum. **Contoh** ``` CREATE TABLE person (id INT, name STRING, age INT); INSERT INTO person VALUES (100, 'John', 30), (200, 'Mary', NULL), (300, 'Mike', 80), (400, 'Dan', 50); SELECT id, CASE WHEN id > 200 THEN 'bigger' ELSE 'small' END FROM person; +------+--------------------------------------------------+ | id | CASE WHEN (id > 200) THEN bigger ELSE small END | +------+--------------------------------------------------+ | 100 | small | | 200 | small | | 300 | bigger | | 400 | bigger | +------+--------------------------------------------------+ SELECT id, CASE id WHEN 100 then 'bigger' WHEN id > 300 THEN '300' ELSE 'small' END FROM person; +------+-----------------------------------------------------------------------------------------------+ | id | CASE WHEN (id = 100) THEN bigger WHEN (id = CAST((id > 300) AS INT)) THEN 300 ELSE small END | +------+-----------------------------------------------------------------------------------------------+ | 100 | bigger | | 200 | small | | 300 | small | | 400 | small | +------+-----------------------------------------------------------------------------------------------+ ``` #### Ekspresi tabel umum **catatan** Untuk melihat integrasi sumber AWS data mana yang mendukung perintah SQL ini, lihat. [Perintah dan OpenSearch fungsi SQL yang didukung](#supported-directquery-sql) Ekspresi tabel umum (CTE) mendefinisikan set hasil sementara yang pengguna dapat referensi mungkin beberapa kali dalam lingkup pernyataan SQL. CTE digunakan terutama dalam sebuah `SELECT` pernyataan. **Sintaksis** ``` WITH common_table_expression [ , ... ] ``` Sementara `common_table_expression` didefinisikan sebagai: ``` Syntexpression_name [ ( column_name [ , ... ] ) ] [ AS ] ( query ) ``` **Parameter** + **expression\$1name** Menentukan nama untuk ekspresi tabel umum. + **query** Sebuah `SELECT` pernyataan. **Contoh** ``` -- CTE with multiple column aliases WITH t(x, y) AS (SELECT 1, 2) SELECT * FROM t WHERE x = 1 AND y = 2; +---+---+ | x| y| +---+---+ | 1| 2| +---+---+ -- CTE in CTE definition WITH t AS ( WITH t2 AS (SELECT 1) SELECT * FROM t2 ) SELECT * FROM t; +---+ | 1| +---+ | 1| +---+ -- CTE in subquery SELECT max(c) FROM ( WITH t(c) AS (SELECT 1) SELECT * FROM t ); +------+ |max(c)| +------+ | 1| +------+ -- CTE in subquery expression SELECT ( WITH t AS (SELECT 1) SELECT * FROM t ); +----------------+ |scalarsubquery()| +----------------+ | 1| +----------------+ -- CTE in CREATE VIEW statement CREATE VIEW v AS WITH t(a, b, c, d) AS (SELECT 1, 2, 3, 4) SELECT * FROM t; SELECT * FROM v; +---+---+---+---+ | a| b| c| d| +---+---+---+---+ | 1| 2| 3| 4| +---+---+---+---+ ``` #### EXPLAIN **catatan** Untuk melihat integrasi sumber AWS data mana yang mendukung perintah SQL ini, lihat. [Perintah dan OpenSearch fungsi SQL yang didukung](#supported-directquery-sql) `EXPLAIN`Pernyataan ini digunakan untuk memberikan rencana logis/fisik untuk pernyataan masukan. Secara default, klausa ini memberikan informasi tentang rencana fisik saja. **Sintaksis** ``` EXPLAIN [ EXTENDED | CODEGEN | COST | FORMATTED ] statement ``` **Parameter** + **DIPERPANJANG** Menghasilkan rencana logis yang diuraikan, menganalisis rencana logis, rencana logis yang dioptimalkan, dan rencana fisik. Parsed Logical plan adalah rencana yang belum terselesaikan yang diekstraksi dari kueri. Rencana logis yang dianalisis mengubah yang menerjemahkan `unresolvedAttribute` dan `unresolvedRelation` menjadi objek yang diketik sepenuhnya. Rencana logis yang dioptimalkan berubah melalui seperangkat aturan optimasi, menghasilkan rencana fisik. + **KODEGEN** Menghasilkan kode untuk pernyataan, jika ada dan rencana fisik. + **BIAYA** Jika statistik node rencana tersedia, menghasilkan rencana logis dan statistik. + **DIFORMAT** Menghasilkan dua bagian: garis besar rencana fisik dan detail simpul. + **pernyataan** Menentukan pernyataan SQL yang akan dijelaskan. **Contoh** ``` -- Default Output EXPLAIN select k, sum(v) from values (1, 2), (1, 3) t(k, v) group by k; +----------------------------------------------------+ | plan| +----------------------------------------------------+ | == Physical Plan == *(2) HashAggregate(keys=[k#33], functions=[sum(cast(v#34 as bigint))]) +- Exchange hashpartitioning(k#33, 200), true, [id=#59] +- *(1) HashAggregate(keys=[k#33], functions=[partial_sum(cast(v#34 as bigint))]) +- *(1) LocalTableScan [k#33, v#34] | +---------------------------------------------------- -- Using Extended EXPLAIN EXTENDED select k, sum(v) from values (1, 2), (1, 3) t(k, v) group by k; +----------------------------------------------------+ | plan| +----------------------------------------------------+ | == Parsed Logical Plan == 'Aggregate ['k], ['k, unresolvedalias('sum('v), None)] +- 'SubqueryAlias `t` +- 'UnresolvedInlineTable [k, v], [List(1, 2), List(1, 3)] == Analyzed Logical Plan == k: int, sum(v): bigint Aggregate [k#47], [k#47, sum(cast(v#48 as bigint)) AS sum(v)#50L] +- SubqueryAlias `t` +- LocalRelation [k#47, v#48] == Optimized Logical Plan == Aggregate [k#47], [k#47, sum(cast(v#48 as bigint)) AS sum(v)#50L] +- LocalRelation [k#47, v#48] == Physical Plan == *(2) HashAggregate(keys=[k#47], functions=[sum(cast(v#48 as bigint))], output=[k#47, sum(v)#50L]) +- Exchange hashpartitioning(k#47, 200), true, [id=#79] +- *(1) HashAggregate(keys=[k#47], functions=[partial_sum(cast(v#48 as bigint))], output=[k#47, sum#52L]) +- *(1) LocalTableScan [k#47, v#48] | +----------------------------------------------------+ -- Using Formatted EXPLAIN FORMATTED select k, sum(v) from values (1, 2), (1, 3) t(k, v) group by k; +----------------------------------------------------+ | plan| +----------------------------------------------------+ | == Physical Plan == * HashAggregate (4) +- Exchange (3) +- * HashAggregate (2) +- * LocalTableScan (1) (1) LocalTableScan [codegen id : 1] Output: [k#19, v#20] (2) HashAggregate [codegen id : 1] Input: [k#19, v#20] (3) Exchange Input: [k#19, sum#24L] (4) HashAggregate [codegen id : 2] Input: [k#19, sum#24L] | +----------------------------------------------------+ ``` #### Klausa SUBQUERY LATERAL **catatan** Untuk melihat integrasi sumber AWS data mana yang mendukung perintah SQL ini, lihat. [Perintah dan OpenSearch fungsi SQL yang didukung](#supported-directquery-sql) `LATERAL SUBQUERY`adalah subquery yang didahului oleh kata kunci. `LATERAL` Ini menyediakan cara untuk referensi kolom dalam klausa sebelumnya. `FROM` Tanpa `LATERAL` kata kunci, subquery hanya dapat merujuk ke kolom di kueri luar, tetapi tidak dalam klausa. `FROM` `LATERAL SUBQUERY`membuat kueri yang rumit lebih sederhana dan lebih efisien. **Sintaksis** ``` [ LATERAL ] primary_relation [ join_relation ] ``` **Parameter** + **hubungan\$1primer** Menentukan hubungan utama. Ini bisa menjadi salah satu dari yang berikut: 1. Hubungan tabel 1. Kueri alias Sintaks: `( query ) [ [ AS ] alias ] ` 1. Hubungan alias `Syntax: ( relation ) [ [ AS ] alias ]` **Contoh** ``` CREATE TABLE t1 (c1 INT, c2 INT); INSERT INTO t1 VALUES (0, 1), (1, 2); CREATE TABLE t2 (c1 INT, c2 INT); INSERT INTO t2 VALUES (0, 2), (0, 3); SELECT * FROM t1, LATERAL (SELECT * FROM t2 WHERE t1.c1 = t2.c1); +--------+-------+--------+-------+ | t1.c1 | t1.c2 | t2.c1 | t2.c2 | +-------+--------+--------+-------+ | 0 | 1 | 0 | 3 | | 0 | 1 | 0 | 2 | +-------+--------+--------+-------+ SELECT a, b, c FROM t1, LATERAL (SELECT c1 + c2 AS a), LATERAL (SELECT c1 - c2 AS b), LATERAL (SELECT a * b AS c); +--------+-------+--------+ | a | b | c | +-------+--------+--------+ | 3 | -1 | -3 | | 1 | -1 | -1 | +-------+--------+--------+ ``` #### Klausa TAMPILAN LATERAL **catatan** Untuk melihat integrasi sumber AWS data mana yang mendukung perintah SQL ini, lihat. [Perintah dan OpenSearch fungsi SQL yang didukung](#supported-directquery-sql) `LATERAL VIEW`Klausul ini digunakan bersama dengan fungsi generator seperti`EXPLODE`, yang akan menghasilkan tabel virtual yang berisi satu atau lebih baris. `LATERAL VIEW`akan menerapkan baris ke setiap baris keluaran asli. **Sintaksis** ``` LATERAL VIEW [ OUTER ] generator_function ( expression [ , ... ] ) [ table_alias ] AS column_alias [ , ... ] ``` **Parameter** + **LUAR** Jika `OUTER` ditentukan, mengembalikan null jika input array/map kosong atau null. + **generator\$1function** Menentukan fungsi generator (`EXPLODE`,`INLINE`, dan sebagainya.). + **table\$1alias** Alias untuk`generator_function`, yang opsional. + **column\$1alias** Daftar alias kolom`generator_function`, yang dapat digunakan dalam baris output. Anda dapat memiliki beberapa alias jika `generator_function` memiliki beberapa kolom output. **Contoh** ``` CREATE TABLE person (id INT, name STRING, age INT, class INT, address STRING); INSERT INTO person VALUES (100, 'John', 30, 1, 'Street 1'), (200, 'Mary', NULL, 1, 'Street 2'), (300, 'Mike', 80, 3, 'Street 3'), (400, 'Dan', 50, 4, 'Street 4'); SELECT * FROM person LATERAL VIEW EXPLODE(ARRAY(30, 60)) tableName AS c_age LATERAL VIEW EXPLODE(ARRAY(40, 80)) AS d_age; +------+-------+-------+--------+-----------+--------+--------+ | id | name | age | class | address | c_age | d_age | +------+-------+-------+--------+-----------+--------+--------+ | 100 | John | 30 | 1 | Street 1 | 30 | 40 | | 100 | John | 30 | 1 | Street 1 | 30 | 80 | | 100 | John | 30 | 1 | Street 1 | 60 | 40 | | 100 | John | 30 | 1 | Street 1 | 60 | 80 | | 200 | Mary | NULL | 1 | Street 2 | 30 | 40 | | 200 | Mary | NULL | 1 | Street 2 | 30 | 80 | | 200 | Mary | NULL | 1 | Street 2 | 60 | 40 | | 200 | Mary | NULL | 1 | Street 2 | 60 | 80 | | 300 | Mike | 80 | 3 | Street 3 | 30 | 40 | | 300 | Mike | 80 | 3 | Street 3 | 30 | 80 | | 300 | Mike | 80 | 3 | Street 3 | 60 | 40 | | 300 | Mike | 80 | 3 | Street 3 | 60 | 80 | | 400 | Dan | 50 | 4 | Street 4 | 30 | 40 | | 400 | Dan | 50 | 4 | Street 4 | 30 | 80 | | 400 | Dan | 50 | 4 | Street 4 | 60 | 40 | | 400 | Dan | 50 | 4 | Street 4 | 60 | 80 | +------+-------+-------+--------+-----------+--------+--------+ SELECT c_age, COUNT(1) FROM person LATERAL VIEW EXPLODE(ARRAY(30, 60)) AS c_age LATERAL VIEW EXPLODE(ARRAY(40, 80)) AS d_age GROUP BY c_age; +--------+-----------+ | c_age | count(1) | +--------+-----------+ | 60 | 8 | | 30 | 8 | +--------+-----------+ SELECT * FROM person LATERAL VIEW EXPLODE(ARRAY()) tableName AS c_age; +-----+-------+------+--------+----------+--------+ | id | name | age | class | address | c_age | +-----+-------+------+--------+----------+--------+ +-----+-------+------+--------+----------+--------+ SELECT * FROM person LATERAL VIEW OUTER EXPLODE(ARRAY()) tableName AS c_age; +------+-------+-------+--------+-----------+--------+ | id | name | age | class | address | c_age | +------+-------+-------+--------+-----------+--------+ | 100 | John | 30 | 1 | Street 1 | NULL | | 200 | Mary | NULL | 1 | Street 2 | NULL | | 300 | Mike | 80 | 3 | Street 3 | NULL | | 400 | Dan | 50 | 4 | Street 4 | NULL | +------+-------+-------+--------+-----------+--------+ ``` #### Seperti predikat **catatan** Untuk melihat integrasi sumber AWS data mana yang mendukung perintah SQL ini, lihat. [Perintah dan OpenSearch fungsi SQL yang didukung](#supported-directquery-sql) `LIKE`Predikat digunakan untuk mencari pola tertentu. Predikat ini juga mendukung beberapa pola dengan quantifier termasuk`ANY`,, `SOME` dan. `ALL` **Sintaksis** ``` [ NOT ] { LIKE search_pattern [ ESCAPE esc_char ] | [ RLIKE | REGEXP ] regex_pattern } [ NOT ] { LIKE quantifiers ( search_pattern [ , ... ]) } ``` **Parameter** + **search\$1pattern** Menentukan pola string yang akan dicari oleh klausa LIKE. Ini dapat berisi karakter pencocokan pola khusus: + `%`cocok dengan nol atau lebih karakter. + `_`cocok persis satu karakter. + **esc\$1char** Menentukan karakter escape. Karakter escape default adalah`\`. + **regex\$1pattern** Menentukan pola pencarian ekspresi reguler yang akan dicari oleh `RLIKE` atau `REGEXP` klausa. + **kuantifier** Menentukan kuantifier predikat termasuk, dan. `ANY` `SOME` `ALL` `ANY`atau `SOME` berarti jika salah satu pola cocok dengan input, maka kembalikan true. `ALL`berarti jika semua pola cocok dengan input, maka kembalikan true. **Contoh** ``` CREATE TABLE person (id INT, name STRING, age INT); INSERT INTO person VALUES (100, 'John', 30), (200, 'Mary', NULL), (300, 'Mike', 80), (400, 'Dan', 50), (500, 'Evan_w', 16); SELECT * FROM person WHERE name LIKE 'M%'; +---+----+----+ | id|name| age| +---+----+----+ |300|Mike| 80| |200|Mary|null| +---+----+----+ SELECT * FROM person WHERE name LIKE 'M_ry'; +---+----+----+ | id|name| age| +---+----+----+ |200|Mary|null| +---+----+----+ SELECT * FROM person WHERE name NOT LIKE 'M_ry'; +---+------+---+ | id| name|age| +---+------+---+ |500|Evan_W| 16| |300| Mike| 80| |100| John| 30| |400| Dan| 50| +---+------+---+ SELECT * FROM person WHERE name RLIKE 'M+'; +---+----+----+ | id|name| age| +---+----+----+ |300|Mike| 80| |200|Mary|null| +---+----+----+ SELECT * FROM person WHERE name REGEXP 'M+'; +---+----+----+ | id|name| age| +---+----+----+ |300|Mike| 80| |200|Mary|null| +---+----+----+ SELECT * FROM person WHERE name LIKE '%\_%'; +---+------+---+ | id| name|age| +---+------+---+ |500|Evan_W| 16| +---+------+---+ SELECT * FROM person WHERE name LIKE '%$_%' ESCAPE '$'; +---+------+---+ | id| name|age| +---+------+---+ |500|Evan_W| 16| +---+------+---+ SELECT * FROM person WHERE name LIKE ALL ('%an%', '%an'); +---+----+----+ | id|name| age| +---+----+----+ |400| Dan| 50| +---+----+----+ SELECT * FROM person WHERE name LIKE ANY ('%an%', '%an'); +---+------+---+ | id| name|age| +---+------+---+ |400| Dan| 50| |500|Evan_W| 16| +---+------+---+ SELECT * FROM person WHERE name LIKE SOME ('%an%', '%an'); +---+------+---+ | id| name|age| +---+------+---+ |400| Dan| 50| |500|Evan_W| 16| +---+------+---+ SELECT * FROM person WHERE name NOT LIKE ALL ('%an%', '%an'); +---+----+----+ | id|name| age| +---+----+----+ |100|John| 30| |200|Mary|null| |300|Mike| 80| +---+----+----+ SELECT * FROM person WHERE name NOT LIKE ANY ('%an%', '%an'); +---+------+----+ | id| name| age| +---+------+----+ |100| John| 30| |200| Mary|null| |300| Mike| 80| |500|Evan_W| 16| +---+------+----+ SELECT * FROM person WHERE name NOT LIKE SOME ('%an%', '%an'); +---+------+----+ | id| name| age| +---+------+----+ |100| John| 30| |200| Mary|null| |300| Mike| 80| |500|Evan_W| 16| +---+------+----+ ``` #### MENGIMBANGI **catatan** Untuk melihat integrasi sumber AWS data mana yang mendukung perintah SQL ini, lihat. [Perintah dan OpenSearch fungsi SQL yang didukung](#supported-directquery-sql) `OFFSET`Klausa ini digunakan untuk menentukan jumlah baris yang akan dilewati sebelum mulai mengembalikan baris yang dikembalikan oleh `SELECT` pernyataan. Secara umum, klausa ini digunakan bersama dengan `ORDER BY` untuk memastikan bahwa hasilnya deterministik. **Sintaksis** ``` OFFSET integer_expression ``` **Parameter** + **integer\$1expression** Menentukan ekspresi dilipat yang mengembalikan integer. **Contoh** ``` CREATE TABLE person (name STRING, age INT); INSERT INTO person VALUES ('Jane Doe', 25), ('Pat C', 18), ('Nikki W', 16), ('Juan L', 25), ('John D', 18), ('Jorge S', 16); -- Skip the first two rows. SELECT name, age FROM person ORDER BY name OFFSET 2; +-------+---+ | name|age| +-------+---+ | John D| 18| | Juan L| 25| |Nikki W| 16| |Jane Doe| 25| +-------+---+ -- Skip the first two rows and returns the next three rows. SELECT name, age FROM person ORDER BY name LIMIT 3 OFFSET 2; +-------+---+ | name|age| +-------+---+ | John D| 18| | Juan L| 25| |Nikki W| 16| +-------+---+ -- A function expression as an input to OFFSET. SELECT name, age FROM person ORDER BY name OFFSET length('WAGON'); +-------+---+ | name|age| +-------+---+ |Jane Doe| 25| +-------+---+ ``` #### Klausul PIVOT **catatan** Untuk melihat integrasi sumber AWS data mana yang mendukung perintah SQL ini, lihat. [Perintah dan OpenSearch fungsi SQL yang didukung](#supported-directquery-sql) `PIVOT`Klausul ini digunakan untuk perspektif data. Kita bisa mendapatkan nilai agregat berdasarkan nilai kolom tertentu, yang akan diubah menjadi beberapa kolom yang digunakan dalam `SELECT` klausa. `PIVOT`Klausa dapat ditentukan setelah nama tabel atau subquery. **Sintaksis** ``` PIVOT ( { aggregate_expression [ AS aggregate_expression_alias ] } [ , ... ] FOR column_list IN ( expression_list ) ) ``` **Parameter** + **aggregate\$1expression** Menentukan ekspresi agregat`(SUM(a)`,`COUNT(DISTINCT b)`, dan sebagainya.). + **aggregate\$1expression\$1alias** Menentukan alias untuk ekspresi agregat. + **column\$1list** Berisi kolom dalam `FROM` klausa, yang menentukan kolom yang ingin Anda ganti dengan kolom baru. Anda dapat menggunakan tanda kurung untuk mengelilingi kolom, seperti. `(c1, c2)` + **expression\$1list** Menentukan kolom baru, yang digunakan untuk mencocokkan nilai `column_list` sebagai kondisi agregasi. Anda juga dapat menambahkan alias untuk mereka. **Contoh** ``` CREATE TABLE person (id INT, name STRING, age INT, class INT, address STRING); INSERT INTO person VALUES (100, 'John', 30, 1, 'Street 1'), (200, 'Mary', NULL, 1, 'Street 2'), (300, 'Mike', 80, 3, 'Street 3'), (400, 'Dan', 50, 4, 'Street 4'); SELECT * FROM person PIVOT ( SUM(age) AS a, AVG(class) AS c FOR name IN ('John' AS john, 'Mike' AS mike) ); +------+-----------+---------+---------+---------+---------+ | id | address | john_a | john_c | mike_a | mike_c | +------+-----------+---------+---------+---------+---------+ | 200 | Street 2 | NULL | NULL | NULL | NULL | | 100 | Street 1 | 30 | 1.0 | NULL | NULL | | 300 | Street 3 | NULL | NULL | 80 | 3.0 | | 400 | Street 4 | NULL | NULL | NULL | NULL | +------+-----------+---------+---------+---------+---------+ SELECT * FROM person PIVOT ( SUM(age) AS a, AVG(class) AS c FOR (name, age) IN (('John', 30) AS c1, ('Mike', 40) AS c2) ); +------+-----------+-------+-------+-------+-------+ | id | address | c1_a | c1_c | c2_a | c2_c | +------+-----------+-------+-------+-------+-------+ | 200 | Street 2 | NULL | NULL | NULL | NULL | | 100 | Street 1 | 30 | 1.0 | NULL | NULL | | 300 | Street 3 | NULL | NULL | NULL | NULL | | 400 | Street 4 | NULL | NULL | NULL | NULL | +------+-----------+-------+-------+-------+-------+ ``` #### Tetapkan operator **catatan** Untuk melihat integrasi sumber AWS data mana yang mendukung perintah SQL ini, lihat. [Perintah dan OpenSearch fungsi SQL yang didukung](#supported-directquery-sql) Operator set digunakan untuk menggabungkan dua relasi input menjadi satu. OpenSearch SQL mendukung tiga jenis operator set: + `EXCEPT` atau `MINUS` + `INTERSECT` + `UNION` Relasi input harus memiliki jumlah kolom yang sama dan tipe data yang kompatibel untuk masing-masing kolom. **KECUALI** `EXCEPT`dan `EXCEPT ALL` kembalikan baris yang ditemukan dalam satu relasi tetapi tidak yang lain. `EXCEPT`(alternatifnya,`EXCEPT DISTINCT`) hanya mengambil baris yang berbeda sementara `EXCEPT ALL` tidak menghapus duplikat dari baris hasil. Perhatikan bahwa itu `MINUS` adalah alias untuk`EXCEPT`. **Sintaksis** ``` [ ( ] relation [ ) ] EXCEPT | MINUS [ ALL | DISTINCT ] [ ( ] relation [ ) ] ``` **Contoh** ``` -- Use table1 and table2 tables to demonstrate set operators in this page. SELECT * FROM table1; +---+ | c| +---+ | 3| | 1| | 2| | 2| | 3| | 4| +---+ SELECT * FROM table2; +---+ | c| +---+ | 5| | 1| | 2| | 2| +---+ SELECT c FROM table1 EXCEPT SELECT c FROM table2; +---+ | c| +---+ | 3| | 4| +---+ SELECT c FROM table1 MINUS SELECT c FROM table2; +---+ | c| +---+ | 3| | 4| +---+ SELECT c FROM table1 EXCEPT ALL (SELECT c FROM table2); +---+ | c| +---+ | 3| | 3| | 4| +---+ SELECT c FROM table1 MINUS ALL (SELECT c FROM table2); +---+ | c| +---+ | 3| | 3| | 4| +---+ ``` **BERPOTONGAN** `INTERSECT`dan `INTERSECT ALL` kembalikan baris yang ditemukan di kedua hubungan. `INTERSECT`(alternatifnya,`INTERSECT DISTINCT`) hanya mengambil baris yang berbeda sementara `INTERSECT ALL` tidak menghapus duplikat dari baris hasil. **Sintaksis** ``` [ ( ] relation [ ) ] INTERSECT [ ALL | DISTINCT ] [ ( ] relation [ ) ] ``` **Contoh** ``` (SELECT c FROM table1) INTERSECT (SELECT c FROM table2); +---+ | c| +---+ | 1| | 2| +---+ (SELECT c FROM table1) INTERSECT DISTINCT (SELECT c FROM table2); +---+ | c| +---+ | 1| | 2| +---+ (SELECT c FROM table1) INTERSECT ALL (SELECT c FROM table2); +---+ | c| +---+ | 1| | 2| | 2| +---+ ``` **SERIKAT** `UNION`dan `UNION ALL` kembalikan baris yang ditemukan di kedua relasi. `UNION`(alternatifnya,`UNION DISTINCT`) hanya mengambil baris yang berbeda sementara `UNION ALL` tidak menghapus duplikat dari baris hasil. **Sintaksis** ``` [ ( ] relation [ ) ] UNION [ ALL | DISTINCT ] [ ( ] relation [ ) ] ``` **Contoh** ``` (SELECT c FROM table1) UNION (SELECT c FROM table2); +---+ | c| +---+ | 1| | 3| | 5| | 4| | 2| +---+ (SELECT c FROM table1) UNION DISTINCT (SELECT c FROM table2); +---+ | c| +---+ | 1| | 3| | 5| | 4| | 2| +---+ SELECT c FROM table1 UNION ALL (SELECT c FROM table2); +---+ | c| +---+ | 3| | 1| | 2| | 2| | 3| | 4| | 5| | 1| | 2| | 2| +---+ ``` #### URUTKAN BERDASARKAN klausa **catatan** Untuk melihat integrasi sumber AWS data mana yang mendukung perintah SQL ini, lihat. [Perintah dan OpenSearch fungsi SQL yang didukung](#supported-directquery-sql) `SORT BY`Klausa ini digunakan untuk mengembalikan baris hasil yang diurutkan dalam setiap partisi dalam urutan yang ditentukan pengguna. Ketika ada lebih dari satu partisi `SORT BY` dapat mengembalikan hasil yang sebagian dipesan. Ini berbeda dari `ORDER BY` klausa yang menjamin urutan total output. **Sintaksis** ``` SORT BY { expression [ sort_direction | nulls_sort_order ] [ , ... ] } ``` **Parameter** + **URUTKAN BERDASARKAN** Menentukan daftar ekspresi dipisahkan koma bersama dengan parameter opsional sort\$1direction dan nulls\$1sort\$1order yang digunakan untuk mengurutkan baris dalam setiap partisi. + **sort\$1direction** Secara opsional menentukan apakah akan mengurutkan baris dalam urutan naik atau turun. Nilai yang valid untuk arah pengurutan adalah `ASC` untuk naik dan `DESC` turun. Jika arah pengurutan tidak ditentukan secara eksplisit, maka secara default baris diurutkan naik. Sintaks: `[ ASC | DESC ]` + **nulls\$1sort\$1order** Opsional menentukan apakah nilai NULL dikembalikan sebelum/sesudah nilai-nilai non-NULL. Jika tidak `null_sort_order` ditentukan, maka NULLs urutkan terlebih dahulu jika urutan sortir adalah `ASC` dan NULLS sortir terakhir jika urutan urutannya. `DESC` 1. Jika `NULLS FIRST` ditentukan, maka nilai NULL dikembalikan terlebih dahulu terlepas dari urutan pengurutan. 2. Jika `NULLS LAST` ditentukan, maka nilai NULL dikembalikan terakhir terlepas dari urutan pengurutan. Sintaks: `[ NULLS { FIRST | LAST } ] ` **Contoh** ``` CREATE TABLE person (zip_code INT, name STRING, age INT); INSERT INTO person VALUES (94588, 'Shirley Rodriguez', 50), (94588, 'Juan Li', 18), (94588, 'Anil K', 27), (94588, 'John D', NULL), (94511, 'David K', 42), (94511, 'Aryan B.', 18), (94511, 'Lalit B.', NULL); -- Sort rows by `name` within each partition in ascending manner SELECT name, age, zip_code FROM person SORT BY name; +------------------+----+--------+ | name| age|zip_code| +------------------+----+--------+ | Anil K| 27| 94588| | Juan Li| 18| 94588| | John D|null| 94588| | Shirley Rodriguez| 50| 94588| | Aryan B.| 18| 94511| | David K| 42| 94511| | Lalit B.|null| 94511| +------------------+----+--------+ -- Sort rows within each partition using column position. SELECT name, age, zip_code FROM person SORT BY 1; +----------------+----+----------+ | name| age|zip_code| +------------------+----+--------+ | Anil K| 27| 94588| | Juan Li| 18| 94588| | John D|null| 94588| | Shirley Rodriguez| 50| 94588| | Aryan B.| 18| 94511| | David K| 42| 94511| | Lalit B.|null| 94511| +------------------+----+--------+ -- Sort rows within partition in ascending manner keeping null values to be last. SELECT age, name, zip_code FROM person SORT BY age NULLS LAST; +----+------------------+--------+ | age| name|zip_code| +----+------------------+--------+ | 18| Juan Li| 94588| | 27| Anil K| 94588| | 50| Shirley Rodriguez| 94588| |null| John D| 94588| | 18| Aryan B.| 94511| | 42| David K| 94511| |null| Lalit B.| 94511| +--------------+--------+--------+ -- Sort rows by age within each partition in descending manner, which defaults to NULL LAST. SELECT age, name, zip_code FROM person SORT BY age DESC; +----+------------------+--------+ | age| name|zip_code| +----+------------------+--------+ | 50| Shirley Rodriguez| 94588| | 27| Anil K| 94588| | 18| Juan Li| 94588| |null| John D| 94588| | 42| David K| 94511| | 18| Aryan B.| 94511| |null| Lalit B.| 94511| +----+------------------+--------+ -- Sort rows by age within each partition in descending manner keeping null values to be first. SELECT age, name, zip_code FROM person SORT BY age DESC NULLS FIRST; +----+------------------+--------+ | age| name|zip_code| +----+------------------+--------+ |null| John D| 94588| | 50| Shirley Rodriguez| 94588| | 27| Anil K| 94588| | 18| Juan Li| 94588| |null| Lalit B.| 94511| | 42| David K| 94511| | 18| Aryan B.| 94511| +--------------+--------+--------+ -- Sort rows within each partition based on more than one column with each column having -- different sort direction. SELECT name, age, zip_code FROM person SORT BY name ASC, age DESC; +------------------+----+--------+ | name| age|zip_code| +------------------+----+--------+ | Anil K| 27| 94588| | Juan Li| 18| 94588| | John D|null| 94588| | Shirley Rodriguez| 50| 94588| | Aryan B.| 18| 94511| | David K| 42| 94511| | Lalit B.|null| 94511| +------------------+----+--------+ ``` #### UNPIVOT **catatan** Untuk melihat integrasi sumber AWS data mana yang mendukung perintah SQL ini, lihat. [Perintah dan OpenSearch fungsi SQL yang didukung](#supported-directquery-sql) `UNPIVOT`Klausa mengubah beberapa kolom menjadi beberapa baris yang digunakan dalam `SELECT` klausa. `UNPIVOT`Klausa dapat ditentukan setelah nama tabel atau subquery. **Sintaksis** ``` UNPIVOT [ { INCLUDE | EXCLUDE } NULLS ] ( { single_value_column_unpivot | multi_value_column_unpivot } ) [[AS] alias] single_value_column_unpivot: values_column FOR name_column IN (unpivot_column [[AS] alias] [, ...]) multi_value_column_unpivot: (values_column [, ...]) FOR name_column IN ((unpivot_column [, ...]) [[AS] alias] [, ...]) ``` **Parameter** + **unpivot\$1column** Berisi kolom dalam `FROM` klausa, yang menentukan kolom yang ingin kita unpivot. + **name\$1column** Nama untuk kolom yang menyimpan nama-nama kolom yang tidak diputar. + **values\$1column** Nama untuk kolom yang menyimpan nilai-nilai kolom unpivoted. **Contoh** ``` CREATE TABLE sales_quarterly (year INT, q1 INT, q2 INT, q3 INT, q4 INT); INSERT INTO sales_quarterly VALUES (2020, null, 1000, 2000, 2500), (2021, 2250, 3200, 4200, 5900), (2022, 4200, 3100, null, null); -- column names are used as unpivot columns SELECT * FROM sales_quarterly UNPIVOT ( sales FOR quarter IN (q1, q2, q3, q4) ); +------+---------+-------+ | year | quarter | sales | +------+---------+-------+ | 2020 | q2 | 1000 | | 2020 | q3 | 2000 | | 2020 | q4 | 2500 | | 2021 | q1 | 2250 | | 2021 | q2 | 3200 | | 2021 | q3 | 4200 | | 2021 | q4 | 5900 | | 2022 | q1 | 4200 | | 2022 | q2 | 3100 | +------+---------+-------+ -- NULL values are excluded by default, they can be included -- unpivot columns can be alias -- unpivot result can be referenced via its alias SELECT up.* FROM sales_quarterly UNPIVOT INCLUDE NULLS ( sales FOR quarter IN (q1 AS Q1, q2 AS Q2, q3 AS Q3, q4 AS Q4) ) AS up; +------+---------+-------+ | year | quarter | sales | +------+---------+-------+ | 2020 | Q1 | NULL | | 2020 | Q2 | 1000 | | 2020 | Q3 | 2000 | | 2020 | Q4 | 2500 | | 2021 | Q1 | 2250 | | 2021 | Q2 | 3200 | | 2021 | Q3 | 4200 | | 2021 | Q4 | 5900 | | 2022 | Q1 | 4200 | | 2022 | Q2 | 3100 | | 2022 | Q3 | NULL | | 2022 | Q4 | NULL | +------+---------+-------+ -- multiple value columns can be unpivoted per row SELECT * FROM sales_quarterly UNPIVOT EXCLUDE NULLS ( (first_quarter, second_quarter) FOR half_of_the_year IN ( (q1, q2) AS H1, (q3, q4) AS H2 ) ); +------+------------------+---------------+----------------+ | id | half_of_the_year | first_quarter | second_quarter | +------+------------------+---------------+----------------+ | 2020 | H1 | NULL | 1000 | | 2020 | H2 | 2000 | 2500 | | 2021 | H1 | 2250 | 3200 | | 2021 | H2 | 4200 | 5900 | | 2022 | H1 | 4200 | 3100 | +------+------------------+---------------+----------------+ ```