Fungsi array - OpenSearch Layanan Amazon

Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

Fungsi array

catatan

Untuk melihat integrasi sumber AWS data mana yang mendukung SQL perintah ini, lihat OpenSearch SQLPerintah dan fungsi yang didukung.

Fungsi Deskripsi
array (expr,...) Mengembalikan array dengan elemen yang diberikan.
array_append (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 NULL output adalah NULL
array_compact (array) Menghapus nilai null dari array.
array_contains (array, nilai) Mengembalikan nilai true jika array berisi nilai.
array_distinct (array) Menghapus nilai duplikat dari array.
array_except (array1, array2) Mengembalikan array elemen dalam array1 tetapi tidak di array2, tanpa duplikat.
array_insert (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_berpotongan (array1, array2) Mengembalikan array elemen di persimpangan array1 dan array2, tanpa duplikat.
array_join (array, pembatas [,]) nullReplacement Menggabungkan elemen array yang diberikan menggunakan pembatas dan string opsional untuk menggantikan nol. Jika tidak ada nilai yang ditetapkannullReplacement, nilai null apa pun disaring.
array_max (array) Mengembalikan nilai maksimum dalam array. NaN lebih besar dari elemen non-NaN untuk tipe double/float. NULLelemen dilewati.
array_min (larik) Mengembalikan nilai minimum dalam array. NaN lebih besar dari elemen non-NaN untuk tipe double/float. NULLelemen dilewati.
array_position (array, elemen) Mengembalikan indeks (1-based) dari elemen pencocokan pertama dari array selama, atau 0 jika tidak ada kecocokan ditemukan.
array_prepend (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 NULL output adalah NULL
array_remove (array, elemen) Hapus semua elemen yang sama dengan elemen dari array.
array_repeat (elemen, hitungan) Mengembalikan array yang berisi jumlah elemen kali.
array_union (array1, array2) Mengembalikan array elemen dalam penyatuan array1 dan array2, tanpa duplikat.
arrays_tumpang 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_zip (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 kembaliNULL.
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_array (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 tipe double/float. 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<Int>), 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<Int>), 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]|
+-----------------------------------------+