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. # Tutorial: Menanyakan data bersarang dengan Amazon Redshift Spectrum Tutorial ini menunjukkan bagaimana untuk query data bersarang dengan Redshift Spectrum. Data bersarang adalah data yang berisi bidang bersarang. Bidang bersarang adalah bidang yang disatukan sebagai entitas tunggal, seperti array, struct, atau objek. **Topics** + [Ikhtisar](#tutorial-nested-data-overview) + [Langkah 1: Buat tabel eksternal yang berisi data bersarang](#tutorial-nested-data-create-table) + [Langkah 2: Kueri data bersarang Anda di Amazon S3 dengan ekstensi SQL](#tutorial-query-nested-data-sqlextensions) + [Kasus penggunaan data bersarang](nested-data-use-cases.md) + [Batasan data bersarang (pratinjau)](nested-data-restrictions.md) + [Serialisasi JSON bersarang kompleks](serializing-complex-JSON.md) ## Ikhtisar Amazon Redshift Spectrum mendukung kueri data bersarang dalam format file Parket, ORC, JSON, dan Ion. Redshift Spectrum mengakses data menggunakan tabel eksternal. Anda dapat membuat tabel eksternal yang menggunakan tipe data yang kompleks`struct`,`array`, dan`map`. Misalnya, misalkan file data Anda berisi data berikut di Amazon S3 dalam folder bernama. `customers` Meskipun tidak ada elemen root tunggal, setiap objek JSON dalam data sampel ini mewakili baris dalam tabel. ``` {"id": 1, "name": {"given": "John", "family": "Smith"}, "phones": ["123-457789"], "orders": [{"shipdate": "2018-03-01T11:59:59.000Z", "price": 100.50}, {"shipdate": "2018-03-01T09:10:00.000Z", "price": 99.12}] } {"id": 2, "name": {"given": "Jenny", "family": "Doe"}, "phones": ["858-8675309", "415-9876543"], "orders": [] } {"id": 3, "name": {"given": "Andy", "family": "Jones"}, "phones": [], "orders": [{"shipdate": "2018-03-02T08:02:15.000Z", "price": 13.50}] } ``` Anda dapat menggunakan Amazon Redshift Spectrum untuk menanyakan data bersarang dalam file. Tutorial berikut menunjukkan cara melakukannya dengan data Apache Parquet. ### Prasyarat Jika Anda belum menggunakan Redshift Spectrum, ikuti langkah-langkah di [Memulai dengan Amazon Redshift Spectrum](c-getting-started-using-spectrum.md) sebelum melanjutkan. [Untuk membuat skema eksternal, ganti ARN peran IAM dalam perintah berikut dengan peran ARN yang Anda buat di Buat peran IAM.](c-getting-started-using-spectrum.md#c-getting-started-using-spectrum-create-role) Kemudian jalankan perintah di klien SQL Anda. ``` create external schema spectrum from data catalog database 'myspectrum_db' iam_role 'arn:aws:iam::123456789012:role/myspectrum_role' create external database if not exists; ``` ## Langkah 1: Buat tabel eksternal yang berisi data bersarang Anda dapat melihat [data sumber](https://s3.amazonaws.com/redshift-downloads/tickit/spectrum/customers/customer_file1) dengan mengunduhnya dari Amazon S3. Untuk membuat tabel eksternal untuk tutorial ini, jalankan perintah berikut. ``` CREATE EXTERNAL TABLE spectrum.customers ( id int, name struct, phones array, orders array> ) STORED AS PARQUET LOCATION 's3://redshift-downloads/tickit/spectrum/customers/'; ``` Pada contoh sebelumnya, tabel eksternal `spectrum.customers` menggunakan tipe `array` data `struct` dan untuk menentukan kolom dengan data bersarang. Amazon Redshift Spectrum mendukung kueri data bersarang dalam format file Parket, ORC, JSON, dan Ion. `STORED AS`Parameternya adalah `PARQUET` untuk file Apache Parquet. `LOCATION`Parameter harus merujuk ke folder Amazon S3 yang berisi data atau file bersarang. Untuk informasi selengkapnya, lihat [CREATE EXTERNAL TABLE](r_CREATE_EXTERNAL_TABLE.md). Anda dapat bersarang `array` dan `struct` mengetik di tingkat mana pun. Misalnya, Anda dapat menentukan kolom bernama `toparray` seperti yang ditunjukkan pada contoh berikut. ``` toparray array>>>> ``` Anda juga dapat `struct` jenis sarang seperti yang ditunjukkan untuk kolom `x` dalam contoh berikut. ``` x struct > > ``` ## Langkah 2: Kueri data bersarang Anda di Amazon S3 dengan ekstensi SQL Redshift Spectrum mendukung kueri `array``map`, dan jenis `struct` kompleks melalui ekstensi ke sintaks Amazon Redshift SQL. ### Ekstensi 1: Akses ke kolom struct Anda dapat mengekstrak data dari `struct` kolom menggunakan notasi titik yang menggabungkan nama bidang menjadi jalur. Misalnya, permintaan berikut mengembalikan nama yang diberikan dan keluarga untuk pelanggan. Nama yang diberikan diakses oleh jalur panjang`c.name.given`. Nama keluarga diakses oleh jalan panjang`c.name.family`. ``` SELECT c.id, c.name.given, c.name.family FROM spectrum.customers c; ``` Query sebelumnya mengembalikan data berikut. ``` id | given | family ---|-------|------- 1 | John | Smith 2 | Jenny | Doe 3 | Andy | Jones (3 rows) ``` A `struct` bisa berupa kolom lain`struct`, yang bisa berupa kolom lain`struct`, di tingkat mana pun. Jalur yang mengakses kolom dalam `struct` s bersarang sedemikian dalam bisa sangat panjang. Misalnya, lihat definisi untuk kolom `x` dalam contoh berikut. ``` x struct > > ``` Anda dapat mengakses data di `e` as`x.b.d.e`. ### Ekstensi 2: Mulai dari array dalam klausa FROM Anda dapat mengekstrak data dari `array` kolom (dan, dengan ekstensi, `map` kolom) dengan menentukan `array` kolom dalam `FROM` klausa sebagai pengganti nama tabel. Ekstensi berlaku untuk `FROM` klausa kueri utama, dan juga `FROM` klausa subquery. Anda dapat mereferensikan `array` elemen berdasarkan posisi, seperti`c.orders[0]`. (pratinjau) Dengan menggabungkan mulai `arrays` dengan gabungan, Anda dapat mencapai berbagai jenis unnesting, seperti yang dijelaskan dalam kasus penggunaan berikut. #### Menghapus sarang menggunakan sambungan batin Kueri berikut memilih tanggal pengiriman pelanggan IDs dan pesanan untuk pelanggan yang memiliki pesanan. Ekstensi SQL dalam klausa FROM `c.orders o` tergantung pada alias. `c` ``` SELECT c.id, o.shipdate FROM spectrum.customers c, c.orders o ``` Untuk setiap pelanggan `c` yang memiliki pesanan, `FROM` klausa mengembalikan satu baris untuk setiap pesanan `o` pelanggan`c`. Baris itu menggabungkan baris pelanggan `c` dan baris pesanan`o`. Kemudian `SELECT` klausa hanya menyimpan `c.id` dan`o.shipdate`. Hasilnya adalah sebagai berikut. ``` id| shipdate --|---------------------- 1 |2018-03-01 11:59:59 1 |2018-03-01 09:10:00 3 |2018-03-02 08:02:15 (3 rows) ``` Alias `c` menyediakan akses ke bidang pelanggan, dan alias `o` menyediakan akses ke bidang pesanan. Semantiknya mirip dengan SQL standar. Anda dapat menganggap `FROM` klausa sebagai menjalankan loop bersarang berikut, yang diikuti dengan `SELECT` memilih bidang yang akan dikeluarkan. ``` for each customer c in spectrum.customers for each order o in c.orders output c.id and o.shipdate ``` Oleh karena itu, jika pelanggan tidak memiliki pesanan, pelanggan tidak muncul di hasilnya. Anda juga dapat menganggap ini sebagai `FROM` klausa yang melakukan a `JOIN` dengan `customers` tabel dan `orders` array. Bahkan, Anda juga dapat menulis query seperti yang ditunjukkan pada contoh berikut. ``` SELECT c.id, o.shipdate FROM spectrum.customers c INNER JOIN c.orders o ON true ``` **catatan** Jika skema bernama `c` ada dengan tabel bernama`orders`, maka `c.orders` mengacu pada tabel`orders`, dan bukan kolom array. `customers` #### Menghapus sarang menggunakan gabungan kiri Kueri berikut menghasilkan semua nama pelanggan dan pesanan mereka. Jika pelanggan belum melakukan pemesanan, nama pelanggan masih dikembalikan. Namun, dalam kasus ini, kolom urutan adalah NULL, seperti yang ditunjukkan pada contoh berikut untuk Jenny Doe. ``` SELECT c.id, c.name.given, c.name.family, o.shipdate, o.price FROM spectrum.customers c LEFT JOIN c.orders o ON true ``` Query sebelumnya mengembalikan data berikut. ``` id | given | family | shipdate | price ----|---------|---------|----------------------|-------- 1 | John | Smith | 2018-03-01 11:59:59 | 100.5 1 | John | Smith | 2018-03-01 09:10:00 | 99.12 2 | Jenny | Doe | | 3 | Andy | Jones | 2018-03-02 08:02:15 | 13.5 (4 rows) ``` ### Ekstensi 3: Mengakses array skalar secara langsung menggunakan alias Ketika alias `p` dalam `FROM` klausa berkisar pada array skalar, kueri mengacu pada nilai as. `p` `p` Misalnya, kueri berikut menghasilkan pasangan nama pelanggan dan nomor telepon. ``` SELECT c.name.given, c.name.family, p AS phone FROM spectrum.customers c LEFT JOIN c.phones p ON true ``` Query sebelumnya mengembalikan data berikut. ``` given | family | phone -------|----------|----------- John | Smith | 123-4577891 Jenny | Doe | 858-8675309 Jenny | Doe | 415-9876543 Andy | Jones | (4 rows) ``` ### Ekstensi 4: Mengakses elemen peta Redshift Spectrum memperlakukan tipe `map` data sebagai `array` tipe yang berisi `struct` tipe dengan `key` kolom dan kolom. `value` `key`Harus a`scalar`; nilainya bisa berupa tipe data apa pun. Misalnya, kode berikut membuat tabel eksternal dengan `map` untuk menyimpan nomor telepon. ``` CREATE EXTERNAL TABLE spectrum.customers2 ( id int, name struct, phones map, orders array> ) STORED AS PARQUET LOCATION 's3://redshift-downloads/tickit/spectrum/customers/'; ``` Karena `map` tipe berperilaku seperti `array` tipe dengan kolom `key` dan`value`, Anda dapat memikirkan skema sebelumnya seolah-olah mereka adalah sebagai berikut. ``` CREATE EXTERNAL TABLE spectrum.customers3 ( id int, name struct, phones array>, orders array> ) STORED AS PARQUET LOCATION 's3://redshift-downloads/tickit/spectrum/customers/'; ``` Kueri berikut mengembalikan nama pelanggan dengan nomor ponsel dan mengembalikan nomor untuk setiap nama. Kueri peta diperlakukan sebagai setara dengan menanyakan tipe bersarang`array`. `struct` Query berikut hanya mengembalikan data jika Anda telah membuat tabel eksternal seperti yang dijelaskan sebelumnya. ``` SELECT c.name.given, c.name.family, p.value FROM spectrum.customers c, c.phones p WHERE p.key = 'mobile'; ``` **catatan** The `key` for a `map` adalah `string` untuk jenis file Ion dan JSON. # Kasus penggunaan data bersarang Topik ini menjelaskan kasus penggunaan untuk data bersarang. Data bersarang adalah data yang berisi bidang bersarang. Bidang bersarang adalah bidang yang disatukan sebagai entitas tunggal, seperti array, struct, atau objek. Anda dapat menggabungkan ekstensi yang dijelaskan sebelumnya dengan fitur SQL biasa. Kasus penggunaan berikut menggambarkan beberapa kombinasi umum. Contoh-contoh ini membantu mendemonstrasikan bagaimana Anda dapat menggunakan data bersarang. Mereka bukan bagian dari tutorial. **Topics** + [Menelan data bersarang](#ingesting-nested-data) + [Menggabungkan data bersarang dengan subkueri](#aggregating-with-subquery) + [Bergabung dengan Amazon Redshift dan data bersarang](#joining-redshift-data) ## Menelan data bersarang Anda dapat menggunakan `CREATE TABLE AS` pernyataan untuk menyerap data dari tabel eksternal yang berisi tipe data kompleks. Kueri berikut mengekstrak semua pelanggan dan nomor telepon mereka dari tabel eksternal, menggunakan`LEFT JOIN`, dan menyimpannya di tabel Amazon Redshift. `CustomerPhones` ``` CREATE TABLE CustomerPhones AS SELECT c.name.given, c.name.family, p AS phone FROM spectrum.customers c LEFT JOIN c.phones p ON true; ``` ## Menggabungkan data bersarang dengan subkueri Anda dapat menggunakan subquery untuk mengumpulkan data bersarang. Contoh berikut menggambarkan pendekatan ini. ``` SELECT c.name.given, c.name.family, (SELECT COUNT(*) FROM c.orders o) AS ordercount FROM spectrum.customers c; ``` Data berikut dikembalikan. ``` given | family | ordercount --------|----------|-------------- Jenny | Doe | 0 John | Smith | 2 Andy | Jones | 1 (3 rows) ``` **catatan** Saat Anda menggabungkan data bersarang dengan mengelompokkan berdasarkan baris induk, cara yang paling efisien adalah yang ditunjukkan pada contoh sebelumnya. Dalam contoh itu, baris bersarang `c.orders` dikelompokkan berdasarkan baris induknya. `c` Atau, jika Anda tahu bahwa `id` unik untuk masing-masing `customer` dan `o.shipdate` tidak pernah nol, Anda dapat menggabungkan seperti yang ditunjukkan pada contoh berikut. Namun, pendekatan ini umumnya tidak seefisien contoh sebelumnya. ``` SELECT c.name.given, c.name.family, COUNT(o.shipdate) AS ordercount FROM spectrum.customers c LEFT JOIN c.orders o ON true GROUP BY c.id, c.name.given, c.name.family; ``` Anda juga dapat menulis kueri dengan menggunakan subquery dalam `FROM` klausa yang mengacu pada alias (`c`) dari kueri leluhur dan mengekstrak data array. Contoh berikut menunjukkan pendekatan ini. ``` SELECT c.name.given, c.name.family, s.count AS ordercount FROM spectrum.customers c, (SELECT count(*) AS count FROM c.orders o) s; ``` ## Bergabung dengan Amazon Redshift dan data bersarang Anda juga dapat menggabungkan data Amazon Redshift dengan data bersarang di tabel eksternal. Misalnya, misalkan Anda memiliki data bersarang berikut di Amazon S3. ``` CREATE EXTERNAL TABLE spectrum.customers2 ( id int, name struct, phones array, orders array> ); ``` Misalkan juga Anda memiliki tabel berikut di Amazon Redshift. ``` CREATE TABLE prices ( id int, price double precision ); ``` Kueri berikut menemukan jumlah total dan jumlah pembelian setiap pelanggan berdasarkan sebelumnya. Contoh berikut hanya ilustrasi. Ini hanya mengembalikan data jika Anda telah membuat tabel yang dijelaskan sebelumnya. ``` SELECT c.name.given, c.name.family, COUNT(o.date) AS ordercount, SUM(p.price) AS ordersum FROM spectrum.customers2 c, c.orders o, prices p ON o.item = p.id GROUP BY c.id, c.name.given, c.name.family; ``` # Batasan data bersarang (pratinjau) Topik ini menjelaskan batasan untuk membaca data bersarang dengan Redshift Spectrum. Data bersarang adalah data yang berisi bidang bersarang. Bidang bersarang adalah bidang yang disatukan sebagai entitas tunggal, seperti array, struct, atau objek. **catatan** Batasan yang ditandai (pratinjau) dalam daftar berikut hanya berlaku untuk kluster pratinjau yang dibuat di Wilayah berikut. AS Timur (Ohio) (us-east-2) AS Timur (Virginia Utara) (us-east-1) AS Barat (California Utara) (us-west-1) Asia Pacific (Tokyo) (ap-northeast-1) Europe (Ireland) (eu-west-1) Eropa (Stockholm) (eu-north-1) Untuk informasi tentang menyiapkan klaster Pratinjau, lihat [Membuat klaster pratinjau](https://docs.aws.amazon.com/redshift/latest/mgmt/managing-clusters-console.html#cluster-preview) di Panduan Manajemen *Pergeseran Merah Amazon*. Batasan berikut berlaku untuk data bersarang: + `map`Tipe `array` atau dapat berisi `map` jenis lain `array` atau selama kueri pada nilai bersarang `arrays` atau `maps` tidak mengembalikan`scalar`. (pratinjau) + Amazon Redshift Spectrum mendukung tipe data yang kompleks hanya sebagai tabel eksternal. + Kolom hasil subquery harus tingkat atas. (pratinjau) + Jika `OUTER JOIN` ekspresi mengacu pada tabel bersarang, itu hanya dapat merujuk ke tabel itu dan array bersarang (dan peta). Jika `OUTER JOIN` ekspresi tidak merujuk ke tabel bersarang, ekspresi dapat merujuk ke sejumlah tabel yang tidak bersarang. + Jika `FROM` klausa dalam subquery mengacu pada tabel bersarang, itu tidak dapat merujuk ke tabel lain. + Jika subquery bergantung pada tabel bersarang yang mengacu pada tabel induk, subquery hanya dapat menggunakan tabel induk dalam klausa. `FROM` Anda tidak dapat menggunakan induk dalam klausa lain, seperti klausa `SELECT` atau`WHERE`. Misalnya, kueri berikut tidak berjalan karena `SELECT` klausa subquery mengacu pada tabel induk. `c` ``` SELECT c.name.given FROM spectrum.customers c WHERE (SELECT COUNT(c.id) FROM c.phones p WHERE p LIKE '858%') > 1; ``` Kueri berikut berfungsi karena induk hanya `c` digunakan dalam `FROM` klausa subquery. ``` SELECT c.name.given FROM spectrum.customers c WHERE (SELECT COUNT(*) FROM c.phones p WHERE p LIKE '858%') > 1; ``` + Subquery yang mengakses data bersarang di mana saja selain `FROM` klausa harus mengembalikan satu nilai. Satu-satunya pengecualian adalah `(NOT) EXISTS` operator dalam `WHERE` klausa. + `(NOT) IN` tidak didukung. + Kedalaman bersarang maksimum untuk semua jenis bersarang adalah 100. Pembatasan ini berlaku untuk semua format file (Parket, ORC, Ion, dan JSON). + Subkueri agregasi yang mengakses data bersarang hanya dapat merujuk ke `arrays` dan `maps` dalam `FROM` klausulnya, bukan ke tabel eksternal. + Menanyakan pseudocolumns dari data bersarang dalam tabel Redshift Spectrum tidak didukung. Untuk informasi selengkapnya, lihat [Pseudokolom](c-spectrum-external-tables.md#c-spectrum-external-tables-pseudocolumns). + Saat mengekstrak data dari kolom array atau peta dengan menentukannya dalam `FROM` klausa, Anda hanya dapat memilih nilai dari kolom tersebut jika nilainya. `scalar` Misalnya, kueri berikut mencoba `SELECT` elemen dari dalam array. Kueri yang memilih `arr.a` berfungsi karena `arr.a` merupakan `scalar` nilai. Kueri kedua tidak berfungsi karena `array` merupakan array yang diekstrak dari `s3.nested table` dalam `FROM` klausa. (pratinjau) ``` SELECT array_column FROM s3.nested_table; array_column ----------------- [{"a":1},{"b":2}] SELECT arr.a FROM s3.nested_table t, t.array_column arr; arr.a ----- 1 --This query fails to run. SELECT array FROM s3.nested_table tab, tab.array_column array; ``` Anda tidak dapat menggunakan array atau peta dalam `FROM` klausa yang berasal dari array atau peta lain. Untuk memilih array atau struktur kompleks lainnya yang bersarang di dalam array lain, pertimbangkan untuk menggunakan indeks dalam pernyataan. `SELECT` # Serialisasi JSON bersarang kompleks Topik ini menunjukkan cara membuat serial data bersarang dalam format JSON. Data bersarang adalah data yang berisi bidang bersarang. Bidang bersarang adalah bidang yang disatukan sebagai entitas tunggal, seperti array, struct, atau objek. Alternatif untuk metode yang ditunjukkan dalam tutorial ini adalah untuk menanyakan kolom koleksi bersarang tingkat atas sebagai JSON serial. Anda dapat menggunakan serialisasi untuk memeriksa, mengonversi, dan menyerap data bersarang sebagai JSON dengan Redshift Spectrum. Metode ini didukung untuk format ORC, JSON, Ion, dan Parket. Gunakan parameter konfigurasi sesi `json_serialization_enable` untuk mengonfigurasi perilaku serialisasi. Saat diatur, tipe data JSON kompleks diserialisasikan ke VARCHAR (65535). JSON bersarang dapat diakses dengan. [Fungsi JSON](json-functions.md) Untuk informasi selengkapnya, lihat [json\$1serialization\$1enable](r_json_serialization_enable.md). Misalnya, tanpa pengaturan`json_serialization_enable`, kueri berikut yang mengakses kolom bersarang langsung gagal. ``` SELECT * FROM spectrum.customers LIMIT 1; => ERROR: Nested tables do not support '*' in the SELECT clause. SELECT name FROM spectrum.customers LIMIT 1; => ERROR: column "name" does not exist in customers ``` Pengaturan `json_serialization_enable` memungkinkan kueri koleksi tingkat atas secara langsung. ``` SET json_serialization_enable TO true; SELECT * FROM spectrum.customers order by id LIMIT 1; id | name | phones | orders ---+--------------------------------------+----------------+---------------------------------------------------------------------------------------------------------------------- 1 | {"given": "John", "family": "Smith"} | ["123-457789"] | [{"shipdate": "2018-03-01T11:59:59.000Z", "price": 100.50}, {"shipdate": "2018-03-01T09:10:00.000Z", "price": 99.12}] SELECT name FROM spectrum.customers order by id LIMIT 1; name --------- {"given": "John", "family": "Smith"} ``` Pertimbangkan item berikut saat membuat serial JSON bersarang. + Ketika kolom koleksi diserialisasikan sebagai VARCHAR (65535), subbidang bersarangnya tidak dapat diakses secara langsung sebagai bagian dari sintaks kueri (misalnya, dalam klausa filter). Namun, fungsi JSON dapat digunakan untuk mengakses JSON bersarang. + Representasi khusus berikut tidak didukung: + Serikat pekerja ORC + Peta ORC dengan tombol tipe kompleks + Datagram ion + Ion SEXP + Stempel waktu dikembalikan sebagai string serial ISO. + Kunci peta primitif dipromosikan ke string (misalnya, `1` ke`"1"`). + Nilai nol tingkat atas diserialisasikan sebagai. NULLs + Jika serialisasi meluap ukuran VARCHAR maksimum 65535, sel diatur ke NULL. ## Serialisasi tipe kompleks yang berisi string JSON Secara default, nilai string yang terkandung dalam koleksi bersarang diserialisasikan sebagai string JSON yang lolos. Melarikan diri mungkin tidak diinginkan ketika string adalah JSON yang valid. Sebagai gantinya, Anda mungkin ingin menulis subelement bersarang atau bidang yang VARCHAR secara langsung sebagai JSON. Aktifkan perilaku ini dengan `json_serialization_parse_nested_strings` konfigurasi tingkat sesi. Ketika keduanya `json_serialization_enable` dan `json_serialization_parse_nested_strings` disetel, nilai JSON yang valid diserialkan sebaris tanpa karakter escape. Ketika nilainya tidak valid JSON, nilai ini diloloskan seolah-olah nilai `json_serialization_parse_nested_strings` konfigurasi tidak disetel. Untuk informasi selengkapnya, lihat [json\$1serialization\$1parse\$1nested\$1string](r_json_serialization_parse_nested_strings.md). Misalnya, asumsikan data dari contoh sebelumnya berisi JSON sebagai tipe `structs` kompleks di bidang `name` VARCHAR (20): ``` name --------- {"given": "{\"first\":\"John\",\"middle\":\"James\"}", "family": "Smith"} ``` Ketika `json_serialization_parse_nested_strings` diatur, `name` kolom diserialisasikan sebagai berikut: ``` SET json_serialization_enable TO true; SET json_serialization_parse_nested_strings TO true; SELECT name FROM spectrum.customers order by id LIMIT 1; name --------- {"given": {"first":"John","middle":"James"}, "family": "Smith"} ``` Alih-alih melarikan diri seperti ini: ``` SET json_serialization_enable TO true; SELECT name FROM spectrum.customers order by id LIMIT 1; name --------- {"given": "{\"first\":\"John\",\"middle\":\"James\"}", "family": "Smith"} ```