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

# Sarang Ion Amazon SerDe
<a name="ion-serde"></a>

Anda dapat menggunakan Amazon Ion Hive SerDe untuk menanyakan data yang disimpan dalam format [Amazon Ion](https://amzn.github.io/ion-docs/guides/cookbook.html). Amazon Ion adalah format data sumber terbuka yang diketik dengan kaya, menggambarkan sendiri. Format Amazon Ion digunakan dalam bahasa kueri SQL open source [PartiQL](https://partiql.org/).

Amazon Ion memiliki format biner dan teks yang dapat dipertukarkan. Fitur ini menggabungkan kemudahan penggunaan teks dengan efisiensi pengkodean biner.

Untuk menanyakan data Amazon Ion dari Athena, Anda dapat menggunakan [Amazon Ion Hive SerDe](https://github.com/amzn/ion-hive-serde), yang membuat serial dan deserialisasi data Amazon Ion. Deserialisasi memungkinkan Anda untuk menjalankan kueri pada data Amazon Ion atau membacanya untuk menulis ke dalam format yang berbeda seperti Parket atau ORC. Serialisasi memungkinkan Anda menghasilkan data dalam format Amazon Ion dengan menggunakan `CREATE TABLE AS SELECT` (CTAS) atau `INSERT INTO` kueri untuk menyalin data dari tabel yang ada.

**catatan**  
Karena Amazon Ion adalah superset dari JSON, Anda dapat menggunakan Amazon Ion Hive SerDe untuk menanyakan kumpulan data JSON non-Amazon Ion. Tidak seperti [ SerDeperpustakaan JSON](https://docs.aws.amazon.com/athena/latest/ug/json-serde.html) lainnya, Amazon Ion SerDe tidak mengharapkan setiap baris data berada pada satu baris. Fitur ini berguna jika Anda ingin menanyakan kumpulan data JSON yang dalam format “cetak cantik” atau memecah bidang berturut-turut dengan karakter baris baru.

Untuk informasi tambahan dan contoh kueri Amazon Ion dengan Athena, lihat [Menganalisis kumpulan data Amazon Ion menggunakan Amazon](https://aws.amazon.com/blogs/big-data/analyze-amazon-ion-datasets-using-amazon-athena/) Athena.

## Nama pustaka serialisasi
<a name="library-name"></a>

Nama pustaka serialisasi untuk Amazon Ion SerDe adalah`com.amazon.ionhiveserde.IonHiveSerDe`. Untuk informasi kode sumber, lihat [Amazon Ion Hive SerDe](https://github.com/amazon-ion/ion-hive-serde) GitHub di.com.

## Pertimbangan dan batasan
<a name="ion-serde-considerations-and-limitations"></a>
+ **Bidang duplikat** - Struct Amazon Ion diurutkan dan mendukung bidang duplikat, sedangkan Hive dan tidak`STRUCT<>`. `MAP<>` Jadi, ketika Anda deserialisasi bidang duplikat dari struct Amazon Ion, satu nilai dipilih secara non deterministik, dan yang lainnya diabaikan.
+ **Tabel simbol eksternal tidak didukung** — Saat ini, Athena tidak mendukung tabel simbol eksternal atau properti Amazon Ion SerDe Hive berikut:
  + `ion.catalog.class`
  + `ion.catalog.file`
  + `ion.catalog.url`
  + `ion.symbol_table_imports`
+ **Ekstensi file** - Amazon Ion menggunakan ekstensi file untuk menentukan codec kompresi mana yang akan digunakan untuk deserialisasi file Amazon Ion. Dengan demikian, file terkompresi harus memiliki ekstensi file yang sesuai dengan algoritma kompresi yang digunakan. Misalnya, jika ZSTD digunakan, file yang sesuai harus memiliki ekstensi. `.zst`
+ **Data homogen** — Amazon Ion tidak memiliki batasan pada tipe data yang dapat digunakan untuk nilai di bidang tertentu. Misalnya, dua dokumen Amazon Ion yang berbeda mungkin memiliki bidang dengan nama yang sama yang memiliki tipe data berbeda. Namun, karena Hive menggunakan skema, semua nilai yang Anda ekstrak ke kolom Hive tunggal harus memiliki tipe data yang sama.
+ **Pembatasan jenis kunci peta** — Saat Anda membuat serial data dari format lain ke Amazon Ion, pastikan bahwa jenis kunci peta adalah salah satu dari`STRING`,`VARCHAR`, atau`CHAR`. Meskipun Hive memungkinkan Anda untuk menggunakan tipe data primitif apa pun sebagai kunci peta, [simbol Amazon Ion](https://amzn.github.io/ion-docs/docs/symbols.html) harus berupa tipe string.
+ **Jenis serikat** [- Athena saat ini tidak mendukung jenis serikat Hive.](https://cwiki.apache.org/confluence/display/hive/languagemanual+types/#LanguageManualTypes-UnionTypesunionUnionTypes)
+ **Tipe data ganda** — Amazon Ion saat ini tidak mendukung tipe `double` data.

**Topics**
+ [Nama pustaka serialisasi](#library-name)
+ [Pertimbangan dan batasan](#ion-serde-considerations-and-limitations)
+ [Buat tabel Amazon Ion](ion-serde-using-create-table.md)
+ [Gunakan CTAS dan INSERT INTO untuk membuat tabel Amazon Ion](ion-serde-using-ctas-and-insert-into-to-create-ion-tables.md)
+ [Referensi SerDe properti Amazon Ion](ion-serde-using-ion-serde-properties.md)
+ [Gunakan ekstraktor jalur](ion-serde-using-path-extractors.md)

# Buat tabel Amazon Ion
<a name="ion-serde-using-create-table"></a>

Untuk membuat tabel di Athena dari data yang disimpan dalam format Amazon Ion, Anda dapat menggunakan salah satu teknik berikut dalam pernyataan CREATE TABLE:
+ Tentukan `STORED AS ION`. Dalam penggunaan ini, Anda tidak perlu menentukan Amazon Ion Hive SerDe secara eksplisit. Pilihan ini adalah opsi yang lebih mudah.
+ Tentukan jalur kelas Amazon Ion di `OUTPUTFORMAT` bidang `ROW FORMAT SERDE``INPUTFORMAT`,, dan.

Anda juga dapat menggunakan pernyataan `CREATE TABLE AS SELECT` (CTAS) untuk membuat tabel Amazon Ion di Athena. Untuk informasi, lihat [Gunakan CTAS dan INSERT INTO untuk membuat tabel Amazon Ion](ion-serde-using-ctas-and-insert-into-to-create-ion-tables.md).

## Tentukan DISIMPAN SEBAGAI ION
<a name="ion-serde-specifying-stored-as-ion"></a>

`CREATE TABLE`Pernyataan contoh berikut menggunakan `STORED AS ION` sebelum `LOCATION` klausa untuk membuat tabel berdasarkan data penerbangan dalam format Amazon Ion. `LOCATION`Klausa menentukan bucket atau folder tempat file input dalam format Ion berada. Semua file di lokasi yang ditentukan dipindai.

```
CREATE EXTERNAL TABLE flights_ion (
    yr INT,
    quarter INT,
    month INT,
    dayofmonth INT,
    dayofweek INT,
    flightdate STRING,
    uniquecarrier STRING,
    airlineid INT,
)
STORED AS ION
LOCATION 's3://amzn-s3-demo-bucket/'
```

## Tentukan jalur kelas Amazon Ion
<a name="ion-serde-specifying-the-ion-class-paths"></a>

Alih-alih menggunakan `STORED AS ION` sintaks, Anda dapat secara eksplisit menentukan nilai jalur kelas Ion untuk`ROW FORMAT SERDE`,`INPUTFORMAT`, dan `OUTPUTFORMAT` klausa sebagai berikut.


****  

| Parameter | Jalur kelas ion | 
| --- | --- | 
| ROW FORMAT SERDE | 'com.amazon.ionhiveserde.IonHiveSerDe' | 
| STORED AS INPUTFORMAT | 'com.amazon.ionhiveserde.formats.IonInputFormat' | 
| OUTPUTFORMAT | 'com.amazon.ionhiveserde.formats.IonOutputFormat' | 

Query DDL berikut menggunakan teknik ini untuk membuat tabel eksternal yang sama seperti pada contoh sebelumnya.

```
CREATE EXTERNAL TABLE flights_ion (
    yr INT,
    quarter INT,
    month INT,
    dayofmonth INT,
    dayofweek INT,
    flightdate STRING,
    uniquecarrier STRING,
    airlineid INT,
)
ROW FORMAT SERDE
 'com.amazon.ionhiveserde.IonHiveSerDe'
STORED AS INPUTFORMAT
 'com.amazon.ionhiveserde.formats.IonInputFormat'
OUTPUTFORMAT
 'com.amazon.ionhiveserde.formats.IonOutputFormat'
LOCATION 's3://amzn-s3-demo-bucket/'
```

Untuk informasi tentang SerDe properti untuk `CREATE TABLE` pernyataan di Athena, lihat. [Referensi SerDe properti Amazon Ion](ion-serde-using-ion-serde-properties.md)

# Gunakan CTAS dan INSERT INTO untuk membuat tabel Amazon Ion
<a name="ion-serde-using-ctas-and-insert-into-to-create-ion-tables"></a>

Anda dapat menggunakan `CREATE TABLE AS SELECT` (CTAS) dan `INSERT INTO` pernyataan untuk menyalin atau menyisipkan data dari tabel ke tabel baru dalam format Amazon Ion di Athena.

Dalam kueri CTAS, tentukan `format='ION'` dalam `WITH` klausa, seperti pada contoh berikut.

```
CREATE TABLE new_table
WITH (format='ION')
AS SELECT * from existing_table
```

Secara default, Athena membuat serial Amazon Ion [dalam format biner Ion](https://amzn.github.io/ion-docs/docs/binary.html), tetapi Anda juga dapat menggunakan format teks. Untuk menggunakan format teks, tentukan `ion_encoding = 'TEXT'` dalam `WITH` klausa CTAS, seperti pada contoh berikut.

```
CREATE TABLE new_table
WITH (format='ION', ion_encoding = 'TEXT')
AS SELECT * from existing_table
```

Untuk informasi selengkapnya tentang properti khusus Amazon Ion dalam `WITH` klausa CTAS, lihat. [Properti Amazon Ion untuk klausa CTAS WITH](#ion-serde-ctas-with-clause-properties)

## Properti Amazon Ion untuk klausa CTAS WITH
<a name="ion-serde-ctas-with-clause-properties"></a>

Dalam kueri CTAS, Anda dapat menggunakan `WITH` klausa untuk menentukan format Amazon Ion dan secara opsional menentukan algoritma kompresi and/or penulisan pengkodean Amazon Ion yang akan digunakan.

**format**  
Anda dapat menentukan `ION` kata kunci sebagai opsi format dalam `WITH` klausa kueri CTAS. Ketika Anda melakukannya, tabel yang Anda buat menggunakan format yang Anda tentukan `IonInputFormat` untuk dibaca, dan menserialkan data dalam format yang Anda tentukan`IonOutputFormat`.  
Contoh berikut menentukan bahwa query CTAS menggunakan format Amazon Ion.  

```
WITH (format='ION')
```

**pengkodean ion\$1**  
Opsional  
Default: `BINARY`  
Nilai:`BINARY`, `TEXT`  
Menentukan apakah data diserialisasikan dalam format biner Amazon Ion atau format teks Amazon Ion. Contoh berikut menentukan format teks Amazon Ion.  

```
WITH (format='ION', ion_encoding='TEXT')
```

**write\$1compression**  
Opsional  
Default: `GZIP`  
Nilai:`GZIP`,`ZSTD`,`BZIP2`,`SNAPPY`, `NONE`  
Menentukan algoritma kompresi untuk digunakan untuk mengompres file output.  
Contoh berikut menentukan bahwa query CTAS menulis outputnya dalam format Amazon Ion menggunakan algoritma kompresi [Zstandard](https://facebook.github.io/zstd/).  

```
WITH (format='ION', write_compression = 'ZSTD')       
```
Untuk informasi tentang penggunaan kompresi di Athena, lihat. [Gunakan kompresi di Athena](compression-formats.md) 

Untuk informasi tentang properti CTAS lainnya di Athena, lihat. [Properti tabel CTAS](create-table-as.md#ctas-table-properties)

# Referensi SerDe properti Amazon Ion
<a name="ion-serde-using-ion-serde-properties"></a>

Topik ini berisi informasi tentang SerDe properti untuk `CREATE TABLE` pernyataan di Athena. Untuk informasi selengkapnya dan contoh penggunaan SerDe properti Amazon Ion, lihat [SerDe properti](https://github.com/amzn/ion-hive-serde/blob/master/docs/serde-properties.md) di SerDe dokumentasi Amazon Ion Hive di [GitHub](https://github.com/amzn/ion-hive-serde/tree/master/docs).

## Cara menentukan SerDe properti Amazon Ion
<a name="ion-serde-specifying-ion-serde-properties"></a>

Untuk menentukan properti untuk Amazon Ion Hive SerDe dalam `CREATE TABLE` pernyataan Anda, gunakan `WITH SERDEPROPERTIES` klausa. Karena `WITH SERDEPROPERTIES` merupakan subfield dari `ROW FORMAT SERDE` klausa, Anda harus menentukan `ROW FORMAT SERDE` dan jalur SerDe kelas Amazon Ion Hive terlebih dahulu, seperti yang ditunjukkan sintaks berikut.

```
...
ROW FORMAT SERDE
 'com.amazon.ionhiveserde.IonHiveSerDe'
WITH SERDEPROPERTIES (
 'property' = 'value',
 'property' = 'value',
...
)
```

Perhatikan bahwa meskipun `ROW FORMAT SERDE` klausa diperlukan jika Anda ingin menggunakan`WITH SERDEPROPERTIES`, Anda dapat menggunakan salah satu `STORED AS ION` atau yang lebih panjang `INPUTFORMAT` dan `OUTPUTFORMAT` sintaks untuk menentukan format Amazon Ion.

## SerDe Properti Amazon Ion
<a name="ion-serde-ion-serde-properties"></a>

Berikut ini adalah SerDe properti Amazon Ion yang dapat digunakan dalam `CREATE TABLE` pernyataan di Athena.

**ion.pengkodean**  
Opsional  
Default: `BINARY`  
Nilai:`BINARY`, `TEXT`  
Properti ini menyatakan apakah nilai baru yang ditambahkan diserialisasikan sebagai [biner Amazon Ion](https://amzn.github.io/ion-docs/docs/binary.html) atau format teks Amazon Ion.  
Contoh SerDe properti berikut menentukan format teks Amazon Ion.  

```
'ion.encoding' = 'TEXT'
```

**ion.fail\$1on\$1overflow**  
Opsional  
Default: `true`  
Nilai:`true`, `false`  
Amazon Ion memungkinkan tipe numerik yang besar secara sewenang-wenang sementara Hive tidak. Secara default, SerDe gagal jika nilai Amazon Ion tidak sesuai dengan kolom Hive, tetapi Anda dapat menggunakan opsi `fail_on_overflow` konfigurasi untuk membiarkan nilai meluap alih-alih gagal.  
Properti ini dapat diatur pada tingkat tabel atau kolom. Untuk menentukannya di tingkat tabel, tentukan `ion.fail_on_overflow` seperti pada contoh berikut. Ini menetapkan perilaku default untuk semua kolom.  

```
'ion.fail_on_overflow' = 'true'
```
Untuk mengontrol kolom tertentu, tentukan nama kolom antara `ion` dan`fail_on_overflow`, dibatasi oleh periode, seperti pada contoh berikut.  

```
'ion.<column>.fail_on_overflow' = 'false'
```

**ion.path\$1extractor.case\$1sensitive**  
Opsional  
Default: `false`  
Nilai:`true`, `false`  
Menentukan apakah akan memperlakukan nama bidang Amazon Ion sebagai peka huruf besar/kecil. Kapan`false`, kasus SerDe mengabaikan penguraian nama bidang Amazon Ion.  
Misalnya, Anda memiliki skema tabel Hive yang mendefinisikan bidang `alias` dalam huruf kecil dan dokumen Amazon Ion dengan `alias` bidang dan `ALIAS` bidang, seperti pada contoh berikut.  

```
-- Hive Table Schema
alias: STRING

-- Amazon Ion Document
{ 'ALIAS': 'value1'} 
{ 'alias': 'value2'}
```
Contoh berikut menunjukkan SerDe properti dan tabel yang diekstraksi yang dihasilkan saat sensitivitas huruf besar diatur ke`false`:  

```
-- Serde properties
'ion.alias.path_extractor' = '(alias)'
'ion.path_extractor.case_sensitive' = 'false'

--Extracted Table
| alias    |
|----------|
| "value1" |
| "value2" |
```
Contoh berikut menunjukkan SerDe properti dan tabel yang diekstraksi yang dihasilkan saat sensitivitas huruf besar diatur ke`true`:  

```
-- Serde properties
'ion.alias.path_extractor' = '(alias)'
'ion.path_extractor.case_sensitive' = 'true'

--Extracted Table
| alias    |
|----------|
| "value2" |
```
Dalam kasus kedua, `value1` untuk `ALIAS` bidang diabaikan ketika sensitivitas kasus disetel ke `true` dan ekstraktor jalur ditentukan sebagai`alias`.

**ion. *<column>*.path\$1extractor**  
Opsional  
Default: NA  
Nilai: String dengan jalur pencarian  
Membuat ekstraktor jalur dengan jalur pencarian yang ditentukan untuk kolom yang diberikan. Ekstraktor jalur memetakan bidang Amazon Ion ke kolom Hive. Jika tidak ada ekstraktor jalur yang ditentukan, Athena secara dinamis membuat ekstraktor jalur pada waktu berjalan berdasarkan nama kolom.  
Contoh berikut path extractor memetakan `example_ion_field` ke. `example_hive_column`  

```
'ion.example_hive_column.path_extractor' = '(example_ion_field)'
```
Untuk informasi selengkapnya tentang ekstraktor jalur dan jalur penelusuran, lihat[Gunakan ekstraktor jalur](ion-serde-using-path-extractors.md).

**ion.timestamp.serialization\$1offset**  
Opsional  
Default: `'Z'`  
Nilai:`OFFSET`, di mana `OFFSET ` direpresentasikan sebagai`<signal>hh:mm`. Contoh nilai:`01:00`,, `+01:00``-09:30`, `Z` (UTC, sama dengan 00:00)  
Tidak seperti [cap waktu](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+Types#LanguageManualTypes-timestamp) Apache Hive, yang tidak memiliki zona waktu bawaan dan disimpan sebagai offset dari zaman UNIX, stempel waktu Amazon Ion memang memiliki offset. Gunakan properti ini untuk menentukan offset saat Anda membuat serial ke Amazon Ion.  
Contoh berikut menambahkan offset satu jam.  

```
'ion.timestamp.serialization_offset' = '+01:00'       
```

**ion.serialize\$1null**  
Opsional  
Default: `OMIT`  
Nilai:`OMIT`,`UNTYPED`, `TYPED`  
Amazon Ion SerDe dapat dikonfigurasi untuk membuat serial atau menghilangkan kolom yang memiliki nilai nol. Anda dapat memilih untuk menulis nulls () yang diketik kuat atau nulls yang tidak diketik (`TYPED`). `UNTYPED` Null yang diketik dengan kuat ditentukan berdasarkan pemetaan tipe Amazon Ion ke Hive default.  
Contoh berikut menentukan null yang diketik kuat.  

```
'ion.serialize_null'='TYPED'
```

**ion.ignore\$1malformed**  
Opsional  
Default: `false`  
Nilai:`true`, `false`  
Kapan`true`, abaikan entri yang salah bentuk atau seluruh file jika tidak dapat SerDe membacanya. Untuk informasi selengkapnya, lihat [Abaikan cacat](https://github.com/amzn/ion-hive-serde/blob/master/docs/serde-properties.md#ignore-malformed) dalam dokumentasi di GitHub.

**ion. *<column>*.serialize\$1as**  
Opsional  
Default: Jenis default untuk kolom.  
Nilai: String yang berisi tipe Amazon Ion  
Menentukan tipe data Amazon Ion di mana nilai diserialisasikan. Karena jenis Amazon Ion dan Hive tidak selalu memiliki pemetaan langsung, beberapa tipe Hive memiliki beberapa tipe data yang valid untuk serialisasi. Untuk membuat serial data sebagai tipe data non-default, gunakan properti ini. Untuk informasi selengkapnya tentang pemetaan tipe, lihat halaman [pemetaan Jenis](https://github.com/amzn/ion-hive-serde/blob/master/docs/type-mapping.md) Ion Amazon. GitHub  
Secara default, kolom Hive biner diserialisasikan sebagai gumpalan Amazon Ion, tetapi mereka juga dapat diserialkan sebagai [gumpalan Ion Amazon](https://amzn.github.io/ion-docs/docs/stringclob.html#ion-clob) (objek besar karakter). Contoh berikut membuat serial kolom `example_hive_binary_column` sebagai gumpalan.  

```
'ion.example_hive_binary_column.serialize_as' = 'clob'       
```

# Gunakan ekstraktor jalur
<a name="ion-serde-using-path-extractors"></a>

Amazon Ion adalah format file gaya dokumen, tetapi Apache Hive adalah format kolom datar. Anda dapat menggunakan SerDe properti Amazon Ion khusus yang dipanggil `path extractors` untuk memetakan antara dua format. Ekstraktor jalur meratakan format Amazon Ion hierarkis, memetakan nilai Amazon Ion ke kolom Hive, dan dapat digunakan untuk mengganti nama bidang.

Athena dapat menghasilkan ekstraktor untuk Anda, tetapi Anda juga dapat menentukan ekstraktor Anda sendiri jika perlu.

**Topics**
+ [Gunakan ekstraktor jalur yang dihasilkan Athena](ion-serde-generated-path-extractors.md)
+ [Tentukan ekstraktor jalur Anda sendiri](ion-serde-specifying-your-own-path-extractors.md)
+ [Gunakan jalur pencarian di ekstraktor jalur](ion-serde-using-search-paths-in-path-extractors.md)
+ [Contoh ekstraktor jalur](ion-serde-examples.md)

# Gunakan ekstraktor jalur yang dihasilkan Athena
<a name="ion-serde-generated-path-extractors"></a>

Secara default, Athena mencari nilai Amazon Ion tingkat atas yang cocok dengan nama kolom Hive dan membuat ekstraktor jalur saat runtime berdasarkan nilai yang cocok ini. Jika format data Amazon Ion Anda cocok dengan skema tabel Hive, Athena secara dinamis menghasilkan ekstraktor untuk Anda, dan Anda tidak perlu menambahkan ekstraktor jalur tambahan apa pun. Ekstraktor jalur default ini tidak disimpan dalam metadata tabel.

Contoh berikut menunjukkan bagaimana Athena menghasilkan ekstraktor berdasarkan nama kolom.

```
-- Example Amazon Ion Document
{
    identification: {
        name: "John Smith",
        driver_license: "XXXX"
    },
    
    alias: "Johnny"    
}

-- Example DDL
CREATE EXTERNAL TABLE example_schema2 (
    identification MAP<STRING, STRING>,
    alias STRING
)
STORED AS ION
LOCATION 's3://amzn-s3-demo-bucket/path_extraction1/'
```

Contoh ekstraktor berikut dihasilkan oleh Athena. Yang pertama mengekstrak `identification` bidang ke `identification` kolom, dan yang kedua mengekstrak `alias` bidang ke `alias` kolom.

```
'ion.identification.path_extractor' = '(identification)'
'ion.alias.path_extractor' = '(alias)'
```

Contoh berikut menunjukkan tabel yang diekstraksi.

```
|                  identification                    |  alias   |
|----------------------------------------------------|----------|
|{["name", "driver_license"],["John Smith", "XXXX"]} | "Johnny" |
```

# Tentukan ekstraktor jalur Anda sendiri
<a name="ion-serde-specifying-your-own-path-extractors"></a>

Jika bidang Amazon Ion Anda tidak dipetakan dengan rapi ke kolom Hive, Anda dapat menentukan ekstraktor jalur Anda sendiri. Dalam `WITH SERDEPROPERTIES` klausa `CREATE TABLE` pernyataan Anda, gunakan sintaks berikut.

```
WITH SERDEPROPERTIES (
   "ion.path_extractor.case_sensitive" = "<Boolean>", 
   "ion.<column_name>.path_extractor" = "<path_extractor_expression>"
)
```

**catatan**  
Secara default, ekstraktor jalur tidak peka huruf besar/kecil. Untuk mengganti setelan ini, setel [ion.path_extractor.case_sensitive](ion-serde-using-ion-serde-properties.md#ioncase) SerDe properti ke`true`.

# Gunakan jalur pencarian di ekstraktor jalur
<a name="ion-serde-using-search-paths-in-path-extractors"></a>

Sintaks SerDe properti untuk path extractor berisi: *<path\$1extractor\$1expression>*

```
"ion.<column_name>.path_extractor" = "<path_extractor_expression>"         
```

Anda dapat menggunakan *<path\$1extractor\$1expression>* untuk menentukan jalur pencarian yang mem-parsing dokumen Amazon Ion dan menemukan data yang cocok. Jalur pencarian tertutup dalam tanda kurung dan dapat berisi satu atau lebih komponen berikut yang dipisahkan oleh spasi.
+ **Wild card** — Cocokkan semua nilai.
+ **Indeks** - Cocokkan nilai pada indeks numerik yang ditentukan. Indeks berbasis nol.
+ **Teks** - Cocokkan semua nilai yang cocok dengan nama bidangnya setara dengan teks yang ditentukan.
+ **Anotasi** - Mencocokkan nilai yang ditentukan oleh komponen jalur terbungkus yang memiliki anotasi yang ditentukan.

Contoh berikut menunjukkan dokumen Amazon Ion dan beberapa contoh jalur pencarian.

```
-- Amazon Ion document
{
    foo: ["foo1", "foo2"] ,
    bar: "myBarValue", 
    bar: A::"annotatedValue"
}

-- Example search paths
(foo 0)       # matches "foo1"
(1)           # matches "myBarValue"
(*)           # matches ["foo1", "foo2"], "myBarValue" and A::"annotatedValue"
()            # matches {foo: ["foo1", "foo2"] , bar: "myBarValue", bar: A::"annotatedValue"}
(bar)         # matches "myBarValue" and A::"annotatedValue"
(A::bar)      # matches A::"annotatedValue"
```

# Contoh ekstraktor jalur
<a name="ion-serde-examples"></a>

Contoh path extractor berikut menunjukkan cara meratakan dan mengganti nama bidang atau mengekstrak data sebagai teks Amazon Ion.

## Ratakan dan ganti nama bidang
<a name="ion-serde-flattening-and-renaming-fields"></a>

Contoh berikut menunjukkan satu set jalur pencarian yang meratakan dan mengganti nama bidang. Contoh menggunakan jalur pencarian untuk melakukan hal berikut:
+ Petakan `nickname` kolom ke `alias` bidang
+ Petakan `name` kolom ke `name` subbidang yang terletak di `identification` struct.

Berikut ini adalah contoh dokumen Amazon Ion.

```
-- Example Amazon Ion Document
{
    identification: {
        name: "John Smith",
        driver_license: "XXXX"
    },
    
    alias: "Johnny"    
}
```

Berikut ini adalah contoh `CREATE TABLE` pernyataan yang mendefinisikan ekstraktor jalur.

```
-- Example DDL Query
CREATE EXTERNAL TABLE example_schema2 (
    name STRING,
    nickname STRING
)
ROW FORMAT SERDE
 'com.amazon.ionhiveserde.IonHiveSerDe'
WITH SERDEPROPERTIES (
 'ion.nickname.path_extractor' = '(alias)',
 'ion.name.path_extractor' = '(identification name)'
 )
STORED AS ION
LOCATION 's3://amzn-s3-demo-bucket/path_extraction2/'
```

Contoh berikut menunjukkan data yang diekstraksi.

```
-- Extracted Table
| name         |   nickname   |
|--------------|--------------|
| "John Smith" |  "Johnny"    |
```

Untuk informasi selengkapnya tentang jalur penelusuran dan contoh jalur penelusuran tambahan, lihat halaman [Ekstraksi Jalur Ion Java](https://github.com/amzn/ion-java-path-extraction) GitHub.

## Ekstrak data penerbangan ke format teks
<a name="ion-serde-extracting-flight-data-to-text-format"></a>

Contoh `CREATE TABLE` kueri berikut digunakan `WITH SERDEPROPERTIES` untuk menambahkan ekstraktor jalur untuk mengekstrak data penerbangan dan menentukan pengkodean output sebagai teks Amazon Ion. Contoh menggunakan `STORED AS ION` sintaks.

```
CREATE EXTERNAL TABLE flights_ion (
    yr INT,
    quarter INT,
    month INT,
    dayofmonth INT,
    dayofweek INT,
    flightdate STRING,
    uniquecarrier STRING,
    airlineid INT,
)
ROW FORMAT SERDE
 'com.amazon.ionhiveserde.IonHiveSerDe'
WITH SERDEPROPERTIES (
 'ion.encoding' = 'TEXT',
 'ion.yr.path_extractor'='(year)',
 'ion.quarter.path_extractor'='(results quarter)',
 'ion.month.path_extractor'='(date month)')
STORED AS ION
LOCATION 's3://amzn-s3-demo-bucket/'
```