Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Utiliser SerDes
Athena prend en charge plusieurs bibliothèques SerDe (sérialiseur/désérialiseur) qui analysent les données provenant de divers formats de données. Lorsque vous créez un tableau dans Athena, vous pouvez spécifier un SerDe qui correspond au format de vos données. Athena ne prend pas en charge la personnalisation. SerDes
Athena peut utiliser des SerDe bibliothèques pour créer des tables à partir des formats CSV, TSV, délimités de manière personnalisée et JSON ; des données à partir des formats ORC, Avro et Parquet liés à Hadoop ; des journaux de Logstash, des journaux et des journaux Apache. AWS CloudTrail WebServer Chacun de ces formats de données possède une ou plusieurs SerDe bibliothèques de sérialiseur-désérialiseur () qu'Athena peut utiliser pour analyser les données.
**Note**
Les formats répertoriés dans cette section sont utilisés par Athena pour la lecture des données. Pour plus d'informations sur les formats utilisés par Athena pour écrire des données lors de l'exécution des requêtes CTAS, voir [Création d’une table à partir des résultats des requêtes (CTAS)](ctas.md).
**Topics**
+ [Choisissez un SerDe pour vos données](supported-serdes.md)
+ [Utiliser un SerDe pour créer une table](serde-create-a-table.md)
+ [Amazon Ion Hive SerDe](ion-serde.md)
+ [Avro SerDe](avro-serde.md)
+ [Grok SerDe](grok-serde.md)
+ [SerDe bibliothèques JSON](json-serde.md)
+ [SerDe bibliothèques CSV](serde-csv-choices.md)
+ [ORC SerDe](orc-serde.md)
+ [Parquet SerDe](parquet-serde.md)
+ [Régex SerDe](regex-serde.md)
# Choisissez un SerDe pour vos données
Le tableau suivant répertorie les formats de données pris en charge par Athena et les bibliothèques correspondantes SerDe .
**Formats de données pris en charge et SerDes**
| Format de données | Description | SerDe types pris en charge dans Athena |
| --- | --- | --- |
| Amazon Ion | Amazon Ion est un format de données abondamment typé et auto-descriptif qui est un superensemble de JSON, développé et ouvert par Amazon. | Utilisez [Amazon Ion Hive SerDe](ion-serde.md). |
| Apache Avro | Format d'enregistrement des données dans Hadoop qui utilise des schémas basés sur JSON pour les valeurs d'enregistrement. | Utilisez [Avro SerDe](avro-serde.md). |
| Apache Parquet | Format pour le stockage en colonnes des données dans Hadoop. | Utilisez le type [Parquet SerDe](parquet-serde.md) et la compression SNAPPY. |
| WebServer Journaux Apache | Format de stockage des journaux dans Apache WebServer. | Utilisez le type [Grok SerDe](grok-serde.md) ou [Régex SerDe](regex-serde.md). |
| CloudTrail journaux | Format de stockage des connexions CloudTrail. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/athena/latest/ug/supported-serdes.html) |
| CSV (valeurs séparées par des virgules) | Pour les données au format CSV, chaque ligne représente un enregistrement de données, et chaque enregistrement se compose d'un ou de plusieurs champs, séparés par des virgules. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/athena/latest/ug/supported-serdes.html) |
| Séparateur personnalisé | Pour les données qui se trouvent dans ce format, chaque ligne représente un enregistrement de données. Les enregistrements sont séparés par des délimiteurs personnalisés. | Utilisez le type [Lazy Simple SerDe pour les fichiers CSV, TSV et délimités sur mesure](lazy-simple-serde.md) et spécifiez un séparateur à caractère unique personnalisé. |
| JSON (notation JavaScript d'objet) | Pour les données JSON, chaque ligne représente un enregistrement de données, et chaque enregistrement se compose de paires attribut-valeur et de tableaux, séparés par des virgules. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/athena/latest/ug/supported-serdes.html) |
| Journaux Logstash | Format pour le stockage des fichiers journaux dans Logstash. | Utilisez [Grok SerDe](grok-serde.md). |
| ORC (Optimized Row Columnar) | Format pour le stockage en colonnes optimisé des données Hive. | Utilisez le type [ORC SerDe](orc-serde.md) et la compression ZLIB. |
| TSV (valeurs séparées par des tabulations) | Pour les données au format TSV, chaque ligne représente un enregistrement de données, et chaque enregistrement se compose d'un ou de plusieurs champs, séparés par des tabulations. | Utilisez le type [Lazy Simple SerDe pour les fichiers CSV, TSV et délimités sur mesure](lazy-simple-serde.md) et spécifiez le caractère séparateur sous la forme `FIELDS TERMINATED BY '\t'`. |
# Utiliser un SerDe pour créer une table
Pour utiliser un SerDe lors de la création d'une table dans Athena, appliquez l'une des méthodes suivantes :
+ Spécifiez `ROW FORMAT DELIMITED`, puis utilisez des instructions DDL pour spécifier des délimiteurs de champs, comme dans l'exemple suivant. Lorsque vous le spécifiez`ROW FORMAT DELIMITED`, Athena utilise le LazySimpleSerDe par défaut.
```
ROW FORMAT DELIMITED
FIELDS TERMINATED BY ','
ESCAPED BY '\\'
COLLECTION ITEMS TERMINATED BY '|'
MAP KEYS TERMINATED BY ':'
```
Pour des exemples de `ROW FORMAT DELIMITED`, consultez les rubriques suivantes :
[Lazy Simple SerDe pour les fichiers CSV, TSV et délimités sur mesure](lazy-simple-serde.md)
[Interrogez les CloudFront journaux d'Amazon](cloudfront-logs.md)
[Interrogation des journaux Amazon EMR](emr-logs.md)
[Interrogation des journaux de flux Amazon VPC](vpc-flow-logs.md)
[Utilisation de CTAS et INSERT INTO pour les opérations ETL et l’analyse des données](ctas-insert-into-etl.md)
+ `ROW FORMAT SERDE`À utiliser pour spécifier explicitement le type SerDe qu'Athéna doit utiliser lorsqu'elle lit et écrit des données dans la table. L'exemple suivant spécifie le LazySimpleSerDe. Pour spécifier les délimiteurs, utilisez `WITH SERDEPROPERTIES`. Les propriétés spécifiées par `WITH SERDEPROPERTIES` correspondent aux instructions séparées (comme `FIELDS TERMINATED BY`) dans l'exemple `ROW FORMAT DELIMITED`.
```
ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe'
WITH SERDEPROPERTIES (
'serialization.format' = ',',
'field.delim' = ',',
'collection.delim' = '|',
'mapkey.delim' = ':',
'escape.delim' = '\\'
)
```
Pour des exemples de `ROW FORMAT SERDE`, consultez les rubriques suivantes :
[Avro SerDe](avro-serde.md)
[Grok SerDe](grok-serde.md)
[SerDe bibliothèques JSON](json-serde.md)
[Ouvrez le fichier CSV SerDe pour le traitement du fichier CSV](csv-serde.md)
[Régex SerDe](regex-serde.md)
# Amazon Ion Hive SerDe
Vous pouvez utiliser Amazon Ion Hive SerDe pour interroger les données stockées au format [Amazon Ion](https://amzn.github.io/ion-docs/guides/cookbook.html). Amazon Ion est un format de données open source riche et auto-descriptif. Le format Amazon Ion est utilisé dans le langage de requête SQL open source [PartiQL](https://partiql.org/).
Amazon Ion possède des formats binaires et texte interchangeables. Cette fonction combine la facilité d'utilisation du texte avec l'efficacité du codage binaire.
Pour interroger les données Amazon Ion auprès d'Athena, vous pouvez utiliser [Amazon Ion Hive SerDe](https://github.com/amzn/ion-hive-serde), qui sérialise et désérialise les données Amazon Ion. La désérialisation vous permet d'exécuter des requêtes sur les données Amazon Ion ou de les lire pour écrire dans un format différent comme Parquet ou ORC. La sérialisation vous permet de générer des données au format Amazon Ion en utilisant des requêtes `CREATE TABLE AS SELECT` (CTAS) ou `INSERT INTO` pour copier des données à partir de tables existantes.
**Note**
Amazon Ion étant un sur-ensemble de JSON, vous pouvez utiliser Amazon Ion Hive SerDe pour interroger des ensembles de données JSON autres qu'Amazon Ion. Contrairement aux autres [ SerDebibliothèques JSON](https://docs.aws.amazon.com/athena/latest/ug/json-serde.html), Amazon Ion SerDe ne s'attend pas à ce que chaque ligne de données se trouve sur une seule ligne. Cette fonction est utile si vous souhaitez interroger des jeux de données JSON au format « pretty print » ou si vous souhaitez diviser les champs d'une ligne avec des caractères de saut de ligne.
Pour obtenir des informations supplémentaires et des exemples d'interrogation d'Amazon Ion avec Athena, consultez [Analyser des ensembles de données Amazon Ion à l'aide d'Amazon Athena](https://aws.amazon.com/blogs/big-data/analyze-amazon-ion-datasets-using-amazon-athena/).
## Nom de la bibliothèque de sérialisation
Le nom de la bibliothèque de sérialisation pour Amazon Ion SerDe est`com.amazon.ionhiveserde.IonHiveSerDe`. Pour obtenir des informations sur le code source, consultez [Amazon Ion Hive SerDe](https://github.com/amazon-ion/ion-hive-serde) sur GitHub .com.
## Considérations et restrictions
+ **Champs dupliqués** – Les structures Amazon Ion sont commandées et prennent en charge les champs dupliqués, tandis que ce n'est pas le cas pour les structures `STRUCT<>` et `MAP<>`. Ainsi, lorsque vous désérialisez un champ dupliqué à partir d'une structure Amazon Ion, une seule valeur est choisie de façon non déterministe et les autres sont ignorées.
+ **Tables de symboles externes non prises en charge** — Actuellement, Athena ne prend pas en charge les tables de symboles externes ni les propriétés Amazon Ion SerDe Hive suivantes :
+ `ion.catalog.class`
+ `ion.catalog.file`
+ `ion.catalog.url`
+ `ion.symbol_table_imports`
+ **Extensions de fichier** – Amazon Ion utilise des extensions de fichiers pour déterminer quel codec de compression utiliser pour désérialiser les fichiers Amazon Ion. Par conséquent, les fichiers compressés doivent avoir l'extension de fichier correspondant à l'algorithme de compression utilisé. Par exemple, si ZSTD est utilisé, les fichiers correspondants doivent porter l'extension `.zst`.
+ **Données homogènes** – Amazon Ion n'a aucune restriction sur les types de données qui peuvent être utilisés pour des valeurs dans des champs particuliers. Par exemple, deux documents Amazon Ion différents peuvent comporter un champ portant le même nom et possédant des types de données différents. Toutefois, comme Hive utilise un schéma, toutes les valeurs que vous extrayez dans une seule colonne Hive doivent avoir le même type de données.
+ **Restrictions relatives aux types de clés** – Lorsque vous sérialisez des données d'un autre format dans Amazon Ion, assurez-vous que le type de clé de mappage est l'un des suivants : `STRING`, `VARCHAR`, ou `CHAR`. Bien que Hive vous permette d'utiliser n'importe quel type de données primitif comme clé de mappage, [Amazon Ion symbols](https://amzn.github.io/ion-docs/docs/symbols.html) (symboles Amazon Ion) doit être un type de chaîne.
+ **Type union** – Athena ne prend pas actuellement en charge le [type union](https://cwiki.apache.org/confluence/display/hive/languagemanual+types/#LanguageManualTypes-UnionTypesunionUnionTypes) de Hive.
+ **Type de données double** : Amazon Ion ne prend actuellement pas en charge le type de données `double`.
**Topics**
+ [Nom de la bibliothèque de sérialisation](#library-name)
+ [Considérations et restrictions](#ion-serde-considerations-and-limitations)
+ [Création de tables Amazon Ion](ion-serde-using-create-table.md)
+ [Utilisation de CTAS et de INSERT INTO pour créer des tables Amazon Ion](ion-serde-using-ctas-and-insert-into-to-create-ion-tables.md)
+ [Référence de SerDe propriété Amazon Ion](ion-serde-using-ion-serde-properties.md)
+ [Utilisation des extracteurs de chemin](ion-serde-using-path-extractors.md)
# Création de tables Amazon Ion
Pour créer une table dans Athena à partir de données stockées au format Amazon Ion, vous pouvez utiliser l'une des techniques suivantes dans une instruction CREATE TABLE :
+ Spécifiez `STORED AS ION`. Dans le cadre de cette utilisation, il n'est pas nécessaire de spécifier l'Amazon Ion Hive de SerDe manière explicite. Ce choix est l'option la plus simple.
+ Spécifiez les chemins d'accès de classe Amazon Ion dans les champs `ROW FORMAT SERDE`, `INPUTFORMAT`, et `OUTPUTFORMAT`.
Vous pouvez également utiliser des instructions `CREATE TABLE AS SELECT` (CTAS) pour créer des tables Amazon Ion dans Athena. Pour plus d'informations, consultez [Utilisation de CTAS et de INSERT INTO pour créer des tables Amazon Ion](ion-serde-using-ctas-and-insert-into-to-create-ion-tables.md).
## Spécification de STORED AS ION
L'exemple d'instruction `CREATE TABLE` suivant utilise la `STORED AS ION` avant la clause `LOCATION` pour créer une table basée sur des données de vol au format Amazon Ion. La clause `LOCATION` indique le compartiment ou le dossier où se trouvent les fichiers d'entrée au format Ion. Tous les fichiers se trouvant à l'emplacement spécifié sont analysés.
```
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/'
```
## Spécification des chemins de classe Amazon Ion
Au lieu d'utiliser la syntaxe `STORED AS ION`, vous pouvez spécifier explicitement les valeurs de chemin d'accès de classe Ion pour les clauses `ROW FORMAT SERDE`, `INPUTFORMAT`, et `OUTPUTFORMAT` comme suit.
****
| Paramètre | Chemin de classe Ion |
| --- | --- |
| ROW FORMAT SERDE | 'com.amazon.ionhiveserde.IonHiveSerDe' |
| STORED AS INPUTFORMAT | 'com.amazon.ionhiveserde.formats.IonInputFormat' |
| OUTPUTFORMAT | 'com.amazon.ionhiveserde.formats.IonOutputFormat' |
La requête DDL suivante utilise cette technique pour créer la même table externe que dans l'exemple précédent.
```
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/'
```
Pour plus d'informations sur les SerDe propriétés des `CREATE TABLE` déclarations dans Athéna, consultez. [Référence de SerDe propriété Amazon Ion](ion-serde-using-ion-serde-properties.md)
# Utilisation de CTAS et de INSERT INTO pour créer des tables Amazon Ion
Vous pouvez utiliser les instructions `CREATE TABLE AS SELECT` (CTAS) et `INSERT INTO` pour copier ou insérer des données d'une table dans une nouvelle table au format Amazon Ion dans Athena.
Dans une requête CTAS, spécifiez `format='ION'` dans la clause `WITH`, comme dans l'exemple suivant.
```
CREATE TABLE new_table
WITH (format='ION')
AS SELECT * from existing_table
```
Par défaut, Athena sérialise les résultats Amazon Ion dans un [format binaire Ion](https://amzn.github.io/ion-docs/docs/binary.html), mais vous pouvez également utiliser le format texte. Pour utiliser un format texte, spécifiez `ion_encoding = 'TEXT'` dans la clause `WITH` CTAS, comme dans l'exemple suivant.
```
CREATE TABLE new_table
WITH (format='ION', ion_encoding = 'TEXT')
AS SELECT * from existing_table
```
Pour plus d’informations sur les propriétés spécifiques à Amazon Ion dans la clause `WITH` CTAS, consultez [Propriétés Amazon Ion de la clause WITH CTAS](#ion-serde-ctas-with-clause-properties).
## Propriétés Amazon Ion de la clause WITH CTAS
Dans une requête CTAS, vous pouvez utiliser la `WITH` clause pour spécifier le format Amazon Ion et éventuellement spécifier l'algorithme de compression d' and/or écriture et de codage Amazon Ion à utiliser.
**format**
Vous pouvez spécifier le mot-clé `ION` comme option de format dans la clause `WITH` d'une requête CTAS. Lorsque vous le faites, la table que vous créez utilise le format que vous spécifiez pour `IonInputFormat` pour les lectures, et il sérialise les données dans le format que vous spécifiez pour `IonOutputFormat`.
L'exemple suivant indique que la requête CTAS utilise le format Amazon Ion.
```
WITH (format='ION')
```
**ion\$1encoding**
Facultatif
Valeur par défaut : `BINARY`
Valeurs: `BINARY`, `TEXT`
Spécifie si les données sont sérialisées au format binaire Amazon Ion ou au format texte Amazon Ion. L'exemple suivant spécifie le format de texte Amazon Ion.
```
WITH (format='ION', ion_encoding='TEXT')
```
**write\$1compression**
Facultatif
Valeur par défaut : `GZIP`
Valeurs : `GZIP`, `ZSTD`, `BZIP2`, `SNAPPY`, `NONE`
Spécifie l'algorithme de compression à utiliser pour compresser les fichiers de sortie.
L'exemple suivant indique que la requête CTAS écrit sa sortie au format Amazon Ion à l'aide de l'algorithme de compression [Zstandard](https://facebook.github.io/zstd/).
```
WITH (format='ION', write_compression = 'ZSTD')
```
Pour plus d'informations sur l'utilisation de la compression sur Athena, consultez [Utilisation de la compression dans Athena](compression-formats.md).
Pour plus d'informations sur les autres propriétés CTAS dans Athena, consultez [Propriétés de la table CTAS](create-table-as.md#ctas-table-properties).
# Référence de SerDe propriété Amazon Ion
Cette rubrique contient des informations sur les SerDe propriétés des `CREATE TABLE` instructions dans Athena. Pour plus d'informations et des exemples d'utilisation des SerDe propriétés Amazon Ion, consultez les [SerDe propriétés](https://github.com/amzn/ion-hive-serde/blob/master/docs/serde-properties.md) dans la SerDe documentation Amazon Ion Hive sur [GitHub](https://github.com/amzn/ion-hive-serde/tree/master/docs).
## Comment spécifier les SerDe propriétés d'Amazon Ion
Pour spécifier les propriétés d'Amazon Ion Hive SerDe dans votre `CREATE TABLE` relevé, utilisez la `WITH SERDEPROPERTIES` clause. Comme il `WITH SERDEPROPERTIES` s'agit d'un sous-champ de la `ROW FORMAT SERDE` clause, vous devez d'abord spécifier `ROW FORMAT SERDE` le chemin de SerDe classe Amazon Ion Hive, comme le montre la syntaxe suivante.
```
...
ROW FORMAT SERDE
'com.amazon.ionhiveserde.IonHiveSerDe'
WITH SERDEPROPERTIES (
'property' = 'value',
'property' = 'value',
...
)
```
Remarque : bien que la clause `ROW FORMAT SERDE` est obligatoire si vous voulez utiliser `WITH SERDEPROPERTIES`, vous pouvez utiliser `STORED AS ION` ou le plus long `INPUTFORMAT` et la syntaxe `OUTPUTFORMAT` pour spécifier le format Amazon Ion.
## SerDe Propriétés d'Amazon Ion
Vous trouverez ci-dessous les SerDe propriétés Amazon Ion qui peuvent être utilisées dans les `CREATE TABLE` instructions d'Athena.
**ion.codage**
Facultatif
Valeur par défaut : `BINARY`
Valeurs: `BINARY`, `TEXT`
Cette propriété déclare si les nouvelles valeurs ajoutées sont sérialisées en tant que [binaire Amazon Ion](https://amzn.github.io/ion-docs/docs/binary.html) ou au format texte Amazon Ion.
L'exemple de SerDe propriété suivant indique le format de texte Amazon Ion.
```
'ion.encoding' = 'TEXT'
```
**ion.fail\$1on\$1overflow**
Facultatif
Valeur par défaut : `true`
Valeurs: `true`, `false`
Amazon Ion autorise des types numériques de taille arbitraire, tandis que Hive ne le fait pas. Par défaut, elle SerDe échoue si la valeur Amazon Ion ne correspond pas à la colonne Hive, mais vous pouvez utiliser l'option de `fail_on_overflow` configuration pour laisser la valeur déborder au lieu d'échouer.
Cette propriété peut être définie au niveau de la table ou de la colonne. Pour le spécifier au niveau de la table, spécifiez `ion.fail_on_overflow` comme dans l'exemple suivant. Cela définit le comportement par défaut de toutes les colonnes.
```
'ion.fail_on_overflow' = 'true'
```
Pour contrôler une colonne spécifique, spécifiez le nom de la colonne entre `ion` et `fail_on_overflow`, délimité par des points, comme dans l'exemple suivant.
```
'ion..fail_on_overflow' = 'false'
```
**ion.path\$1extractor.case\$1sensitive**
Facultatif
Valeur par défaut : `false`
Valeurs: `true`, `false`
Détermine s'il convient de traiter les noms de champs Amazon Ion comme sensibles à la casse. Lorsque`false`, l'analyse des SerDe noms de champs Amazon Ion n'est pas prise en compte.
Par exemple, supposons que vous ayez un schéma de table Hive qui définit un champ `alias` en minuscules et un document Amazon Ion avec un champ `alias` et un champ `ALIAS`, comme dans l'exemple suivant.
```
-- Hive Table Schema
alias: STRING
-- Amazon Ion Document
{ 'ALIAS': 'value1'}
{ 'alias': 'value2'}
```
L'exemple suivant montre les SerDe propriétés et le tableau extrait obtenu lorsque la distinction majuscules/minuscules est définie sur `false` :
```
-- Serde properties
'ion.alias.path_extractor' = '(alias)'
'ion.path_extractor.case_sensitive' = 'false'
--Extracted Table
| alias |
|----------|
| "value1" |
| "value2" |
```
L'exemple suivant montre les SerDe propriétés et le tableau extrait obtenu lorsque la distinction majuscules/minuscules est définie sur `true` :
```
-- Serde properties
'ion.alias.path_extractor' = '(alias)'
'ion.path_extractor.case_sensitive' = 'true'
--Extracted Table
| alias |
|----------|
| "value2" |
```
Dans le second cas, la valeur `value1` pour le champ `ALIAS` est ignorée lorsque la sensibilité à la casse est définie sur `true` et l'extracteur de chemin est spécifié comme suit : `alias`.
**ion. **.path\$1extractor**
Facultatif
Valeur par défaut : NA
Valeurs : chaîne avec chemin de recherche
Crée un extracteur de chemin avec le chemin de recherche spécifié pour la colonne donnée. Les extracteurs de chemins mappent les champs Amazon Ion aux colonnes Hive. Si aucun extracteur de chemin n'est spécifié, Athena crée dynamiquement des extracteurs de chemin au moment de l'exécution en fonction des noms de colonnes.
L'exemple d'extracteur de chemin suivant mappe le champ `example_ion_field` vers la colonne `example_hive_column`.
```
'ion.example_hive_column.path_extractor' = '(example_ion_field)'
```
Pour plus d'informations sur les extracteurs de chemin d'accès et les chemins de recherche, consultez [Utilisation des extracteurs de chemin](ion-serde-using-path-extractors.md).
**ion.timestamp.serialization\$1offset**
Facultatif
Valeur par défaut : `'Z'`
Valeurs : `OFFSET`, où `OFFSET ` est représenté par `hh:mm`. Exemples de valeurs : `01:00`, `+01:00`, `-09:30`, `Z` (UTC, identique à 00:00)
Contrairement aux [horodatages](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+Types#LanguageManualTypes-timestamp) Apache Hive qui n'ont pas de fuseau horaire intégré et sont stockés sous forme de décalage par rapport à l'époque UNIX, les horodatages Amazon Ion ont un décalage. Utilisez cette propriété pour spécifier le décalage lorsque vous sérialisez sur Amazon Ion.
L'exemple suivant montre comment ajouter un décalage d'une heure.
```
'ion.timestamp.serialization_offset' = '+01:00'
```
**ion.serialize\$1null**
Facultatif
Valeur par défaut : `OMIT`
Valeurs : `OMIT`, `UNTYPED`, `TYPED`
L'Amazon Ion SerDe peut être configuré pour sérialiser ou omettre les colonnes contenant des valeurs nulles. Vous pouvez choisir d'écrire des valeurs nulles fortement typées (`TYPED`) ou des valeurs nulles non typées (`UNTYPED`). Les valeurs null fortement typées sont déterminées en fonction du mappage de type Amazon Ion vers Hive par défaut.
L'exemple suivant spécifie des valeurs nulles fortement typées.
```
'ion.serialize_null'='TYPED'
```
**ion.ignore\$1malformed**
Facultatif
Valeur par défaut : `false`
Valeurs: `true`, `false`
Lorsque`true`, ignore les entrées mal formées ou le fichier entier s'il n' SerDe est pas en mesure de le lire. Pour plus d'informations, consultez la section [Ignorer les malformés](https://github.com/amzn/ion-hive-serde/blob/master/docs/serde-properties.md#ignore-malformed) dans la documentation sur GitHub.
**ion. **.serialize\$1as**
Facultatif
Par défaut : type par défaut de la colonne.
Valeurs : chaîne contenant le type Amazon Ion
Détermine le type de données Amazon Ion dans lequel une valeur est sérialisée. Étant donné que les types Amazon Ion et Hive n'ont pas toujours de mappage direct, quelques types Hive ont plusieurs types de données valides pour la sérialisation. Pour sérialiser les données en tant que type de données autre que par défaut, utilisez cette propriété. Pour plus d'informations sur le mappage des types, consultez la page de [mappage des types](https://github.com/amzn/ion-hive-serde/blob/master/docs/type-mapping.md) Amazon Ion sur GitHub.
Par défaut, les colonnes binaires Hive sont sérialisées en tant que blobs Amazon Ion, mais elles peuvent également être sérialisées au format [clob Amazon Ion](https://amzn.github.io/ion-docs/docs/stringclob.html#ion-clob) (grand objet de caractères). L'exemple suivant montre comment sérialiser la colonne `example_hive_binary_column` au format clob.
```
'ion.example_hive_binary_column.serialize_as' = 'clob'
```
# Utilisation des extracteurs de chemin
Amazon Ion est un format de fichier de style document, mais Apache Hive est un format à colonnes plates. Vous pouvez utiliser les SerDe propriétés spéciales d'Amazon Ion appelées `path extractors` pour établir une correspondance entre les deux formats. Les extracteurs de chemins aplatissent le format hiérarchique Amazon Ion, mappent les valeurs Amazon Ion aux colonnes Hive et peuvent être utilisés pour renommer des champs.
Athena peut générer les extracteurs pour vous, mais vous pouvez également définir vos propres extracteurs si nécessaire.
**Topics**
+ [Utilisation des extracteurs de chemin générés par Athena](ion-serde-generated-path-extractors.md)
+ [Spécification de vos propres extracteurs de chemin](ion-serde-specifying-your-own-path-extractors.md)
+ [Utilisation des chemins de recherche dans les extracteurs de chemins](ion-serde-using-search-paths-in-path-extractors.md)
+ [Exemples d’extracteurs de chemin](ion-serde-examples.md)
# Utilisation des extracteurs de chemin générés par Athena
Par défaut, Athena recherche des valeurs Amazon Ion de premier niveau qui correspondent aux noms de colonnes Hive et crée des extracteurs de chemin à l'exécution en fonction de ces valeurs correspondantes. Si votre format de données Amazon Ion correspond au schéma de la table Hive, Athena génère dynamiquement les extracteurs pour vous, et vous n'avez pas besoin d'ajouter d'autres extracteurs de chemin. Ces extracteurs de chemins par défaut ne sont pas stockés dans les métadonnées de la table.
L'exemple suivant montre comment Athena génère des extracteurs basés sur le nom de la colonne.
```
-- Example Amazon Ion Document
{
identification: {
name: "John Smith",
driver_license: "XXXX"
},
alias: "Johnny"
}
-- Example DDL
CREATE EXTERNAL TABLE example_schema2 (
identification MAP,
alias STRING
)
STORED AS ION
LOCATION 's3://amzn-s3-demo-bucket/path_extraction1/'
```
Les exemples d’extracteurs suivants sont générés par Athena. Le premier extrait le champ `identification` vers la colonne `identification` et le second extrait le champ `alias` vers la colonne `alias`.
```
'ion.identification.path_extractor' = '(identification)'
'ion.alias.path_extractor' = '(alias)'
```
L'exemple suivant montre la table extraite.
```
| identification | alias |
|----------------------------------------------------|----------|
|{["name", "driver_license"],["John Smith", "XXXX"]} | "Johnny" |
```
# Spécification de vos propres extracteurs de chemin
Si vos champs Amazon Ion ne sont pas parfaitement mappés avec les colonnes Hive, vous pouvez spécifier vos propres extracteurs de chemin. Dans la clause `WITH SERDEPROPERTIES` de votre instruction `CREATE TABLE`, utilisez la syntaxe suivante.
```
WITH SERDEPROPERTIES (
"ion.path_extractor.case_sensitive" = "",
"ion..path_extractor" = ""
)
```
**Note**
Par défaut, les extracteurs de chemins ne sont pas sensibles à la casse. Pour annuler ce paramètre, définissez la [ion.path_extractor.case_sensitive](ion-serde-using-ion-serde-properties.md#ioncase) SerDe propriété sur. `true`
# Utilisation des chemins de recherche dans les extracteurs de chemins
La syntaxe des SerDe propriétés de l'extracteur de chemin contient : **
```
"ion..path_extractor" = ""
```
Vous pouvez utiliser le ** pour spécifier un chemin de recherche qui analyse le document Amazon Ion et trouve les données correspondantes. Le chemin de recherche est entre parenthèses et peut contenir un ou plusieurs des composants suivants séparés par des espaces.
+ **Wild card** – Correspond à toutes les valeurs.
+ **Index** – Correspond à la valeur de l'index numérique spécifié. Les index sont basés sur zéro.
+ **Text** – Correspond à toutes les valeurs dont les noms de champs correspondants sont équivalents au texte spécifié.
+ **Annotations** – Correspond aux valeurs spécifiées par un composant de chemin encapsulé dont les annotations sont spécifiées.
L'exemple suivant montre un document Amazon Ion et quelques exemples de chemins de recherche.
```
-- 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"
```
# Exemples d’extracteurs de chemin
Les exemples d’extracteurs de chemin suivants montrent comment aplatir et renommer des champs ou comment extraire des données sous forme de texte Amazon Ion.
## Aplatissement et renommage de champs
L'exemple suivant montre un ensemble de chemins de recherche qui aplatissent et renomment les champs. L'exemple utilise des chemins de recherche pour effectuer les opérations suivantes :
+ Mapper la colonne `nickname` au champ `alias`
+ Mapper la colonne `name` au sous-champ `name` situé dans le struct `identification`.
Voici l'exemple de document Amazon Ion.
```
-- Example Amazon Ion Document
{
identification: {
name: "John Smith",
driver_license: "XXXX"
},
alias: "Johnny"
}
```
Voici l'exemple suivant d'instruction `CREATE TABLE` qui définit les extracteurs de chemin.
```
-- 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/'
```
L'exemple suivant montre les données extraites.
```
-- Extracted Table
| name | nickname |
|--------------|--------------|
| "John Smith" | "Johnny" |
```
Pour plus d'informations sur les chemins de recherche et d'autres exemples de chemins de recherche, consultez la page [Ion Java Path Extraction](https://github.com/amzn/ion-java-path-extraction) sur GitHub.
## Extraction de données de vol au format texte
L'exemple de requête `CREATE TABLE` suivant utilise `WITH SERDEPROPERTIES` pour ajouter des extracteurs de chemin pour extraire les données de vol et spécifier le codage de sortie sous forme de texte Amazon Ion. L'exemple utilise la syntaxe `STORED AS ION`.
```
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/'
```
# Avro SerDe
Utilisez l'Avro SerDe pour créer des tables Athena à partir des données Avro.
## Nom de la bibliothèque de sérialisation
Le nom de la bibliothèque de sérialisation de l'Avro SerDe est. `org.apache.hadoop.hive.serde2.avro.AvroSerDe` Pour obtenir des informations techniques, consultez [AvroSerDe](https://cwiki.apache.org/confluence/display/Hive/AvroSerDe)la documentation d'Apache.
## Utilisez l'Avro SerDe
Pour des raisons de sécurité, Athena ne permet pas de spécifier le schéma de table à l’aide de `avro.schema.url`. Il est recommandé d’utiliser `avro.schema.literal`.
Pour extraire le schéma de données au format Avro, utilisez le fichier Apache `avro-tools-.jar` qui se trouve dans le sous-répertoire `java` de votre version d’Avro. Utilisez le paramètre `getschema` pour renvoyer un schéma que vous pourrez utiliser dans votre instruction `WITH SERDEPROPERTIES`, comme illustré dans l’exemple suivant.
```
java -jar avro-tools-1.8.2.jar getschema my_data.avro
```
Pour télécharger Avro, consultez [les versions d'Apache Avro](http://avro.apache.org/releases.html#Download). Pour télécharger Apache Avro Tools directement, consultez [Apache Avro Tools Maven Repository](https://mvnrepository.com/artifact/org.apache.avro/avro-tools).
Après avoir obtenu le schéma, utilisez une instruction `CREATE TABLE` pour créer une table Athena à partir des données Avro sous-jacentes stockées dans Amazon S3. Pour spécifier l'Avro SerDe dans votre `CREATE TABLE` relevé, utilisez`ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.avro.AvroSerDe'`. Spécifiez le schéma à l’aide de la clause `WITH SERDEPROPERTIES`, comme illustré dans l’exemple suivant.
**Note**
*myregion*Remplacez-le `s3://athena-examples-myregion/path/to/data/` par l'identifiant de la région dans laquelle vous exécutez Athena, par exemple. `s3://athena-examples-us-west-1/path/to/data/`
```
CREATE EXTERNAL TABLE flights_avro_example (
yr INT,
flightdate STRING,
uniquecarrier STRING,
airlineid INT,
carrier STRING,
flightnum STRING,
origin STRING,
dest STRING,
depdelay INT,
carrierdelay INT,
weatherdelay INT
)
PARTITIONED BY (year STRING)
ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.avro.AvroSerDe'
WITH SERDEPROPERTIES ('avro.schema.literal'='
{
"type" : "record",
"name" : "flights_avro_subset",
"namespace" : "default",
"fields" : [ {
"name" : "yr",
"type" : [ "null", "int" ],
"default" : null
}, {
"name" : "flightdate",
"type" : [ "null", "string" ],
"default" : null
}, {
"name" : "uniquecarrier",
"type" : [ "null", "string" ],
"default" : null
}, {
"name" : "airlineid",
"type" : [ "null", "int" ],
"default" : null
}, {
"name" : "carrier",
"type" : [ "null", "string" ],
"default" : null
}, {
"name" : "flightnum",
"type" : [ "null", "string" ],
"default" : null
}, {
"name" : "origin",
"type" : [ "null", "string" ],
"default" : null
}, {
"name" : "dest",
"type" : [ "null", "string" ],
"default" : null
}, {
"name" : "depdelay",
"type" : [ "null", "int" ],
"default" : null
}, {
"name" : "carrierdelay",
"type" : [ "null", "int" ],
"default" : null
}, {
"name" : "weatherdelay",
"type" : [ "null", "int" ],
"default" : null
} ]
}
')
STORED AS AVRO
LOCATION 's3://athena-examples-myregion/flight/avro/';
```
Exécutez l'instruction `MSCK REPAIR TABLE` sur la table pour actualiser les métadonnées de la partition.
```
MSCK REPAIR TABLE flights_avro_example;
```
Recherchez les 10 principales villes de départ par nombre total de départs.
```
SELECT origin, count(*) AS total_departures
FROM flights_avro_example
WHERE year >= '2000'
GROUP BY origin
ORDER BY total_departures DESC
LIMIT 10;
```
**Note**
Les données du tableau des vols proviennent des [Vols](http://www.transtats.bts.gov/DL_SelectFields.asp?Table_ID=236&DB_Short_Name=On-Time) fournis par le ministère américain des transports, [Bureau of Transportation Statistics](http://www.transtats.bts.gov/) (Bureau des statistiques des transports). Désaturé de l'original.
# Grok SerDe
Le Logstash Grok SerDe est une bibliothèque contenant un ensemble de modèles spécialisés pour la désérialisation de données textuelles non structurées, généralement des journaux. Chaque modèle Grok est une expression régulière nommée. Vous pouvez identifier et réutiliser ces modèles de désérialisation selon vos besoins. Il est ainsi plus facile d'utiliser Grok que des expressions régulières. Grok fournit un ensemble de [modèles prédéfinis](https://github.com/elastic/logstash/blob/v1.4.2/patterns/grok-patterns). Vous pouvez aussi créer des modèles personnalisés.
## Nom de la bibliothèque de sérialisation
Le nom de la bibliothèque de sérialisation du Grok SerDe est. `com.amazonaws.glue.serde.GrokSerDe`
## Comment utiliser le Grok SerDe
Pour spécifier le Grok SerDe lors de la création d'une table dans Athena, utilisez `ROW FORMAT SERDE 'com.amazonaws.glue.serde.GrokSerDe'` la clause, suivie de `WITH SERDEPROPERTIES` la clause qui spécifie les modèles à associer à vos données, où :
+ L'expression `input.format` définit les modèles de correspondance du fichier de données. C’est obligatoire.
+ L'expression `input.grokCustomPatterns` définit un modèle personnalisé nommé, que vous pouvez ensuite utiliser au sein de l'expression `input.format`. Ce nom est facultatif. Pour inclure plusieurs entrées dans le modèle d' expression `input.grokCustomPatterns`, utilisez le caractère d'échappement de saut de ligne (`\n`) pour les séparer, comme suit : `'input.grokCustomPatterns'='INSIDE_QS ([^\"]*)\nINSIDE_BRACKETS ([^\\]]*)')`.
+ Les clauses `STORED AS INPUTFORMAT` et `OUTPUTFORMAT` sont obligatoires.
+ La clause `LOCATION` spécifie un compartiment Simple Storage Service (Amazon S3), qui peut contenir plusieurs objets de données. Tous les objets de données du compartiment sont désérialisés pour créer la table.
## Exemples
Les exemples de cette section s’appuient sur la liste de modèles Grok prédéfinis. Pour plus d'informations, consultez [grok-patterns sur GitHub .com](https://github.com/elastic/logstash/blob/v1.4.2/patterns/grok-patterns).
### Exemple 1
Cet exemple utilise la source des données d'entrées maillog Postfix enregistrées dans `s3://amzn-s3-demo-bucket/groksample/`.
```
Feb 9 07:15:00 m4eastmail postfix/smtpd[19305]: B88C4120838: connect from unknown[192.168.55.4]
Feb 9 07:15:00 m4eastmail postfix/smtpd[20444]: B58C4330038: client=unknown[192.168.55.4]
Feb 9 07:15:03 m4eastmail postfix/cleanup[22835]: BDC22A77854: message-id=<31221401257553.5004389LCBF@m4eastmail.example.com>
```
L'instruction suivante crée une table dans Athena appelée `mygroktable` depuis le fichier de données source, à l'aide d'un modèle personnalisé et des modèles prédéfinis que vous spécifiez :
```
CREATE EXTERNAL TABLE `mygroktable`(
syslogbase string,
queue_id string,
syslog_message string
)
ROW FORMAT SERDE
'com.amazonaws.glue.serde.GrokSerDe'
WITH SERDEPROPERTIES (
'input.grokCustomPatterns' = 'POSTFIX_QUEUEID [0-9A-F]{7,12}',
'input.format'='%{SYSLOGBASE} %{POSTFIX_QUEUEID:queue_id}: %{GREEDYDATA:syslog_message}'
)
STORED AS INPUTFORMAT
'org.apache.hadoop.mapred.TextInputFormat'
OUTPUTFORMAT
'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'
LOCATION
's3://amzn-s3-demo-bucket/groksample/';
```
Commencez par un modèle tel que `%{NOTSPACE:column}` pour mapper les colonnes, puis spécialisez les colonnes si nécessaire.
### Exemple 2
Dans l'exemple suivant, vous créez une requête pour les journaux Log4j. Le format des entrées de l'exemple de journal est le suivant :
```
2017-09-12 12:10:34,972 INFO - processType=AZ, processId=ABCDEFG614B6F5E49, status=RUN,
threadId=123:amqListenerContainerPool23P:AJ|ABCDE9614B6F5E49||2017-09-12T12:10:11.172-0700],
executionTime=7290, tenantId=12456, userId=123123f8535f8d76015374e7a1d87c3c, shard=testapp1,
jobId=12312345e5e7df0015e777fb2e03f3c, messageType=REAL_TIME_SYNC,
action=receive, hostname=1.abc.def.com
```
Pour interroger les données de ce journal :
+ Ajoutez le modèle Grok au format `input.format` pour chaque colonne. Par exemple, pour `timestamp`, ajoutez `%{TIMESTAMP_ISO8601:timestamp}`. Pour `loglevel`, ajoutez `%{LOGLEVEL:loglevel}`.
+ Assurez-vous que le modèle défini dans `input.format` correspond exactement au format du journal, en mappant les tirets (`-`) et les virgules qui séparent les entrées dans le format du journal.
```
CREATE EXTERNAL TABLE bltest (
timestamp STRING,
loglevel STRING,
processtype STRING,
processid STRING,
status STRING,
threadid STRING,
executiontime INT,
tenantid INT,
userid STRING,
shard STRING,
jobid STRING,
messagetype STRING,
action STRING,
hostname STRING
)
ROW FORMAT SERDE 'com.amazonaws.glue.serde.GrokSerDe'
WITH SERDEPROPERTIES (
"input.grokCustomPatterns" = 'C_ACTION receive|send',
"input.format" = "%{TIMESTAMP_ISO8601:timestamp} %{LOGLEVEL:loglevel} - processType=%{NOTSPACE:processtype}, processId=%{NOTSPACE:processid}, status=%{NOTSPACE:status}, threadId=%{NOTSPACE:threadid}, executionTime=%{POSINT:executiontime}, tenantId=%{POSINT:tenantid}, userId=%{NOTSPACE:userid}, shard=%{NOTSPACE:shard}, jobId=%{NOTSPACE:jobid}, messageType=%{NOTSPACE:messagetype}, action=%{C_ACTION:action}, hostname=%{HOST:hostname}"
) STORED AS INPUTFORMAT 'org.apache.hadoop.mapred.TextInputFormat'
OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'
LOCATION 's3://amzn-s3-demo-bucket/samples/';
```
### Exemple 3
Dans l’exemple suivant relatif aux [journaux d’accès aux serveurs Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/LogFormat.html), l’instruction `CREATE TABLE` comporte l’expression `'input.grokCustomPatterns'`, qui contient deux entrées de modèle séparées par le caractère d’échappement de saut de ligne (`\n`), comme illustré dans cet extrait de l’exemple de requête : `'input.grokCustomPatterns'='INSIDE_QS ([^\"]*)\nINSIDE_BRACKETS ([^\\]]*)')`.
```
CREATE EXTERNAL TABLE `s3_access_auto_raw_02`(
`bucket_owner` string COMMENT 'from deserializer',
`bucket` string COMMENT 'from deserializer',
`time` string COMMENT 'from deserializer',
`remote_ip` string COMMENT 'from deserializer',
`requester` string COMMENT 'from deserializer',
`request_id` string COMMENT 'from deserializer',
`operation` string COMMENT 'from deserializer',
`key` string COMMENT 'from deserializer',
`request_uri` string COMMENT 'from deserializer',
`http_status` string COMMENT 'from deserializer',
`error_code` string COMMENT 'from deserializer',
`bytes_sent` string COMMENT 'from deserializer',
`object_size` string COMMENT 'from deserializer',
`total_time` string COMMENT 'from deserializer',
`turnaround_time` string COMMENT 'from deserializer',
`referrer` string COMMENT 'from deserializer',
`user_agent` string COMMENT 'from deserializer',
`version_id` string COMMENT 'from deserializer')
ROW FORMAT SERDE
'com.amazonaws.glue.serde.GrokSerDe'
WITH SERDEPROPERTIES (
'input.format'='%{NOTSPACE:bucket_owner} %{NOTSPACE:bucket} \\[%{INSIDE_BRACKETS:time}\\] %{NOTSPACE:remote_ip} %{NOTSPACE:requester} %{NOTSPACE:request_id} %{NOTSPACE:operation} %{NOTSPACE:key} \"?%{INSIDE_QS:request_uri}\"? %{NOTSPACE:http_status} %{NOTSPACE:error_code} %{NOTSPACE:bytes_sent} %{NOTSPACE:object_size} %{NOTSPACE:total_time} %{NOTSPACE:turnaround_time} \"?%{INSIDE_QS:referrer}\"? \"?%{INSIDE_QS:user_agent}\"? %{NOTSPACE:version_id}',
'input.grokCustomPatterns'='INSIDE_QS ([^\"]*)\nINSIDE_BRACKETS ([^\\]]*)')
STORED AS INPUTFORMAT
'org.apache.hadoop.mapred.TextInputFormat'
OUTPUTFORMAT
'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'
LOCATION
's3://amzn-s3-demo-bucket'
```
## Consultez aussi
+ [Understanding Grok Patterns](https://edgedelta.com/company/blog/what-are-grok-patterns) (site web externe)
+ [Motifs intégrés](https://docs.aws.amazon.com/glue/latest/dg/custom-classifier.html#classifier-builtin-patterns) (*guide de AWS Glue l'utilisateur*)
# SerDe bibliothèques JSON
Dans Athena, vous pouvez utiliser des SerDe bibliothèques pour désérialiser les données JSON. La désérialisation convertit les données JSON afin qu'elles puissent être sérialisées (écrites) dans un format différent comme Parquet ou ORC.
+ [Hive JSON SerDe](hive-json-serde.md)
+ [OpenX JSON SerDe](openx-json-serde.md)
+ [Amazon Ion Hive SerDe](ion-serde.md)
**Note**
Les bibliothèques Hive et OpenX s'attendent à ce que les données JSON soient sur une seule ligne (non formatées), les registres étant séparés par un caractère de nouvelle ligne.
Amazon Ion étant un sur-ensemble de JSON, vous pouvez utiliser Amazon Ion Hive SerDe pour interroger des ensembles de données JSON autres qu'Amazon Ion. Contrairement aux bibliothèques SerDe JSON Hive et OpenX, Amazon SerDe Ion ne s'attend pas à ce que chaque ligne de données se trouve sur une seule ligne. Cette fonction est utile si vous souhaitez interroger des jeux de données JSON au format « pretty print » ou si vous souhaitez diviser les champs d'une ligne avec des caractères de saut de ligne.
## Noms des bibliothèques
Utilisez l'une des options suivantes :
[org.apache.hive.hcatalog.data. JsonSerDe](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+DDL#LanguageManualDDL-JSON)
[org.openx.data.json. JsonSerDe](https://github.com/rcongiu/Hive-JSON-Serde)
[com.amazon.ionhiveserde. IonHiveSerDe](https://github.com/amzn/ion-hive-serde)
# Hive JSON SerDe
Le Hive JSON SerDe est couramment utilisé pour traiter des données JSON comme des événements. Ces événements sont représentés sous forme de chaînes sur une ligne de texte codées en JSON et séparées par une nouvelle ligne. Le JSON Hive n' SerDe autorise pas la duplication de clés `map` ou de noms de `struct` clés.
**Note**
Il SerDe s'attend à ce que chaque document JSON se trouve sur une seule ligne de texte sans aucun caractère de fin de ligne séparant les champs de l'enregistrement. Si le texte JSON est dans un joli format d'impression, vous pouvez recevoir un message d'erreur tel que HIVE\$1CURSOR\$1ERROR : Row is not a valid JSON Object ou HIVE\$1CURSOR\$1ERROR : : Unexpected JsonParseException end-of-input : expected close marker for OBJECT lorsque vous essayez d'interroger la table après l'avoir créée. Pour plus d'informations, consultez la section [Fichiers de données JSON](https://github.com/rcongiu/Hive-JSON-Serde#json-data-files) dans la SerDe documentation OpenX sur. GitHub
L'exemple d'instruction DDL suivant utilise le code JSON Hive SerDe pour créer un tableau basé sur des exemples de données publicitaires en ligne. Dans la `LOCATION` clause, remplacez le *myregion* in `s3://amzn-s3-demo-bucket.elasticmapreduce/samples/hive-ads/tables/impressions` par l'identifiant de la région dans laquelle vous exécutez Athena (par exemple,`s3://us-west-2.elasticmapreduce/samples/hive-ads/tables/impressions`).
```
CREATE EXTERNAL TABLE impressions (
requestbegintime string,
adid string,
impressionid string,
referrer string,
useragent string,
usercookie string,
ip string,
number string,
processid string,
browsercookie string,
requestendtime string,
timers struct
<
modellookup:string,
requesttime:string
>,
threadid string,
hostname string,
sessionid string
)
PARTITIONED BY (dt string)
ROW FORMAT SERDE 'org.apache.hive.hcatalog.data.JsonSerDe'
LOCATION 's3://amzn-s3-demo-bucket.elasticmapreduce/samples/hive-ads/tables/impressions';
```
## Spécifiez les formats d'horodatage avec le Hive JSON SerDe
Pour analyser les valeurs de l'horodatage à partir d'une chaîne, vous pouvez ajouter le sous-champ `WITH SERDEPROPERTIES` à la clause `ROW FORMAT SERDE` et l'utiliser pour spécifier le paramètre `timestamp.formats`. Dans le paramètre, spécifiez une liste séparée par des virgules d'un ou plusieurs modèles d'horodatage, comme dans l'exemple suivant :
```
...
ROW FORMAT SERDE 'org.apache.hive.hcatalog.data.JsonSerDe'
WITH SERDEPROPERTIES ("timestamp.formats"="yyyy-MM-dd'T'HH:mm:ss.SSS'Z',yyyy-MM-dd'T'HH:mm:ss")
...
```
Pour en savoir plus, consultez la rubrique [Horodatage](https://cwiki.apache.org/confluence/display/hive/languagemanual+types#LanguageManualTypes-TimestampstimestampTimestamps) dans la documentation Apache Hive.
## Chargement de la table pour interrogation
Après avoir créé la table, exécutez [MSCK REPAIR TABLE](msck-repair-table.md) pour charger la table et la rendre interrogeable à partir d'Athena :
```
MSCK REPAIR TABLE impressions
```
## CloudTrail Journaux de requêtes
Vous pouvez utiliser le JSON Hive SerDe pour interroger les CloudTrail journaux. Pour plus d'informations et des exemples d'instructions `CREATE TABLE`, voir [AWS CloudTrail Journaux de requêtes](cloudtrail-logs.md).
# OpenX JSON SerDe
Comme le JSON Hive SerDe, vous pouvez utiliser le JSON OpenX pour traiter les données JSON. Les données sont également représentées sous forme de chaînes sur une ligne de texte codées en JSON et séparées par une nouvelle ligne. Comme le JSON Hive SerDe, le JSON OpenX SerDe n'autorise pas la duplication de clés `struct` ou de noms `map` de clés.
## Considérations et restrictions
+ Lorsque vous utilisez le JSON OpenX SerDe, le nombre de résultats et leurs valeurs peuvent être non déterministes. Les résultats peuvent contenir plus ou moins de lignes que prévu ou encore des valeurs nulles alors que les données sous-jacentes n’en contiennent pas. Pour contourner ce problème, utilisez le [Hive JSON SerDe](hive-json-serde.md) ou réécrivez les données dans un autre type de format de fichier.
+ Il SerDe s'attend à ce que chaque document JSON se trouve sur une seule ligne de texte sans aucun caractère de fin de ligne séparant les champs de l'enregistrement. Si le texte JSON est dans un joli format d'impression, vous pouvez recevoir un message d'erreur tel que HIVE\$1CURSOR\$1ERROR : Row is not a valid JSON Object ou HIVE\$1CURSOR\$1ERROR : : Unexpected JsonParseException end-of-input : expected close marker for OBJECT lorsque vous essayez d'interroger la table après l'avoir créée.
Pour plus d'informations, consultez la section [Fichiers de données JSON](https://github.com/rcongiu/Hive-JSON-Serde#json-data-files) dans la SerDe documentation OpenX sur. GitHub
## Propriétés facultatives
Contrairement au JSON Hive SerDe, le JSON OpenX SerDe possède également les propriétés SerDe facultatives suivantes qui peuvent être utiles pour corriger les incohérences dans les données.
**use.null.for.invalid.data**
Facultatif. La valeur par défaut est `FALSE`. Lorsque cette valeur est définie sur`TRUE`, les SerDe utilisations `NULL` des valeurs de colonne qui n'ont pas pu être désérialisées dans le type de colonne défini à partir du schéma de table.
La définition de `use.null.for.invalid.data` sur `TRUE` peut entraîner des résultats incorrects ou inattendus, car les valeurs `NULL` remplacent les données non valides dans les colonnes présentant des problèmes de correspondance de schéma. Il est préférable de corriger les données dans vos fichiers ou votre schéma de table que d’activer cette propriété. Lorsque vous activez cette propriété, les données non valides n’entraînent pas l’échec des requêtes, ce qui peut vous empêcher de déceler des problèmes de qualité des données.
**ignore.malformed.json**
Facultatif. Lorsque la valeur est définie sur `TRUE`, cela vous permet d'ignorer la syntaxe JSON incorrecte. La valeur par défaut est `FALSE`.
**dots.in.keys**
Facultatif. La valeur par défaut est `FALSE`. Lorsqu'il est défini sur`TRUE`, permet de remplacer SerDe les points dans les noms des clés par des traits de soulignement. Par exemple, si le jeu de données JSON contient une clé portant le nom `"a.b"`, vous pouvez utiliser cette propriété pour définir le nom de la colonne comme étant `"a_b"` dans Athena. Par défaut (sans cela SerDe), Athena n'autorise pas les points dans les noms de colonnes.
**case.insensitive**
Facultatif. La valeur par défaut est `TRUE`. Lorsqu'il est défini sur`TRUE`, il SerDe convertit toutes les colonnes majuscules en minuscules.
Pour utiliser des noms de clés sensibles à la casse dans vos données, utilisez `WITH SERDEPROPERTIES ("case.insensitive"= FALSE;)`. Ensuite, pour chaque clé qui n'est pas encore entièrement en minuscules, fournissez un mappage entre le nom de la colonne et le nom de la propriété à l'aide de la syntaxe suivante :
```
ROW FORMAT SERDE 'org.openx.data.jsonserde.JsonSerDe'
WITH SERDEPROPERTIES ("case.insensitive" = "FALSE", "mapping.userid" = "userId")
```
Si vous avez deux clés, comme `URL` et `Url`, qui sont identiques quand elles sont écrites en minuscules, une erreur comme celle-ci peut se produire :
HIVE\$1CURSOR\$1ERROR : La ligne n'est pas un objet JSON valide - JSONException : clé dupliquée « url »
Pour résoudre ce problème, définissez la propriété `case.insensitive` sur `FALSE` et mapper les clés avec différents noms, comme dans l'exemple suivant :
```
ROW FORMAT SERDE 'org.openx.data.jsonserde.JsonSerDe'
WITH SERDEPROPERTIES ("case.insensitive" = "FALSE", "mapping.url1" = "URL", "mapping.url2" = "Url")
```
**mappage**
Facultatif. Cette propriété mappe les noms de colonnes aux clés JSON qui ne sont pas identiques aux noms de colonne. Le paramètre `mapping` est utile lorsque les données JSON contiennent des clés qui sont des [mots-clés](reserved-words.md). Par exemple, si vous avez une clé JSON nommée `timestamp`, utilisez la syntaxe suivante pour mapper la clé à une colonne nommée `ts`:
```
ROW FORMAT SERDE 'org.openx.data.jsonserde.JsonSerDe'
WITH SERDEPROPERTIES ("mapping.ts" = "timestamp")
```
**Mapper les noms de champs imbriqués avec des deux-points à des noms compatibles avec Hive**
Si vous avez un nom de champ avec des deux-points à l’intérieur d’un `struct`, vous pouvez utiliser la propriété `mapping` pour associer le champ à un nom compatible avec Hive. Par exemple, si vos définitions de type de colonne contiennent `my:struct:field:string`, vous pouvez mapper la définition à `my_struct_field:string` en incluant l’entrée suivante dans `WITH SERDEPROPERTIES` :
```
("mapping.my_struct_field" = "my:struct:field")
```
L’exemple suivant montre l’instruction `CREATE TABLE` correspondante.
```
CREATE EXTERNAL TABLE colon_nested_field (
item struct)
ROW FORMAT SERDE 'org.openx.data.jsonserde.JsonSerDe'
WITH SERDEPROPERTIES ("mapping.my_struct_field" = "my:struct:field")
```
## Exemple : données publicitaires
L'exemple d'instruction DDL suivant utilise le code SerDe JSON OpenX pour créer un tableau basé sur les mêmes exemples de données publicitaires en ligne que ceux utilisés dans l'exemple du fichier JSON Hive. SerDe Dans la `LOCATION` clause, remplacez-le *myregion* par l'identifiant de la région dans laquelle vous exécutez Athena.
```
CREATE EXTERNAL TABLE impressions (
requestbegintime string,
adid string,
impressionId string,
referrer string,
useragent string,
usercookie string,
ip string,
number string,
processid string,
browsercokie string,
requestendtime string,
timers struct<
modellookup:string,
requesttime:string>,
threadid string,
hostname string,
sessionid string
) PARTITIONED BY (dt string)
ROW FORMAT SERDE 'org.openx.data.jsonserde.JsonSerDe'
LOCATION 's3://amzn-s3-demo-bucket.elasticmapreduce/samples/hive-ads/tables/impressions';
```
## Exemple : désérialisation des données JSON imbriquées
Vous pouvez utiliser le JSON SerDes pour analyser des données plus complexes codées en JSON. Cela implique l'utilisation d'instructions `CREATE TABLE` utilisant des éléments `struct` et `array` pour représenter des structures imbriquées.
L'exemple suivant crée une table Athena à partir de données JSON ayant des structures imbriquées. Il présente la structure suivante :
```
{
"DocId": "AWS",
"User": {
"Id": 1234,
"Username": "carlos_salazar",
"Name": "Carlos",
"ShippingAddress": {
"Address1": "123 Main St.",
"Address2": null,
"City": "Anytown",
"State": "CA"
},
"Orders": [
{
"ItemId": 6789,
"OrderDate": "11/11/2022"
},
{
"ItemId": 4352,
"OrderDate": "12/12/2022"
}
]
}
}
```
N'oubliez pas qu'OpenX SerDe s'attend à ce que chaque enregistrement JSON se trouve sur une seule ligne de texte. Lorsqu’elles sont stockées dans Amazon S3, toutes les données de l’exemple précédent doivent figurer sur une seule ligne, comme illustré ci-dessous :
```
{"DocId":"AWS","User":{"Id":1234,"Username":"carlos_salazar","Name":"Carlos","ShippingAddress" ...
```
L'`CREATE TABLE`instruction suivante utilise le [Openx- JsonSerDe](https://github.com/rcongiu/Hive-JSON-Serde) avec les types de données de `array` collecte `struct` et pour établir des groupes d'objets pour les données d'exemple.
```
CREATE external TABLE complex_json (
docid string,
`user` struct<
id:INT,
username:string,
name:string,
shippingaddress:struct<
address1:string,
address2:string,
city:string,
state:string
>,
orders:array<
struct<
itemid:INT,
orderdate:string
>
>
>
)
ROW FORMAT SERDE 'org.openx.data.jsonserde.JsonSerDe'
LOCATION 's3://amzn-s3-demo-bucket/myjsondata/';
```
Utilisez une instruction `SELECT` semblable à la suivante pour interroger la table :
```
SELECT
user.name as Name,
user.shippingaddress.address1 as Address,
user.shippingaddress.city as City,
o.itemid as Item_ID, o.orderdate as Order_date
FROM complex_json, UNNEST(user.orders) as temp_table (o)
```
Pour accéder aux champs de données des structures, la requête de l’exemple utilise la notation par points (par exemple, `user.name`). Vous pouvez utiliser la fonction `UNNEST` pour accéder aux données d’un tableau de structures (comme pour le champ `orders`). La fonction `UNNEST` aplatit le tableau en table temporaire (appelée `o` dans ce cas). Vous pouvez ainsi utiliser la notation par points comme vous le feriez avec les structures pour accéder aux éléments de tableau non imbriqués (par exemple, `o.itemid`). Le nom `temp_table`, utilisé dans l’exemple à des fins d’illustration, est souvent abrégé en `t`.
Le tableau ci-dessous présente les résultats de la requête.
****
| \$1 | Nom | Adresse | City | Item\$1ID | Order\$1date |
| --- | --- | --- | --- | --- | --- |
| 1 | Carlos | 123 Main St. | Anytown | 6789 | 11/11/2022 |
| 2 | Carlos | 123 Main St. | Anytown | 4352 | 12/12/2022 |
## Ressources supplémentaires
Pour de plus amples informations sur l'utilisation de JSON et de JSON imbriqué dans Athena, consultez les ressources suivantes :
+ [Créez des tables dans Amazon Athena à partir de JSON imbriqué et de mappages à l'aide JSONSer de De](https://aws.amazon.com/blogs/big-data/create-tables-in-amazon-athena-from-nested-json-and-mappings-using-jsonserde/) (AWS Big Data Blog)
+ [Je reçois des erreurs lorsque j'essaie de lire des données JSON dans Amazon Athena](https://aws.amazon.com/premiumsupport/knowledge-center/error-json-athena/) (article du AWS Knowledge Center)
+ [hive-json-schema](https://github.com/quux00/hive-json-schema)(GitHub) — Outil écrit en Java qui génère des `CREATE TABLE` instructions à partir d'exemples de documents JSON. Les instructions `CREATE TABLE` générées utilisent le SerDe JSON OpenX.
# SerDe bibliothèques CSV
Lorsque vous créez un tableau pour les données CSV dans Athena, vous pouvez utiliser la bibliothèque Open CSV SerDe ou la bibliothèque Lazy Simple SerDe . Appuyez-vous sur les recommandations suivantes pour déterminer laquelle utiliser.
+ Si vos données contiennent des valeurs entre guillemets (`"`), vous pouvez utiliser la SerDe bibliothèque [Open CSV](https://cwiki.apache.org/confluence/display/Hive/CSV+Serde) pour désérialiser les valeurs dans Athena. Si vos données ne contiennent pas de valeurs entre guillemets (`"`), vous pouvez ne pas SerDe en spécifier. Dans ce cas, Athena utilise le Lazy Simple par défaut. SerDe Pour plus d'informations, consultez [Lazy Simple SerDe pour les fichiers CSV, TSV et délimités sur mesure](lazy-simple-serde.md).
+ Si vos données contiennent des `TIMESTAMP` valeurs numériques UNIX (par exemple,`1579059880000`), utilisez le fichier CSV ouvert. SerDe Si vos données utilisent ce `java.sql.Timestamp` format, utilisez le Lazy Simple SerDe.
**Topics**
+ [Lazy Simple SerDe pour les fichiers CSV, TSV et délimités sur mesure](lazy-simple-serde.md)
+ [Ouvrez le fichier CSV SerDe pour le traitement du fichier CSV](csv-serde.md)
# Lazy Simple SerDe pour les fichiers CSV, TSV et délimités sur mesure
Comme il s'agit de la valeur par défaut SerDe dans Athena pour les données au format CSV, TSV et aux formats délimités de manière personnalisée, il est facultatif de le spécifier. Dans votre `CREATE TABLE` déclaration, si vous ne spécifiez pas a SerDe et spécifiez uniquement`ROW FORMAT DELIMITED`, Athéna l'utilise. SerDe Utilisez-le SerDe si vos données ne comportent pas de valeurs entre guillemets.
Pour une documentation de référence sur le Lazy Simple SerDe, consultez la SerDe section [Hive](https://cwiki.apache.org/confluence/display/Hive/DeveloperGuide#DeveloperGuide-HiveSerDe) du guide du développeur d'Apache Hive.
## Nom de la bibliothèque de sérialisation
Le nom de la bibliothèque de sérialisation du Lazy Simple SerDe est`org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe`. Pour obtenir des informations sur le code source, consultez [LazySimpleSerDe.java](https://github.com/apache/hive/blob/master/serde/src/java/org/apache/hadoop/hive/serde2/lazy/LazySimpleSerDe.java) sur GitHub .com.
## Omission des en-têtes
Pour ignorer les en-têtes dans vos données lorsque vous définissez une table, vous pouvez utiliser la propriété de table `skip.header.line.count`, comme dans l'exemple suivant.
```
TBLPROPERTIES ("skip.header.line.count"="1")
```
Pour découvrir des exemples qui ignorent les en-têtes, consultez les instructions `CREATE TABLE` dans [Interrogation des journaux de flux Amazon VPC](vpc-flow-logs.md) et [Interrogez les CloudFront journaux d'Amazon](cloudfront-logs.md).
## Exemple CSV
L’exemple suivant montre comment utiliser la bibliothèque `LazySimpleSerDe` pour créer une table dans Athena à partir de données CSV. Pour désérialiser des fichiers délimités de manière personnalisée à l'aide de cette méthode SerDe, suivez le modèle décrit dans les exemples, mais utilisez la `FIELDS TERMINATED BY` clause pour spécifier un autre délimiteur à caractère unique. Lazy Simple SerDe ne prend pas en charge les séparateurs à plusieurs caractères.
**Note**
*myregion*Remplacez-le `s3://athena-examples-myregion/path/to/data/` par l'identifiant de la région dans laquelle vous exécutez Athena, par exemple. `s3://athena-examples-us-west-1/path/to/data/`
Utilisez l'instruction `CREATE TABLE` pour créer une table Athena à partir données CSV sous-jacentes stockées dans Simple Storage Service (Amazon S3).
```
CREATE EXTERNAL TABLE flight_delays_csv (
yr INT,
quarter INT,
month INT,
dayofmonth INT,
dayofweek INT,
flightdate STRING,
uniquecarrier STRING,
airlineid INT,
carrier STRING,
tailnum STRING,
flightnum STRING,
originairportid INT,
originairportseqid INT,
origincitymarketid INT,
origin STRING,
origincityname STRING,
originstate STRING,
originstatefips STRING,
originstatename STRING,
originwac INT,
destairportid INT,
destairportseqid INT,
destcitymarketid INT,
dest STRING,
destcityname STRING,
deststate STRING,
deststatefips STRING,
deststatename STRING,
destwac INT,
crsdeptime STRING,
deptime STRING,
depdelay INT,
depdelayminutes INT,
depdel15 INT,
departuredelaygroups INT,
deptimeblk STRING,
taxiout INT,
wheelsoff STRING,
wheelson STRING,
taxiin INT,
crsarrtime INT,
arrtime STRING,
arrdelay INT,
arrdelayminutes INT,
arrdel15 INT,
arrivaldelaygroups INT,
arrtimeblk STRING,
cancelled INT,
cancellationcode STRING,
diverted INT,
crselapsedtime INT,
actualelapsedtime INT,
airtime INT,
flights INT,
distance INT,
distancegroup INT,
carrierdelay INT,
weatherdelay INT,
nasdelay INT,
securitydelay INT,
lateaircraftdelay INT,
firstdeptime STRING,
totaladdgtime INT,
longestaddgtime INT,
divairportlandings INT,
divreacheddest INT,
divactualelapsedtime INT,
divarrdelay INT,
divdistance INT,
div1airport STRING,
div1airportid INT,
div1airportseqid INT,
div1wheelson STRING,
div1totalgtime INT,
div1longestgtime INT,
div1wheelsoff STRING,
div1tailnum STRING,
div2airport STRING,
div2airportid INT,
div2airportseqid INT,
div2wheelson STRING,
div2totalgtime INT,
div2longestgtime INT,
div2wheelsoff STRING,
div2tailnum STRING,
div3airport STRING,
div3airportid INT,
div3airportseqid INT,
div3wheelson STRING,
div3totalgtime INT,
div3longestgtime INT,
div3wheelsoff STRING,
div3tailnum STRING,
div4airport STRING,
div4airportid INT,
div4airportseqid INT,
div4wheelson STRING,
div4totalgtime INT,
div4longestgtime INT,
div4wheelsoff STRING,
div4tailnum STRING,
div5airport STRING,
div5airportid INT,
div5airportseqid INT,
div5wheelson STRING,
div5totalgtime INT,
div5longestgtime INT,
div5wheelsoff STRING,
div5tailnum STRING
)
PARTITIONED BY (year STRING)
ROW FORMAT DELIMITED
FIELDS TERMINATED BY ','
ESCAPED BY '\\'
LINES TERMINATED BY '\n'
LOCATION 's3://athena-examples-myregion/flight/csv/';
```
Exécutez l'instruction `MSCK REPAIR TABLE` pour actualiser les métadonnées de la partition à chaque ajout d'une nouvelle partition à cette table :
```
MSCK REPAIR TABLE flight_delays_csv;
```
Recherchez les 10 principaux itinéraires dont le retard dépasse 1 heure :
```
SELECT origin, dest, count(*) as delays
FROM flight_delays_csv
WHERE depdelayminutes > 60
GROUP BY origin, dest
ORDER BY 3 DESC
LIMIT 10;
```
**Note**
Les données du tableau des vols proviennent des [Vols](http://www.transtats.bts.gov/DL_SelectFields.asp?Table_ID=236&DB_Short_Name=On-Time) fournis par le ministère américain des transports, [Bureau of Transportation Statistics](http://www.transtats.bts.gov/) (Bureau des statistiques des transports). Désaturé de l'original.
## Exemple TSV
Pour créer une table Athena à partir de données TSV stockées dans Amazon S3, utilisez `ROW FORMAT DELIMITED` et spécifiez le `\t` comme délimiteur de champs de tabulation, `\n` comme séparateur de ligne et `\` comme caractère d'échappement. L'extrait suivant montre cette syntaxe. Aucun exemple de données de vol TSV n'est disponible sur l'emplacement `athena-examples`, mais comme dans le cas de la table CSV, vous devez exécuter `MSCK REPAIR TABLE` pour actualiser les métadonnées de partition chaque fois qu'une nouvelle partition est ajoutée.
```
...
ROW FORMAT DELIMITED
FIELDS TERMINATED BY '\t'
ESCAPED BY '\\'
LINES TERMINATED BY '\n'
...
```
# Ouvrez le fichier CSV SerDe pour le traitement du fichier CSV
Utilisez le fichier CSV ouvert SerDe pour créer des tables Athena à partir de données séparées par des virgules (CSV).
## Nom de la bibliothèque de sérialisation
Le nom de la bibliothèque de sérialisation pour le fichier Open CSV SerDe est`org.apache.hadoop.hive.serde2.OpenCSVSerde`. Pour obtenir des informations sur le code source, voir [CSV SerDe](https://cwiki.apache.org/confluence/display/Hive/CSV+Serde) dans la documentation d'Apache.
## Utilisation du fichier CSV ouvert SerDe
Pour l'utiliser SerDe, spécifiez son nom de classe complet après`ROW FORMAT SERDE`. Spécifiez également les délimiteurs dans `SERDEPROPERTIES`, comme illustré dans l’exemple ci-dessous.
```
...
ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.OpenCSVSerde'
WITH SERDEPROPERTIES (
"separatorChar" = ",",
"quoteChar" = "`",
"escapeChar" = "\\"
)
```
### Ignorer les en-têtes
Pour ignorer les en-têtes dans vos données lorsque vous définissez une table, vous pouvez utiliser la propriété de table `skip.header.line.count`, comme dans l'exemple suivant.
```
TBLPROPERTIES ("skip.header.line.count"="1")
```
Pour des exemples, voir les instructions `CREATE TABLE` dans [Interrogation des journaux de flux Amazon VPC](vpc-flow-logs.md) et [Interrogez les CloudFront journaux d'Amazon](cloudfront-logs.md).
### Utilisation de la valeur NULL pour les données non valides
Pour utiliser des valeurs NULL pour les données dont la désérialisation dans le type défini pour la colonne échoue, vous pouvez utiliser la propriété de table `use.null.for.invalid.data`, comme illustré dans l’exemple suivant.
```
TBLPROPERTIES ("skip.header.line.count"="1")
```
**Important**
La définition de `use.null.for.invalid.data` sur `TRUE` peut entraîner des résultats incorrects ou inattendus, car les valeurs `NULL` remplacent les données non valides dans les colonnes présentant des problèmes de correspondance de schéma. Il est préférable de corriger les données dans vos fichiers ou votre schéma de table que d’activer cette propriété. Lorsque vous activez cette propriété, les données non valides n’entraînent pas l’échec des requêtes, ce qui peut vous empêcher de déceler des problèmes de qualité des données.
### Considérations relatives aux données de type chaîne
L'Open CSV SerDe présente les caractéristiques suivantes pour les données sous forme de chaîne :
+ Utilise des guillemets (`"`) en tant que caractère par défaut et vous permet de spécifier des séparateurs, des guillemets et des caractères d'échappement, tels que :
```
WITH SERDEPROPERTIES ("separatorChar" = ",", "quoteChar" = "`", "escapeChar" = "\\" )
```
+ Vous ne pouvez pas échapper directement `\t` ou `\n`. Pour ce faire, utilisez `"escapeChar" = "\\"`. Pour obtenir un exemple, consultez [Example: Escaping \t or \n](#csv-serde-opencsvserde-example-escaping-t-or-n).
+ L'Open CSV SerDe ne prend pas en charge les sauts de ligne intégrés dans les fichiers CSV.
### Considérations relatives aux données d’un type autre que chaîne
Pour les types de données autres que`STRING`, le fichier Open CSV SerDe se comporte comme suit :
+ Reconnaît les de données `BOOLEAN`, `BIGINT`, `INT` et `DOUBLE`.
+ Ne reconnaît pas les valeurs vides ou nulles dans les colonnes définies en tant que type de données numériques, et les conserve en tant que `string`. Une solution consiste à créer la colonne avec les valeurs nulles en tant que `string` et utiliser ensuite `CAST` pour convertir le champ dans une requête en un type de données numérique, en fournissant une valeur par défaut de `0` pour les valeurs nulles. Pour plus d'informations, voir [Lorsque j'interroge des données CSV dans Athena, l'erreur HIVE\$1BAD\$1DATA s'affiche : Erreur lors de l'analyse](https://aws.amazon.com/premiumsupport/knowledge-center/athena-hive-bad-data-error-csv/) de la valeur du champ dans le Knowledge Center. AWS
+ Pour les colonnes spécifiées avec le type de données `timestamp` dans votre instruction `CREATE TABLE`, il reconnaît les données `TIMESTAMP` si elles sont spécifiées dans le format numérique UNIX en millisecondes, par exemple, `1579059880000`. Pour obtenir un exemple, consultez [Example: Using the TIMESTAMP type and DATE type specified in the UNIX numeric format](#csv-serde-opencsvserde-example-timestamp-unix).
+ L'Open CSV SerDe ne prend pas `TIMESTAMP` en charge le `java.sql.Timestamp` format compatible JDBC, tel que `"YYYY-MM-DD HH:MM:SS.fffffffff"` (précision à 9 décimales).
+ Pour les colonnes spécifiées avec le type de données `DATE` dans votre instruction `CREATE TABLE`, il reconnaît les valeurs comme des dates si les valeurs représentent le nombre de jours qui se sont écoulés depuis le 1er janvier 1970. Par exemple, la valeur `18276` dans une colonne avec le type de données `date` est rendue comme `2020-01-15` lorsqu'elle est interrogée. Dans ce format UNIX, chaque jour est considéré comme ayant 86 400 secondes.
+ L'Open CSV SerDe ne prend directement `DATE` en charge aucun autre format. Pour traiter les données d'horodatage dans d'autres formats, vous pouvez définir la colonne comme `string` et ensuite utiliser les fonctions de conversion de temps pour retourner les résultats souhaités dans votre requête `SELECT`. Pour plus d'informations, consultez l'article [Lorsque j'interroge une table dans Amazon Athena, le résultat TIMESTAMP est vide](https://aws.amazon.com/premiumsupport/knowledge-center/query-table-athena-timestamp-empty/) dans le [Centre de connaissances AWS](https://aws.amazon.com/premiumsupport/knowledge-center/).
+ Pour mieux convertir les colonnes en le type souhaité dans une table, vous pouvez [créer une vue](views.md) sur la table et utiliser `CAST` pour la conversion.
## Exemples
**Example Exemple : Interrogation de données CSV simples**
L’exemple suivant suppose que vous avez enregistré des données CSV dans `s3://amzn-s3-demo-bucket/mycsv/` avec le contenu suivant :
```
"a1","a2","a3","a4"
"1","2","abc","def"
"a","a1","abc3","ab4"
```
Utilisez une instruction `CREATE TABLE` pour créer une table Athena basée sur les données. Référencez `OpenCSVSerde` (notez la lettre « d » minuscule) après `ROW FORMAT SERDE` et spécifiez le caractère de séparation, le caractère de guillemet et le caractère d’échappement dans `WITH SERDEPROPERTIES`, comme illustré dans l’exemple suivant.
```
CREATE EXTERNAL TABLE myopencsvtable (
col1 string,
col2 string,
col3 string,
col4 string
)
ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.OpenCSVSerde'
WITH SERDEPROPERTIES (
'separatorChar' = ',',
'quoteChar' = '"',
'escapeChar' = '\\'
)
STORED AS TEXTFILE
LOCATION 's3://amzn-s3-demo-bucket/mycsv/';
```
Interrogez toutes les valeurs de la table :
```
SELECT * FROM myopencsvtable;
```
La requête renvoie les valeurs suivantes :
```
col1 col2 col3 col4
-----------------------------
a1 a2 a3 a4
1 2 abc def
a a1 abc3 ab4
```
**Example Exemple : Utilisation des types TIMESTAMP et DATE spécifiés au format numérique UNIX**
Considérez les trois colonnes suivantes de données séparées par des virgules. Les valeurs de chaque colonne sont placées entre guillemets.
```
"unixvalue creationdate 18276 creationdatetime 1579059880000","18276","1579059880000"
```
L'instruction suivante crée une table dans Athena à partir de l'emplacement du compartiment Simple Storage Service (Amazon S3) spécifié.
```
CREATE EXTERNAL TABLE IF NOT EXISTS testtimestamp1(
`profile_id` string,
`creationdate` date,
`creationdatetime` timestamp
)
ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.OpenCSVSerde'
LOCATION 's3://amzn-s3-demo-bucket'
```
Ensuite, exécutez la requête suivante :
```
SELECT * FROM testtimestamp1
```
La requête renvoie le résultat suivant, affichant les données de date et d'heure :
```
profile_id creationdate creationdatetime
unixvalue creationdate 18276 creationdatetime 1579146280000 2020-01-15 2020-01-15 03:44:40.000
```
**Example Exemple : Échappement de \$1t ou \$1n**
Examinez les données de test suivantes :
```
" \\t\\t\\n 123 \\t\\t\\n ",abc
" 456 ",xyz
```
L'instruction suivante crée une table dans Athena, en spécifiant que `"escapeChar" = "\\"`.
```
CREATE EXTERNAL TABLE test1 (
f1 string,
s2 string)
ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.OpenCSVSerde'
WITH SERDEPROPERTIES ("separatorChar" = ",", "escapeChar" = "\\")
LOCATION 's3://amzn-s3-demo-bucket/dataset/test1/'
```
Ensuite, exécutez la requête suivante :
```
SELECT * FROM test1;
```
Elle renvoie ce résultat, en échappant correctement `\t` ou `\n` :
```
f1 s2
\t\t\n 123 \t\t\n abc
456 xyz
```
# ORC SerDe
Utilisez l'ORC SerDe pour créer des tables Athena à partir des données ORC.
## Nom de la bibliothèque de sérialisation
La bibliothèque de sérialisation de l'ORC l' SerDe est`org.apache.hadoop.hive.ql.io.orc.OrcSerde`, mais dans vos `CREATE TABLE` instructions, vous le spécifiez avec la clause. `STORED AS ORC` Pour obtenir des informations sur le code source, consultez [OrcSerde.java](https://github.com/apache/hive/blob/master/ql/src/java/org/apache/hadoop/hive/ql/io/orc/OrcSerde.java) sur GitHub .com.
## Exemple : Création d’une table pour des données de vol ORC
**Note**
*myregion*Remplacez-le `s3://athena-examples-myregion/path/to/data/` par l'identifiant de la région dans laquelle vous exécutez Athena, par exemple. `s3://athena-examples-us-west-1/path/to/data/`
L'exemple suivant crée une table pour les données de retard de vol dans ORC. La table comprend des partitions :
```
DROP TABLE flight_delays_orc;
CREATE EXTERNAL TABLE flight_delays_orc (
yr INT,
quarter INT,
month INT,
dayofmonth INT,
dayofweek INT,
flightdate STRING,
uniquecarrier STRING,
airlineid INT,
carrier STRING,
tailnum STRING,
flightnum STRING,
originairportid INT,
originairportseqid INT,
origincitymarketid INT,
origin STRING,
origincityname STRING,
originstate STRING,
originstatefips STRING,
originstatename STRING,
originwac INT,
destairportid INT,
destairportseqid INT,
destcitymarketid INT,
dest STRING,
destcityname STRING,
deststate STRING,
deststatefips STRING,
deststatename STRING,
destwac INT,
crsdeptime STRING,
deptime STRING,
depdelay INT,
depdelayminutes INT,
depdel15 INT,
departuredelaygroups INT,
deptimeblk STRING,
taxiout INT,
wheelsoff STRING,
wheelson STRING,
taxiin INT,
crsarrtime INT,
arrtime STRING,
arrdelay INT,
arrdelayminutes INT,
arrdel15 INT,
arrivaldelaygroups INT,
arrtimeblk STRING,
cancelled INT,
cancellationcode STRING,
diverted INT,
crselapsedtime INT,
actualelapsedtime INT,
airtime INT,
flights INT,
distance INT,
distancegroup INT,
carrierdelay INT,
weatherdelay INT,
nasdelay INT,
securitydelay INT,
lateaircraftdelay INT,
firstdeptime STRING,
totaladdgtime INT,
longestaddgtime INT,
divairportlandings INT,
divreacheddest INT,
divactualelapsedtime INT,
divarrdelay INT,
divdistance INT,
div1airport STRING,
div1airportid INT,
div1airportseqid INT,
div1wheelson STRING,
div1totalgtime INT,
div1longestgtime INT,
div1wheelsoff STRING,
div1tailnum STRING,
div2airport STRING,
div2airportid INT,
div2airportseqid INT,
div2wheelson STRING,
div2totalgtime INT,
div2longestgtime INT,
div2wheelsoff STRING,
div2tailnum STRING,
div3airport STRING,
div3airportid INT,
div3airportseqid INT,
div3wheelson STRING,
div3totalgtime INT,
div3longestgtime INT,
div3wheelsoff STRING,
div3tailnum STRING,
div4airport STRING,
div4airportid INT,
div4airportseqid INT,
div4wheelson STRING,
div4totalgtime INT,
div4longestgtime INT,
div4wheelsoff STRING,
div4tailnum STRING,
div5airport STRING,
div5airportid INT,
div5airportseqid INT,
div5wheelson STRING,
div5totalgtime INT,
div5longestgtime INT,
div5wheelsoff STRING,
div5tailnum STRING
)
PARTITIONED BY (year String)
STORED AS ORC
LOCATION 's3://athena-examples-myregion/flight/orc/'
tblproperties ("orc.compress"="ZLIB");
```
Exécutez l'instruction `MSCK REPAIR TABLE` sur la table pour actualiser les métadonnées de la partition:
```
MSCK REPAIR TABLE flight_delays_orc;
```
Utilisez cette requête pour obtenir les 10 principaux itinéraires dont le retard dépasse 1 heure :
```
SELECT origin, dest, count(*) as delays
FROM flight_delays_orc
WHERE depdelayminutes > 60
GROUP BY origin, dest
ORDER BY 3 DESC
LIMIT 10;
```
# Parquet SerDe
Utilisez le parquet SerDe pour créer des tables Athena à partir des données du parquet.
Le parquet SerDe est utilisé pour les données stockées au [format Parquet](https://cwiki.apache.org/confluence/display/Hive/Parquet). Pour convertir des données au format Parquet, vous pouvez utiliser les requêtes [CREATE TABLE AS SELECT (CTAS)](create-table-as.md) . Pour plus d’informations, consultez [Création d’une table à partir des résultats des requêtes (CTAS)](ctas.md), [Exemples de requêtes CTAS](ctas-examples.md) et [Utilisation de CTAS et INSERT INTO pour les opérations ETL et l’analyse des données](ctas-insert-into-etl.md).
## Nom de la bibliothèque de sérialisation
Le nom de la bibliothèque de sérialisation du Parquet SerDe est`org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe`. Pour plus d'informations sur le code source, consultez [Class ParquetHiveSerDe](https://svn.apache.org/repos/infra/websites/production/hive/content/javadocs/r2.1.1/api/org/apache/hadoop/hive/ql/io/parquet/serde/ParquetHiveSerDe.html) dans la documentation d'Apache.
## Exemple : Interrogation d’un fichier stocké au format Parquet
**Note**
*myregion*Remplacez-le `s3://athena-examples-myregion/path/to/data/` par l'identifiant de la région dans laquelle vous exécutez Athena, par exemple. `s3://athena-examples-us-west-1/path/to/data/`
Utilisez l’instruction `CREATE TABLE` suivante pour créer une table Athena à partir des données sous-jacentes stockées au format Parquet dans Amazon S3 :
```
CREATE EXTERNAL TABLE flight_delays_pq (
yr INT,
quarter INT,
month INT,
dayofmonth INT,
dayofweek INT,
flightdate STRING,
uniquecarrier STRING,
airlineid INT,
carrier STRING,
tailnum STRING,
flightnum STRING,
originairportid INT,
originairportseqid INT,
origincitymarketid INT,
origin STRING,
origincityname STRING,
originstate STRING,
originstatefips STRING,
originstatename STRING,
originwac INT,
destairportid INT,
destairportseqid INT,
destcitymarketid INT,
dest STRING,
destcityname STRING,
deststate STRING,
deststatefips STRING,
deststatename STRING,
destwac INT,
crsdeptime STRING,
deptime STRING,
depdelay INT,
depdelayminutes INT,
depdel15 INT,
departuredelaygroups INT,
deptimeblk STRING,
taxiout INT,
wheelsoff STRING,
wheelson STRING,
taxiin INT,
crsarrtime INT,
arrtime STRING,
arrdelay INT,
arrdelayminutes INT,
arrdel15 INT,
arrivaldelaygroups INT,
arrtimeblk STRING,
cancelled INT,
cancellationcode STRING,
diverted INT,
crselapsedtime INT,
actualelapsedtime INT,
airtime INT,
flights INT,
distance INT,
distancegroup INT,
carrierdelay INT,
weatherdelay INT,
nasdelay INT,
securitydelay INT,
lateaircraftdelay INT,
firstdeptime STRING,
totaladdgtime INT,
longestaddgtime INT,
divairportlandings INT,
divreacheddest INT,
divactualelapsedtime INT,
divarrdelay INT,
divdistance INT,
div1airport STRING,
div1airportid INT,
div1airportseqid INT,
div1wheelson STRING,
div1totalgtime INT,
div1longestgtime INT,
div1wheelsoff STRING,
div1tailnum STRING,
div2airport STRING,
div2airportid INT,
div2airportseqid INT,
div2wheelson STRING,
div2totalgtime INT,
div2longestgtime INT,
div2wheelsoff STRING,
div2tailnum STRING,
div3airport STRING,
div3airportid INT,
div3airportseqid INT,
div3wheelson STRING,
div3totalgtime INT,
div3longestgtime INT,
div3wheelsoff STRING,
div3tailnum STRING,
div4airport STRING,
div4airportid INT,
div4airportseqid INT,
div4wheelson STRING,
div4totalgtime INT,
div4longestgtime INT,
div4wheelsoff STRING,
div4tailnum STRING,
div5airport STRING,
div5airportid INT,
div5airportseqid INT,
div5wheelson STRING,
div5totalgtime INT,
div5longestgtime INT,
div5wheelsoff STRING,
div5tailnum STRING
)
PARTITIONED BY (year STRING)
STORED AS PARQUET
LOCATION 's3://athena-examples-myregion/flight/parquet/'
tblproperties ("parquet.compression"="SNAPPY");
```
Exécutez l'instruction `MSCK REPAIR TABLE` sur la table pour actualiser les métadonnées de la partition:
```
MSCK REPAIR TABLE flight_delays_pq;
```
Recherchez les 10 principaux itinéraires dont le retard dépasse 1 heure :
```
SELECT origin, dest, count(*) as delays
FROM flight_delays_pq
WHERE depdelayminutes > 60
GROUP BY origin, dest
ORDER BY 3 DESC
LIMIT 10;
```
**Note**
Les données du tableau des vols proviennent des [Vols](http://www.transtats.bts.gov/DL_SelectFields.asp?Table_ID=236&DB_Short_Name=On-Time) fournis par le ministère américain des transports, [Bureau of Transportation Statistics](http://www.transtats.bts.gov/) (Bureau des statistiques des transports). Désaturé de l'original.
## Ignorer les statistiques Parquet
Lorsque vous lisez des données Parquet, vous pouvez recevoir des messages d'erreur tels que les suivants :
```
HIVE_CANNOT_OPEN_SPLIT: Index x out of bounds for length y
HIVE_CURSOR_ERROR: Failed to read x bytes
HIVE_CURSOR_ERROR: FailureException at Malformed input: offset=x
HIVE_CURSOR_ERROR: FailureException at java.io.IOException:
can not read class org.apache.parquet.format.PageHeader: Socket is closed by peer.
```
Pour contourner ce problème, utilisez l'[ALTER TABLE SET TBLPROPERTIES](alter-table-set-tblproperties.md)instruction [CREATE TABLE](create-table.md) or pour définir la SerDe `parquet.ignore.statistics` propriété Parquet sur`true`, comme dans les exemples suivants.
Exemple CREATE TABLE
```
...
ROW FORMAT SERDE
'org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe'
WITH SERDEPROPERTIES (
'parquet.ignore.statistics'='true')
STORED AS PARQUET
...
```
Exemple ALTER TABLE
```
ALTER TABLE ... SET TBLPROPERTIES ('parquet.ignore.statistics'='true')
```
# Régex SerDe
La Regex SerDe utilise une expression régulière (regex) pour désérialiser les données en extrayant des groupes d'expressions régulières dans des colonnes de table.
Si une ligne des données ne correspond pas à l'expression régulière, toutes les colonnes de la ligne sont renvoyées comme `NULL`. Si une ligne correspond à l'expression rationnelle mais a moins de groupes que prévu, les groupes manquants sont `NULL`. Si une ligne des données correspond à l'expression régulière mais contient plus de colonnes que de groupes dans l'expression régulière, les colonnes supplémentaires sont ignorées.
Pour plus d'informations, consultez [Class RegexSerDe](https://svn.apache.org/repos/infra/websites/production/hive/content/javadocs/r1.2.2/api/org/apache/hadoop/hive/serde2/RegexSerDe.html) dans la documentation d'Apache Hive.
## Nom de la bibliothèque de sérialisation
Le nom de la bibliothèque de sérialisation pour le Regex SerDe est. `org.apache.hadoop.hive.serde2.RegexSerDe` Pour plus d'informations sur le code source, consultez [Class RegexSerDe](https://svn.apache.org/repos/infra/websites/production/hive/content/javadocs/r1.2.2/api/org/apache/hadoop/hive/serde2/RegexSerDe.html) dans la documentation d'Apache.
## Exemple
L'exemple suivant crée une table à partir de CloudFront journaux à l'aide du RegExSerDe. *myregion*Remplacez-le `s3://athena-examples-myregion/cloudfront/plaintext/` par l'identifiant de la région dans laquelle vous exécutez Athena (par exemple,`s3://athena-examples-us-west-1/cloudfront/plaintext/`).
```
CREATE EXTERNAL TABLE IF NOT EXISTS cloudfront_logs (
`Date` DATE,
Time STRING,
Location STRING,
Bytes INT,
RequestIP STRING,
Method STRING,
Host STRING,
Uri STRING,
Status INT,
Referrer STRING,
os STRING,
Browser STRING,
BrowserVersion STRING
)
ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.RegexSerDe'
WITH SERDEPROPERTIES (
"input.regex" = "^(?!#)([^ ]+)\\s+([^ ]+)\\s+([^ ]+)\\s+([^ ]+)\\s+([^ ]+)\\s+([^ ]+)\\s+([^ ]+)\\s+([^ ]+)\\s+([^ ]+)\\s+([^ ]+)\\s+[^\(]+[\(]([^\;]+).*\%20([^\/]+)[\/](.*)$"
)
LOCATION 's3://athena-examples-myregion/cloudfront/plaintext/';
```