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.
# Utilisation de la projection de partition avec Amazon Athena
Vous pouvez utiliser la projection de partition dans Athena pour accélérer le traitement des requêtes de tables hautement partitionnées et automatiser la gestion des partitions.
Dans une projection de partition, Athena calcule les valeurs et les emplacements de partition à l'aide des propriétés de table que vous configurez directement sur votre table dans AWS Glue. Les propriétés de table permettent à Athena de « projeter », ou de déterminer, les informations de partition nécessaires au lieu d'avoir à effectuer une recherche de métadonnées fastidieuse dans le AWS Glue Data Catalog. Étant donné que les opérations en mémoire sont souvent plus rapides que les opérations distantes, la projection de partition peut réduire le temps d'exécution des requêtes sur les tables hautement partitionnées. Selon les caractéristiques spécifiques de la requête et des données sous-jacentes, la projection de partition peut réduire considérablement le temps d'exécution des requêtes qui sont contraintes lors de la récupération des métadonnées de partition.
## Présentation de l’élagage des partitions et de la projection de partition
L'élagage des partitions rassemble les métadonnées et les « élaguent » afin de ne conserver que les partitions qui s'appliquent à votre requête. Cette approche accélère souvent les requêtes. Athena utilise l'élagage de partition pour toutes les tables contenant des colonnes de partition, y compris les tables configurées pour la projection de partition.
Normalement, lors du traitement des requêtes, Athena `GetPartitions` appelle le AWS Glue Data Catalog avant de procéder à l'élagage de la partition. Si une table comporte un grand nombre de partitions, l'utilisation de `GetPartitions` peut nuire aux performances. Pour pallier ce problème, vous pouvez utiliser la projection de partition. La projection de partition permet à Athena d'éviter d'appeler `GetPartitions`, car la configuration de la projection de partition donne à Athena toutes les informations nécessaires pour créer les partitions.
## Comment utiliser la projection de partition
Pour utiliser la projection de partition, vous devez spécifier les plages de valeurs de partition et les types de projection pour chaque colonne de partition dans les propriétés de table du [métastore Hive externe AWS Glue Data Catalog](connect-to-data-source-hive.md) ou dans celui-ci. Ces propriétés personnalisées permettent à Athena d'identifier les modèles de partition prévus lorsqu'il exécute une requête au niveau de la table. Pendant l'exécution de la requête, Athena utilise ces informations pour projeter les valeurs de partition au lieu de les récupérer depuis le métastore Hive AWS Glue Data Catalog ou depuis un autre métastore Hive. Cette approche permet non seulement de réduire le temps d'exécution des requêtes, mais aussi d'automatiser la gestion des partitions, car cela élimine la nécessité de créer manuellement des partitions dans Athena, AWS Glue ou dans votre métastore Hive externe.
**Important**
L'activation de la projection de partition sur une table oblige Athena à ignorer toutes les métadonnées de partition enregistrées sur la table dans le métastore AWS Glue Data Catalog ou Hive.
## Cas d’utilisation
Les scénarios dans lesquels la projection de partition est utile sont les suivants :
+ Les requêtes relatives à une table hautement partitionnée ne se terminent pas aussi rapidement que vous le souhaitez.
+ Vous ajoutez régulièrement des partitions aux tables au fur et à mesure que de nouvelles partitions de date ou d'heure sont créées dans vos données. Avec la projection de partition, vous configurez des plages de dates relatives qui peuvent être utilisées lors de l'arrivée de nouvelles données.
+ Des données sont hautement partitionnées dans Simple Storage Service (Amazon S3). Les données ne sont pas pratiques à modéliser dans votre métastore AWS Glue Data Catalog ou dans Hive, et vos requêtes n'en lisent que de petites parties.
### Structures de partition projetables
La projection de partition est plus facilement configurée lorsque vos partitions respectent un modèle prévisible comme suit (exemple non exhautif) :
+ **Entiers** : toute séquence continue d'entiers, telle que `[1, 2, 3, 4, ..., 1000]` ou `[0500, 0550, 0600, ..., 2500]`.
+ **Dates** : toute séquence continue de dates ou de dates et heures, telle que `[20200101, 20200102, ..., 20201231]` ou `[1-1-2020 00:00:00, 1-1-2020 01:00:00, ..., 12-31-2020 23:00:00]`.
+ **Valeurs énumérées** : ensemble fini de valeurs énumérées, telles que les codes d'aéroport ou. Régions AWS
+ **Service AWS journaux** — Service AWS les journaux ont généralement une structure connue dont vous pouvez spécifier le schéma de partition AWS Glue et qu'Athena peut donc utiliser pour la projection de partitions.
### Comment personnaliser le modèle de chemin de partition
Par défaut, Athena construit des emplacements de partition à l'aide du formulaire `s3://amzn-s3-demo-bucket//partition-col-1=/partition-col-2=/`, mais si vos données sont organisées différemment, Athena offre un mécanisme pour personnaliser ce modèle de chemin. Pour les étapes, consultez [Comment spécifier des emplacements de stockage S3 personnalisés](partition-projection-setting-up.md#partition-projection-specifying-custom-s3-storage-locations).
## Considérations et restrictions
Les considérations suivantes s'appliquent :
+ La projection de partition élimine le besoin de spécifier manuellement des partitions dans AWS Glue ou dans un métastore Hive externe.
+ Lorsque vous activez la projection de partition sur une table, Athena ignore les métadonnées de partition présentes dans le métastore Hive AWS Glue Data Catalog ou dans un métastore Hive externe pour cette table.
+ Si une partition projetée n'existe pas dans Simple Storage Service (Amazon S3), Athena projette quand même la partition. Athena ne renvoie pas d'erreur, mais aucune donnée n'est renvoyée. Toutefois, si un trop grand nombre de vos partitions sont vides, les performances peuvent être ralenties par rapport aux AWS Glue partitions traditionnelles. Si plus de la moitié de vos partitions projetées sont vides, il est recommandé d'utiliser des partitions traditionnelles.
+ Les requêtes portant sur des valeurs qui dépassent les limites de l'intervalle défini pour la projection de partition ne renvoient pas d'erreur. Au lieu de cela, la requête s'exécute, mais retourne zéro ligne. Par exemple, si vous avez des données temporelles qui commencent en 2020 et qui sont définies comme `'projection.timestamp.range'='2020/01/01,NOW'`, une requête comme `SELECT * FROM table-name WHERE timestamp = '2019/02/02'` se terminera avec succès, mais renverra zéro ligne.
+ La projection des partitions n'est utilisable que lorsque la table est interrogée par Athena. Si la même table est lue par un autre service tel que Amazon Redshift Spectrum, Athena pour Spark ou Amazon EMR, les métadonnées de partition standard sont utilisées.
+ La projection de partition étant une fonctionnalité uniquement DML, `SHOW PARTITIONS` elle ne répertorie pas les partitions projetées par Athena mais non enregistrées dans le AWS Glue catalogue ou dans le métastore Hive externe.
+ Athena n'utilise pas les propriétés des tables des vues comme configuration pour la projection des partitions. Pour contourner cette limitation, configurez et activez la projection de partition dans les propriétés des tables auxquelles les vues font référence.
## Vidéo
La vidéo suivante montre comment utiliser la projection de partition pour augmenter les performances de vos requêtes dans Athena.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/iUD5pPpcyZk)
**Topics**
+ [Présentation de l’élagage des partitions et de la projection de partition](#partition-projection-pruning-vs-projection)
+ [Comment utiliser la projection de partition](#partition-projection-using)
+ [Cas d’utilisation](#partition-projection-use-cases)
+ [Considérations et restrictions](#partition-projection-considerations-and-limitations)
+ [Vidéo](#partition-projection-video)
+ [Configuration de la projection de partition](partition-projection-setting-up.md)
+ [Types pris en charge pour la projection de partition](partition-projection-supported-types.md)
+ [Utilisation du partitionnement d’ID dynamique](partition-projection-dynamic-id-partitioning.md)
+ [Example : Amazon Data Firehose](partition-projection-kinesis-firehose-example.md)
# Configuration de la projection de partition
La configuration de la projection de partition dans les propriétés d'une table s'effectue en deux étapes :
1. Spécifiez les plages de données et les modèles pertinents pour chaque colonne de partition, ou utilisez un modèle personnalisé.
1. Activez la projection de partition pour la table.
**Note**
Avant d'ajouter des propriétés de projection de partition à une table existante, la colonne de partition pour laquelle vous configurez les propriétés de projection de partition doit déjà exister dans le schéma de la table. Si la colonne de partition n'existe pas encore, vous devez ajouter manuellement une colonne de partition à la table existante. AWS Glue n'exécute pas cette étape automatiquement pour vous.
Cette section explique comment définir les propriétés de la table pour AWS Glue. Pour les définir, vous pouvez utiliser la AWS Glue console, les [CREATE TABLE](create-table.md) requêtes Athena ou [AWS Glue API](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api.html)les opérations. La procédure suivante indique comment définir les propriétés dans la AWS Glue console.
**Pour configurer et activer la projection de partitions à l'aide de la AWS Glue console**
1. Connectez-vous à la AWS Glue console AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. Choisissez l'onglet **Tables**.
Sous l'onglet **Tables**, vous pouvez modifier des tables existantes ou choisir **Add tables** (Ajouter des tables) pour en créer de nouvelles. Pour plus d'informations sur l'ajout de tables manuellement ou à l'aide d'un Crawler, consultez la rubrique [Travail avec des tables dans la console AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/console-tables.html) du *Guide du développeur AWS Glue *.
1. Dans la liste des tables, choisissez le lien correspondant à la table que vous souhaitez modifier.
![\[Dans la AWS Glue console, choisissez le tableau à modifier.\]](http://docs.aws.amazon.com/fr_fr/athena/latest/ug/images/partition-projection-1.png)
1. Sélectionnez **Actions**, puis **Edit table** (Modifier la table).
1. Sur la page **Edit table** (Modifier la table), dans la section **Table properties** (Propriétés de la table), ajoutez la paire clé-valeur suivante pour chaque colonne partitionnée :
1. Pour **Key** (Clé), ajoutez `projection.columnName.type`.
1. Pour **Value** (Valeur), ajoutez l'un des types pris en charge : `enum`, `integer`, `date`, ou `injected`. Pour de plus amples informations, veuillez consulter [Types pris en charge pour la projection de partition](partition-projection-supported-types.md).
1. En suivant les instructions indiquées dans [Types pris en charge pour la projection de partition](partition-projection-supported-types.md), ajoutez des paires clé-valeur supplémentaires en fonction de vos exigences de configuration.
L'exemple de configuration de table suivant configure la colonne `year` pour la projection de partition, limitant les valeurs susceptibles d'être renvoyées à une plage comprise entre 2010 et 2016.
![\[Configuration de la projection de partition pour une colonne de partition dans les propriétés de la table de la console AWS Glue .\]](http://docs.aws.amazon.com/fr_fr/athena/latest/ug/images/partition-projection-3.png)
1. Ajoutez une paire clé-valeur pour activer la projection de partition. Pour **Key** (Clé), saisissez `projection.enabled` et pour **Value** (Valeur), saisissez `true`.
**Note**
Vous pouvez désactiver la projection de partition sur cette table à tout moment en définissant la valeur `projection.enabled` sur `false`.
1. Lorsque vous avez terminé, choisissez **Save**.
1. Dans l'éditeur de requête Athena, testez les colonnes que vous avez configurées pour la table.
L'exemple de requête suivant utilise `SELECT DISTINCT` pour renvoyer les valeurs uniques de la colonne `year`. La base de données contient des données comprises entre la plage de dates 1987 et 2016, mais la propriété `projection.year.range` limite les valeurs renvoyées aux années 2010 à 2016.
![\[Interrogation d'une colonne qui utilise la projection de partition.\]](http://docs.aws.amazon.com/fr_fr/athena/latest/ug/images/partition-projection-5.png)
**Note**
Si vous définissez `projection.enabled` sur `true`, mais ne parvenez pas à configurer une ou plusieurs colonnes de partition, un message d'erreur du type suivant s'affiche :
`HIVE_METASTORE_ERROR: Table database_name.table_name is configured for partition projection, but the following partition columns are missing projection configuration: [column_name] (table database_name.table_name)`.
## Comment spécifier des emplacements de stockage S3 personnalisés
Lorsque vous modifiez les propriétés d'une table dans AWS Glue, vous pouvez également spécifier un modèle de chemin Amazon S3 personnalisé pour les partitions projetées. Un modèle personnalisé permet à Athena de mapper correctement les valeurs de partition à des emplacements de fichiers Simple Storage Service (Amazon S3) personnalisés qui ne suivent pas un modèle `.../column=value/...` typique.
L'utilisation d'un modèle personnalisé est facultative. Toutefois, si vous utilisez un modèle personnalisé, celui-ci doit contenir un espace réservé pour chaque colonne de partition. Les emplacements modélisés doivent se terminer par une barre oblique afin que les fichiers de données partitionnés se trouvent dans un « dossier » par partition.
**Pour spécifier un modèle d'emplacement de partition personnalisé**
1. En suivant les étapes pour [configurer et activer la projection de partition à l'aide de la AWS Glue console](#partition-projection-setting-up-procedure), ajoutez une paire clé-valeur supplémentaire qui spécifie un modèle personnalisé comme suit :
1. Pour **Key** (Clé), saisissez `storage.location.template`.
1. Pour **Value** (Valeur), spécifiez un emplacement qui inclut un espace réservé pour chaque colonne de partition. Assurez-vous que chaque espace réservé (et le chemin S3 lui-même) se termine par une barre oblique unique.
Les exemples de valeurs de modèle suivants reposent sur une table avec les colonnes de partition `a`, `b` et `c`.
```
s3://amzn-s3-demo-bucket/table_root/a=${a}/${b}/some_static_subdirectory/${c}/
```
```
s3://amzn-s3-demo-bucket/table_root/c=${c}/${b}/some_static_subdirectory/${a}/${b}/${c}/${c}/
```
Pour la même table, l'exemple de valeur de modèle suivant n'est pas valide, car il ne contient aucun espace réservé pour la colonne `c`.
```
s3://amzn-s3-demo-bucket/table_root/a=${a}/${b}/some_static_subdirectory/
```
1. Cliquez sur **Appliquer**.
# Types pris en charge pour la projection de partition
Une table peut avoir n'importe quelle combinaison de types de colonnes de partition `enum`, `integer`, `date,` ou `injected`.
## Type d'énumération
Utilisez le `enum` type pour les colonnes de partition dont les valeurs sont membres d'un ensemble énuméré (par exemple, des codes d'aéroport ou Régions AWS).
Définissez les propriétés de partition dans le tableau comme suit :
****
| Nom de la propriété | Exemples de valeur | Description |
| --- | --- | --- |
| projection.columnName.type | `enum` | Obligatoire. Type de projection à utiliser pour la colonnecolumnName. La valeur doit être enum (insensible à la casse) pour signaler l'utilisation du type énumération. L'espace de début et de fin est autorisé. |
| projection.columnName.values | `A,B,C,D,E,F,G,Unknown` | Obligatoire. Liste séparée par des virgules des valeurs de partition énumérées pour la colonne. columnName Tout espace est considéré comme faisant partie d'une valeur d'énumération. |
**Note**
En tant que bonne pratique, nous recommandons de limiter l'utilisation des projections de partitions basées sur `enum` à quelques dizaines ou moins. Bien qu'il n'existe aucune limite spécifique pour les `enum` projections, la taille totale des métadonnées de votre table ne peut pas dépasser la AWS Glue limite d'environ 1 Mo lors de la compression gzip. Notez que cette limite est partagée entre les éléments clés de votre table, comme les noms de colonnes, l'emplacement, le format de stockage, etc. Si vous utilisez plus de quelques dizaines d'unités uniques IDs dans votre `enum` projection, envisagez une autre approche, par exemple en répartissant un plus petit nombre de valeurs uniques dans un champ de substitution. En échangeant la cardinalité, vous pouvez contrôler le nombre de valeurs uniques dans votre champ `enum`.
## Type d'entier
Utilisez le type entier pour les colonnes de partition dont les valeurs possibles peuvent être interprétées comme des entiers dans une plage définie. Les colonnes d'entier projetées sont actuellement limitées à la plage d'un entier Java long signé (-263 à 263-1 inclus).
****
| Nom de la propriété | Exemples de valeur | Description |
| --- | --- | --- |
| projection.columnName.type | `integer` | Obligatoire. Type de projection à utiliser pour la colonnecolumnName. La valeur doit être integer (insensible à la casse) pour signaler l'utilisation du type entier. L'espace de début et de fin est autorisé. |
| projection.columnName.range | `0,10` `-1,8675309` `0001,9999` | Obligatoire. Liste à deux éléments séparés par des virgules qui fournit les valeurs de plage minimale et maximale à renvoyer par les requêtes sur la colonne. columnName Notez que les valeurs doivent être séparées par une virgule, et non par un tiret. Ces valeurs sont inclusives, peuvent être négatives et peuvent contenir des zéros de début. L'espace de début et de fin est autorisé. |
| projection.columnName.interval | `1` `5` | Facultatif. Un entier positif qui indique l'intervalle entre les valeurs de partition successives de la colonnecolumnName. Par exemple, la valeur range « 1,3 » avec une valeur interval correspondant à « 1 » génère les valeurs 1, 2 et 3. La même valeur range avec une valeur interval correspondant à « 2 » génère les valeurs 1 et 3 et ignore 2. L'espace de début et de fin est autorisé. La valeur par défaut est 1. |
| projection.columnName.digits | `1` `5` | Facultatif. Un entier positif qui indique le nombre de chiffres à inclure dans la représentation finale de la valeur de partition pour la colonnecolumnName. Par exemple, la valeur range « 1,3 » avec une valeur digits correspondant à « 1 » génère les valeurs 1, 2 et 3. La même valeur range avec une valeur digits correspondant à « 2 » génère les valeurs 01, 02 et 03. L'espace de début et de fin est autorisé. La valeur par défaut est un nombre non statique de chiffres et ne contient aucun zéro de début. |
## Type de date
Utilisez le type de date pour les colonnes de partition dont les valeurs sont interprétables comme des dates (avec des heures facultatives) dans une plage définie.
**Important**
Les colonnes de date projetée sont générées en temps universel coordonné (UTC) au moment de l'exécution de la requête.
****
| Nom de la propriété | Exemples de valeur | Description |
| --- | --- | --- |
| projection.columnName.type | `date` | Obligatoire. Type de projection à utiliser pour la colonnecolumnName. La valeur doit être date (insensible à la casse) pour signaler l'utilisation du type date. L'espace de début et de fin est autorisé. |
| projection.columnName.range | `201701,201812` `01-01-2010,12-31-2018` `NOW-3YEARS,NOW` `201801,NOW+1MONTH` | Obligatoire. Liste à deux éléments séparés par des virgules qui fournit les `range` valeurs minimale et maximale de la colonne. *columnName* Ces valeurs sont inclusives et peuvent utiliser n'importe quel format compatible avec les types de date Java `java.time.*`. Les valeurs minimales et maximales doivent utiliser le même format. Le format spécifié dans la propriété `.format` doit correspondre au format utilisé pour ces valeurs. Cette colonne peut également contenir des chaînes de date relatives, formatées dans ce modèle d'expression régulière : `\s*NOW\s*(([\+\-])\s*([0-9]+)\s*(YEARS?\|MONTHS?\|WEEKS?\|DAYS?\|HOURS?\|MINUTES?\|SECONDS?)\s*)?` Les espaces sont autorisés, mais les littéraux de type date sont considérés comme faisant partie des chaînes de date elles-mêmes. |
| projection.columnName.format | `yyyyMM` `dd-MM-yyyy` `dd-MM-yyyy-HH-mm-ss` | Obligatoire. Chaîne de format de date basée sur le format de date Java [DateTimeFormatter](https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html). Il peut s'agir de n'importe quel type Java.time.\$1 pris en charge. |
| projection.columnName.interval | `1` `5` | Un entier positif qui indique l'intervalle entre les valeurs de partition successives d'une colonne*columnName*. Par exemple, la valeur `range` `2017-01,2018-12` avec une valeur `interval` correspondant à `1` et une valeur `interval.unit` correspondant à `MONTHS` génère les valeurs 2017-01, 2017-02, 2017-03, etc. La même valeur `range` avec une valeur `interval` correspondant à `2` et une valeur `interval.unit` correspondant `MONTHS` génère les valeurs 2017-01, 2017-03, 2017-05, etc. L'espace de début et de fin est autorisé. Lorsque les dates fournies sont précises à un jour ou à un mois, la valeur `interval` est facultative, et la valeur par défaut est 1 jour ou 1 mois, respectivement. Dans le cas contraire, la valeur `interval` est obligatoire. |
| projection.columnName.interval.unit | `YEARS` `MONTHS` `WEEKS` `DAYS` `HOURS` `MINUTES` `SECONDS` `MILLIS` | Un mot d'unité de temps qui représente la forme sérialisée de a. [ChronoUnit](https://docs.oracle.com/javase/8/docs/api/java/time/temporal/ChronoUnit.html) Les valeurs possibles sont `YEARS`, `MONTHS`, `WEEKS`, `DAYS`, `HOURS`, `MINUTES`, `SECONDS` ou `MILLIS`. Ces valeurs ne sont pas sensibles à la casse. Lorsque les dates fournies sont précises à un jour ou à un mois, la valeur `interval.unit` est facultative, et la valeur par défaut est 1 jour ou 1 mois, respectivement. Dans le cas contraire, la valeur `interval.unit` est obligatoire. |
**Example : partitionnement par mois**
L’exemple de configuration de table ci-dessous partitionne les données par mois de 2015 à aujourd’hui.
```
'projection.month.type'='date',
'projection.month.format'='yyyy-MM',
'projection.month.interval'='1',
'projection.month.interval.unit'='MONTHS',
'projection.month.range'='2015-01,NOW',
...
```
## Type injecté
Utilisez le type injecté pour les colonnes de partition avec des valeurs possibles qui ne peuvent pas être générées de manière procédurale dans une plage logique, mais qui sont fournies dans la clause `WHERE` d'une requête en tant que valeur unique.
Il est important de garder à l'esprit les points suivants :
+ Les requêtes au niveau des colonnes injectées échouent si aucune expression de filtre n'est fournie pour chaque colonne injectée.
+ Les requêtes comportant plusieurs valeurs pour une expression de filtre sur une colonne injectée réussissent uniquement si les valeurs sont disjointes.
+ Seules les colonnes de type `string` sont prises en charge.
+ Lorsque vous utilisez la clause `WHERE IN` avec une colonne de partition injectée, vous pouvez spécifier au maximum 1 000 valeurs dans la liste `IN`. Pour interroger un jeu de données contenant plus de 1 000 partitions pour une colonne injectée, divisez la requête en plusieurs requêtes de plus petite taille contenant chacune jusqu’à 1 000 valeurs dans la clause `WHERE IN`, puis agrégez les résultats.
****
| Nom de la propriété | Value | Description |
| --- | --- | --- |
| projection.columnName.type | `injected` | Obligatoire. Type de projection à utiliser pour la colonnecolumnName. Seul le type string est pris en charge. La valeur spécifiée doit être injected (insensible à la casse). L'espace de début et de fin est autorisé. |
Pour de plus amples informations, veuillez consulter [Quand utiliser le type de projection `injected`](partition-projection-dynamic-id-partitioning.md#partition-projection-injection).
# Utilisation du partitionnement d’ID dynamique
Lorsque vos données sont partitionnées par une propriété avec une cardinalité élevée ou lorsque les valeurs ne peuvent pas être connues à l’avance, vous pouvez utiliser le type de projection `injected`. Les noms d'utilisateur et les noms d'appareils ou de produits sont IDs des exemples de telles propriétés. Lorsque vous utilisez le type de projection `injected` pour configurer une clé de partition, Athena utilise les valeurs de la requête elle-même pour calculer l’ensemble des partitions qui seront lues.
Pour qu’Athena puisse exécuter une requête sur une table dont la clé de partition est configurée avec le type de projection `injected`, les critères suivants doivent être remplis :
+ Votre requête doit inclure au moins une valeur pour la clé de partition.
+ La ou les valeurs doivent être des littéraux ou des expressions qui peuvent être évalués sans lire aucune donnée.
Si l’un de ces critères n’est pas rempli, votre requête échoue avec l’erreur suivante :
CONSTRAINT\$1VIOLATION : Pour la colonne de partition projetée injectée*column\$1name*, la clause WHERE doit contenir uniquement des conditions d'égalité statiques, et au moins une de ces conditions doit être présente.
## Quand utiliser le type de projection `injected`
Imaginez que vous disposiez d'un ensemble de données composé d'événements provenant d'appareils IoT, répartis sur les appareils IDs. Ce jeu de données possède les caractéristiques suivantes :
+ Les appareils IDs sont générés de manière aléatoire.
+ de nouveaux appareils sont fréquemment alloués ;
+ il existe actuellement des centaines de milliers d’appareils, et dans le futur, il y en existera des millions.
Ce jeu de données est difficile à gérer en utilisant des métastores classiques. Il est difficile de synchroniser les partitions entre le stockage de données et le métastore, et le filtrage des partitions peut être lent lors de la planification des requêtes. Mais si vous configurez une table pour utiliser la projection de partition et que vous utilisez le type de projection `injected`, vous avez deux avantages : vous n’avez pas à gérer les partitions dans le métastore et vos requêtes n’ont pas à rechercher les métadonnées des partitions.
L’exemple `CREATE TABLE` suivant crée une table pour le jeu de données d’événements d’appareil que nous venons de décrire. La table utilise le type de projection injecté.
```
CREATE EXTERNAL TABLE device_events (
event_time TIMESTAMP,
data STRING,
battery_level INT
)
PARTITIONED BY (
device_id STRING
)
LOCATION "s3://amzn-s3-demo-bucket/prefix/"
TBLPROPERTIES (
"projection.enabled" = "true",
"projection.device_id.type" = "injected",
"storage.location.template" = "s3://amzn-s3-demo-bucket/prefix/${device_id}"
)
```
L’exemple de requête suivant recherche le nombre d’événements reçus par trois appareils spécifiques sur une période de 12 heures.
```
SELECT device_id, COUNT(*) AS events
FROM device_events
WHERE device_id IN (
'4a770164-0392-4a41-8565-40ed8cec737e',
'f71d12cf-f01f-4877-875d-128c23cbde17',
'763421d8-b005-47c3-ba32-cc747ab32f9a'
)
AND event_time BETWEEN TIMESTAMP '2023-11-01 20:00' AND TIMESTAMP '2023-11-02 08:00'
GROUP BY device_id
```
Lorsque vous exécutez cette requête, Athena voit les trois valeurs de la clé de partition `device_id` et les utilise pour calculer les emplacements des partitions. Athena utilise la valeur de la propriété `storage.location.template` pour générer les emplacements suivants :
+ `s3://amzn-s3-demo-bucket/prefix/4a770164-0392-4a41-8565-40ed8cec737e`
+ `s3://amzn-s3-demo-bucket/prefix/f71d12cf-f01f-4877-875d-128c23cbde17`
+ `s3://amzn-s3-demo-bucket/prefix/763421d8-b005-47c3-ba32-cc747ab32f9a`
Si vous omettez la propriété `storage.location.template` dans la configuration de projection de partition, Athena utilise le partitionnement de style Hive pour projeter les emplacements des partitions en fonction de la valeur contenue dans `LOCATION` (par exemple, `s3://amzn-s3-demo-bucket/prefix/device_id=4a770164-0392-4a41-8565-40ed8cec737e`).
# Example : Amazon Data Firehose
Lorsque vous utilisez Firehose pour fournir des données à Amazon S3, la configuration par défaut écrit des objets avec des clés semblables à l’exemple suivant :
```
s3://amzn-s3-demo-bucket/prefix/yyyy/MM/dd/HH/file.extension
```
Pour créer une table Athena qui trouve les partitions automatiquement au moment de la requête, au lieu de devoir les ajouter à AWS Glue Data Catalog mesure que de nouvelles données arrivent, vous pouvez utiliser la projection de partitions.
L’exemple d’instruction `CREATE TABLE` suivant utilise la configuration Firehose par défaut.
```
CREATE EXTERNAL TABLE my_ingested_data (
...
)
...
PARTITIONED BY (
datehour STRING
)
LOCATION "s3://amzn-s3-demo-bucket/prefix/"
TBLPROPERTIES (
"projection.enabled" = "true",
"projection.datehour.type" = "date",
"projection.datehour.format" = "yyyy/MM/dd/HH",
"projection.datehour.range" = "2021/01/01/00,NOW",
"projection.datehour.interval" = "1",
"projection.datehour.interval.unit" = "HOURS",
"storage.location.template" = "s3://amzn-s3-demo-bucket/prefix/${datehour}/"
)
```
La clause `TBLPROPERTIES` dans l'instruction `CREATE TABLE` indique à Athena ce qui suit :
+ Utiliser la projection de partition lors de l'interrogation de la table
+ La clé de partition `datehour` est de type `date` (qui inclut une heure facultative)
+ Comment les dates sont formatées
+ La plage de dates et heures. Notez que les valeurs doivent être séparées par une virgule, et non par un tiret.
+ Où trouver les données sur Amazon S3.
Lorsque vous interrogez la table, Athena calcule les valeurs pour `datehour` et utilise le modèle d'emplacement de stockage pour générer une liste d'emplacements de partition.
**Topics**
+ [Comment utiliser le type `date`](partition-projection-kinesis-firehose-example-using-the-date-type.md)
+ [Comment choisir les clés de partition](partition-projection-kinesis-firehose-example-choosing-partition-keys.md)
+ [Comment utiliser des préfixes personnalisés et le partitionnement dynamique](partition-projection-kinesis-firehose-example-using-custom-prefixes-and-dynamic-partitioning.md)
# Comment utiliser le type `date`
Lorsque vous utilisez le type `date` pour une clé de partition projetée, vous devez spécifier une plage. Puisque vous ne disposez pas de données pour les dates antérieures à la création du flux de diffusion Firehose, vous pouvez utiliser la date de création comme début. Et comme vous ne disposez pas de données pour les dates à l'avenir, vous pouvez utiliser le jeton spécial `NOW` comme fin.
Dans l'exemple `CREATE TABLE`, la date de début est spécifiée le 1er janvier 2021 à minuit UTC.
**Note**
Configurez une plage qui correspond aussi précisément que possible à vos données afin qu'Athena ne recherche que les partitions existantes.
Lorsqu'une requête est exécutée sur la table d'exemple, Athena utilise les conditions sur la clé de partition `datehour` en combinaison avec la plage pour générer des valeurs. Considérons la requête suivante :
```
SELECT *
FROM my_ingested_data
WHERE datehour >= '2020/12/15/00'
AND datehour < '2021/02/03/15'
```
La première condition dans la requête `SELECT` utilise une date antérieure au début de la plage de dates spécifiée par l'instruction `CREATE TABLE`. Étant donné que la configuration de projection de partitions ne spécifie aucune partition pour les dates antérieures au 1er janvier 2021, Athena recherche des données uniquement aux emplacements suivants et ignore les dates antérieures dans la requête.
```
s3://amzn-s3-demo-bucket/prefix/2021/01/01/00/
s3://amzn-s3-demo-bucket/prefix/2021/01/01/01/
s3://amzn-s3-demo-bucket/prefix/2021/01/01/02/
...
s3://amzn-s3-demo-bucket/prefix/2021/02/03/12/
s3://amzn-s3-demo-bucket/prefix/2021/02/03/13/
s3://amzn-s3-demo-bucket/prefix/2021/02/03/14/
```
De même, si la requête s'est exécutée à une date et une heure avant le 3 février 2021 à 15 h 00, la dernière partition refléterait la date et l'heure actuelles, et non la date et l'heure dans la condition de requête.
Si vous souhaitez rechercher les données les plus récentes, vous pouvez profiter du fait qu'Athena ne génère pas de dates futures et ne spécifier qu'une `datehour` de début, comme dans l'exemple suivant.
```
SELECT *
FROM my_ingested_data
WHERE datehour >= '2021/11/09/00'
```
# Comment choisir les clés de partition
Vous pouvez spécifier comment la projection de partition mappe les emplacements des partitions aux clés de partition. Dans l'exemple `CREATE TABLE` de la section précédente, la date et l'heure ont été combinées dans une clé de partition appelée datehour, mais d'autres schémas sont possibles. Par exemple, vous pouvez également configurer une table avec des clés de partition distinctes pour l'année, le mois, le jour et l'heure.
Cependant, si vous divisez les dates en année, mois et jour, le type de projection de partition de `date` ne peut pas être utilisé. Une alternative consiste à séparer la date de l'heure afin de continuer à exploiter le type de projection de partition de `date`, tout en facilitant la lecture des requêtes qui spécifient des plages d'heures.
Dans cette optique, l'exemple `CREATE TABLE` suivant sépare la date de l'heure. Étant donné que `date` est un mot réservé dans SQL, l'exemple utilise `day` comme nom de la clé de partition qui représente la date.
```
CREATE EXTERNAL TABLE my_ingested_data2 (
...
)
...
PARTITIONED BY (
day STRING,
hour INT
)
LOCATION "s3://amzn-s3-demo-bucket/prefix/"
TBLPROPERTIES (
"projection.enabled" = "true",
"projection.day.type" = "date",
"projection.day.format" = "yyyy/MM/dd",
"projection.day.range" = "2021/01/01,NOW",
"projection.day.interval" = "1",
"projection.day.interval.unit" = "DAYS",
"projection.hour.type" = "integer",
"projection.hour.range" = "0,23",
"projection.hour.digits" = "2",
"storage.location.template" = "s3://amzn-s3-demo-bucket/prefix/${day}/${hour}/"
)
```
Dans l'exemple d'instruction `CREATE TABLE`, l'heure est une clé de partition distincte, configurée comme un nombre entier. La configuration de la clé de partition des heures spécifie la plage 0 à 23, et que l'heure doit être formatée à deux chiffres lorsque Athena génère les emplacements de partition.
Une requête pour la table `my_ingested_data2` pourrait ressembler à ceci :
```
SELECT *
FROM my_ingested_data2
WHERE day = '2021/11/09'
AND hour > 3
```
## Présentation des types de données de clé de partition et de projection de partition
Notez que la clé `datehour` dans le premier exemple `CREATE TABLE` est configurée comme `date` dans la configuration de projection de partition, mais le type de clé de partition est `string`. Il en va de même pour `day` dans le second exemple. Les types de la configuration de projection de partition indiquent uniquement à Athena comment formater les valeurs lorsqu'elle génère les emplacements de partition. Les types que vous spécifiez ne modifient pas le type de clé de partition. Dans les requêtes, `datehour` et `day` sont de type `string`.
Lorsqu'une requête inclut une condition telle que `day = '2021/11/09'`, Athena analyse la chaîne située à droite de l'expression en utilisant le format de date spécifié dans la configuration de projection de partition. Après avoir vérifié que la date est comprise dans la plage configurée, Athena utilise à nouveau le format de date pour insérer la date sous forme de chaîne dans le modèle d'emplacement de stockage.
De même, pour une condition de requête telle que `day > '2021/11/09'`, Athena analyse le côté droit et génère une liste de toutes les dates correspondantes dans la plage configurée. Le format de date est ensuite utilisé pour insérer chaque date dans le modèle d'emplacement de stockage afin de créer la liste des emplacements de partition.
Écrire la même condition que `day > '2021-11-09'` ou `day > DATE '2021-11-09'` ne fonctionne pas. Dans le premier cas, le format de date ne correspond pas (notez les traits d'union plutôt que les barres obliques) et, dans le second cas, les types de données ne correspondent pas.
# Comment utiliser des préfixes personnalisés et le partitionnement dynamique
Firehose peut être configuré pour utiliser des [préfixes personnalisés](https://docs.aws.amazon.com/firehose/latest/dev/s3-prefixes.html) et le [partitionnement dynamique](https://docs.aws.amazon.com/firehose/latest/dev/dynamic-partitioning.html). À l'aide de ces fonctions, vous pouvez configurer les clés Amazon S3 et configurer des schémas de partitionnement qui prennent mieux en charge votre cas d'utilisation. Vous pouvez également utiliser la projection de partitions avec ces schémas de partitionnement et les configurer en conséquence.
Par exemple, vous pouvez utiliser la fonction de préfixe personnalisé pour obtenir des clés Amazon S3 dont les dates sont au format ISO au lieu du schéma par défaut `yyyy/MM/dd/HH`.
Vous pouvez également combiner des préfixes personnalisés avec le partitionnement dynamique pour extraire une propriété telle que `customer_id` de messages Firehose, comme illustré dans l’exemple suivant.
```
prefix/!{timestamp:yyyy}-!{timestamp:MM}-!{timestamp:dd}/!{partitionKeyFromQuery:customer_id}/
```
Avec ce préfixe Amazon S3, le flux de diffusion Firehose écrit les objets dans des clés telles que `s3://amzn-s3-demo-bucket/prefix/2021-11-01/customer-1234/file.extension`. Pour une propriété comme `customer_id`, où les valeurs peuvent ne pas être connues à l'avance, vous pouvez utiliser le type de projection de partition `injected` et utilisez une instruction `CREATE TABLE` comme suit :
```
CREATE EXTERNAL TABLE my_ingested_data3 (
...
)
...
PARTITIONED BY (
day STRING,
customer_id STRING
)
LOCATION "s3://amzn-s3-demo-bucket/prefix/"
TBLPROPERTIES (
"projection.enabled" = "true",
"projection.day.type" = "date",
"projection.day.format" = "yyyy-MM-dd",
"projection.day.range" = "2021-01-01,NOW",
"projection.day.interval" = "1",
"projection.day.interval.unit" = "DAYS",
"projection.customer_id.type" = "injected",
"storage.location.template" = "s3://amzn-s3-demo-bucket/prefix/${day}/${customer_id}/"
)
```
Lorsque vous interrogez une table comportant une clé de partition de type `injected`, votre requête doit inclure une valeur pour cette clé de partition. Une requête pour la table `my_ingested_data3` pourrait ressembler à ceci :
```
SELECT *
FROM my_ingested_data3
WHERE day BETWEEN '2021-11-01' AND '2021-11-30'
AND customer_id = 'customer-1234'
```
## Utilisation du type DATE pour la clé de partition de jour
Comme les valeurs de la clé de partition `day` sont au format ISO, vous pouvez également utiliser le type `DATE` pour la clé de partition day au lieu de `STRING`, comme dans l'exemple suivant :
```
PARTITIONED BY (day DATE, customer_id STRING)
```
Lorsque vous effectuez une requête, cette stratégie vous permet d'utiliser des fonctions de date sur la clé de partition sans analyse ni diffusion, comme dans l'exemple suivant :
```
SELECT *
FROM my_ingested_data3
WHERE day > CURRENT_DATE - INTERVAL '7' DAY
AND customer_id = 'customer-1234'
```
**Note**
La spécification d'une clé de partition du type `DATE` suppose que vous avez utilisé la fonctionnalité de [préfixe personnalisé](https://docs.aws.amazon.com/firehose/latest/dev/s3-prefixes.html) pour créer des clés Amazon S3 dont les dates sont au format ISO. Si vous utilisez le format Firehose par défaut `yyyy/MM/dd/HH`, vous devez spécifier la clé de partition comme type `string`, même si la propriété de table correspondante est de type `date`, comme dans l’exemple suivant :
```
PARTITIONED BY (
`mydate` string)
TBLPROPERTIES (
'projection.enabled'='true',
...
'projection.mydate.type'='date',
'storage.location.template'='s3://amzn-s3-demo-bucket/prefix/${mydate}')
```