Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

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

Sie können Amazon Ion Hive verwenden, SerDe um Daten abzufragen, die im [Amazon Ion-Format](https://amzn.github.io/ion-docs/guides/cookbook.html) gespeichert sind. Amazon Ion ist ein reich typisiertes, selbstbeschreibendes Open-Source-Datenformat. Das Amazon Ion-Format wird in der Open-Source SQL-Abfragesprache [PartiQL](https://partiql.org/) verwendet.

Amazon Ion verfügt über Binär- und Textformate, die austauschbar sind. Dieses Feature kombiniert die Benutzerfreundlichkeit von Text mit der Effizienz der Binärcodierung.

Um Amazon Ion-Daten von Athena abzufragen, können Sie [Amazon Ion Hive verwenden SerDe, das Amazon Ion-Daten](https://github.com/amzn/ion-hive-serde) serialisiert und deserialisiert. Die Deserialisierung ermöglicht es Ihnen, Abfragen zu den Amazon-Ion-Daten auszuführen oder sie zu lesen, um sie in ein anderes Format wie Parquet oder ORC zu schreiben. Mit der Serialisierung können Sie Daten im Amazon-Ion-Format generieren, indem Sie `CREATE TABLE AS SELECT` (CTAS)- oder `INSERT INTO`-Abfragen verwenden, um Daten aus vorhandenen Tabellen zu kopieren.

**Anmerkung**  
Da Amazon Ion ein Superset von JSON ist, können Sie Amazon Ion Hive verwenden, um JSON-Datensätze abzufragen SerDe , die nicht zu Amazon Ion gehören. Im Gegensatz zu anderen [ SerDeJSON-Bibliotheken](https://docs.aws.amazon.com/athena/latest/ug/json-serde.html) erwartet Amazon Ion SerDe nicht, dass sich jede Datenzeile in einer einzigen Zeile befindet. Dieses Feature ist nützlich, wenn Sie JSON-Datensätze im „Pretty Print“-Format abfragen oder die Felder in einer Zeile mit Zeilenumbruchzeichen aufteilen möchten.

Weitere Informationen und Beispiele für die Abfrage von Amazon Ion mit Athena finden Sie unter [Analysieren von Amazon-Ion-Datensätzen mit Amazon Athena](https://aws.amazon.com/blogs/big-data/analyze-amazon-ion-datasets-using-amazon-athena/).

## Name der Serialisierungsbibliothek
<a name="library-name"></a>

Der Name der Serialisierungsbibliothek für Amazon Ion SerDe lautet`com.amazon.ionhiveserde.IonHiveSerDe`. Informationen zum Quellcode finden Sie unter [Amazon Ion Hive SerDe](https://github.com/amazon-ion/ion-hive-serde) auf GitHub .com.

## Überlegungen und Einschränkungen
<a name="ion-serde-considerations-and-limitations"></a>
+ **Doppelte Felder** – Amazon-Ion-Strukturen sind geordnet und unterstützen duplizierte Felder, während `STRUCT<>` und `MAP<>` von Hive dies nicht tun. Wenn Sie also ein dupliziertes Feld aus einer Amazon-Ion-Struktur deserialisieren, wird ein einzelner Wert nicht deterministisch gewählt und die anderen werden ignoriert.
+ **Externe Symboltabellen werden nicht unterstützt** — Derzeit unterstützt Athena keine externen Symboltabellen oder die folgenden Amazon Ion SerDe Hive-Eigenschaften:
  + `ion.catalog.class`
  + `ion.catalog.file`
  + `ion.catalog.url`
  + `ion.symbol_table_imports`
+ **Dateierweiterungen** – Amazon Ion verwendet Dateierweiterungen, um zu ermitteln, welcher Komprimierungs-Codec für die Deserialisierung von Amazon-Ion-Dateien verwendet werden soll. Als solche müssen komprimierte Dateien die Dateierweiterung haben, die dem verwendeten Komprimierungs-Algorithmus entspricht. Wenn beispielsweise ZSTD verwendet wird, sollten entsprechende Dateien die Erweiterung `.zst` haben.
+ **Homogene Daten** – Amazon Ion hat keine Beschränkungen für die Datentypen, die für Werte in bestimmten Feldern verwendet werden können. Beispielsweise können zwei verschiedene Amazon Ion-Dokumente ein Feld mit demselben Namen haben, das verschiedene Datentypen hat. Da Hive jedoch ein Schema verwendet, müssen alle Werte, die Sie in eine einzelne Hive-Spalte extrahieren, denselben Datentyp haben.
+ **Beschränkungen für Schlüsseltypen zuweisen** – Wenn Sie Daten aus einem anderen Format in Amazon Ion serialisieren, stellen Sie sicher, dass der Map-Schlüsseltyp einer von `STRING`, `VARCHAR`, oder `CHAR` ist. Obwohl Sie mit Hive jeden primitiven Datentyp als Zuordnungsschlüssel verwenden können, müssen [Amazon-Ion-Symbole](https://amzn.github.io/ion-docs/docs/symbols.html) vom Typ Zeichenfolge sein.
+ **Union-Art** – Athena unterstützt die Hive-[Union-Art](https://cwiki.apache.org/confluence/display/hive/languagemanual+types/#LanguageManualTypes-UnionTypesunionUnionTypes) derzeit nicht.
+ **Doppelter Datentyp** — Amazon Ion unterstützt den Datentyp `double` derzeit nicht.

**Topics**
+ [Name der Serialisierungsbibliothek](#library-name)
+ [Überlegungen und Einschränkungen](#ion-serde-considerations-and-limitations)
+ [Amazon-Ion-Tabellen erstellen](ion-serde-using-create-table.md)
+ [Erstellen von Amazon-Ion-Tabellen mithilfe von CTAS und INSERT INTO](ion-serde-using-ctas-and-insert-into-to-create-ion-tables.md)
+ [Amazon SerDe Ion-Immobilienreferenz](ion-serde-using-ion-serde-properties.md)
+ [Pfad-Extraktoren verwenden](ion-serde-using-path-extractors.md)

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

Um eine Tabelle in Athena aus Daten zu erstellen, die im Amazon-Ion-Format gespeichert sind, können Sie eine der folgenden Techniken in einer CREATE-TABLE-Anweisung verwenden:
+ Geben Sie an `STORED AS ION`. Bei dieser Verwendung müssen Sie Amazon Ion Hive nicht SerDe explizit angeben. Diese Wahl ist die einfachere Option.
+ Geben Sie die Amazon-Ion-Klassenpfade in den Feldern `ROW FORMAT SERDE`, `INPUTFORMAT` und `OUTPUTFORMAT` an.

Sie können auch `CREATE TABLE AS SELECT` (CTAS)-Anweisungen verwenden, um Amazon-Ion-Tabellen in Athena zu erstellen. Weitere Informationen finden Sie unter [Erstellen von Amazon-Ion-Tabellen mithilfe von CTAS und INSERT INTO](ion-serde-using-ctas-and-insert-into-to-create-ion-tables.md).

## GESPEICHERT ALS ION angeben
<a name="ion-serde-specifying-stored-as-ion"></a>

Die folgende beispielhafte `CREATE TABLE`-Anweisung verwendet `STORED AS ION` vor der `LOCATION`-Klausel, um eine Tabelle basierend auf Flugdaten im Amazon-Ion-Format zu erstellen. Die `LOCATION`-Klausel gibt den Bucket oder Ordner an, in dem sich die Eingabedateien im Ion-Format befinden. Alle Dateien am angegebenen Speicherort werden gescannt.

```
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/'
```

## Die Amazon-Ion-Klassenpfade angeben
<a name="ion-serde-specifying-the-ion-class-paths"></a>

Anstatt die `STORED AS ION`-Syntax zu verwenden, können Sie die Ion-Klassenpfadwerte für die `ROW FORMAT SERDE`-, `INPUTFORMAT`- und `OUTPUTFORMAT`-Klauseln wie folgt explizit angeben.


****  

| Parameter | Ion-Klassenpfad | 
| --- | --- | 
| ROW FORMAT SERDE | 'com.amazon.ionhiveserde.IonHiveSerDe' | 
| STORED AS INPUTFORMAT | 'com.amazon.ionhiveserde.formats.IonInputFormat' | 
| OUTPUTFORMAT | 'com.amazon.ionhiveserde.formats.IonOutputFormat' | 

Die folgende DDL-Abfrage verwendet diese Technik, um dieselbe externe Tabelle wie im vorherigen Beispiel zu erstellen.

```
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/'
```

Informationen zu den SerDe Eigenschaften von `CREATE TABLE` Anweisungen in Athena finden Sie unter[Amazon SerDe Ion-Immobilienreferenz](ion-serde-using-ion-serde-properties.md).

# Erstellen von Amazon-Ion-Tabellen mithilfe von CTAS und INSERT INTO
<a name="ion-serde-using-ctas-and-insert-into-to-create-ion-tables"></a>

Sie können die Anweisungen `CREATE TABLE AS SELECT` (CTAS) und `INSERT INTO` verwenden, um Daten aus einer Tabelle in eine neue Tabelle im Amazon-Ion-Format in Athena zu kopieren oder einzufügen.

Geben Sie in einer CTAS-Abfrage `format='ION'` in der `WITH`-Klausel an, wie im folgenden Beispiel.

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

Standardmäßig serialisiert Athena Amazon Ion-Ergebnisse im [Ion-Binärformat](https://amzn.github.io/ion-docs/docs/binary.html), aber Sie können auch das Textformat verwenden. Um das Textformat zu verwenden, geben Sie `ion_encoding = 'TEXT'` in der CTAS-`WITH`-Klausel an, wie im folgenden Beispiel.

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

Weitere Informationen zu Amazon-Ion-spezifischen Eigenschaften in der CTAS-`WITH`-Klausel finden Sie in [Amazon-Ion-Eigenschaften für die CTAS-WITH-Klausel](#ion-serde-ctas-with-clause-properties).

## Amazon-Ion-Eigenschaften für die CTAS-WITH-Klausel
<a name="ion-serde-ctas-with-clause-properties"></a>

In einer CTAS-Abfrage können Sie die `WITH` Klausel verwenden, um das Amazon Ion-Format und optional den zu verwendenden Amazon and/or Ion-Kodierungs-Schreibkomprimierungsalgorithmus anzugeben.

**Format**  
Sie können das Schlüsselwort `ION` als Formatoption in der `WITH`-Klausel einer CTAS-Abfrage angeben. Wenn Sie dies tun, verwendet die von Ihnen erstellte Tabelle das Format, das Sie für `IonInputFormat` für Lesevorgänge angeben, und sie serialisiert Daten in dem Format, das Sie für `IonOutputFormat` angeben.  
Im folgenden Beispiel wird angegeben, dass die CTAS-Abfrage das Amazon-Ion-Format verwendet.  

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

**ion\$1encoding**  
Optional  
Standard: `BINARY`  
Werte: `BINARY`, `TEXT`  
Gibt an, ob Daten im Amazon-Ion-Binärformat oder im Amazon-Ion-Textformat serialisiert werden. Im folgenden Beispiel wird das Amazon-Ion-Textformat angegeben.  

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

**write\$1compression**  
Optional  
Standard: `GZIP`  
Werte: `GZIP`, `ZSTD`, `BZIP2`, `SNAPPY`, `NONE`  
Gibt den Komprimierungs-Algorithmus an, der zum Komprimieren von Ausgabedateien verwendet werden soll.  
Das folgende Beispiel gibt an, dass die CTAS-Abfrage ihre Ausgabe im Amazon-Ion-Format unter Verwendung des [Zstandard](https://facebook.github.io/zstd/)-Komprimierungs-Algorithmus schreibt.  

```
WITH (format='ION', write_compression = 'ZSTD')       
```
Weitere Informationen zur Verwendung der Komprimierung in Athena finden Sie unter [Komprimierung in Athena verwenden](compression-formats.md). 

Weitere CTAS-Eigenschaften in Athena finden Sie unter [CTAS-Tabelleneigenschaften](create-table-as.md#ctas-table-properties).

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

Dieses Thema enthält Informationen zu den SerDe Eigenschaften von `CREATE TABLE` Anweisungen in Athena. Weitere Informationen und Beispiele für die Nutzung von Amazon SerDe Ion-Eigenschaften finden Sie unter [SerDe Eigenschaften](https://github.com/amzn/ion-hive-serde/blob/master/docs/serde-properties.md) in der Amazon Ion SerDe Hive-Dokumentation unter. [GitHub](https://github.com/amzn/ion-hive-serde/tree/master/docs)

## So geben Sie Amazon SerDe Ion-Eigenschaften an
<a name="ion-serde-specifying-ion-serde-properties"></a>

Verwenden Sie die `WITH SERDEPROPERTIES` Klausel, um Eigenschaften für Amazon Ion Hive SerDe in Ihrem `CREATE TABLE` Kontoauszug anzugeben. Da `WITH SERDEPROPERTIES` es sich um ein Unterfeld der `ROW FORMAT SERDE` Klausel handelt, müssen Sie zuerst den Amazon Ion SerDe Hive-Klassenpfad angeben`ROW FORMAT SERDE`, wie die folgende Syntax zeigt.

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

Beachten Sie, dass, obwohl die `ROW FORMAT SERDE`-Klausel erforderlich ist, wenn Sie `WITH SERDEPROPERTIES` verwenden möchten, Sie entweder `STORED AS ION` oder die längere `INPUTFORMAT`- und `OUTPUTFORMAT`-Syntax verwenden können, um das Amazon-Ion-Format anzugeben.

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

Im Folgenden sind die Amazon SerDe Ion-Eigenschaften aufgeführt, die in `CREATE TABLE` Aussagen in Athena verwendet werden können.

**ion.encoding**  
Optional  
Standard: `BINARY`  
Werte: `BINARY`, `TEXT`  
Diese Eigenschaft gibt an, ob neu hinzugefügte Werte als [Amazon-Ion-Binär](https://amzn.github.io/ion-docs/docs/binary.html) oder Amazon-Ion-Textformat serialisiert werden.  
Das folgende SerDe Eigenschaftsbeispiel spezifiziert das Amazon Ion-Textformat.  

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

**ion.fail\$1on\$1overflow**  
Optional  
Standard: `true`  
Werte: `true`, `false`  
Amazon Ion erlaubt beliebig große numerische Typen, während Hive dies nicht tut. Standardmäßig SerDe schlägt das fehl, wenn der Amazon Ion-Wert nicht in die Hive-Spalte passt. Sie können jedoch die `fail_on_overflow` Konfigurationsoption verwenden, um den Wert überlaufen zu lassen, anstatt dass er fehlschlägt.  
Diese Eigenschaft kann entweder auf Tabellen- oder Spaltenebene festgelegt werden. Um es auf Tabellenebene anzugeben, geben Sie `ion.fail_on_overflow` wie im folgenden Beispiel an. Dies legt das Standardverhalten für alle Spalten fest.  

```
'ion.fail_on_overflow' = 'true'
```
Um eine bestimmte Spalte zu steuern, geben Sie den Spaltennamen zwischen `ion` und `fail_on_overflow` an, getrennt durch Punkte, wie im folgenden Beispiel.  

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

**ion.path\$1extractor.case\$1sensitive**  
Optional  
Standard: `false`  
Werte: `true`, `false`  
Bestimmt, ob bei Amazon-Ion-Feldnamen die Groß-/Kleinschreibung beachtet werden soll. Wenn`false`, SerDe ignoriert der Amazon Ion-Feldnamen bei der Groß- und Kleinschreibung.  
Angenommen, Sie haben ein Hive-Tabellenschema, das ein Feld `alias` in Kleinbuchstaben definiert, und ein Amazon Ion-Dokument mit sowohl einem `alias`-Feld als auch einem `ALIAS`-Feld, wie im folgenden Beispiel.  

```
-- Hive Table Schema
alias: STRING

-- Amazon Ion Document
{ 'ALIAS': 'value1'} 
{ 'alias': 'value2'}
```
Das folgende Beispiel zeigt SerDe Eigenschaften und die daraus resultierende extrahierte Tabelle, wenn die Berücksichtigung von Groß- und Kleinschreibung auf eingestellt ist: `false`  

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

--Extracted Table
| alias    |
|----------|
| "value1" |
| "value2" |
```
Das folgende Beispiel zeigt SerDe Eigenschaften und die daraus resultierende extrahierte Tabelle, wenn die Groß- und Kleinschreibung auf eingestellt ist`true`:  

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

--Extracted Table
| alias    |
|----------|
| "value2" |
```
Im zweiten Fall wird `value1` für das `ALIAS`-Feld ignoriert, wenn die Groß-/Kleinschreibung auf `true` eingestellt ist und der Pfad-Extraktor als `alias` angegeben ist.

**Ion. *<column>*.path\$1extractor**  
Optional  
Standard: Nicht angegeben  
Werte: Zeichenfolge mit Suchpfad  
Erstellt einen Pfad-Extraktor mit dem angegebenen Suchpfad für die angegebene Spalte. Pfad-Extraktoren ordnen Amazon-Ion-Felder Hive-Spalten zu. Wenn keine Pfad-Extraktoren angegeben werden, erstellt Athena dynamisch Pfad-Extraktoren zur Laufzeit basierend auf Spaltennamen.  
Im folgenden Beispiel wird der Pfad-Extraktor `example_ion_field` zum `example_hive_column` zugeordnet.  

```
'ion.example_hive_column.path_extractor' = '(example_ion_field)'
```
Weitere Informationen zu Pfad-Extraktoren und Suchpfaden finden Sie unter [Pfad-Extraktoren verwenden](ion-serde-using-path-extractors.md).

**ion.timestamp.serialization\$1offset**  
Optional  
Standard: `'Z'`  
Werte: `OFFSET`, wobei `OFFSET ` als `<signal>hh:mm` dargestellt wird. Beispielwerte: `01:00`, `+01:00`, `-09:30`, `Z` (UTC, wie 00:00 Uhr)  
Im Gegensatz zu Apache-Hive-[Zeitstempeln](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+Types#LanguageManualTypes-timestamp), die keine integrierte Zeitzone haben und als Offset von der UNIX-Epoche gespeichert werden, haben Amazon-Ion-Zeitstempel einen Offset. Verwenden Sie diese Eigenschaft, um den Offset anzugeben, wenn Sie auf Amazon Ion serialisieren.  
Im folgenden Beispiel wird ein Offset von einer Stunde hinzugefügt.  

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

**ion.serialize\$1null**  
Optional  
Standard: `OMIT`  
Werte: `OMIT`, `UNTYPED`, `TYPED`  
Amazon Ion SerDe kann so konfiguriert werden, dass Spalten mit Nullwerten entweder serialisiert oder weggelassen werden. Sie können wählen, stark typisierte Nullen auszuschreiben (`TYPED`) oder nicht typisierte Nullen (`UNTYPED`) enthalten. Stark typisierte Nullen werden basierend auf der Standardzuordnung des Typs Amazon Ion zu Hive bestimmt.  
Das folgende Beispiel gibt stark typisierte Nullen an.  

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

**ion.ignore\$1malformed**  
Optional  
Standard: `false`  
Werte: `true`, `false`  
Wenn`true`, ignoriert falsch formatierte Einträge oder die gesamte Datei, wenn sie nicht gelesen SerDe werden kann. Weitere Informationen finden Sie unter [Fehlformatierte Dateien ignorieren](https://github.com/amzn/ion-hive-serde/blob/master/docs/serde-properties.md#ignore-malformed) in der Dokumentation zu. GitHub

**Ion. *<column>*.serialize\$1as**  
Optional  
Standard: Standardtyp für die Spalte.  
Werte: Zeichenfolge mit Amazon-Ion-Typ  
Bestimmt den Amazon-Ion-Datentyp, in dem ein Wert serialisiert wird. Da Amazon-Ion- und Hive-Typen nicht immer über eine direkte Zuordnung verfügen, haben einige Hive-Typen mehrere gültige Datentypen für die Serialisierung. Verwenden Sie diese Eigenschaft, um Daten als nicht standardmäßigen Datentyp zu serialisieren. Weitere Informationen zur Typenzuweisung finden Sie auf der Seite Amazon Ion [Type Mapping](https://github.com/amzn/ion-hive-serde/blob/master/docs/type-mapping.md) unter GitHub.  
Standardmäßig werden binäre Hive-Spalten als Amazon-Ion-Blobs serialisiert, sie können aber auch als [Amazon-Ion-Clob](https://amzn.github.io/ion-docs/docs/stringclob.html#ion-clob) (Character Large Object) serialisiert werden. Im folgenden Beispiel wird die Spalte `example_hive_binary_column` als Clob serialisiert.  

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

# Pfad-Extraktoren verwenden
<a name="ion-serde-using-path-extractors"></a>

Amazon Ion ist ein Dateiformat im Dokumentstil, aber Apache Hive ist ein flaches Säulenformat. Sie können spezielle Amazon SerDe Ion-Eigenschaften verwenden, die aufgerufen werden`path extractors`, um die beiden Formate zuzuordnen. Pfad-Extraktoren flachen das hierarchische Amazon-Ion-Format ab, ordnen Amazon-Ion-Werte Hive-Spalten zu und können zum Umbenennen von Feldern verwendet werden.

Athena kann die Extraktoren für Sie generieren, aber Sie können bei Bedarf auch Ihre eigenen Extraktoren definieren.

**Topics**
+ [Von Athena generierte Pfadextraktoren verwenden](ion-serde-generated-path-extractors.md)
+ [Ihre eigenen Pfad-Extraktoren angeben](ion-serde-specifying-your-own-path-extractors.md)
+ [Suchpfaden in Pfad-Extraktoren verwenden](ion-serde-using-search-paths-in-path-extractors.md)
+ [Beispiele für Pfadextraktoren](ion-serde-examples.md)

# Von Athena generierte Pfadextraktoren verwenden
<a name="ion-serde-generated-path-extractors"></a>

Standardmäßig sucht Athena nach Amazon-Ion-Werten der obersten Ebene, die Hive-Spaltennamen entsprechen, und erstellt zur Laufzeit Pfad-Extraktoren basierend auf diesen übereinstimmenden Werten. Wenn Ihr Amazon-Ion-Datenformat mit dem Hive-Tabellenschema übereinstimmt, generiert Athena die Extraktoren dynamisch für Sie und Sie müssen keine zusätzlichen Pfad-Extraktoren hinzufügen. Diese Standard-Pfad-Extraktoren werden nicht in den Tabellen-Metadaten gespeichert.

Im folgenden Beispiel wird gezeigt, wie Athena Extraktoren basierend auf dem Spaltennamen generiert.

```
-- 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/'
```

Die folgenden Beispiel-Extraktoren werden von Athena generiert. Der erste extrahiert das `identification`-Feld in die `identification`-Spalte und der zweite extrahiert das `alias`-Feld in die `alias`-Spalte.

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

Das folgende Beispiel zeigt die extrahierte Tabelle.

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

# Ihre eigenen Pfad-Extraktoren angeben
<a name="ion-serde-specifying-your-own-path-extractors"></a>

Wenn Ihre Amazon-Ion-Felder nicht ordentlich Hive-Spalten zugeordnet werden, können Sie Ihre eigenen Pfad-Extraktoren angeben. Verwenden Sie in der `WITH SERDEPROPERTIES`-Klausel Ihrer `CREATE TABLE`-Anweisung die folgende Syntax.

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

**Anmerkung**  
Standardmäßig wird nicht zwischen Groß- und Kleinschreibung unterschieden. Um diese Einstellung zu überschreiben, setzen Sie die [ion.path_extractor.case_sensitive](ion-serde-using-ion-serde-properties.md#ioncase) SerDe Eigenschaft auf`true`.

# Suchpfaden in Pfad-Extraktoren verwenden
<a name="ion-serde-using-search-paths-in-path-extractors"></a>

Die SerDe Eigenschaftssyntax für Path Extractor enthält: *<path\$1extractor\$1expression>*

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

Sie können den verwenden*<path\$1extractor\$1expression>*, um einen Suchpfad anzugeben, der das Amazon Ion-Dokument analysiert und passende Daten findet. Der Suchpfad ist in Klammern eingeschlossen und kann eine oder mehrere der folgenden durch Leerzeichen getrennten Komponenten enthalten.
+ **Platzhalter** – Entspricht allen Werten.
+ **Index** – Entspricht dem Wert beim angegebenen numerischen Index. Die Indizes sind nullbasiert.
+ **Text** – Entspricht allen Werten, deren Feldnamen übereinstimmen, dem angegebenen Text entsprechen.
+ **Annotationen** – Entspricht Werten, die durch eine umbrochene Pfadkomponente angegeben wurden, für die die Anmerkungen angegeben wurden.

Das folgende Beispiel zeigt ein Amazon-Ion-Dokument und einige Beispiel-Suchpfade.

```
-- 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"
```

# Beispiele für Pfadextraktoren
<a name="ion-serde-examples"></a>

Die folgenden Beispiele für Pfadextraktoren zeigen, wie Sie Felder abflachen und umbenennen oder Daten als Amazon Ion-Text extrahieren.

## Felder abflachen und umbenennen
<a name="ion-serde-flattening-and-renaming-fields"></a>

Das folgende Beispiel zeigt eine Reihe von Suchpfaden, die Felder abflachen und umbenennen. Im Beispiel werden Suchpfade verwendet, um Folgendes durchzuführen:
+ Ordnen Sie die `nickname`-Spalte dem `alias`-Feld zu
+ Ordnen Sie die `name`-Spalte dem `name`-Unterfeld zu, das sich in der `identification`-Struktur befindet.

Es folgt das Beispiel für Amazon-Ion-Dokument.

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

Das Folgende ist die beispielhafte `CREATE TABLE`-Anweisung, die die Pfad-Extraktoren definiert.

```
-- 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/'
```

Das folgende Beispiel zeigt die extrahierten Dateien.

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

Weitere Informationen zu Suchpfaden und weitere Beispiele für Suchpfade finden Sie auf GitHub der Seite [Ion Java Path Extraction](https://github.com/amzn/ion-java-path-extraction) unter.

## Flugdaten in Textformat extrahieren
<a name="ion-serde-extracting-flight-data-to-text-format"></a>

Die folgende `CREATE TABLE`-Beispielabfrage verwendet `WITH SERDEPROPERTIES`, um Pfad-Extraktoren zum Extrahieren von Flugdaten hinzuzufügen und die Ausgabecodierung als Amazon-Ion-Text anzugeben. Im Beispiel wird die `STORED AS ION`-Syntax verwendet.

```
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/'
```