Amazon Redshift ne prendra plus en charge la création de nouveaux Python à UDFs partir du patch 198. UDFs Le Python existant continuera de fonctionner jusqu'au 30 juin 2026. Pour plus d’informations, consultez le [ billet de blog ](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/).
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.
# Tables externes pour Redshift Spectrum
Cette rubrique décrit comment créer et utiliser des tables externes avec Redshift Spectrum. Les tables externes sont des tables que vous utilisez comme références pour accéder à des données en dehors de votre cluster Amazon Redshift. Ces tables contiennent des métadonnées relatives aux données externes lues par Redshift Spectrum.
Vous créez une table externe dans un schéma externe. Pour créer des tables externes, vous devez être le propriétaire du schéma externe ou un superutilisateur. Pour transférer la propriété d’un schéma externe, utilisez [ALTER SCHEMA](r_ALTER_SCHEMA.md) pour modifier le propriétaire. L’exemple suivant remplace le propriétaire du schéma `spectrum_schema` par `newowner`.
```
alter schema spectrum_schema owner to newowner;
```
Pour exécuter une requête Redshift Spectrum, vous devez avoir les autorisations suivantes :
+ Autorisations d’utilisation du schéma
+ Autorisation de créer des tables temporaires dans la base de données actuelle
L’exemple suivant accorde l’autorisation d’utiliser le schéma `spectrum_schema` au groupe d’utilisateurs `spectrumusers`.
```
grant usage on schema spectrum_schema to group spectrumusers;
```
L’exemple suivant accorde une autorisation temporaire concernant la base de données `spectrumdb` au groupe d’utilisateurs `spectrumusers`.
```
grant temp on database spectrumdb to group spectrumusers;
```
Vous pouvez créer une table externe dans Amazon Redshift AWS Glue, Amazon Athena ou dans un métastore Apache Hive. Pour plus d’informations, consultez [Premiers pas avec AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/getting-started.html) dans le *guide du développeur AWS Glue *, [Démarrez](https://docs.aws.amazon.com/athena/latest/ug/getting-started.html) dans le *guide de l’utilisateur d’Amazon Athena*, ou [Apache Hive](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-hive.html) dans le *guide du développeur Amazon EMR*.
Si votre table externe est définie dans Athena ou dans AWS Glue un métastore Hive, vous devez d'abord créer un schéma externe qui fait référence à la base de données externe. Vous pouvez alors faire référence à la table externe dans votre instruction SELECT en faisant précéder le nom de la table du nom du schéma, sans avoir à créer la table dans Amazon Redshift. Pour de plus amples informations, veuillez consulter [Schémas externes dans Amazon Redshift Spectrum](c-spectrum-external-schemas.md).
Pour permettre à Amazon Redshift d'afficher les tables dans le AWS Glue Data Catalog, ajoutez-les `glue:GetTable` au rôle Amazon Redshift IAM. Sinon, vous risquez de recevoir une erreur similaire à ce qui suit.
```
RedshiftIamRoleSession is not authorized to perform: glue:GetTable on resource: *;
```
Par exemple, supposons que vous ayez une table externe nommée `lineitem_athena` définie dans un catalogue externe Athena. Vous pouvez dans ce cas définir un schéma externe nommé `athena_schema`, puis interroger la table à l’aide de l’instruction SELECT suivante.
```
select count(*) from athena_schema.lineitem_athena;
```
Pour définir une table externe dans Amazon Redshift, utilisez la commande [CREATE EXTERNAL TABLE](r_CREATE_EXTERNAL_TABLE.md). L’instruction de la table externe définit les colonnes de la table, le format des fichiers de données ainsi que l’emplacement des données dans Amazon S3. Redshift Spectrum analyse les fichiers dans le dossier spécifié, mais pas dans les sous-dossiers. Redshift Spectrum ignore les fichiers masqués ainsi que les fichiers dont le nom commence par un point, un trait de soulignement ou une marque de hachage ( . , \$1 ou \$1) ou se termine par un tilde (\$1).
L’exemple suivant crée une table nommée SALES dans le schéma externe Amazon Redshift nommé `spectrum`. Les données figurent dans des fichiers texte délimités par des tabulations.
```
create external table spectrum.sales(
salesid integer,
listid integer,
sellerid integer,
buyerid integer,
eventid integer,
dateid smallint,
qtysold smallint,
pricepaid decimal(8,2),
commission decimal(8,2),
saletime timestamp)
row format delimited
fields terminated by '\t'
stored as textfile
location 's3://redshift-downloads/tickit/spectrum/sales/'
table properties ('numRows'='172000');
```
Pour afficher les tables externes, interrogez la vue système [SVV\$1EXTERNAL\$1TABLES](r_SVV_EXTERNAL_TABLES.md).
## Pseudocolonnes
Par défaut, Amazon Redshift crée des tables externes avec les pseudo-colonnes `$path`, `$size` et `$spectrum_oid`. Sélectionnez la colonne `$path` pour afficher le chemin d’accès aux fichiers de données sur Amazon S3 et sélectionnez la colonne `$size` pour afficher la taille des données de chaque ligne renvoyée par une requête. La colonne `$spectrum_oid` permet d’effectuer des requêtes corrélées avec Redshift Spectrum. Pour obtenir un exemple, consultez [Exemple : exécution de sous-requêtes corrélées dans Redshift Spectrum](c_performing-correlated-subqueries-spectrum.md). Vous devez délimiter les noms de colonne `$path`, `$size` et `$spectrum_oid` par des guillemets doubles. Une clause SELECT \$1 ne renvoie pas les pseudo-colonnes. Vous devez inclure explicitement les noms de colonne `$path`, `$size` et `$spectrum_oid` dans votre requête, comme l’illustre l’exemple suivant.
```
select "$path", "$size", "$spectrum_oid"
from spectrum.sales_part where saledate = '2008-12-01';
```
Vous pouvez désactiver la création de pseudo-colonnes d’une séance en définissant le paramètre de configuration `spectrum_enable_pseudo_columns` avec la valeur `false`. Pour de plus amples informations, veuillez consulter [spectrum\$1enable\$1pseudo\$1columns](r_spectrum_enable_pseudo_columns.md). Vous pouvez aussi désactiver uniquement la pseudo-colonne `$spectrum_oid` en définissant `enable_spectrum_oid` sur `false`. Pour de plus amples informations, veuillez consulter [enable\$1spectrum\$1oid](r_spectrum_enable_spectrum_oid.md). Toutefois, la désactivation de la pseudo-colonne `$spectrum_oid` désactive également la prise en charge des requêtes corrélées avec Redshift Spectrum.
**Important**
La sélection de `$size`, `$path` ou `$spectrum_oid` entraîne des frais, car Redshift Spectrum analyse les fichiers de données sur Amazon S3 pour déterminer la taille de l’ensemble de résultats. Pour plus d’informations, consultez la section [Tarification Amazon Redshift](https://aws.amazon.com/redshift/pricing/).
### Exemple de pseudocolonnes
L’exemple suivant renvoie la taille totale des fichiers de données associés pour une table externe.
```
select distinct "$path", "$size"
from spectrum.sales_part;
$path | $size
--------------------------------------------------------------------------+-------
s3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-01/ | 1616
s3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-02/ | 1444
s3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-03/ | 1644
```
## Partitionnement des tables externes Redshift Spectrum
Lorsque vous partitionnez vos données, vous pouvez restreindre la quantité de données analysées par Redshift Spectrum en les filtrant en fonction de n’importe quelle clé de partition.
Il est courant de les partitionner selon des critères temporels. Par exemple, vous pouvez les partitionner en fonction de l’année, du mois, de la date et de l’heure. Si les données sont issues de plusieurs sources, vous pouvez les partitionner selon un identificateur de source de données et une date.
La procédure suivante décrit comment partitionner les données.
**Pour partitionner les données**
1. Stockez les données dans des dossiers d’Amazon S3 en fonction de la clé de partition.
Créez pour chaque valeur de partition un dossier que vous nommerez à l’aide de la clé et de la valeur de partition. Par exemple, si vous partitionnez les données par date, vos dossiers peuvent être nommés `saledate=2017-04-01`, `saledate=2017-04-02`, etc. Redshift Spectrum analyse les fichiers dans le dossier de partition et tous les sous-dossiers. Redshift Spectrum ignore les fichiers masqués ainsi que les fichiers dont le nom commence par un point, un trait de soulignement ou une marque de hachage ( . , \$1 ou \$1) ou se termine par un tilde (\$1).
1. Créez une table externe, puis spécifiez la clé de partition dans la clause PARTITIONED BY.
La clé de partition ne peut pas correspondre au nom d’une colonne de la table. Le type de données peut être SMALLINT, INTEGER, BIGINT, DECIMAL, REAL, DOUBLE PRECISION, BOOLEAN, CHAR, VARCHAR, DATE ou TIMESTAMP.
1. Ajoutez des partitions.
En utilisant [ALTER TABLE](r_ALTER_TABLE.md) … ADD PARTITION, ajoutez chaque partition, en spécifiant la colonne de la partition et la valeur de la clé, ainsi que l’emplacement du dossier de partition dans Amazon S3. Vous pouvez ajouter plusieurs partitions en une seule instruction ALTER TABLE … ADD. L’exemple qui suit ajoute des partitions pour `'2008-01'` et `'2008-03'`.
```
alter table spectrum.sales_part add
partition(saledate='2008-01-01')
location 's3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-01/'
partition(saledate='2008-03-01')
location 's3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-03/';
```
**Note**
Si vous utilisez le AWS Glue catalogue, vous pouvez ajouter jusqu'à 100 partitions à l'aide d'une seule instruction ALTER TABLE.
### Exemples de partitionnement de données
Dans cet exemple, vous devez créer une table externe partitionnée par une seule clé de partition et une table externe partitionnée par deux clés de partition.
Les exemples de données de cet exemple se trouvent dans un compartiment Amazon S3 qui donne un accès en lecture à tous les AWS utilisateurs authentifiés. Votre cluster et vos fichiers de données externes doivent se trouver dans la même Région AWS. L’exemple de compartiment de données se trouve dans la région USA Est (Virginie du Nord) (us-east-1). Pour pouvoir accéder aux données à l’aide de Redshift Spectrum, votre cluster doit donc également se trouver dans la région us-east-1. Pour répertorier les dossiers dans Amazon S3, exécutez la commande suivante.
```
aws s3 ls s3://redshift-downloads/tickit/spectrum/sales_partition/
```
```
PRE saledate=2008-01/
PRE saledate=2008-03/
PRE saledate=2008-04/
PRE saledate=2008-05/
PRE saledate=2008-06/
PRE saledate=2008-12/
```
Si vous ne possédez pas encore de schéma externe, exécutez la commande ci-dessous. Remplacez votre rôle (IAM) par le nom de ressource Amazon Gestion des identités et des accès AWS (ARN).
```
create external schema spectrum
from data catalog
database 'spectrumdb'
iam_role 'arn:aws:iam::123456789012:role/myspectrumrole'
create external database if not exists;
```
#### Exemple 1 : Partitionnement avec une seule clé de partition
Dans l’exemple suivant, vous devez créer une table externe partitionnée par mois.
Pour créer une table externe partitionnée par mois, exécutez la commande suivante.
```
create external table spectrum.sales_part(
salesid integer,
listid integer,
sellerid integer,
buyerid integer,
eventid integer,
dateid smallint,
qtysold smallint,
pricepaid decimal(8,2),
commission decimal(8,2),
saletime timestamp)
partitioned by (saledate char(10))
row format delimited
fields terminated by '|'
stored as textfile
location 's3://redshift-downloads/tickit/spectrum/sales_partition/'
table properties ('numRows'='172000');
```
Exécutez la commande ALTER TABLE suivante pour ajouter les partitions.
```
alter table spectrum.sales_part add
partition(saledate='2008-01')
location 's3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-01/'
partition(saledate='2008-03')
location 's3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-03/'
partition(saledate='2008-04')
location 's3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-04/';
```
Pour sélectionner les données de la table partitionnée, exécutez la requête suivante.
```
select top 5 spectrum.sales_part.eventid, sum(spectrum.sales_part.pricepaid)
from spectrum.sales_part, event
where spectrum.sales_part.eventid = event.eventid
and spectrum.sales_part.pricepaid > 30
and saledate = '2008-01'
group by spectrum.sales_part.eventid
order by 2 desc;
```
```
eventid | sum
--------+---------
4124 | 21179.00
1924 | 20569.00
2294 | 18830.00
2260 | 17669.00
6032 | 17265.00
```
Pour afficher les partitions de la table externe, interrogez la vue système [SVV\$1EXTERNAL\$1PARTITIONS](r_SVV_EXTERNAL_PARTITIONS.md).
```
select schemaname, tablename, values, location from svv_external_partitions
where tablename = 'sales_part';
```
```
schemaname | tablename | values | location
-----------+------------+-------------+-------------------------------------------------------------------------
spectrum | sales_part | ["2008-01"] | s3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-01
spectrum | sales_part | ["2008-03"] | s3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-03
spectrum | sales_part | ["2008-04"] | s3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-04
```
#### Exemple 2 : Partitionnement avec plusieurs clés de partition
Pour créer une table externe partitionnée par `date` et `eventid`, exécutez la commande suivante.
```
create external table spectrum.sales_event(
salesid integer,
listid integer,
sellerid integer,
buyerid integer,
eventid integer,
dateid smallint,
qtysold smallint,
pricepaid decimal(8,2),
commission decimal(8,2),
saletime timestamp)
partitioned by (salesmonth char(10), event integer)
row format delimited
fields terminated by '|'
stored as textfile
location 's3://redshift-downloads/tickit/spectrum/salesevent/'
table properties ('numRows'='172000');
```
Exécutez la commande ALTER TABLE suivante pour ajouter les partitions.
```
alter table spectrum.sales_event add
partition(salesmonth='2008-01', event='101')
location 's3://redshift-downloads/tickit/spectrum/salesevent/salesmonth=2008-01/event=101/'
partition(salesmonth='2008-01', event='102')
location 's3://redshift-downloads/tickit/spectrum/salesevent/salesmonth=2008-01/event=102/'
partition(salesmonth='2008-01', event='103')
location 's3://redshift-downloads/tickit/spectrum/salesevent/salesmonth=2008-01/event=103/'
partition(salesmonth='2008-02', event='101')
location 's3://redshift-downloads/tickit/spectrum/salesevent/salesmonth=2008-02/event=101/'
partition(salesmonth='2008-02', event='102')
location 's3://redshift-downloads/tickit/spectrum/salesevent/salesmonth=2008-02/event=102/'
partition(salesmonth='2008-02', event='103')
location 's3://redshift-downloads/tickit/spectrum/salesevent/salesmonth=2008-02/event=103/'
partition(salesmonth='2008-03', event='101')
location 's3://redshift-downloads/tickit/spectrum/salesevent/salesmonth=2008-03/event=101/'
partition(salesmonth='2008-03', event='102')
location 's3://redshift-downloads/tickit/spectrum/salesevent/salesmonth=2008-03/event=102/'
partition(salesmonth='2008-03', event='103')
location 's3://redshift-downloads/tickit/spectrum/salesevent/salesmonth=2008-03/event=103/';
```
Exécutez la requête suivante pour sélectionner les données de la table partitionnée.
```
select spectrum.sales_event.salesmonth, event.eventname, sum(spectrum.sales_event.pricepaid)
from spectrum.sales_event, event
where spectrum.sales_event.eventid = event.eventid
and salesmonth = '2008-02'
and (event = '101'
or event = '102'
or event = '103')
group by event.eventname, spectrum.sales_event.salesmonth
order by 3 desc;
```
```
salesmonth | eventname | sum
-----------+-----------------+--------
2008-02 | The Magic Flute | 5062.00
2008-02 | La Sonnambula | 3498.00
2008-02 | Die Walkure | 534.00
```
## Mappage de colonnes de table externe à des colonnes ORC
Vous utilisez les tables externes Amazon Redshift Spectrum pour interroger les données des fichiers au format ORC. Le format Optimized Row Columnar (ORC) est un format de fichier de stockage en colonnes qui prend en charge les structures de données imbriquées. Pour plus d’informations sur l’interrogation de données imbriquées, consultez [Interrogation de données imbriquées avec Amazon Redshift Spectrum](tutorial-query-nested-data.md#tutorial-nested-data-overview).
Lorsque vous créez une table externe qui fait référence à des données dans un fichier ORC, vous mappez chaque colonne de la table externe à une colonne dans les données ORC. Pour ce faire, vous utilisez l’une des méthodes suivantes :
+ [Mappage par position](#orc-mapping-by-position)
+ [Mappage par nom de colonne](#orc-mapping-by-name)
Le mappage par nom de colonne est l’option par défaut.
### Mappage par position
Avec le mappage par position, la première colonne définie dans la table externe est mappée à la première colonne du fichier de données ORC, la deuxième colonne à la deuxième colonne, et ainsi de suite. Pour le mappage par position, l’ordre des colonnes dans la table externe et dans le fichier ORC doivent correspondre. Si l’ordre des colonnes ne correspond pas, vous pouvez mapper les colonnes par nom.
**Important**
Dans des versions précédentes, Redshift Spectrum utilisait le mappage par position par défaut. Si vous avez besoin de continuer à utiliser le mappage par position pour des tables existantes, définissez la propriété de table `orc.schema.resolution` sur `position`, comme illustré dans l’exemple suivant.
```
alter table spectrum.orc_example
set table properties('orc.schema.resolution'='position');
```
Par exemple, la table `SPECTRUM.ORC_EXAMPLE` est définie comme suit.
```
create external table spectrum.orc_example(
int_col int,
float_col float,
nested_col struct<
"int_col" : int,
"map_col" : map>
>
) stored as orc
location 's3://example/orc/files/';
```
La structure de table peut être extraite comme suit.
```
• 'int_col' : int
• 'float_col' : float
• 'nested_col' : struct
o 'int_col' : int
o 'map_col' : map
- key : int
- value : array
- value : float
```
Le fichier ORC sous-jacent a la structure de fichier suivante.
```
• ORC file root(id = 0)
o 'int_col' : int (id = 1)
o 'float_col' : float (id = 2)
o 'nested_col' : struct (id = 3)
- 'int_col' : int (id = 4)
- 'map_col' : map (id = 5)
- key : int (id = 6)
- value : array (id = 7)
- value : float (id = 8)
```
Dans cet exemple, vous pouvez mapper chaque colonne de la table externe à une colonne du fichier ORC strictement par position. Voici une illustration du mappage.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/c-spectrum-external-tables.html)
### Mappage par nom de colonne
À l’aide du mappage par nom, vous mappez des colonnes d’une table externe à des colonnes nommées de fichiers ORC sur le même niveau avec le même nom.
Par exemple, supposons que vous souhaitez mapper la table de l’exemple précédent, `SPECTRUM.ORC_EXAMPLE`, avec un fichier ORC qui utilise la structure de fichier suivante.
```
• ORC file root(id = 0)
o 'nested_col' : struct (id = 1)
- 'map_col' : map (id = 2)
- key : int (id = 3)
- value : array (id = 4)
- value : float (id = 5)
- 'int_col' : int (id = 6)
o 'int_col' : int (id = 7)
o 'float_col' : float (id = 8)
```
À l’aide du mappage par position, Redshift Spectrum tente le mappage suivant.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/c-spectrum-external-tables.html)
Lorsque vous interrogez une table avec le mappage par position précédent, la commande SELECT échoue pour la validation du type parce que les structures sont différentes.
Vous pouvez mapper la même table externe aux deux structures de fichier illustrés dans les exemples précédents à l’aide du mappage par nom de colonne. Les colonnes de table `int_col`, `float_col` et `nested_col` sont mappées par nom de colonne aux colonnes avec les mêmes noms dans le fichier ORC. La colonne de table nommée `nested_col`dans la table externe est une colonne `struct` avec des sous-colonnes nommées `map_col` et `int_col`. Les sous-colonnes sont mappées correctement aux colonnes correspondantes dans le fichier ORC par nom de colonne.
## Créer des tables externes pour les données gérées dans Apache Hudi
Pour interroger des données au format Apache Hudi Copy On Write (CoW), vous pouvez utiliser les tables externes Amazon Redshift Spectrum. Une table Hudi Copy On Write est une collection de fichiers Apache Parquet stockés dans Amazon S3. Vous pouvez lire les tables Copy On Write (Copie sur écriture, CoW) qui sont créées et modifiées avec les opérations d’écriture insert, delete et upsert dans Apache Hudi versions 0.5.2, 0.6.0, 0.7.0, 0.8.0, 0.9.0, 0.10.0, 0.10.1, 0.11.0 et 0.11.1. Par exemple, les tables d’amorçage ne sont pas prises en charge. Pour de plus amples informations, consultez [Table Copy On Write](https://hudi.apache.org/docs/next/table_types#copy-on-write-table) dans la documentation open source Apache Hudi.
Lorsque vous créez une table externe qui fait référence à des données au format CoW Hudi, vous mappez chaque colonne de la table externe à une colonne des données Hudi. Le mappage se fait par colonne.
Les instructions DDL (Data Definition Language) pour les tables Hudi partitionnées et non partitionnées sont similaires à celles des autres formats de fichier Apache Parquet. Pour les tables Hudi, vous définissez `INPUTFORMAT` sur `org.apache.hudi.hadoop.HoodieParquetInputFormat`. Le paramètre `LOCATION` doit être tourné vers le dossier de base de la table Hudi qui contient le dossier `.hoodie`, qui est nécessaire pour établir la chronologie de validation Hudi. Dans certains cas, une opération SELECT sur une table Hudi peut échouer avec le message No valid Hudi commit timeline found (Aucune chronologie de validation Hudi valide n’a été trouvée). Si c’est le cas, vérifiez si le dossier `.hoodie` est à l’emplacement correct et contient une chronologie de validation Hudi valide.
**Note**
Le format Apache Hudi n’est pris en charge que lorsque vous utilisez un AWS Glue Data Catalog. Il n’est pas pris en charge lorsque vous utilisez un métastore Apache Hive comme catalogue externe.
Le format DDL pour définir une table non partitionnée est au format suivant.
```
CREATE EXTERNAL TABLE tbl_name (columns)
ROW FORMAT SERDE 'org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe'
STORED AS
INPUTFORMAT 'org.apache.hudi.hadoop.HoodieParquetInputFormat'
OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.parquet.MapredParquetOutputFormat'
LOCATION 's3://s3-bucket/prefix'
```
Le DDL pour définir une table partitionnée est au format suivant.
```
CREATE EXTERNAL TABLE tbl_name (columns)
PARTITIONED BY(pcolumn1 pcolumn1-type[,...])
ROW FORMAT SERDE 'org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe'
STORED AS
INPUTFORMAT 'org.apache.hudi.hadoop.HoodieParquetInputFormat'
OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.parquet.MapredParquetOutputFormat'
LOCATION 's3://s3-bucket/prefix'
```
Pour ajouter des partitions à une table Hudi partitionnée, exécutez une commande ALTER TABLE ADD PARTITION dans laquelle le paramètre `LOCATION` est tourné vers le sous-dossier Amazon S3 avec les fichiers qui appartiennent à la partition.
Le DDL pour ajouter des partitions est au format suivant.
```
ALTER TABLE tbl_name
ADD IF NOT EXISTS PARTITION(pcolumn1=pvalue1[,...])
LOCATION 's3://s3-bucket/prefix/partition-path'
```
## Créer des tables externes pour les données gérées dans Delta Lake
Pour interroger des données dans des tables Delta Lake, vous pouvez utiliser des tables externes Amazon Redshift Spectrum.
Pour accéder à une table Delta Lake à partir de Redshift Spectrum, générez un manifeste avant la requête. Un *manifeste* Delta Lake contient une liste des fichiers qui constituent un instantané cohérent de la table Delta Lake. Dans une table partitionnée, il y a un manifeste par partition. Une table Delta Lake est une collection de fichiers Apache Parquet stockés dans Amazon S3. Pour plus d’informations, consultez [Delta Lake](https://delta.io) dans la documentation open source de Delta Lake.
Lorsque vous créez une table externe qui fait référence aux données des tables Delta Lake, vous mappez chaque colonne de la table externe à une colonne de la table Delta Lake. Le mappage se fait par nom de colonne.
La DDL pour les tables Delta Lake partitionnées et non partitionnées est similaire à celle des autres formats de fichiers Apache Parquet. Pour les tables Delta Lake, vous définissez `INPUTFORMAT` sur `org.apache.hadoop.hive.ql.io.SymlinkTextInputFormat` et `OUTPUTFORMAT` sur `org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat`. Le paramètre `LOCATION` doit être tourné vers le dossier manifeste dans le dossier de base de la table. Si une opération SELECT sur une table Delta Lake échoue, pour des raisons possibles, consultez [Limites et dépannage pour les tables Delta Lake](#c-spectrum-column-mapping-delta-limitations).
Le format DDL pour définir une table non partitionnée est au format suivant.
```
CREATE EXTERNAL TABLE tbl_name (columns)
ROW FORMAT SERDE 'org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe'
STORED AS
INPUTFORMAT 'org.apache.hadoop.hive.ql.io.SymlinkTextInputFormat'
OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'
LOCATION 's3://s3-bucket/prefix/_symlink_format_manifest'
```
Le DDL pour définir une table partitionnée est au format suivant.
```
CREATE EXTERNAL TABLE tbl_name (columns)
PARTITIONED BY(pcolumn1 pcolumn1-type[,...])
ROW FORMAT SERDE 'org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe'
STORED AS
INPUTFORMAT 'org.apache.hadoop.hive.ql.io.SymlinkTextInputFormat'
OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'
LOCATION 's3://s3-bucket>/prefix/_symlink_format_manifest'
```
Pour ajouter des partitions à une table Delta Lake partitionnée, exécutez une commande ALTER TABLE ADD PARTITION dans laquelle le paramètre `LOCATION` est tourné vers le sous-dossier Amazon S3 qui contient le manifeste de la partition.
Le DDL pour ajouter des partitions est au format suivant.
```
ALTER TABLE tbl_name
ADD IF NOT EXISTS PARTITION(pcolumn1=pvalue1[,...])
LOCATION
's3://s3-bucket/prefix/_symlink_format_manifest/partition-path'
```
Sinon, exécutez DDL qui est tourné directement vers le fichier manifeste Delta Lake.
```
ALTER TABLE tbl_name
ADD IF NOT EXISTS PARTITION(pcolumn1=pvalue1[,...])
LOCATION
's3://s3-bucket/prefix/_symlink_format_manifest/partition-path/manifest'
```
### Limites et dépannage pour les tables Delta Lake
Tenez compte des éléments suivants lorsque vous interrogez des tables Delta Lake à partir de Redshift Spectrum :
+ Si un manifeste est tourné vers un instantané ou une partition qui n’existe plus, les requêtes échouent jusqu’à ce qu’un nouveau manifeste valide ait été généré. Par exemple, cela peut résulter d’une opération VACUUM sur la table sous-jacente,
+ Les manifestes Delta Lake fournissent uniquement une cohérence au niveau des partitions.
Le tableau suivant explique les raisons potentielles de certaines erreurs lorsque vous interrogez une table Delta Lake.
| Error message (Message d’erreur) | Raison possible |
| --- | --- |
| Le manifeste Delta Lake dans le compartiment *s3-bucket-1* ne peut pas contenir d’entrées dans le compartiment *s3-bucket-2*. | Les entrées de manifeste sont tournées vers des fichiers dans un compartiment Amazon S3 différent de celui spécifié. |
| Les fichiers Delta Lake doivent se trouver dans le même dossier. | Les entrées de manifeste sont tournées vers des fichiers qui ont un préfixe Amazon S3 différent de celui spécifié. |
| Le fichier *filename* figurant dans le manifeste Delta Lake *manifest-path* n’a pas été trouvé. | Un fichier répertorié dans le manifeste n’a pas été trouvé dans Amazon S3. |
| Erreur lors de la récupération du manifeste Delta Lake. | Le manifeste n’a pas été trouvé dans Amazon S3. |
| Chemin d’accès S3 non valide. | Une entrée dans le fichier manifeste n’est pas un chemin d’accès Amazon S3 valide ou le fichier manifeste a été corrompu. |