Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Array kueri
Amazon Athena memungkinkan Anda membuat larik, menggabungkan mereka, mengonversi mereka ke tipe data yang berbeda, kemudian memfilter, meratakan, dan mengurutkan mereka.
**Topics**
+ [Buat array](creating-arrays.md)
+ [Gandungkan string dan array](concatenating-strings-and-arrays.md)
+ [Mengkonversi tipe data array](converting-array-data-types.md)
+ [Temukan panjang array](finding-lengths.md)
+ [Mengakses elemen array](accessing-array-elements.md)
+ [Ratakan array bersarang](flattening-arrays.md)
+ [Buat array dari subqueries](creating-arrays-from-subqueries.md)
+ [Filter array](filtering-arrays.md)
+ [Urutkan array](sorting-arrays.md)
+ [Gunakan fungsi agregasi dengan array](arrays-and-aggregation.md)
+ [Mengkonversi array ke string](converting-arrays-to-strings.md)
+ [Gunakan array untuk membuat peta](arrays-create-maps.md)
+ [Array kueri dengan tipe kompleks](rows-and-structs.md)
# Buat array
Untuk membangun sebuah larik literal di Athena, gunakan`ARRAY`kata kunci, diikuti dengan tanda kurung`[ ]`, dan termasuk elemen larik dipisahkan dengan koma.
## Contoh
Kueri ini menciptakan satu larik dengan empat elemen.
```
SELECT ARRAY [1,2,3,4] AS items
```
Ini menghasilkan:
```
+-----------+
| items |
+-----------+
| [1,2,3,4] |
+-----------+
```
Kueri ini menciptakan dua larik.
```
SELECT ARRAY[ ARRAY[1,2], ARRAY[3,4] ] AS items
```
Ini menghasilkan:
```
+--------------------+
| items |
+--------------------+
| [[1, 2], [3, 4]] |
+--------------------+
```
Untuk membuat larik dari kolom yang dipilih dari tipe yang kompatibel, gunakan kueri, seperti dalam contoh ini:
```
WITH
dataset AS (
SELECT 1 AS x, 2 AS y, 3 AS z
)
SELECT ARRAY [x,y,z] AS items FROM dataset
```
Kueri ini kembali:
```
+-----------+
| items |
+-----------+
| [1,2,3] |
+-----------+
```
Pada contoh berikut, dua larik dipilih dan dikembalikan sebagai pesan selamat datang.
```
WITH
dataset AS (
SELECT
ARRAY ['hello', 'amazon', 'athena'] AS words,
ARRAY ['hi', 'alexa'] AS alexa
)
SELECT ARRAY[words, alexa] AS welcome_msg
FROM dataset
```
Kueri ini kembali:
```
+----------------------------------------+
| welcome_msg |
+----------------------------------------+
| [[hello, amazon, athena], [hi, alexa]] |
+----------------------------------------+
```
Untuk membuat larik pasangan nilai kunci, gunakan`MAP`operator yang mengambil larik kunci diikuti oleh larik nilai, seperti dalam contoh ini:
```
SELECT ARRAY[
MAP(ARRAY['first', 'last', 'age'],ARRAY['Bob', 'Smith', '40']),
MAP(ARRAY['first', 'last', 'age'],ARRAY['Jane', 'Doe', '30']),
MAP(ARRAY['first', 'last', 'age'],ARRAY['Billy', 'Smith', '8'])
] AS people
```
Kueri ini menghasilkan:
```
+-----------------------------------------------------------------------------------------------------+
| people |
+-----------------------------------------------------------------------------------------------------+
| [{last=Smith, first=Bob, age=40}, {last=Doe, first=Jane, age=30}, {last=Smith, first=Billy, age=8}] |
+-----------------------------------------------------------------------------------------------------+
```
# Gandungkan string dan array
String penggabungan dan array gabungan menggunakan teknik serupa.
## Senar gabungan
Untuk menggabungkan dua string, Anda dapat menggunakan alur ganda`||`operator, seperti dalam contoh berikut.
```
SELECT 'This' || ' is' || ' a' || ' test.' AS Concatenated_String
```
Kueri ini menghasilkan:
****
| \$1 | Concatenated\$1String |
| --- | --- |
| 1 | `This is a test.` |
Anda dapat menggunakan`concat()`fungsi untuk mencapai hasil yang sama.
```
SELECT concat('This', ' is', ' a', ' test.') AS Concatenated_String
```
Kueri ini menghasilkan:
****
| \$1 | Concatenated\$1String |
| --- | --- |
| 1 | `This is a test.` |
Anda dapat menggunakan `concat_ws()` fungsi untuk menggabungkan string dengan pemisah yang ditentukan dalam argumen pertama.
```
SELECT concat_ws(' ', 'This', 'is', 'a', 'test.') as Concatenated_String
```
Kueri ini menghasilkan:
****
| \$1 | Concatenated\$1String |
| --- | --- |
| 1 | `This is a test.` |
Untuk menggabungkan dua kolom tipe data string menggunakan titik, rujuk dua kolom menggunakan tanda kutip ganda, dan lampirkan titik dalam tanda kutip tunggal sebagai string hard-code. Jika kolom bukan tipe data string, Anda dapat menggunakan `CAST("column_name" as VARCHAR)` untuk mentransmisikan kolom terlebih dahulu.
```
SELECT "col1" || '.' || "col2" as Concatenated_String
FROM my_table
```
Kueri ini menghasilkan:
****
| \$1 | Concatenated\$1String |
| --- | --- |
| 1 | `col1_string_value.col2_string_value` |
## Array gabungan
Anda dapat menggunakan teknik yang sama untuk menggabungkan larik.
Untuk menggabungkan beberapa larik, menggunakan alur ganda`||`Operator.
```
SELECT ARRAY [4,5] || ARRAY[ ARRAY[1,2], ARRAY[3,4] ] AS items
```
Kueri ini menghasilkan:
****
| \$1 | item |
| --- | --- |
| 1 | `[[4, 5], [1, 2], [3, 4]]` |
Untuk menggabungkan beberapa larik ke dalam satu larik, menggunakan operator alur ganda atau`concat()`fungsi.
```
WITH
dataset AS (
SELECT
ARRAY ['Hello', 'Amazon', 'Athena'] AS words,
ARRAY ['Hi', 'Alexa'] AS alexa
)
SELECT concat(words, alexa) AS welcome_msg
FROM dataset
```
Kueri ini menghasilkan:
****
| \$1 | selamat datang\$1msg |
| --- | --- |
| 1 | `[Hello, Amazon, Athena, Hi, Alexa]` |
Untuk informasi selengkapnya tentang fungsi string `concat()` lainnya, lihat [Fungsi dan operator String](https://trino.io/docs/current/functions/string.html) dalam dokumentasi Trino.
# Mengkonversi tipe data array
Untuk mengonversi data dalam larik untuk tipe data yang didukung, gunakan`CAST`Operator, sebagai`CAST(value AS type)`. Athena mendukung semua tipe data Presto asli.
```
SELECT
ARRAY [CAST(4 AS VARCHAR), CAST(5 AS VARCHAR)]
AS items
```
Kueri ini kembali:
```
+-------+
| items |
+-------+
| [4,5] |
+-------+
```
Buat dua larik dengan elemen pasangan kunci-nilai, mengonversi mereka ke JSON, dan menggabungkan, seperti dalam contoh ini:
```
SELECT
ARRAY[CAST(MAP(ARRAY['a1', 'a2', 'a3'], ARRAY[1, 2, 3]) AS JSON)] ||
ARRAY[CAST(MAP(ARRAY['b1', 'b2', 'b3'], ARRAY[4, 5, 6]) AS JSON)]
AS items
```
Kueri ini menghasilkan:
```
+--------------------------------------------------+
| items |
+--------------------------------------------------+
| [{"a1":1,"a2":2,"a3":3}, {"b1":4,"b2":5,"b3":6}] |
+--------------------------------------------------+
```
# Temukan panjang array
Fungsi `cardinality` mengembalikan panjang larik, seperti dalam contoh ini:
```
SELECT cardinality(ARRAY[1,2,3,4]) AS item_count
```
Kueri ini mengembalikan:
```
+------------+
| item_count |
+------------+
| 4 |
+------------+
```
# Mengakses elemen array
Untuk mengakses elemen larik, gunakan`[]`operator, dengan 1 menentukan elemen pertama, 2 menentukan elemen kedua, dan seterusnya, seperti dalam contoh ini:
```
WITH dataset AS (
SELECT
ARRAY[CAST(MAP(ARRAY['a1', 'a2', 'a3'], ARRAY[1, 2, 3]) AS JSON)] ||
ARRAY[CAST(MAP(ARRAY['b1', 'b2', 'b3'], ARRAY[4, 5, 6]) AS JSON)]
AS items )
SELECT items[1] AS item FROM dataset
```
Kueri ini kembali:
```
+------------------------+
| item |
+------------------------+
| {"a1":1,"a2":2,"a3":3} |
+------------------------+
```
Untuk mengakses elemen larik pada posisi tertentu (dikenal sebagai posisi indeks), gunakan`element_at()`fungsi dan menentukan nama larik dan posisi indeks:
+ Jika indeks lebih besar dari 0,`element_at()`mengembalikan elemen yang Anda tentukan, menghitung dari awal sampai akhir larik. Berperilaku sebagai`[]`Operator.
+ Jika indeks kurang dari 0,`element_at()`mengembalikan elemen menghitung dari akhir ke awal larik.
Kueri berikut membuat larik`words`, dan memilih elemen pertama`hello`dari itu sebagai`first_word`, elemen kedua`amazon`(menghitung dari akhir larik) sebagai`middle_word`, dan elemen ketiga`athena`, sebagai`last_word`.
```
WITH dataset AS (
SELECT ARRAY ['hello', 'amazon', 'athena'] AS words
)
SELECT
element_at(words, 1) AS first_word,
element_at(words, -2) AS middle_word,
element_at(words, cardinality(words)) AS last_word
FROM dataset
```
Kueri ini menghasilkan:
```
+----------------------------------------+
| first_word | middle_word | last_word |
+----------------------------------------+
| hello | amazon | athena |
+----------------------------------------+
```
# Ratakan array bersarang
Saat bekerja dengan larik nest, Anda sering perlu memperluas elemen larik nest ke dalam satu larik, atau memperluas larik menjadi beberapa baris.
## Gunakan fungsi meratakan
Untuk meratakan elemen larik nest ini ke dalam satu larik nilai, gunakan`flatten`fungsi. Kueri ini mengembalikan baris untuk setiap elemen dalam larik.
```
SELECT flatten(ARRAY[ ARRAY[1,2], ARRAY[3,4] ]) AS items
```
Kueri ini menghasilkan:
```
+-----------+
| items |
+-----------+
| [1,2,3,4] |
+-----------+
```
## Gunakan CROSS JOIN dan UNNEST
Untuk meratakan larik menjadi beberapa baris, gunakan`CROSS JOIN`dalam hubungannya dengan`UNNEST`operator, seperti dalam contoh ini:
```
WITH dataset AS (
SELECT
'engineering' as department,
ARRAY['Sharon', 'John', 'Bob', 'Sally'] as users
)
SELECT department, names FROM dataset
CROSS JOIN UNNEST(users) as t(names)
```
Kueri ini kembali:
```
+----------------------+
| department | names |
+----------------------+
| engineering | Sharon |
+----------------------|
| engineering | John |
+----------------------|
| engineering | Bob |
+----------------------|
| engineering | Sally |
+----------------------+
```
Untuk meratakan larik pasangan kunci-nilai, transpose kunci yang dipilih ke dalam kolom, seperti dalam contoh ini:
```
WITH
dataset AS (
SELECT
'engineering' as department,
ARRAY[
MAP(ARRAY['first', 'last', 'age'],ARRAY['Bob', 'Smith', '40']),
MAP(ARRAY['first', 'last', 'age'],ARRAY['Jane', 'Doe', '30']),
MAP(ARRAY['first', 'last', 'age'],ARRAY['Billy', 'Smith', '8'])
] AS people
)
SELECT names['first'] AS
first_name,
names['last'] AS last_name,
department FROM dataset
CROSS JOIN UNNEST(people) AS t(names)
```
Kueri ini kembali:
```
+--------------------------------------+
| first_name | last_name | department |
+--------------------------------------+
| Bob | Smith | engineering |
| Jane | Doe | engineering |
| Billy | Smith | engineering |
+--------------------------------------+
```
Dari daftar karyawan, pilih karyawan dengan skor gabungan tertinggi.`UNNEST`dapat digunakan dalam`FROM`klausul tanpa sebelumnya`CROSS JOIN`karena merupakan default bergabung operator dan karena itu tersirat.
```
WITH
dataset AS (
SELECT ARRAY[
CAST(ROW('Sally', 'engineering', ARRAY[1,2,3,4]) AS ROW(name VARCHAR, department VARCHAR, scores ARRAY(INTEGER))),
CAST(ROW('John', 'finance', ARRAY[7,8,9]) AS ROW(name VARCHAR, department VARCHAR, scores ARRAY(INTEGER))),
CAST(ROW('Amy', 'devops', ARRAY[12,13,14,15]) AS ROW(name VARCHAR, department VARCHAR, scores ARRAY(INTEGER)))
] AS users
),
users AS (
SELECT person, score
FROM
dataset,
UNNEST(dataset.users) AS t(person),
UNNEST(person.scores) AS t(score)
)
SELECT person.name, person.department, SUM(score) AS total_score FROM users
GROUP BY (person.name, person.department)
ORDER BY (total_score) DESC
LIMIT 1
```
Kueri ini kembali:
```
+---------------------------------+
| name | department | total_score |
+---------------------------------+
| Amy | devops | 54 |
+---------------------------------+
```
Dari daftar karyawan, pilih karyawan dengan skor individu tertinggi.
```
WITH
dataset AS (
SELECT ARRAY[
CAST(ROW('Sally', 'engineering', ARRAY[1,2,3,4]) AS ROW(name VARCHAR, department VARCHAR, scores ARRAY(INTEGER))),
CAST(ROW('John', 'finance', ARRAY[7,8,9]) AS ROW(name VARCHAR, department VARCHAR, scores ARRAY(INTEGER))),
CAST(ROW('Amy', 'devops', ARRAY[12,13,14,15]) AS ROW(name VARCHAR, department VARCHAR, scores ARRAY(INTEGER)))
] AS users
),
users AS (
SELECT person, score
FROM
dataset,
UNNEST(dataset.users) AS t(person),
UNNEST(person.scores) AS t(score)
)
SELECT person.name, score FROM users
ORDER BY (score) DESC
LIMIT 1
```
Kueri ini menghasilkan:
```
+--------------+
| name | score |
+--------------+
| Amy | 15 |
+--------------+
```
### Pertimbangan untuk CROSS JOIN dan UNNEST
Jika `UNNEST` digunakan pada satu atau lebih array dalam query, dan salah satu array adalah`NULL`, query tidak mengembalikan baris. Jika `UNNEST` digunakan pada array yang merupakan string kosong, string kosong dikembalikan.
Misalnya, dalam query berikut, karena array kedua adalah null, query tidak mengembalikan baris.
```
SELECT
col1,
col2
FROM UNNEST (ARRAY ['apples','oranges','lemons']) AS t(col1)
CROSS JOIN UNNEST (ARRAY []) AS t(col2)
```
Dalam contoh berikutnya, array kedua dimodifikasi untuk berisi string kosong. Untuk setiap baris, query mengembalikan nilai dalam `col1` dan string kosong untuk nilai dalam`col2`. String kosong dalam array kedua diperlukan agar nilai-nilai dalam array pertama dikembalikan.
```
SELECT
col1,
col2
FROM UNNEST (ARRAY ['apples','oranges','lemons']) AS t(col1)
CROSS JOIN UNNEST (ARRAY ['']) AS t(col2)
```
# Buat array dari subqueries
Buat larik dari koleksi baris.
```
WITH
dataset AS (
SELECT ARRAY[1,2,3,4,5] AS items
)
SELECT array_agg(i) AS array_items
FROM dataset
CROSS JOIN UNNEST(items) AS t(i)
```
Kueri ini kembali:
```
+-----------------+
| array_items |
+-----------------+
| [1, 2, 3, 4, 5] |
+-----------------+
```
Untuk membuat larik nilai unik dari satu set baris, gunakan`distinct`kata kunci.
```
WITH
dataset AS (
SELECT ARRAY [1,2,2,3,3,4,5] AS items
)
SELECT array_agg(distinct i) AS array_items
FROM dataset
CROSS JOIN UNNEST(items) AS t(i)
```
Kueri ini akan mengembalikan hasil berikut. Perhatikan bahwa pemesanan tidak dijamin.
```
+-----------------+
| array_items |
+-----------------+
| [1, 2, 3, 4, 5] |
+-----------------+
```
Untuk informasi selengkapnya tentang penggunaan `array_agg` fungsi, lihat [Fungsi agregat](https://trino.io/docs/current/functions/aggregate.html) dalam dokumentasi Trino.
# Filter array
Membuat larik dari koleksi baris jika mereka cocok dengan kriteria filter.
```
WITH
dataset AS (
SELECT ARRAY[1,2,3,4,5] AS items
)
SELECT array_agg(i) AS array_items
FROM dataset
CROSS JOIN UNNEST(items) AS t(i)
WHERE i > 3
```
Kueri ini kembali:
```
+-------------+
| array_items |
+-------------+
| [4, 5] |
+-------------+
```
Filter larik berdasarkan apakah salah satu unsur-unsurnya mengandung nilai tertentu, seperti 2, seperti dalam contoh ini:
```
WITH
dataset AS (
SELECT ARRAY
[
ARRAY[1,2,3,4],
ARRAY[5,6,7,8],
ARRAY[9,0]
] AS items
)
SELECT i AS array_items FROM dataset
CROSS JOIN UNNEST(items) AS t(i)
WHERE contains(i, 2)
```
Kueri ini menghasilkan:
```
+--------------+
| array_items |
+--------------+
| [1, 2, 3, 4] |
+--------------+
```
## Gunakan `filter` fungsi
```
filter(ARRAY [list_of_values], boolean_function)
```
Anda dapat menggunakan `filter` fungsi pada `ARRAY` ekspresi untuk membuat array baru yang merupakan bagian dari item dalam *list\$1of\$1values* yang *boolean\$1function* benar. `filter`Fungsi ini dapat berguna dalam kasus di mana Anda tidak dapat menggunakan *UNNEST* fungsi tersebut.
Contoh berikut filter untuk nilai yang lebih besar dari nol dalam array`[1,0,5,-1]`.
```
SELECT filter(ARRAY [1,0,5,-1], x -> x>0)
```
**Hasil**
`[1,5]`
Contoh berikut filter untuk nilai-nilai non-null dalam array. `[-1, NULL, 10, NULL]`
```
SELECT filter(ARRAY [-1, NULL, 10, NULL], q -> q IS NOT NULL)
```
**Hasil**
`[-1,10]`
# Urutkan array
Untuk membuat larik diurutkan nilai-nilai unik dari satu set baris, Anda dapat menggunakan[array\$1sort](https://prestodb.io/docs/current/functions/array.html#array_sort), seperti dalam contoh berikut.
```
WITH
dataset AS (
SELECT ARRAY[3,1,2,5,2,3,6,3,4,5] AS items
)
SELECT array_sort(array_agg(distinct i)) AS array_items
FROM dataset
CROSS JOIN UNNEST(items) AS t(i)
```
Kueri ini menghasilkan:
```
+--------------------+
| array_items |
+--------------------+
| [1, 2, 3, 4, 5, 6] |
+--------------------+
```
Untuk informasi tentang memperluas array menjadi beberapa baris, lihat[Ratakan array bersarang](flattening-arrays.md).
# Gunakan fungsi agregasi dengan array
+ Untuk menambahkan nilai dalam larik, gunakan`SUM`, seperti dalam contoh berikut.
+ Untuk agregat beberapa baris dalam larik, gunakan`array_agg`. Untuk informasi, lihat [Buat array dari subqueries](creating-arrays-from-subqueries.md).
**catatan**
`ORDER BY`didukung untuk fungsi agregasi dimulai pada mesin Athena versi 2.
```
WITH
dataset AS (
SELECT ARRAY
[
ARRAY[1,2,3,4],
ARRAY[5,6,7,8],
ARRAY[9,0]
] AS items
),
item AS (
SELECT i AS array_items
FROM dataset, UNNEST(items) AS t(i)
)
SELECT array_items, sum(val) AS total
FROM item, UNNEST(array_items) AS t(val)
GROUP BY array_items;
```
Pada akhirnya`SELECT`pernyataan, bukan menggunakan`sum()`dan`UNNEST`, Anda dapat menggunakan`reduce()`untuk mengurangi waktu pemrosesan dan transfer data, seperti dalam contoh berikut.
```
WITH
dataset AS (
SELECT ARRAY
[
ARRAY[1,2,3,4],
ARRAY[5,6,7,8],
ARRAY[9,0]
] AS items
),
item AS (
SELECT i AS array_items
FROM dataset, UNNEST(items) AS t(i)
)
SELECT array_items, reduce(array_items, 0 , (s, x) -> s + x, s -> s) AS total
FROM item;
```
DKueri berikut mengembalikan hasil ini. Urutan hasil yang dikembalikan tidak dijamin.
```
+----------------------+
| array_items | total |
+----------------------+
| [1, 2, 3, 4] | 10 |
| [5, 6, 7, 8] | 26 |
| [9, 0] | 9 |
+----------------------+
```
# Mengkonversi array ke string
Untuk mengonversi larik menjadi string tunggal, gunakan`array_join`fungsi. Contoh mandiri berikut membuat tabel yang disebut`dataset`yang berisi sebuah larik alias disebut`words`. Penggunaan kueri`array_join`untuk bergabung dengan elemen larik di`words`, memisahkan mereka dengan spasi, dan mengembalikan string yang dihasilkan dalam kolom alias disebut`welcome_msg`.
```
WITH
dataset AS (
SELECT ARRAY ['hello', 'amazon', 'athena'] AS words
)
SELECT array_join(words, ' ') AS welcome_msg
FROM dataset
```
Kueri ini menghasilkan:
```
+---------------------+
| welcome_msg |
+---------------------+
| hello amazon athena |
+---------------------+
```
# Gunakan array untuk membuat peta
Peta adalah pasangan kunci-nilai yang terdiri dari tipe data yang tersedia di Athena. Untuk membuat peta, gunakan`MAP`operator dan lulus dua larik: yang pertama adalah kolom (kunci) nama, dan yang kedua adalah nilai-nilai. Semua nilai dalam larik harus dari tipe yang sama. Jika salah satu elemen nilai larik peta harus dari berbagai tipe, Anda dapat mengonversi mereka nanti.
## Contoh
Contoh ini memilih pengguna dari set data. Menggunakan`MAP`operator dan melewati dua larik. Larik pertama mencakup nilai-nilai untuk nama kolom, seperti “pertama”, “terakhir”, dan “usia”. Larik kedua terdiri dari nilai untuk masing-masing kolom ini, seperti “Bob”, “Smith”, “35".
```
WITH dataset AS (
SELECT MAP(
ARRAY['first', 'last', 'age'],
ARRAY['Bob', 'Smith', '35']
) AS user
)
SELECT user FROM dataset
```
Kueri ini kembali:
```
+---------------------------------+
| user |
+---------------------------------+
| {last=Smith, first=Bob, age=35} |
+---------------------------------+
```
Anda dapat mengambil`Map`nilai dengan memilih nama field diikuti oleh`[key_name]`, seperti dalam contoh ini:
```
WITH dataset AS (
SELECT MAP(
ARRAY['first', 'last', 'age'],
ARRAY['Bob', 'Smith', '35']
) AS user
)
SELECT user['first'] AS first_name FROM dataset
```
Kueri ini menghasilkan:
```
+------------+
| first_name |
+------------+
| Bob |
+------------+
```
# Array kueri dengan tipe kompleks dan struktur bersarang
Data sumber Anda sering berisi larik dengan tipe data yang kompleks dan struktur nest. Contoh dalam bagian ini menunjukkan bagaimana mengubah tipe data elemen, menemukan elemen dalam larik, dan menemukan kata kunci menggunakan kueri Athena.
**Topics**
+ [Buat `ROW`](creating-row.md)
+ [Ubah nama bidang dalam array menggunakan `CAST`](changing-row-arrays-with-cast.md)
+ [Filter array menggunakan notasi `.`](filtering-with-dot.md)
+ [Filter array dengan nilai bersarang](filtering-nested-with-dot.md)
+ [Filter array menggunakan `UNNEST`](filtering-with-unnest.md)
+ [Temukan kata kunci dalam array menggunakan `regexp_like`](filtering-with-regexp.md)
# Buat `ROW`
**catatan**
Contoh dalam bagian ini menggunakan`ROW`sebagai sarana untuk membuat data sampel untuk bekerja dengan. Saat Anda kueri tabel dalam Athena, Anda tidak perlu membuat`ROW`jenis data, karena mereka telah dibuat dari sumber data Anda. Saat Anda menggunakan`CREATE_TABLE`, Athena mendefinisikan`STRUCT`di dalamnya, mengisi dengan data, dan menciptakan`ROW`tipe data untuk Anda, untuk setiap baris dalam set data. Yang mendasari`ROW`tipe data terdiri dari bidang bernama dari setiap tipe data SQL yang didukung.
```
WITH dataset AS (
SELECT
ROW('Bob', 38) AS users
)
SELECT * FROM dataset
```
Kueri ini menghasilkan:
```
+-------------------------+
| users |
+-------------------------+
| {field0=Bob, field1=38} |
+-------------------------+
```
# Ubah nama bidang dalam array menggunakan `CAST`
Untuk mengubah nama field dalam larik yang berisi`ROW`nilai, Anda dapat`CAST`yang`ROW`deklarasi:
```
WITH dataset AS (
SELECT
CAST(
ROW('Bob', 38) AS ROW(name VARCHAR, age INTEGER)
) AS users
)
SELECT * FROM dataset
```
Kueri ini kembali:
```
+--------------------+
| users |
+--------------------+
| {NAME=Bob, AGE=38} |
+--------------------+
```
**catatan**
Pada contoh di atas, Anda menyatakan`name`sebagai`VARCHAR`karena ini adalah jenisnya di Presto. Jika Anda menyatakan hal ini`STRUCT`di dalam`CREATE TABLE`pernyataan, gunakan`String`jenis karena Hive mendefinisikan tipe data ini sebagai`String`.
# Filter array menggunakan notasi `.`
Dalam contoh berikut, pilih `accountId` bidang dari `userIdentity` kolom tabel AWS CloudTrail log dengan menggunakan `.` notasi titik. Untuk informasi selengkapnya, lihat [Menanyakan AWS CloudTrail Log](cloudtrail-logs.md).
```
SELECT
CAST(useridentity.accountid AS bigint) as newid
FROM cloudtrail_logs
LIMIT 2;
```
Kueri ini menghasilkan:
```
+--------------+
| newid |
+--------------+
| 112233445566 |
+--------------+
| 998877665544 |
+--------------+
```
Untuk kueri larik nilai, masalah kueri ini:
```
WITH dataset AS (
SELECT ARRAY[
CAST(ROW('Bob', 38) AS ROW(name VARCHAR, age INTEGER)),
CAST(ROW('Alice', 35) AS ROW(name VARCHAR, age INTEGER)),
CAST(ROW('Jane', 27) AS ROW(name VARCHAR, age INTEGER))
] AS users
)
SELECT * FROM dataset
```
Ini mengembalikan hasil ini:
```
+-----------------------------------------------------------------+
| users |
+-----------------------------------------------------------------+
| [{NAME=Bob, AGE=38}, {NAME=Alice, AGE=35}, {NAME=Jane, AGE=27}] |
+-----------------------------------------------------------------+
```
# Filter array dengan nilai bersarang
Larik besar sering mengandung struktur nest, dan Anda harus dapat memfilter, atau mencari, untuk nilai-nilai di dalamnya.
Untuk menentukan set data untuk larik nilai yang mencakup bersarang`BOOLEAN`nilai, masalah kueri ini:
```
WITH dataset AS (
SELECT
CAST(
ROW('aws.amazon.com', ROW(true)) AS ROW(hostname VARCHAR, flaggedActivity ROW(isNew BOOLEAN))
) AS sites
)
SELECT * FROM dataset
```
Ini mengembalikan hasil ini:
```
+----------------------------------------------------------+
| sites |
+----------------------------------------------------------+
| {HOSTNAME=aws.amazon.com, FLAGGEDACTIVITY={ISNEW=true}} |
+----------------------------------------------------------+
```
Selanjutnya, untuk memfilter dan mengakses`BOOLEAN`nilai dari elemen itu, terus menggunakan titik`.`notasi.
```
WITH dataset AS (
SELECT
CAST(
ROW('aws.amazon.com', ROW(true)) AS ROW(hostname VARCHAR, flaggedActivity ROW(isNew BOOLEAN))
) AS sites
)
SELECT sites.hostname, sites.flaggedactivity.isnew
FROM dataset
```
Kueri ini memilih bidang nest dan mengembalikan hasil ini:
```
+------------------------+
| hostname | isnew |
+------------------------+
| aws.amazon.com | true |
+------------------------+
```
# Filter array menggunakan `UNNEST`
Untuk memfilter larik yang mencakup struktur nest oleh salah satu elemen anaknya, mengeluarkan kueri dengan`UNNEST`Operator. Untuk informasi selengkapnya tentang`UNNEST`, lihat[Perataan Larik Nest](flattening-arrays.md).
Misalnya, kueri ini menemukan nama host situs dalam kumpulan data.
```
WITH dataset AS (
SELECT ARRAY[
CAST(
ROW('aws.amazon.com', ROW(true)) AS ROW(hostname VARCHAR, flaggedActivity ROW(isNew BOOLEAN))
),
CAST(
ROW('news.cnn.com', ROW(false)) AS ROW(hostname VARCHAR, flaggedActivity ROW(isNew BOOLEAN))
),
CAST(
ROW('netflix.com', ROW(false)) AS ROW(hostname VARCHAR, flaggedActivity ROW(isNew BOOLEAN))
)
] as items
)
SELECT sites.hostname, sites.flaggedActivity.isNew
FROM dataset, UNNEST(items) t(sites)
WHERE sites.flaggedActivity.isNew = true
```
Ini menghasilkan:
```
+------------------------+
| hostname | isnew |
+------------------------+
| aws.amazon.com | true |
+------------------------+
```
# Temukan kata kunci dalam array menggunakan `regexp_like`
Contoh berikut menggambarkan cara mencari set data untuk kata kunci dalam elemen dalam larik, menggunakan[regexp\$1like](https://prestodb.io/docs/current/functions/regexp.html)fungsi. Dibutuhkan sebagai masukan pola ekspresi reguler untuk mengevaluasi, atau daftar istilah dipisahkan oleh alur (\$1), mengevaluasi pola, dan menentukan apakah string yang ditentukan berisi itu.
Pola ekspresi reguler perlu terkandung dalam string, dan tidak harus mencocokkannya. Untuk mencocokkan seluruh string, lampirkan pola dengan ^ di awal itu, dan \$1 di akhir, seperti`'^pattern$'`.
Pertimbangkan berbagai situs yang berisi nama host mereka, dan `flaggedActivity` elemen. Elemen ini mencakup`ARRAY`, berisi beberapa`MAP`elemen, setiap daftar kata kunci populer yang berbeda dan jumlah popularitas mereka. Asumsikan Anda ingin menemukan kata kunci tertentu di dalam `MAP` di larik ini.
Untuk mencari set data ini untuk situs dengan kata kunci tertentu, kami menggunakan`regexp_like`bukan SQL yang sama`LIKE`operator, karena mencari sejumlah besar kata kunci lebih efisien dengan`regexp_like`.
**Example Contoh 1: Menggunakan`regexp_like`**
Kueri dalam contoh ini menggunakan fungsi `regexp_like` untuk mencari istilah `'politics|bigdata'`, ditemukan dalam nilai-nilai dalam larik:
```
WITH dataset AS (
SELECT ARRAY[
CAST(
ROW('aws.amazon.com', ROW(ARRAY[
MAP(ARRAY['term', 'count'], ARRAY['bigdata', '10']),
MAP(ARRAY['term', 'count'], ARRAY['serverless', '50']),
MAP(ARRAY['term', 'count'], ARRAY['analytics', '82']),
MAP(ARRAY['term', 'count'], ARRAY['iot', '74'])
])
) AS ROW(hostname VARCHAR, flaggedActivity ROW(flags ARRAY(MAP(VARCHAR, VARCHAR)) ))
),
CAST(
ROW('news.cnn.com', ROW(ARRAY[
MAP(ARRAY['term', 'count'], ARRAY['politics', '241']),
MAP(ARRAY['term', 'count'], ARRAY['technology', '211']),
MAP(ARRAY['term', 'count'], ARRAY['serverless', '25']),
MAP(ARRAY['term', 'count'], ARRAY['iot', '170'])
])
) AS ROW(hostname VARCHAR, flaggedActivity ROW(flags ARRAY(MAP(VARCHAR, VARCHAR)) ))
),
CAST(
ROW('netflix.com', ROW(ARRAY[
MAP(ARRAY['term', 'count'], ARRAY['cartoons', '1020']),
MAP(ARRAY['term', 'count'], ARRAY['house of cards', '112042']),
MAP(ARRAY['term', 'count'], ARRAY['orange is the new black', '342']),
MAP(ARRAY['term', 'count'], ARRAY['iot', '4'])
])
) AS ROW(hostname VARCHAR, flaggedActivity ROW(flags ARRAY(MAP(VARCHAR, VARCHAR)) ))
)
] AS items
),
sites AS (
SELECT sites.hostname, sites.flaggedactivity
FROM dataset, UNNEST(items) t(sites)
)
SELECT hostname
FROM sites, UNNEST(sites.flaggedActivity.flags) t(flags)
WHERE regexp_like(flags['term'], 'politics|bigdata')
GROUP BY (hostname)
```
Kueri ini mengembalikan dua situs:
```
+----------------+
| hostname |
+----------------+
| aws.amazon.com |
+----------------+
| news.cnn.com |
+----------------+
```
**Example Contoh 2: Menggunakan`regexp_like`**
Kueri dalam contoh berikut menambahkan skor popularitas total untuk situs yang cocok dengan istilah pencarian Anda dengan`regexp_like`fungsi, kemudian perintah mereka dari tertinggi ke terendah.
```
WITH dataset AS (
SELECT ARRAY[
CAST(
ROW('aws.amazon.com', ROW(ARRAY[
MAP(ARRAY['term', 'count'], ARRAY['bigdata', '10']),
MAP(ARRAY['term', 'count'], ARRAY['serverless', '50']),
MAP(ARRAY['term', 'count'], ARRAY['analytics', '82']),
MAP(ARRAY['term', 'count'], ARRAY['iot', '74'])
])
) AS ROW(hostname VARCHAR, flaggedActivity ROW(flags ARRAY(MAP(VARCHAR, VARCHAR)) ))
),
CAST(
ROW('news.cnn.com', ROW(ARRAY[
MAP(ARRAY['term', 'count'], ARRAY['politics', '241']),
MAP(ARRAY['term', 'count'], ARRAY['technology', '211']),
MAP(ARRAY['term', 'count'], ARRAY['serverless', '25']),
MAP(ARRAY['term', 'count'], ARRAY['iot', '170'])
])
) AS ROW(hostname VARCHAR, flaggedActivity ROW(flags ARRAY(MAP(VARCHAR, VARCHAR)) ))
),
CAST(
ROW('netflix.com', ROW(ARRAY[
MAP(ARRAY['term', 'count'], ARRAY['cartoons', '1020']),
MAP(ARRAY['term', 'count'], ARRAY['house of cards', '112042']),
MAP(ARRAY['term', 'count'], ARRAY['orange is the new black', '342']),
MAP(ARRAY['term', 'count'], ARRAY['iot', '4'])
])
) AS ROW(hostname VARCHAR, flaggedActivity ROW(flags ARRAY(MAP(VARCHAR, VARCHAR)) ))
)
] AS items
),
sites AS (
SELECT sites.hostname, sites.flaggedactivity
FROM dataset, UNNEST(items) t(sites)
)
SELECT hostname, array_agg(flags['term']) AS terms, SUM(CAST(flags['count'] AS INTEGER)) AS total
FROM sites, UNNEST(sites.flaggedActivity.flags) t(flags)
WHERE regexp_like(flags['term'], 'politics|bigdata')
GROUP BY (hostname)
ORDER BY total DESC
```
Kueri ini mengembalikan dua situs:
```
+------------------------------------+
| hostname | terms | total |
+----------------+-------------------+
| news.cnn.com | politics | 241 |
+----------------+-------------------+
| aws.amazon.com | bigdata | 10 |
+----------------+-------------------+
```