Amazon Redshift tidak akan lagi mendukung pembuatan Python UDFs baru mulai Patch 198. Python yang ada UDFs akan terus berfungsi hingga 30 Juni 2026. Untuk informasi lebih lanjut, lihat [posting blog](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/). Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris. # Operator dan fungsi Dengan Amazon Redshift, Anda dapat melakukan analisis lanjutan pada kumpulan data besar menggunakan data SUPER menggunakan operator dan fungsi. Operator dan fungsi untuk data SUPER adalah konstruksi SQL yang memungkinkan analisis kompleks dan manipulasi data semi-terstruktur yang disimpan dalam tabel Amazon Redshift. Bagian berikut akan mencakup sintaks, contoh, dan praktik terbaik untuk menggunakan operator dan fungsi untuk data SUPER di Amazon Redshift untuk membuka potensi penuh data semi-terstruktur Anda. ## Operator aritmatika Nilai SUPER mendukung semua operator aritmatika dasar \$1, -, \$1,/,% menggunakan pengetikan dinamis. Jenis operasi yang dihasilkan tetap sebagai SUPER. Untuk semua operator, kecuali operator biner \$1, operan input harus berupa angka. Jika tidak, Amazon Redshift mengembalikan nol. Perbedaan antara nilai desimal dan floating-point dipertahankan saat Amazon Redshift menjalankan operator ini dan tipe dinamis tidak berubah. Namun, skala desimal berubah saat Anda menggunakan perkalian dan pembagian. Limpahan aritmatika masih menyebabkan kesalahan kueri, mereka tidak diubah menjadi null. Operator biner\$1melakukan penambahan jika inputnya adalah angka atau penggabungan jika inputnya adalah string. Jika satu operan adalah string dan operan lainnya adalah angka, hasilnya adalah nol. Operator awalan unary \$1 dan - mengembalikan null jika nilai SUPER bukan angka seperti yang ditunjukkan pada contoh berikut: ``` SELECT (c_orders[0]. o_orderkey + 0.5) * c_orders[0]. o_orderkey / 10 AS math FROM customer_orders_lineitem; math ---------------------------- 1757958232200.1500 (1 row) ``` Pengetikan dinamis memungkinkan nilai desimal di SUPER memiliki skala yang berbeda. Amazon Redshift memperlakukan nilai desimal seolah-olah mereka adalah tipe statis yang berbeda dan memungkinkan semua operasi matematika. Amazon Redshift menghitung skala yang dihasilkan secara dinamis berdasarkan skala operan. Jika salah satu operan adalah angka floating-point, maka Amazon Redshift mempromosikan operan lainnya ke nomor floating-point dan menghasilkan hasilnya sebagai angka floating-point. ## Fungsi aritmatika Amazon Redshift mendukung fungsi aritmatika berikut untuk kolom SUPER. Mereka mengembalikan null jika inputnya bukan angka: + LANTAI. Untuk informasi selengkapnya, lihat [Fungsi FLOOR](r_FLOOR.md). + CEIL dan LANGIT-LANGIT. Untuk informasi selengkapnya, lihat [Fungsi CEILING (atau CEIL)](r_CEILING_FLOOR.md). + BULAT. Untuk informasi selengkapnya, lihat [Fungsi ROUND](r_ROUND.md). + BATANG. Untuk informasi selengkapnya, lihat [Fungsi TRUNC](r_TRUNC.md). + PERUT. Untuk informasi selengkapnya, lihat [Fungsi ABS](r_ABS.md). Contoh berikut menggunakan fungsi aritmatika untuk query data: ``` SELECT x, FLOOR(x), CEIL(x), ROUND(x) FROM ( SELECT (c_orders[0]. o_orderkey + 0.5) * c_orders[0].o_orderkey / 10 AS x FROM customer_orders_lineitem ); x | floor | ceil | round --------------------+---------------+---------------+--------------- 1389636795898.0500 | 1389636795898 | 1389636795899 | 1389636795898 ``` Fungsi ABS mempertahankan skala desimal input sementara FLOOR, CEIL. ROUND menghilangkan skala desimal input. ## Fungsi array Amazon Redshift mendukung komposisi array dan fungsi utilitas berikut: + ARRAY. Untuk informasi selengkapnya, lihat [Fungsi ARRAY](r_array.md). + ARRAY\$1CONCAT. Untuk informasi selengkapnya, lihat [Fungsi ARRAY\$1CONCAT](r_array_concat.md). + ARRAY\$1CONTAINS. Untuk informasi selengkapnya, lihat [Fungsi ARRAY\$1CONTAINS](array_contains.md). + ARRAY\$1DISTINCT. Untuk informasi selengkapnya, lihat [Fungsi ARRAY\$1DISTINCT](array_distinct.md). + ARRAY\$1EXCEPT. Untuk informasi selengkapnya, lihat [Fungsi ARRAY\$1EXCEPLE](array_except.md). + ARRAY\$1RATAKAN. Untuk informasi selengkapnya, lihat [Fungsi ARRAY\$1FLATTEN](array_flatten.md). + ARRAY\$1PERSIMPANGAN. Untuk informasi selengkapnya, lihat [Fungsi ARRAY\$1INTERSECTION](array_intersection.md). + ARRAY\$1POSISI. Untuk informasi selengkapnya, lihat [Fungsi ARRAY\$1POSITION](array_position.md). + ARRAY\$1POSITIONS. Untuk informasi selengkapnya, lihat [Fungsi ARRAY\$1POSITIONS](array_positions.md). + ARRAY\$1SORT. Untuk informasi selengkapnya, lihat [Fungsi ARRAY\$1SORT](array_sort.md). + ARRAY\$1UNION. Untuk informasi selengkapnya, lihat [Fungsi ARRAY\$1UNION](array_union.md). + ARRAYS\$1TUMPANG TINDIH. Untuk informasi selengkapnya, lihat [Fungsi ARRAYS\$1OVERLAP](arrays_overlap.md). + GET\$1ARRAY\$1LENGTH. Untuk informasi selengkapnya, lihat [Fungsi GET\$1ARRAY\$1LENGTH](get_array_length.md). + SPLIT\$1TO\$1ARRAY. Untuk informasi selengkapnya, lihat [Fungsi SPLIT\$1TO\$1ARRAY](split_to_array.md). + SUBARRAY. Untuk informasi selengkapnya, lihat [Fungsi SUBARRAY](r_subarray.md). Anda dapat membuat array SUPER dari nilai dalam tipe data Amazon Redshift menggunakan fungsi ARRAY, termasuk nilai SUPER lainnya. Contoh berikut menggunakan fungsi variadik ARRAY: ``` SELECT ARRAY(1, c.c_custkey, NULL, c.c_name, 'abc') FROM customer_orders_lineitem c; array ------------------------------------------------------- [1,8401,null,""Customer#000008401"",""abc""] [1,9452,null,""Customer#000009452"",""abc""] [1,9451,null,""Customer#000009451"",""abc""] [1,8251,null,""Customer#000008251"",""abc""] [1,5851,null,""Customer#000005851"",""abc""] (5 rows) ``` Contoh berikut menggunakan rangkaian array dengan fungsi ARRAY\$1CONCAT: ``` SELECT ARRAY_CONCAT(JSON_PARSE('[10001,10002]'),JSON_PARSE('[10003,10004]')); array_concat ------------------------------------ [10001,10002,10003,10004] (1 row) ``` Contoh berikut menggunakan manipulasi array dengan fungsi SUBARRAY yang mengembalikan subset dari array input. ``` SELECT SUBARRAY(ARRAY('a', 'b', 'c', 'd', 'e', 'f'), 2, 3); subarray --------------- ["c","d","e"] (1 row)) ``` Contoh berikut menggabungkan beberapa tingkat array ke dalam array tunggal menggunakan ARRAY\$1FLATTEN: ``` SELECT x, ARRAY_FLATTEN(x) FROM (SELECT ARRAY(1, ARRAY(2, ARRAY(3, ARRAY()))) AS x); x | array_flatten ----------------+--------------- [1,[2,[3,[]]]] | [1,2,3] (1 row) ``` Fungsi array ARRAY\$1CONCAT dan ARRAY\$1FLATTEN menggunakan aturan pengetikan dinamis. Mereka mengembalikan null alih-alih kesalahan jika input bukan array. Fungsi GET\$1ARRAY\$1LENGTH mengembalikan panjang array SUPER diberikan objek atau jalur array. ``` SELECT c_name FROM customer_orders_lineitem WHERE GET_ARRAY_LENGTH(c_orders) = ( SELECT MAX(GET_ARRAY_LENGTH(c_orders)) FROM customer_orders_lineitem ); ``` Contoh berikut membagi string ke array string menggunakan SPLIT\$1TO\$1ARRAY. Fungsi ini menggunakan pembatas sebagai parameter opsional. Jika tidak ada pembatas yang tidak ada, maka defaultnya adalah koma. ``` SELECT SPLIT_TO_ARRAY('12|345|6789', '|'); split_to_array --------------------- ["12","345","6789"] (1 row) ``` ## Perilaku pengumpulan [Dengan SUPER, Anda dapat mengatur pemeriksaan kolom dengan [CREATE TABLE](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_TABLE_NEW.html), mengambil set pemeriksaan default dengan [CREATE DATABASE](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_DATABASE.html), dan mengatur pemeriksaan ekspresi dengan fungsi COLLATE.](https://docs.aws.amazon.com/redshift/latest/dg/r_COLLATE.html) Pengaturan pemeriksaan berlaku untuk semua operator perbandingan dan nilai string yang disimpan di SUPER, apakah itu nilai string, string di dalam array SUPER, atau nilai objek SUPER. Untuk objek SUPER, perilaku pemeriksaan hanya berlaku untuk nilai dan bukan pada atribut. Misalnya, perbandingan nilai yang memiliki pemeriksaan case insensitive mengembalikan true, sementara `{"attribute": "a"} = {"attribute": "A"}` `{"attribute": "a"} = {"ATTRIBUTE": "a"}` mengembalikan false. ## Fungsi informasi Kolom data SUPER mendukung fungsi inspeksi yang mengembalikan tipe dinamis dan informasi tipe lainnya tentang nilai SUPER. Contoh paling umum adalah fungsi skalar JSON\$1TYPEOF yang mengembalikan VARCHAR dengan nilai boolean, number, string, object, array, atau null, tergantung pada tipe dinamis dari nilai SUPER. Amazon Redshift mendukung fungsi boolean berikut untuk kolom data SUPER: + [Fungsi IS\$1ARRAY](r_is_array.md) + [Fungsi IS\$1BIGINT](r_is_bigint.md) + [Fungsi IS\$1CHAR](r_is_char.md) + [Fungsi IS\$1DECIMAL](r_is_decimal.md) + [Fungsi IS\$1FLOAT](r_is_float.md) + [Fungsi IS\$1INTEGER](r_is_integer.md) + [fungsi IS\$1OBJECT](r_is_object.md) + [Fungsi IS\$1SCALAR](r_is_scalar.md) + [Fungsi IS\$1SMALLINT](r_is_smallint.md) + [Fungsi IS\$1VARCHAR](r_is_varchar.md) Untuk informasi selengkapnya tentang fungsi informasi tipe SUPER, lihat[Fungsi informasi tipe SUPER](c_Type_Info_Functions.md). ## Fungsi objek Berikut ini adalah fungsi objek SQL yang didukung Amazon Redshift untuk membuat dan mengoperasikan objek tipe SUPER: + [Fungsi GET\$1NUMBER\$1ATTRIBUTES](get_number_attributes.md) + [fungsi LOWER\$1ATTRIBUTE\$1NAMES](r_lower_attribute_names.md) + [Fungsi OBJECT](r_object_function.md) + [fungsi OBJECT\$1TRANSFORM](r_object_transform_function.md) + [Fungsi UPPER\$1ATTRIBUTE\$1NAMES](r_upper_attribute_names.md) Untuk informasi lebih lanjut tentang fungsi objek, lihat[Fungsi objek](Object_Functions.md). ## Fungsi string Untuk menggunakan fungsi string dengan literal string dalam tipe data SUPER, Anda harus mengonversi string literal ke tipe string sebelum menerapkan fungsi. Fungsi mengembalikan null jika input bukan string literal. [Fungsi string](String_functions_header.md)sekarang mendukung hingga 16.000.000 byte. Contoh berikut menggunakan SUBSTRING untuk mengekstrak pratinjau string dengan ukuran 5.000.000 byte yang disimpan dalam objek SUPER JSON ``` CREATE TABLE customer_data ( customer_id INT, profile SUPER ); INSERT INTO customer_data VALUES ( 1, JSON_PARSE('{"name": "John Doe", "description": "' || REPEAT('A', 5000000) || '"}') ); SELECT customer_id, profile.name::VARCHAR AS name, SUBSTRING(profile.description::VARCHAR, 1, 50) AS description_preview FROM customer_data; customer_id | name | description_preview -------------+----------+---------------------------------------------------- 1 | John Doe | AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA ``` Contoh berikut menunjukkan fungsi KIRI, KANAN, dan CONCAT pada literal string dari array SUPER: ``` CREATE TABLE documents ( doc_id INT, chapters SUPER ); INSERT INTO documents VALUES ( 1, JSON_PARSE('["' || REPEAT('hello', 400000) || '", "' || REPEAT('world', 600000) || '"]') ); SELECT doc_id, LEFT(chapters[0]::VARCHAR, 20) AS chapter1_start, RIGHT(chapters[1]::VARCHAR, 20) AS chapter2_end, LEN(CONCAT(chapters[0]::VARCHAR, chapters[1]::VARCHAR)) AS concat_size FROM documents; doc_id | chapter1_start | chapter2_end | concat_size --------+----------------------+----------------------+------------- 1 | hellohellohellohello | worldworldworldworld | 5000000 ``` Contoh berikut menyimpan string mandiri di SUPER: ``` CREATE TABLE text_storage ( text_id INT, content SUPER ); INSERT INTO text_storage VALUES (1, REPEAT('A', 8000000)), (2, REPEAT('B', 16000000)); SELECT text_id, LEN(content::VARCHAR) AS content_length FROM text_storage; text_id | content_length ---------+---------------- 1 | 8000000 2 | 16000000 ```