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. # Fungsi objek Berikut ini adalah fungsi objek SQL yang didukung Amazon Redshift untuk membuat dan mengoperasikan objek tipe SUPER: **Topics** + [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) # Fungsi GET\$1NUMBER\$1ATTRIBUTES Mengembalikan hitungan berapa banyak pasangan kunci-nilai ada di tingkat root dari objek kamus. ## Sintaksis ``` GET_NUMBER_ATTRIBUTES( super_expression ) ``` ## Argumen *super\$1ekspresi* Ekspresi SUPER dari bentuk kamus. ## Jenis pengembalian Fungsi GET\$1NUMBER\$1ATTRIBUTES mengembalikan tipe INT. ## Catatan Fungsi ini hanya menghitung atribut langsung dan tidak menyertakan pasangan dalam kamus bersarang. ## Contoh Contoh berikut menunjukkan fungsi GET\$1NUMBER\$1ATTRIBUTES. ``` SELECT GET_NUMBER_ATTRIBUTES(JSON_PARSE('{"a": 1, "b": 2, "c": 3}')); get_number_attributes ----------------------- 3 (1 row) ``` Fungsi GET\$1NUMBER\$1ATTRIBUTES hanya beroperasi pada tingkat pertama kamus. ``` SELECT GET_NUMBER_ATTRIBUTES(JSON_PARSE('{"a": 1, "b": {"c": 3}}')); get_number_attributes ----------------------- 2 (1 row) ``` # fungsi LOWER\$1ATTRIBUTE\$1NAMES Mengonversi semua nama atribut yang berlaku dalam nilai SUPER ke huruf kecil, menggunakan rutin konversi kasus yang sama dengan. [Fungsi LOWER](r_LOWER.md) LOWER\$1ATTRIBUTE\$1NAMES mendukung karakter multibyte UTF-8, hingga maksimal empat byte per karakter. Untuk mengonversi nama atribut SUPER menjadi huruf besar, gunakan. [Fungsi UPPER\$1ATTRIBUTE\$1NAMES](r_upper_attribute_names.md) ## Sintaksis ``` LOWER_ATTRIBUTE_NAMES( super_expression ) ``` ## Argumen *super\$1ekspresi* Ekspresi SUPER. ## Jenis pengembalian `SUPER` ## Catatan penggunaan Di Amazon Redshift, pengidentifikasi kolom secara tradisional tidak peka huruf besar/kecil dan diubah menjadi huruf kecil. Jika Anda menyerap data dari format data case-sensitive seperti JSON, data tersebut mungkin berisi nama atribut mixed-case. Pertimbangkan contoh berikut. ``` CREATE TABLE t1 (s) AS SELECT JSON_PARSE('{"AttributeName": "Value"}'); SELECT s.AttributeName FROM t1; attributename ------------- NULL SELECT s."AttributeName" FROM t1; attributename ------------- NULL ``` Amazon Redshift mengembalikan NULL untuk kedua kueri. Untuk kueri`AttributeName`, gunakan LOWER\$1ATTRIBUTE\$1NAMES untuk mengonversi nama atribut data menjadi huruf kecil. Pertimbangkan contoh berikut. ``` CREATE TABLE t2 (s) AS SELECT LOWER_ATTRIBUTE_NAMES(s) FROM t1; SELECT s.attributename FROM t2; attributename ------------- "Value" SELECT s.AttributeName FROM t2; attributename ------------- "Value" SELECT s."attributename" FROM t2; attributename ------------- "Value" SELECT s."AttributeName" FROM t2; attributename ------------- "Value" ``` Opsi terkait untuk bekerja dengan nama atribut objek kasus campuran adalah opsi `enable_case_sensitive_super_attribute` konfigurasi, yang memungkinkan Amazon Redshift mengenali kasus dalam nama atribut SUPER. Ini bisa menjadi solusi alternatif untuk menggunakan LOWER\$1ATTRIBUTE\$1NAMES. Untuk informasi lebih lanjut tentang`enable_case_sensitive_super_attribute`, kunjungi[enable\$1case\$1sensitive\$1super\$1attribute](r_enable_case_sensitive_super_attribute.md). ## Contoh **Mengonversi nama atribut SUPER menjadi huruf kecil** Contoh berikut menggunakan LOWER\$1ATTRIBUTE\$1NAMES untuk mengonversi nama atribut dari semua nilai SUPER dalam tabel. ``` -- Create a table and insert several SUPER values. CREATE TABLE t (i INT, s SUPER); INSERT INTO t VALUES (1, NULL), (2, 'A'::SUPER), (3, JSON_PARSE('{"AttributeName": "B"}')), (4, JSON_PARSE( '[{"Subobject": {"C": "C"}, "Subarray": [{"D": "D"}, "E"] }]')); -- Convert all attribute names to lowercase. UPDATE t SET s = LOWER_ATTRIBUTE_NAMES(s); SELECT i, s FROM t ORDER BY i; i | s ---+-------------------------------------------------- 1 | NULL 2 | "A" 3 | {"attributename":"B"} 4 | [{"subobject":{"c":"C"},"subarray":[{"d":"D"}, "E"]}] ``` Amati bagaimana LOWER\$1ATTRIBUTE\$1NAMES berfungsi. + Nilai NULL dan nilai SUPER skalar seperti `"A"` tidak berubah. + Dalam objek SUPER, semua nama atribut diubah menjadi huruf kecil, tetapi nilai atribut seperti `"B"` tetap tidak berubah. + LOWER\$1ATTRIBUTE\$1NAMES berlaku secara rekursif ke objek SUPER apa pun yang bersarang di dalam array SUPER atau di dalam objek lain. **Menggunakan LOWER\$1ATTRIBUTE\$1NAMES pada objek SUPER dengan nama atribut duplikat** Jika objek SUPER berisi atribut yang namanya hanya berbeda dalam kasus mereka, LOWER\$1ATTRIBUTE\$1NAMES akan memunculkan kesalahan. Pertimbangkan contoh berikut. ``` SELECT LOWER_ATTRIBUTE_NAMES(JSON_PARSE('{"A": "A", "a": "a"}')); error: Invalid input code: 8001 context: SUPER value has duplicate attributes after case conversion. ``` # Fungsi OBJECT Menciptakan objek dari tipe data SUPER. ## Sintaksis ``` OBJECT ( [ key1, value1 ], [ key2, value2 ...] ) ``` ## Argumen *key1, key2* Ekspresi yang mengevaluasi string tipe VARCHAR. *value1, value2* Ekspresi tipe data Amazon Redshift apa pun kecuali tipe datetime, karena Amazon Redshift tidak mentransmisikan tipe datetime ke tipe data SUPER. Untuk informasi selengkapnya tentang jenis datetime, lihat. [Jenis Datetime](r_Datetime_types.md) `value`ekspresi dalam suatu objek tidak harus dari tipe data yang sama. ## Jenis pengembalian `SUPER` ## Contoh ``` -- Creates an empty object. select object(); object -------- {} (1 row) -- Creates objects with different keys and values. select object('a', 1, 'b', true, 'c', 3.14); object --------------------------- {"a":1,"b":true,"c":3.14} (1 row) select object('a', object('aa', 1), 'b', array(2,3), 'c', json_parse('{}')); object --------------------------------- {"a":{"aa":1},"b":[2,3],"c":{}} (1 row) -- Creates objects using columns from a table. create table bar (k varchar, v super); insert into bar values ('k1', json_parse('[1]')), ('k2', json_parse('{}')); select object(k, v) from bar; object ------------ {"k1":[1]} {"k2":{}} (2 rows) -- Errors out because DATE type values can't be converted to SUPER type. select object('k', '2008-12-31'::date); ERROR: OBJECT could not convert type date to super ``` # fungsi OBJECT\$1TRANSFORM Mengubah objek SUPER. ## Sintaksis ``` OBJECT_TRANSFORM( input [KEEP path1, ...] [SET path1, value1, ..., ... ] ) ``` ## Argumen *masukan* Ekspresi yang menyelesaikan objek tipe SUPER. *JAGA* Semua nilai *jalur* yang ditentukan dalam klausa ini disimpan dan dibawa ke objek output. Klausul ini opsional. *jalur1*, *jalan2*,... Literal string konstan, dalam format komponen jalur kutip ganda yang dibatasi oleh periode. Misalnya, `'"a"."b"."c"'` adalah nilai jalur yang valid. Ini berlaku untuk parameter jalur di kedua klausa KEEP dan SET. *SET* *jalur* dan pasangan *nilai* untuk memodifikasi jalur keluar atau menambahkan jalur baru, dan mengatur nilai jalur itu di objek output. Klausul ini opsional. *value1, *value2**,... Ekspresi yang menyelesaikan nilai tipe SUPER. Perhatikan bahwa tipe numerik, teks, dan Boolean dapat diselesaikan ke SUPER. ## Jenis pengembalian `SUPER` ## Catatan penggunaan OBJECT\$1TRANSFORM mengembalikan objek tipe SUPER yang berisi nilai jalur dari *masukan* yang ditentukan dalam KEEP dan pasangan *jalur* dan *nilai* yang ditentukan dalam SET. *Jika KEEP dan SET kosong, OBJECT\$1TRANSFORM mengembalikan masukan.* Jika *input* bukan *objek* tipe SUPER, OBJECT\$1TRANSFORM mengembalikan *masukan*, terlepas dari nilai KEEP atau SET. ## Contoh Contoh berikut mengubah objek SUPER menjadi objek SUPER lain. ``` CREATE TABLE employees ( col_person SUPER ); INSERT INTO employees VALUES ( json_parse(' { "name": { "first": "John", "last": "Doe" }, "age": 25, "ssn": "111-22-3333", "company": "Company Inc.", "country": "U.S." } ') ), ( json_parse(' { "name": { "first": "Jane", "last": "Appleseed" }, "age": 34, "ssn": "444-55-7777", "company": "Organization Org.", "country": "Ukraine" } ') ) ; SELECT OBJECT_TRANSFORM( col_person KEEP '"name"."first"', '"age"', '"company"', '"country"' SET '"name"."first"', UPPER(col_person.name.first::TEXT), '"age"', col_person.age + 5, '"company"', 'Amazon' ) AS col_person_transformed FROM employees; --This result is formatted for ease of reading. col_person_transformed ------------------------------------------------------------- { "name": { "first": "JOHN" }, "age": 30, "company": "Amazon", "country": "U.S." } { "name": { "first": "JANE" }, "age": 39, "company": "Amazon", "country": "Ukraine" } ``` # Fungsi UPPER\$1ATTRIBUTE\$1NAMES Mengonversi semua nama atribut yang berlaku dalam nilai SUPER ke huruf besar, menggunakan rutin konversi kasus yang sama seperti. [Fungsi UPPER](r_UPPER.md) UPPER\$1ATTRIBUTE\$1NAMES mendukung karakter multibyte UTF-8, hingga maksimal empat byte per karakter. Untuk mengonversi nama atribut SUPER menjadi huruf kecil, gunakan. [fungsi LOWER\$1ATTRIBUTE\$1NAMES](r_lower_attribute_names.md) ## Sintaksis ``` UPPER_ATTRIBUTE_NAMES( super_expression ) ``` ## Argumen *super\$1ekspresi* Ekspresi SUPER. ## Jenis pengembalian `SUPER` ## Contoh **Mengonversi nama atribut SUPER ke huruf besar** Contoh berikut menggunakan UPPER\$1ATTRIBUTE\$1NAMES untuk mengonversi nama atribut dari semua nilai SUPER dalam tabel. ``` -- Create a table and insert several SUPER values. CREATE TABLE t (i INT, s SUPER); INSERT INTO t VALUES (1, NULL), (2, 'a'::SUPER), (3, JSON_PARSE('{"AttributeName": "b"}')), (4, JSON_PARSE( '[{"Subobject": {"c": "c"}, "Subarray": [{"d": "d"}, "e"] }]')); -- Convert all attribute names to uppercase. UPDATE t SET s = UPPER_ATTRIBUTE_NAMES(s); SELECT i, s FROM t ORDER BY i; i | s ---+-------------------------------------------------- 1 | NULL 2 | "a" 3 | {"ATTRIBUTENAME":"B"} 4 | [{"SUBOBJECT":{"C":"c"},"SUBARRAY":[{"D":"d"}, "e"]}] ``` Amati bagaimana UPPER\$1ATTRIBUTE\$1NAMES berfungsi. + Nilai NULL dan nilai SUPER skalar seperti `"a"` tidak berubah. + Dalam objek SUPER, semua nama atribut diubah menjadi huruf besar, tetapi nilai atribut seperti `"b"` tetap tidak berubah. + UPPER\$1ATTRIBUTE\$1NAMES berlaku secara rekursif ke objek SUPER apa pun yang bersarang di dalam array SUPER atau di dalam objek lain. **Menggunakan UPPER\$1ATTRIBUTE\$1NAMES pada objek SUPER dengan nama atribut duplikat** Jika objek SUPER berisi atribut yang namanya hanya berbeda dalam kasus mereka, UPPER\$1ATTRIBUTE\$1NAMES akan memunculkan kesalahan. Pertimbangkan contoh berikut. ``` SELECT UPPER_ATTRIBUTE_NAMES(JSON_PARSE('{"A": "A", "a": "a"}')); error: Invalid input code: 8001 context: SUPER value has duplicate attributes after case conversion. ```