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.
# COPY
| |
| --- |
| Le chiffrement côté client pour les commandes COPY et UNLOAD ne sera plus ouvert aux nouveaux clients à compter du 30 avril 2025. Si vous avez utilisé le chiffrement côté client avec les commandes COPY et UNLOAD au cours des 12 mois précédant le 30 avril 2025, vous pouvez continuer à utiliser le chiffrement côté client avec les commandes COPY ou UNLOAD jusqu’au 30 avril 2026. Après le 30 avril 2026, vous ne pourrez plus utiliser le chiffrement côté client pour COPY et UNLOAD. Nous vous recommandons de passer au chiffrement côté serveur pour COPY et UNLOAD dès que possible. Si vous utilisez déjà le chiffrement côté serveur pour COPY et UNLOAD, il n’y a aucun changement et vous pouvez continuer à l’utiliser sans modifier vos requêtes. Pour plus d’informations sur le chiffrement pour COPY et UNLOAD, consultez le paramètre ENCRYPTED ci-dessous. |
Charge des données dans une table depuis des fichiers de données ou une table Amazon DynamoDB. Les fichiers peuvent être situés dans un compartiment Amazon Simple Storage Service (Amazon S3), un cluster Amazon EMR ou un hôte distant auquel on accède à l’aide d’une connexion SSH (Secure Shell).
**Note**
Les tables externes d’Amazon Redshift Spectrum sont en lecture seule. Vous ne pouvez pas copier (COPY) une table externe.
La commande COPY ajoute les données d’entrée à la table sous forme de lignes supplémentaires.
La taille maximale d’une seule ligne d’entrée à partir de n’importe quelle source est de 4 Mo.
**Topics**
+ [
## Autorisations requises
](#r_COPY-permissions)
+ [
## Syntaxe de la commande COPY
](#r_COPY-syntax)
+ [
## Paramètres requis
](#r_COPY-syntax-required-parameters)
+ [
## Paramètres facultatifs
](#r_COPY-syntax-overview-optional-parameters)
+ [
## Notes d’utilisation et ressources supplémentaires pour la commande COPY
](#r_COPY-using-the-copy-command)
+ [
## Exemples de commandes COPY
](#r_COPY-using-the-copy-command-examples)
+ [
# COPY JOB
](r_COPY-JOB.md)
+ [
# COPIER avec TEMPLATE
](r_COPY-WITH-TEMPLATE.md)
+ [
# Description des paramètres de la commande COPY
](r_COPY-parameters.md)
+ [
# Notes d’utilisation
](r_COPY_usage_notes.md)
+ [
# Exemples de commandes COPY
](r_COPY_command_examples.md)
## Autorisations requises
Pour utiliser la commande COPY, vous devez avoir le privilège [INSERT](r_GRANT.md#grant-insert) pour la table Amazon Redshift.
## Syntaxe de la commande COPY
```
COPY table-name
[ column-list ]
FROM data_source
authorization
[ [ FORMAT ] [ AS ] data_format ]
[ parameter [ argument ] [, ... ] ]
```
Vous pouvez effectuer une opération COPY avec aussi peu que trois paramètres : un nom de table, une source de données et l’autorisation d’accéder aux données.
Amazon Redshift étend la fonctionnalité de la commande COPY pour vous permettre de charger les données dans plusieurs formats de données à partir de plusieurs sources de données, de contrôler l’accès pour charger les données, de gérer les transformations des données et de gérer l’opération de chargement.
Les sections suivantes présentent les paramètres de la commande COPY requis et regroupent les paramètres facultatifs par fonction. Elles décrivent également chaque paramètre et expliquent comment différentes options fonctionnent ensemble. Vous pouvez accéder directement à une description du paramètre à l’aide de la liste alphabétique des paramètres.
## Paramètres requis
La commande COPY nécessite trois éléments :
+ [Table Name](#r_COPY-syntax-overview-table-name)
+ [Data Source](#r_COPY-syntax-overview-data-source)
+ [Authorization](#r_COPY-syntax-overview-credentials)
La commande COPY la plus simple utilise le format suivant.
```
COPY table-name
FROM data-source
authorization;
```
L’exemple suivant crée une table nommée CATDEMO et puis charge la table avec des exemples de données à partir d’un fichier de données dans Amazon S3 nommé `category_pipe.txt`.
```
create table catdemo(catid smallint, catgroup varchar(10), catname varchar(10), catdesc varchar(50));
```
Dans l’exemple suivant, la source de données de la commande COPY est un fichier de données nommé `category_pipe.txt` dans le dossier `tickit` d’un compartiment Amazon S3 nommé `redshift-downloads`. La commande COPY est autorisée à accéder au compartiment Amazon S3 via un rôle Gestion des identités et des accès AWS (IAM). Si votre cluster comporte un rôle IAM existant avec la permission d’accès à Amazon S3 attaché, vous pouvez remplacer le nom Amazon Resource Name (ARN) de votre rôle dans la commande COPY suivante et l’exécuter.
```
copy catdemo
from 's3://redshift-downloads/tickit/category_pipe.txt'
iam_role 'arn:aws:iam:::role/'
region 'us-east-1';
```
Pour obtenir des instructions complètes sur l'utilisation des commandes COPY pour charger des échantillons de données, y compris des instructions pour charger des données provenant d'autres AWS régions, consultez la section [Charger des échantillons de données depuis Amazon S3](https://docs.aws.amazon.com/redshift/latest/gsg/rs-gsg-create-sample-db.html) dans le guide de démarrage Amazon Redshift.
*table-name*
Nom de la table cible de la commande COPY. La table doit déjà exister dans la base de données. La table peut être temporaire ou permanente. La commande COPY ajoute les nouvelles données d’entrée à toutes les lignes existantes de la table.
FROM *data-source*
Emplacement des données source à charger dans la table cible. Un fichier manifeste peut être spécifié avec des sources de données.
Le référentiel de données le plus couramment utilisé est un compartiment Amazon S3. Vous pouvez également charger des fichiers de données situés dans un cluster Amazon EMR, une instance Amazon EC2 ou un hôte distant auquel votre cluster peut accéder à l’aide d’une connexion SSH, ou vous pouvez charger directement depuis une table DynamoDB.
+ [Commande COPY depuis Amazon S3](copy-parameters-data-source-s3.md)
+ [Commande COPY depuis Amazon EMR](copy-parameters-data-source-emr.md)
+ [Exécution de la commande COPY à partir de l’hôte distant (SSH)](copy-parameters-data-source-ssh.md)
+ [Commande COPY depuis Amazon DynamoDB](copy-parameters-data-source-dynamodb.md)
Autorisation
Clause qui indique la méthode utilisée par votre cluster pour l'authentification et l'autorisation d'accéder à d'autres AWS ressources. La commande COPY nécessite une autorisation pour accéder aux données d'une autre AWS ressource, notamment Amazon S3, Amazon EMR, Amazon DynamoDB et Amazon EC2. Vous pouvez fournir cette autorisation en faisant référence à un rôle IAM qui est attaché à votre cluster ou en fournissant l’ID de clé d’accès et la clé d’accès secrète pour un utilisateur IAM.
+ [Paramètres d’autorisation](copy-parameters-authorization.md)
+ [Contrôle d’accès basé sur les rôles](copy-usage_notes-access-permissions.md#copy-usage_notes-access-role-based)
+ [Contrôle d’accès basé sur les clés](copy-usage_notes-access-permissions.md#copy-usage_notes-access-key-based)
## Paramètres facultatifs
Le cas échéant, vous pouvez spécifier comment la commande COPY mappe les données de champ aux colonnes dans la table cible, définir les attributs de données source pour activer la commande COPY afin de lire et d’analyser correctement les données source et gérer les opérations que la commande COPY effectue pendant le processus de chargement.
+ [Options de mappage de colonnes](copy-parameters-column-mapping.md)
+ [Paramètres du format de données](#r_COPY-syntax-overview-data-format)
+ [Paramètres de conversion de données](#r_COPY-syntax-overview-data-conversion)
+ [Opérations de chargement de données](#r_COPY-syntax-overview-data-load)
### Mappage de colonnes
Par défaut, la commande COPY insère des valeurs de champ dans les colonnes de la table cible dans le même ordre que les champs se présentent dans les fichiers de données. Si l'ordre des colonnes par défaut ne fonctionne pas, vous pouvez spécifier une liste de colonnes ou utiliser des JSONPath expressions pour mapper les champs de données source aux colonnes cibles.
+ [Column List](copy-parameters-column-mapping.md#copy-column-list)
+ [JSONPaths File](copy-parameters-column-mapping.md#copy-column-mapping-jsonpaths)
### Paramètres du format de données
Vous pouvez charger les données à partir de fichiers texte au format JSON, dans des fichiers de valeurs séparées par des virgules, par des caractères, à largeur fixe (CSV), ou à partir de fichiers Avro.
Par défaut, la commande COPY attend que les données source se trouvent dans des fichiers texte UTF-8 séparés par des caractères. Le délimiteur par défaut est une barre verticale ( \$1 ). Si les données source sont dans un autre format, utilisez les paramètres suivants pour spécifier le format des données.
+ [FORMAT](copy-parameters-data-format.md#copy-format)
+ [CSV](copy-parameters-data-format.md#copy-csv)
+ [DELIMITER](copy-parameters-data-format.md#copy-delimiter)
+ [FIXEDWIDTH](copy-parameters-data-format.md#copy-fixedwidth)
+ [SHAPEFILE](copy-parameters-data-format.md#copy-shapefile)
+ [AVRO](copy-parameters-data-format.md#copy-avro)
+ [JSON format for COPY](copy-parameters-data-format.md#copy-json)
+ [ENCRYPTED](copy-parameters-data-source-s3.md#copy-encrypted)
+ [BZIP2](copy-parameters-file-compression.md#copy-bzip2)
+ [GZIP](copy-parameters-file-compression.md#copy-gzip)
+ [LZOP](copy-parameters-file-compression.md#copy-lzop)
+ [PARQUET](copy-parameters-data-format.md#copy-parquet)
+ [ORC](copy-parameters-data-format.md#copy-orc)
+ [ZSTD](copy-parameters-file-compression.md#copy-zstd)
### Paramètres de conversion de données
Lorsqu’elle charge la table, la commande COPY tente implicitement de convertir les chaînes dans les données source vers le type de données de la colonne cible. Si vous devez spécifier une conversion qui est différente du comportement par défaut, ou si la conversion par défaut entraîne des erreurs, vous pouvez gérer les conversions de données en spécifiant les paramètres suivants.
+ [ACCEPTANYDATE](copy-parameters-data-conversion.md#copy-acceptanydate)
+ [ACCEPTINVCHARS](copy-parameters-data-conversion.md#copy-acceptinvchars)
+ [BLANKSASNULL](copy-parameters-data-conversion.md#copy-blanksasnull)
+ [DATEFORMAT](copy-parameters-data-conversion.md#copy-dateformat)
+ [EMPTYASNULL](copy-parameters-data-conversion.md#copy-emptyasnull)
+ [ENCODING](copy-parameters-data-conversion.md#copy-encoding)
+ [ESCAPE](copy-parameters-data-conversion.md#copy-escape)
+ [EXPLICIT_IDS](copy-parameters-data-conversion.md#copy-explicit-ids)
+ [FILLRECORD](copy-parameters-data-conversion.md#copy-fillrecord)
+ [IGNOREBLANKLINES](copy-parameters-data-conversion.md#copy-ignoreblanklines)
+ [IGNOREHEADER](copy-parameters-data-conversion.md#copy-ignoreheader)
+ [NULL AS](copy-parameters-data-conversion.md#copy-null-as)
+ [REMOVEQUOTES](copy-parameters-data-conversion.md#copy-removequotes)
+ [ROUNDEC](copy-parameters-data-conversion.md#copy-roundec)
+ [TIMEFORMAT](copy-parameters-data-conversion.md#copy-timeformat)
+ [TRIMBLANKS](copy-parameters-data-conversion.md#copy-trimblanks)
+ [TRUNCATECOLUMNS](copy-parameters-data-conversion.md#copy-truncatecolumns)
### Opérations de chargement de données
Gérez le comportement par défaut de l’opération de chargement pour le dépannage ou pour réduire les temps de chargement en spécifiant les paramètres suivants.
+ [COMPROWS](copy-parameters-data-load.md#copy-comprows)
+ [COMPUPDATE](copy-parameters-data-load.md#copy-compupdate)
+ [IGNOREALLERRORS](copy-parameters-data-load.md#copy-ignoreallerrors)
+ [MAXERROR](copy-parameters-data-load.md#copy-maxerror)
+ [NOLOAD](copy-parameters-data-load.md#copy-noload)
+ [STATUPDATE](copy-parameters-data-load.md#copy-statupdate)
## Notes d’utilisation et ressources supplémentaires pour la commande COPY
Pour plus d’informations sur la façon d’utiliser la commande COPY, consultez les rubriques suivantes :
+ [Notes d’utilisation](r_COPY_usage_notes.md)
+ [Didacticiel : chargement des données à partir d’Amazon S3](tutorial-loading-data.md)
+ [Bonnes pratiques de chargement des données sur Amazon Redshift](c_loading-data-best-practices.md)
+ [Chargement de tables à l’aide de la commande COPY](t_Loading_tables_with_the_COPY_command.md)
+ [Chargement des données à partir d’Amazon S3](t_Loading-data-from-S3.md)
+ [Chargement de données à partir d’Amazon EMR](loading-data-from-emr.md)
+ [Chargement des données à partir des hôtes distants](loading-data-from-remote-hosts.md)
+ [Chargement de données à partir d’une table Amazon DynamoDB](t_Loading-data-from-dynamodb.md)
+ [Résolution des problèmes de chargement de données](t_Troubleshooting_load_errors.md)
## Exemples de commandes COPY
Pour d’autres exemples montrant comment utiliser COPY à partir de différentes sources, dans des formats disparates et avec différentes options de copie, consultez [Exemples de commandes COPY](r_COPY_command_examples.md).
# COPY JOB
Pour plus d’informations sur l’utilisation de cette commande, consultez [Créer une intégration d’événements S3 pour copier automatiquement des fichiers à partir de compartiments Amazon S3](loading-data-copy-job.md).
Gère les commandes COPY qui chargent les données dans une table. La commande COPY JOB est une extension de la commande COPY et automatise le chargement des données à partir des compartiments Amazon S3. Lorsque vous créez une tâche COPY, Amazon Redshift détecte quand de nouveaux fichiers Amazon S3 sont créés dans un chemin spécifié, puis les charge automatiquement sans votre intervention. Les mêmes paramètres que ceux utilisés dans la commande COPY d’origine sont utilisés lors du chargement des données. Amazon Redshift assure le suivi des fichiers chargés (en fonction du nom des fichiers) afin de vérifier qu’ils ne sont chargés qu’une seule fois.
**Note**
Pour plus d’informations sur la commande COPY, notamment sur l’utilisation, les paramètres et les autorisations, consultez [COPY](r_COPY.md).
## Autorisation obligatoire
Pour utiliser la commande COPY JOB, vous devez disposer de l’une des autorisations suivantes en plus de toutes les autorisations requises pour utiliser COPY :
+ Superuser
+ Tous les éléments suivants :
+ L’autorisation étendue CREATE, ALTER ou DROP appropriée pour utiliser COPY JOBS dans la base de données vers laquelle vous souhaitez copier.
+ Autorisation USAGE pour le schéma vers lequel vous souhaitez utiliser COPY, ou autorisation étendue USAGE pour les schémas de la base de données vers laquelle vous souhaitez utiliser COPY.
+ Autorisation INSERT pour la table vers laquelle vous souhaitez utiliser COPY, ou autorisation étendue INSERT pour les tables du schéma ou de la base de données vers lesquels vous souhaitez utiliser COPY.
Le rôle IAM spécifié avec la commande COPY doit être autorisé à accéder aux données à charger. Pour plus d’informations, consultez [Autorisations IAM pour les commandes COPY, UNLOAD et CREATE LIBRARY](copy-usage_notes-access-permissions.md#copy-usage_notes-iam-permissions).
## Syntaxe
Créez une tâche de copie. Les paramètres de la commande COPY sont enregistrés avec la tâche de copie.
Vous ne pouvez pas exécuter COPY JOB CREATE dans le cadre d’un bloc de transactions.
```
COPY copy-command JOB CREATE job-name
[AUTO ON | OFF]
```
Modifiez la configuration d’une tâche de copie.
```
COPY JOB ALTER job-name
[AUTO ON | OFF]
```
Exécutez une tâche de copie. Les paramètres de la commande COPY stockés sont utilisés.
```
COPY JOB RUN job-name
```
Répertoriez toutes les tâches de copie.
```
COPY JOB LIST
```
Afficher les détails d’une tâche de copie.
```
COPY JOB SHOW job-name
```
Supprimez une tâche de copie.
Vous ne pouvez pas exécuter COPY JOB DROP dans le cadre d’un bloc de transactions.
```
COPY JOB DROP job-name
```
## Parameters
*copy-command*
Une commande COPY qui charge les données d’Amazon S3 vers Amazon Redshift. La clause contient des paramètres COPY qui définissent le compartiment Amazon S3, la table cible, le rôle IAM et d’autres paramètres utilisés lors du chargement des données. Tous les paramètres de commande COPY pour un chargement de données Amazon S3 sont pris en charge, à l’exception des suivants :
+ La tâche COPY JOB n’ingère pas les fichiers préexistants dans le dossier pointé par la commande COPY. Seuls les fichiers créés après l’horodatage de création de COPY JOB sont ingérés.
+ Vous ne pouvez pas spécifier de commande COPY avec les options MAXERROR ou IGNOREALLERRORS.
+ Vous ne pouvez pas spécifier un fichier manifeste. COPY JOB nécessite un emplacement Amazon S3 désigné pour surveiller les fichiers nouvellement créés.
+ Vous ne pouvez pas spécifier de commande COPY avec des types d’autorisation tels que des clés d’accès et des clés secrètes. Seules les commandes COPY qui utilisent le paramètre `IAM_ROLE` pour l’autorisation sont prises en charge. Pour plus d’informations, consultez [Paramètres d’autorisation](copy-parameters-authorization.md).
+ COPY JOB ne prend pas en charge le rôle IAM par défaut associé au cluster. Vous devez spécifier le `IAM_ROLE` dans la commande COPY.
Pour plus d’informations, consultez [Commande COPY depuis Amazon S3](copy-parameters-data-source-s3.md).
*job-name*
Nom de la tâche utilisé pour référencer la tâche COPY. Le *nom de la tâche* ne peut pas contenir de tiret (‐).
[AUTO ON \$1 OFF]
Clause indiquant si les données Amazon S3 sont automatiquement chargées dans les tables Amazon Redshift.
+ Sur `ON`, Amazon Redshift surveille le chemin Amazon S3 source pour les fichiers nouvellement créés et, s’il en trouve, une commande COPY est exécutée avec les paramètres COPY dans la définition de la tâche. Il s’agit de l’option par défaut.
+ Sur `OFF`, Amazon Redshift n’exécute pas automatiquement COPY JOB.
## Notes d’utilisation
Les options de la commande COPY ne sont validées qu’au moment de l’exécution. Par exemple, un `IAM_ROLE` ou une source de données Amazon S3 non valide entraîne des erreurs d’exécution lorsque COPY JOB démarre.
Si le cluster est suspendu, COPY JOBS ne sont pas exécutées.
Pour interroger les fichiers de commandes COPY chargés et les erreurs de chargement, consultez [STL\$1LOAD\$1COMMITS](r_STL_LOAD_COMMITS.md), [STL\$1LOAD\$1ERRORS](r_STL_LOAD_ERRORS.md) et [STL\$1LOADERROR\$1DETAIL](r_STL_LOADERROR_DETAIL.md). Pour de plus amples informations, veuillez consulter [Vérification que les données ont été chargées correctement](verifying-that-data-loaded-correctly.md).
Les tâches de copie ne sont pas prises en charge sur les bases de données Zero-ETL car elles fonctionnent en mode lecture seule.
## Exemples
L’exemple suivant montre comment créer COPY JOB pour charger les données d’un compartiment Amazon S3.
```
COPY public.target_table
FROM 's3://amzn-s3-demo-bucket/staging-folder'
IAM_ROLE 'arn:aws:iam::123456789012:role/MyLoadRoleName'
JOB CREATE my_copy_job_name
AUTO ON;
```
# COPIER avec TEMPLATE
Vous pouvez utiliser les modèles Redshift avec les commandes COPY pour simplifier la syntaxe des commandes et garantir la cohérence des opérations de chargement de données. Au lieu de spécifier les mêmes paramètres de mise en forme à plusieurs reprises, vous les définissez une fois dans un modèle et vous référencez le modèle dans vos commandes COPY. Lorsque vous utilisez un modèle, la commande COPY combine les paramètres du modèle avec tous les paramètres spécifiés directement dans la commande. Si le même paramètre apparaît à la fois dans le modèle et dans la commande, le paramètre de commande est prioritaire. Pour de plus amples informations, veuillez consulter [CRÉER UN MODÈLE](r_CREATE_TEMPLATE.md).
Les modèles pour la commande COPY peuvent être créés avec :
+ [Paramètres du format de données](copy-parameters-data-format.md)
+ [Paramètres de compression de fichier](copy-parameters-file-compression.md)
+ [Paramètres de conversion de données](copy-parameters-data-conversion.md)
+ [Opérations de chargement de données](copy-parameters-data-load.md)
Pour une liste complète des paramètres pris en charge, voir [COPY](r_COPY.md) commande.
## Autorisation obligatoire
Pour utiliser un modèle dans une commande COPY, vous devez disposer des éléments suivants :
+ Toutes les autorisations requises pour exécuter la commande COPY (voir[Autorisations requises](r_COPY.md#r_COPY-permissions))
+ L'une des autorisations de modèle suivantes :
+ Privilèges de superutilisateur
+ Privilège USAGE sur le modèle et privilège USAGE sur le schéma contenant le modèle
## Syntaxe
```
COPY target_table FROM 's3://...'
authorization
[ option, ...]
USING TEMPLATE [database_name.][schema_name.]template_name;
```
## Parameters
*database\$1name*
(Facultatif) Nom de la base de données dans laquelle le modèle existe. Si elle n'est pas spécifiée, la base de données actuelle est utilisée.
*nom\$1schéma*
(Facultatif) Nom du schéma dans lequel le modèle existe. S'il n'est pas spécifié, le modèle est recherché dans le chemin de recherche actuel.
*nom\$1modèle*
Nom du modèle à utiliser dans COPY.
## Notes d’utilisation
+ Les paramètres spécifiques à la commande (source, destination, autorisation) doivent toujours être spécifiés dans la commande COPY.
+ Les modèles ne peuvent pas contenir de spécifications de fichier manifeste pour les commandes COPY.
## Exemples
Les exemples suivants montrent comment créer un modèle et l'utiliser dans les commandes COPY :
```
CREATE TEMPLATE public.test_template FOR COPY AS
CSV DELIMITER '|' IGNOREHEADER 1 MAXERROR 100;
COPY public.target_table
FROM 's3://amzn-s3-demo-bucket/staging-folder'
IAM_ROLE 'arn:aws:iam::123456789012:role/MyLoadRoleName'
USING TEMPLATE public.test_template;
```
Lorsqu'un paramètre existe à la fois dans le modèle et dans la commande, le paramètre de commande est prioritaire. Dans cet exemple, si le modèle `public.test_template` contient `DELIMITER '|'` mais que la commande COPY le spécifie`DELIMITER ','`, le séparateur de virgule (`,`) de la commande sera utilisé à la place du séparateur de canaux (`|`) du modèle.
```
COPY public.target_table
FROM 's3://amzn-s3-demo-bucket/staging-folder'
IAM_ROLE 'arn:aws:iam::123456789012:role/MyLoadRoleName'
DELIMITER ','
USING TEMPLATE public.test_template;
```
# Description des paramètres de la commande COPY
COPY possède de nombreux paramètres qui peuvent être utilisés dans de nombreuses situations. Toutefois, tous les paramètres ne sont pas pris en charge dans chaque situation. Par exemple, pour le chargement à partir de fichiers ORC ou PARQUET, le nombre de paramètres pris en charge est limité. Pour plus d’informations, consultez [COPY depuis les formats de données en colonnes](copy-usage_notes-copy-from-columnar.md).
**Topics**
+ [
# Sources de données
](copy-parameters-data-source.md)
+ [
# Paramètres d’autorisation
](copy-parameters-authorization.md)
+ [
# Options de mappage de colonnes
](copy-parameters-column-mapping.md)
+ [
# Paramètres du format de données
](copy-parameters-data-format.md)
+ [
# Paramètres de compression de fichier
](copy-parameters-file-compression.md)
+ [
# Paramètres de conversion de données
](copy-parameters-data-conversion.md)
+ [
# Opérations de chargement de données
](copy-parameters-data-load.md)
+ [
# Liste alphabétique des paramètres
](r_COPY-alphabetical-parm-list.md)
# Sources de données
Vous pouvez charger des données à partir de fichiers texte dans un compartiment Amazon S3, dans un cluster Amazon EMR, ou sur un hôte distant auquel votre cluster peut accéder à l’aide d’une connexion SSH. Vous pouvez également charger les données directement à partir d’une table DynamoDB.
La taille maximale d’une seule ligne d’entrée à partir de n’importe quelle source est de 4 Mo.
Pour exporter les données d’une table dans un ensemble de fichiers dans une instance Amazon S3, utilisez la commande [UNLOAD](r_UNLOAD.md).
**Topics**
+ [
# Commande COPY depuis Amazon S3
](copy-parameters-data-source-s3.md)
+ [
# Commande COPY depuis Amazon EMR
](copy-parameters-data-source-emr.md)
+ [
# Exécution de la commande COPY à partir de l’hôte distant (SSH)
](copy-parameters-data-source-ssh.md)
+ [
# Commande COPY depuis Amazon DynamoDB
](copy-parameters-data-source-dynamodb.md)
# Commande COPY depuis Amazon S3
Pour charger des données à partir de fichiers situés dans un ou plusieurs compartiments S3, utilisez la clause FROM pour indiquer comment la commande COPY localise les fichiers dans Amazon S3. Vous pouvez fournir le chemin d’objet aux fichiers de données dans le cadre de la clause FROM, ou vous pouvez fournir l’emplacement d’un fichier manifeste qui contient une liste de chemins d’objets Amazon S3. L’exécution de la commande COPY à partir d’Amazon S3 utilise une connexion HTTPS. Assurez-vous que les plages d’adresses IP S3 sont ajoutées à votre liste des autorisations. Pour plus d’informations sur les plages d’adresses IP S3 requises, consultez [Isolement de réseau](https://docs.aws.amazon.com//redshift/latest/mgmt/security-network-isolation.html#network-isolation).
**Important**
Si les compartiments Amazon S3 qui contiennent les fichiers de données ne résident pas dans la même AWS région que votre cluster, vous devez utiliser le [REGION](#copy-region) paramètre pour spécifier la région dans laquelle se trouvent les données.
**Topics**
+ [
## Syntaxe
](#copy-parameters-data-source-s3-syntax)
+ [
## Exemples
](#copy-parameters-data-source-s3-examples)
+ [
## Paramètres facultatifs
](#copy-parameters-data-source-s3-optional-parms)
+ [
## Paramètres non pris en charge
](#copy-parameters-data-source-s3-unsupported-parms)
## Syntaxe
```
FROM { 's3://objectpath' | 's3://manifest_file' }
authorization
| MANIFEST
| ENCRYPTED
| REGION [AS] 'aws-region'
| optional-parameters
```
## Exemples
L’exemple suivant utilise un chemin d’objet pour charger les données à partir d’Amazon S3.
```
copy customer
from 's3://amzn-s3-demo-bucket/customer'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole';
```
L’exemple suivant utilise un fichier manifeste pour charger les données à partir d’Amazon S3.
```
copy customer
from 's3://amzn-s3-demo-bucket/cust.manifest'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
manifest;
```
### Parameters
FROM
Source des données à charger. Pour plus d’informations sur l’encodage du fichier Amazon S3, consultez [Paramètres de conversion de données](copy-parameters-data-conversion.md).
’s3://*copy\$1from\$1s3\$1objectpath*’
Spécifie le chemin d’accès aux objets Amazon S3 contenant les données (par exemple `'s3://amzn-s3-demo-bucket/custdata.txt'`). Le paramètre *s3://copy\$1from\$1s3\$1objectpath* peut faire référence à un seul fichier ou à un ensemble d’objets ou de dossiers ayant le même préfixe de clé. Par exemple, le nom `custdata.txt` est un préfixe de clé qui fait référence à un certain nombre de fichiers physiques : `custdata.txt`, `custdata.txt.1`, `custdata.txt.2`, `custdata.txt.bak` et ainsi de suite. Le préfixe de clé peut également faire référence à un certain nombre de dossiers. Par exemple, `'s3://amzn-s3-demo-bucket/custfolder'` fait référence aux dossiers `custfolder`, `custfolder_1`, `custfolder_2` et ainsi de suite. Si un préfixe de clé fait référence à plusieurs dossiers, tous les fichiers dans les dossiers sont chargés. Si un préfixe de clé correspond à un fichier et à un dossier, par exemple `custfolder.log`, COPY tente de charger le fichier également. Si un préfixe de clé risque d’entraîner le chargement de fichiers indésirables par COPY, utilisez un fichier manifeste. Pour plus d’informations, consultez [copy_from_s3_manifest_file](#copy-manifest-file), ci-après.
Si le compartiment S3 qui contient les fichiers de données ne réside pas dans la même AWS région que votre cluster, vous devez utiliser le [REGION](#copy-region) paramètre pour spécifier la région dans laquelle se trouvent les données.
Pour de plus amples informations, veuillez consulter [Chargement des données à partir d’Amazon S3](t_Loading-data-from-S3.md).
’s3://*copy\$1from\$1s3\$1manifest\$1file*’
Spécifie la clé de l’objet Amazon S3 d’un fichier manifeste qui répertorie les fichiers de données à charger. L’argument *’s3://*copy\$1from\$1s3\$1manifest\$1file’** doit explicitement faire référence à un seul fichier, par exemple, `'s3://amzn-s3-demo-bucket/manifest.txt'`. Il ne peut pas faire référence à un préfixe de clé.
Le manifeste est un fichier texte au format JSON qui répertorie l’URL de chaque fichier qui doit être chargé à partir d’Amazon S3. L’URL inclut le nom du compartiment et le chemin d’objet complet du fichier. Les fichiers spécifiés dans le manifeste peuvent se trouver dans différents compartiments, mais tous les compartiments doivent se trouver dans la même AWS région que le cluster Amazon Redshift. Si un fichier est répertorié deux fois, le fichier est chargé deux fois. L’exemple suivant illustre le format JSON pour un manifeste qui charge trois fichiers.
```
{
"entries": [
{"url":"s3://amzn-s3-demo-bucket1/custdata.1","mandatory":true},
{"url":"s3://amzn-s3-demo-bucket1/custdata.2","mandatory":true},
{"url":"s3://amzn-s3-demo-bucket2/custdata.1","mandatory":false}
]
}
```
Les guillemets doubles sont nécessaires et doivent être des guillemets simples (0x22), ni culbutés, ni courbes. Chaque entrée dans le manifeste peut éventuellement inclure un indicateur `mandatory`. Si `mandatory` est défini sur `true`, la commande COPY s’arrête si elle ne trouve pas le fichier pour cette entrée ; dans le cas contraire, la commande COPY se poursuit. La valeur par défaut de `mandatory` est `false`.
Lors du chargement des fichiers de données au format ORC or Parquet, le champ `meta` est obligatoire, comme illustré dans l’exemple suivant.
```
{
"entries":[
{
"url":"s3://amzn-s3-demo-bucket1/orc/2013-10-04-custdata",
"mandatory":true,
"meta":{
"content_length":99
}
},
{
"url":"s3://amzn-s3-demo-bucket2/orc/2013-10-05-custdata",
"mandatory":true,
"meta":{
"content_length":99
}
}
]
}
```
Le fichier manifeste ne doit pas être chiffré ou compressé, même si les options ENCRYPTED, GZIP, LZOP ou ZSTD sont spécifiées. BZIP2 La commande COPY renvoie une erreur si le fichier manifeste spécifié est introuvable ou si le fichier manifeste n’est pas correctement formé.
Si un fichier manifeste est utilisé, le paramètre MANIFEST doit être spécifié avec la commande COPY. Si le paramètre MANIFEST n’est pas spécifié, la commande COPY présume que le fichier spécifié avec FROM est un fichier de données.
Pour plus d'informations, consultez [Chargement des données à partir d’Amazon S3](t_Loading-data-from-S3.md).
*authorization*
La commande COPY a besoin de l'autorisation pour accéder aux données dans une autre ressource AWS , y compris Amazon S3, Amazon EMR, Amazon DynamoDB et Amazon EC2. Vous pouvez fournir cette autorisation en référençant un rôle Gestion des identités et des accès AWS (IAM) attaché à votre cluster (contrôle d'accès basé sur les rôles) ou en fournissant les informations d'identification d'accès d'un utilisateur (contrôle d'accès basé sur des clés). Pour plus de sécurité et de flexibilité, nous recommandons d’utiliser contrôle d’accès basé sur les rôles IAM. Pour plus d'informations, consultez [Paramètres d’autorisation](copy-parameters-authorization.md).
MANIFEST
Spécifie qu’un manifeste est utilisé pour identifier les fichiers de données à charger à partir d’Amazon S3. Si le paramètre MANIFEST est utilisé, la commande COPY charge des données depuis les fichiers répertoriés dans le manifeste référencé par *’s3://copy\$1from\$1s3\$1manifest\$1file’*. Si le fichier manifeste n’est pas trouvé ou est dans un format incorrect, la commande COPY échoue. Pour plus d'informations, consultez [Utilisation d’un manifeste pour spécifier les fichiers de données](loading-data-files-using-manifest.md).
ENCRYPTED
Une clause qui spécifie que les fichiers d’entrée sur Amazon S3 sont chiffrés à l’aide du chiffrement côté client avec des clés gérées par le client. Pour plus d'informations, consultez [Chargement de fichiers de données chiffrés à partir d’Amazon S3](c_loading-encrypted-files.md). N’indiquez pas ENCRYPTED si les fichiers d’entrée sont chiffrés à l’aide du chiffrement côté serveur Amazon S3 (SSE-KMS ou SSE-S3). La commande COPY lit automatiquement les fichiers chiffrés côté serveur.
Si vous spécifiez le paramètre ENCRYPTED, vous devez également spécifier le paramètre [MASTER_SYMMETRIC_KEY](#copy-master-symmetric-key) ou inclure la valeur **master\$1symmetric\$1key** dans la chaîne [Utilisation du paramètre CREDENTIALS](copy-parameters-authorization.md#copy-credentials).
Si les fichiers chiffrés sont au format compressé, ajoutez le paramètre GZIP, LZOP ou BZIP2 ZSTD.
Les fichiers manifestes et JSONPaths les fichiers ne doivent pas être chiffrés, même si l'option ENCRYPTED est spécifiée.
MASTER\$1SYMMETRIC\$1KEY ’*root\$1key*’
La clé symétrique racine qui a été utilisée pour chiffrer les fichiers de données sur Amazon S3. Si la clé MASTER\$1SYMMETRIC\$1KEY est spécifiée, le paramètre [ENCRYPTED](#copy-encrypted) doit également être spécifié. La clé MASTER\$1SYMMETRIC\$1KEY ne peut pas être utilisée avec le paramètre CREDENTIALS. Pour de plus amples informations, veuillez consulter [Chargement de fichiers de données chiffrés à partir d’Amazon S3](c_loading-encrypted-files.md).
Si les fichiers chiffrés sont au format compressé, ajoutez le paramètre GZIP, LZOP ou BZIP2 ZSTD.
REGION [AS] ’*aws-region*’
Spécifie la AWS région dans laquelle se trouvent les données sources. REGION est nécessaire pour exécuter la commande COPY depuis un compartiment Amazon S3 ou une table DynamoDB lorsque la ressource AWS qui contient les données ne se trouve pas dans la même région que le cluster Amazon Redshift.
La valeur pour *aws\$1region* doit correspondre à une région répertoriée dans le tableau [Régions et points de terminaison Amazon Redshift](https://docs.aws.amazon.com/general/latest/gr/rande.html#redshift_region).
Si le paramètre REGION est spécifié, toutes les ressources, y compris un fichier manifeste ou plusieurs compartiments Amazon S3, doivent se trouver dans la région spécifiée.
Le transfert de données entre les régions engage des frais supplémentaires pour le compartiment Amazon S3 ou la table DynamoDB qui contient les données. Pour plus d'informations sur la tarification, consultez les sections **Transfert de données sortantes d'Amazon S3 vers une autre AWS région** sur la page de [tarification d'Amazon S3](https://aws.amazon.com/s3/pricing/) et **Transfert de données sortantes** sur la page de tarification d'[Amazon DynamoDB](https://aws.amazon.com/dynamodb/pricing/).
Par défaut, la commande COPY part du principe que les données se trouvent dans la même région que le cluster Amazon Redshift.
## Paramètres facultatifs
Vous pouvez éventuellement spécifier les paramètres suivants avec la commande COPY à partir d’Amazon S3 :
+ [Options de mappage de colonnes](copy-parameters-column-mapping.md)
+ [Paramètres du format de données](copy-parameters-data-format.md#copy-data-format-parameters)
+ [Paramètres de conversion de données](copy-parameters-data-conversion.md)
+ [Opérations de chargement de données](copy-parameters-data-load.md)
## Paramètres non pris en charge
Vous ne pouvez pas utiliser les paramètres suivants avec la commande COPY à partir d’Amazon S3 :
+ SSH
+ READRATIO
# Commande COPY depuis Amazon EMR
Vous pouvez utiliser la commande COPY pour charger des données en parallèle à partir d’un cluster Amazon EMR configuré pour écrire des fichiers texte dans le système de fichiers distribué Hadoop (HDFS) du cluster sous la forme de fichiers à largeur fixe, de fichiers séparés par des caractères, de fichiers CSV, de fichiers au format JSON ou de fichiers Avro.
**Topics**
+ [
## Syntaxe
](#copy-parameters-data-source-emr-syntax)
+ [
## Exemple
](#copy-parameters-data-source-emr-example)
+ [
## Parameters
](#copy-parameters-data-source-emr-parameters)
+ [
## Paramètres pris en charge
](#copy-parameters-data-source-emr-optional-parms)
+ [
## Paramètres non pris en charge
](#copy-parameters-data-source-emr-unsupported-parms)
## Syntaxe
```
FROM 'emr://emr_cluster_id/hdfs_filepath'
authorization
[ optional_parameters ]
```
## Exemple
L’exemple suivant charge des données depuis un cluster Amazon EMR.
```
copy sales
from 'emr://j-SAMPLE2B500FC/myoutput/part-*'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole';
```
## Parameters
FROM
Source des données à charger.
’emr://*emr\$1cluster\$1id*/*hdfs\$1file\$1path*’
Identifiant unique du cluster Amazon EMR et chemin d’accès au fichier HDFS faisant référence aux fichiers de données pour la commande COPY. Les noms de fichiers de données HDFS ne doivent pas comporter les caractères génériques suivants : l’astérisque (\$1) et le point d’interrogation (?).
Le cluster Amazon EMR doit continuer de s’exécuter jusqu’à la fin de l’opération COPY. Si l’un des fichiers de données HDFS est modifié ou supprimé avant la fin de l’opération COPY, vous pouvez avoir des résultats inattendus ou l’opération COPY peut échouer.
Vous pouvez utiliser les caractères génériques astérisque (\$1) et point d’interrogation (?) dans le cadre de l’argument *hdfs\$1file\$1path* pour spécifier le chargement de plusieurs fichiers. Par exemple, `'emr://j-SAMPLE2B500FC/myoutput/part*'` identifie les fichiers `part-0000`, `part-0001`, et ainsi de suite. Si le chemin d’accès ne contient pas de caractères génériques, il est traité comme un littéral de chaîne. Si vous spécifiez uniquement un nom de dossier, COPY tente de charger tous les fichiers dans le dossier.
Si vous utilisez des caractères génériques ou uniquement le nom du dossier, vérifiez qu’aucun fichier indésirable ne sera chargé. Par exemple, certains processus peuvent écrire un fichier journal sur le dossier de sortie.
Pour plus d'informations, consultez [Chargement de données à partir d’Amazon EMR](loading-data-from-emr.md).
*authorization*
La commande COPY a besoin de l'autorisation pour accéder aux données dans une autre ressource AWS , y compris Amazon S3, Amazon EMR, Amazon DynamoDB et Amazon EC2. Vous pouvez fournir cette autorisation en référençant un rôle Gestion des identités et des accès AWS (IAM) attaché à votre cluster (contrôle d'accès basé sur les rôles) ou en fournissant les informations d'identification d'accès d'un utilisateur (contrôle d'accès basé sur des clés). Pour plus de sécurité et de flexibilité, nous recommandons d’utiliser contrôle d’accès basé sur les rôles IAM. Pour plus d'informations, consultez [Paramètres d’autorisation](copy-parameters-authorization.md).
## Paramètres pris en charge
Vous pouvez éventuellement spécifier les paramètres suivants avec la commande COPY à partir d’Amazon EMR :
+ [Options de mappage de colonnes](copy-parameters-column-mapping.md)
+ [Paramètres du format de données](copy-parameters-data-format.md#copy-data-format-parameters)
+ [Paramètres de conversion de données](copy-parameters-data-conversion.md)
+ [Opérations de chargement de données](copy-parameters-data-load.md)
## Paramètres non pris en charge
Vous ne pouvez pas utiliser les paramètres suivants avec la commande COPY à partir d’Amazon EMR :
+ ENCRYPTED
+ MANIFEST
+ REGION
+ READRATIO
+ SSH
# Exécution de la commande COPY à partir de l’hôte distant (SSH)
Vous pouvez utiliser la commande COPY pour charger les données en parallèle à partir d’un ou de plusieurs hôtes distants, comme les instances Amazon Elastic Compute Cloud (Amazon EC2) ou d’autres ordinateurs. La commande COPY se connecte aux hôtes distants à l’aide de SSH (Secure Shell) et exécute les commandes sur les hôtes distants pour générer la sortie de texte. L’hôte distant peut être une instance Linux EC2 ou un autre ordinateur Unix ou Linux configuré pour accepter les connexions SSH. Amazon Redshift peut se connecter à plusieurs hôtes et ouvrir plusieurs connexions SSH à chaque hôte. Amazon Redshift envoie une commande unique lors de chaque connexion pour générer la sortie de texte sur la sortie standard de l’hôte, qu’Amazon Redshift lit alors comme un fichier texte.
Utilisez la clause FROM pour spécifier la clé d’objet Amazon S3 pour le fichier manifeste qui fournit les informations que la commande COPY utilise pour ouvrir des connexions SSH et exécuter les commandes à distance.
**Topics**
+ [
## Syntaxe
](#copy-parameters-data-source-ssh-syntax)
+ [
## Exemples
](#copy-parameters-data-source-ssh-examples)
+ [
## Parameters
](#copy-parameters-data-source-ssh-parameters)
+ [
## Paramètres facultatifs
](#copy-parameters-data-source-ssh-optional-parms)
+ [
## Paramètres non pris en charge
](#copy-parameters-data-source-ssh-unsupported-parms)
**Important**
Si le compartiment S3 contenant le fichier manifeste ne réside pas dans la même région AWS que votre cluster, vous devez utiliser le paramètre REGION pour spécifier la région dans laquelle le compartiment se trouve.
## Syntaxe
```
FROM 's3://'ssh_manifest_file' }
authorization
SSH
| optional-parameters
```
## Exemples
L’exemple suivant utilise un fichier manifeste pour charger les données à partir d’un hôte distant à l’aide de SSH.
```
copy sales
from 's3://amzn-s3-demo-bucket/ssh_manifest'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
ssh;
```
## Parameters
FROM
Source des données à charger.
’s3://*copy\$1from\$1ssh\$1manifest\$1file*’
La commande COPY peut se connecter à plusieurs hôtes à l’aide de SSH et créer plusieurs connexions SSH à chaque hôte. COPY exécute une commande via chaque connexion hôte, puis charge la sortie à partir des commandes en parallèle de la table. L’argument *s3://copy\$1from\$1ssh\$1manifest\$1file* spécifie la clé d’objet Amazon S3 du fichier manifeste qui fournit les informations que la commande COPY utilise pour ouvrir les connexions SSH et exécuter les commandes à distance.
L’argument *s3://copy\$1from\$1ssh\$1manifest\$1file* doit explicitement faire référence à un seul fichier ; il ne peut pas être un préfixe de clé. Voici un exemple:
```
's3://amzn-s3-demo-bucket/ssh_manifest.txt'
```
Le fichier manifeste est un fichier texte au format JSON qu’Amazon Redshift utilise pour se connecter à l’hôte. Le fichier manifeste spécifie les points de terminaison hôte SSH et les commandes qui seront exécutées sur les hôtes pour renvoyer les données à Amazon Redshift. Le cas échéant, vous pouvez inclure la clé publique de l’hôte, le nom d’utilisateur de connexion et un indicateur obligatoire pour chaque entrée. L’exemple suivant montre un fichier manifeste qui crée deux connexions SSH :
```
{
"entries": [
{"endpoint":"",
"command": "",
"mandatory":true,
"publickey": "",
"username": ""},
{"endpoint":"",
"command": "",
"mandatory":true,
"publickey": "",
"username": ""}
]
}
```
Le fichier manifeste contient une construction `"entries"` pour chaque connexion SSH. Vous pouvez avoir plusieurs connexions à un seul hôte ou plusieurs connexions à plusieurs hôtes. Les guillemets doubles sont obligatoires comme illustré, aussi bien pour les noms de champ que pour les valeurs. Les guillemets doivent être des guillemets simples (0x22), ni culbutés, ni courbes. La seule valeur qui n’a pas besoin de guillemets doubles est la valeur booléenne `true` ou `false` pour le champ `"mandatory"`.
La liste suivante décrit les champs dans le fichier manifeste.
point de terminaison
L’adresse URL ou l’adresse IP de l’hôte, par exemple, `"ec2-111-222-333.compute-1.amazonaws.com"` ou `"198.51.100.0"`.
command
La commande doit être exécutée par l’hôte pour générer la sortie de texte ou la sortie binaire au format gzip, lzop, bzip2 ou zstd. La commande peut être n’importe quelle commande que l’utilisateur *« host\$1user\$1name »* est autorisé à exécuter. La commande peut être aussi simple que l’impression d’un fichier, ou elle bien peut interroger une base de données ou lancer un script. Les sorties (fichier texte, fichier binaire gzip, fichier binaire lzop ou fichier binaire bzip2) doivent être sous une forme que la commande COPY Amazon Redshift peut intégrer. Pour plus d'informations, consultez [Préparation de vos données d’entrée](t_preparing-input-data.md).
publickey
(Facultatif) La clé publique de l’hôte. Si la clé est fournie, Amazon Redshift l’utilise pour identifier l’hôte. Si la clé publique n’est pas fournie, Amazon Redshift n’essaie pas d’identifier l’hôte. Par exemple, si la clé publique l’hôte distant est `ssh-rsa AbcCbaxxx…Example root@amazon.com`, tapez le texte suivant dans le champ de clé publique : `"AbcCbaxxx…Example"`
mandatory
(Facultatif) Clause qui indique si la commande COPY doit échouer en cas d’échec de la tentative de connexion. La valeur par défaut est `false`. Si Amazon Redshift n’établit pas au moins une connexion, la commande COPY échoue.
nom d’utilisateur
(Facultatif) Nom d’utilisateur qui sera utilisé pour vous connecter au système hôte et exécuter la commande à distance. Le nom de connexion d’utilisateur doit être le même que la connexion qui a été utilisée pour ajouter la clé publique du cluster Amazon Redshift au fichier de clés autorisé de l’hôte. Le nom d’utilisateur par défaut est `redshift`.
Pour plus d’informations sur la création d’un fichier manifeste, consultez [Processus de chargement de données](loading-data-from-remote-hosts.md#load-from-host-process).
Pour exécuter la commande COPY d’un hôte distant, le paramètre SSH doit être spécifié avec la commande COPY. Si le paramètre SSH n’est pas spécifié, la commande COPY suppose que le fichier spécifié avec FROM est un fichier de données et échoue.
Si vous utilisez la compression automatique, la commande COPY effectue deux opérations de lecture des données, ce qui signifie qu’elle va exécuter la commande à distance à deux reprises. La première opération de lecture vise à fournir un échantillon de données pour l’analyse de la compression, et la deuxième opération de lecture charge réellement les données. Si l’exécution de la commande à distance à deux reprises est susceptible d’entraîner un problème, vous devez désactiver la compression automatique. Pour désactiver la compression automatique, exécutez la commande COPY avec le paramètre COMPUPDATE défini sur OFF. Pour plus d'informations, consultez [Chargement des tables avec compression automatique](c_Loading_tables_auto_compress.md).
Pour connaître les procédures détaillées de l’utilisation de la commande COPY dans SSH, consultez [Chargement des données à partir des hôtes distants](loading-data-from-remote-hosts.md).
*authorization*
La commande COPY a besoin de l'autorisation pour accéder aux données dans une autre ressource AWS , y compris Amazon S3, Amazon EMR, Amazon DynamoDB et Amazon EC2. Vous pouvez fournir cette autorisation en référençant un rôle Gestion des identités et des accès AWS (IAM) attaché à votre cluster (contrôle d'accès basé sur les rôles) ou en fournissant les informations d'identification d'accès d'un utilisateur (contrôle d'accès basé sur des clés). Pour plus de sécurité et de flexibilité, nous recommandons d’utiliser contrôle d’accès basé sur les rôles IAM. Pour plus d'informations, consultez [Paramètres d’autorisation](copy-parameters-authorization.md).
SSH
Clause qui spécifie que les données doivent être chargées à partir d’un hôte distant à l’aide du protocole SSH. Si vous spécifiez SSH, vous devez également fournir un fichier manifeste à l’aide de l’argument [s3://copy_from_ssh_manifest_file](#copy-ssh-manifest).
Si vous utilisez SSH pour effectuer une copie à partir d’un hôte à l’aide d’une adresse IP privée dans un VPC distant, le routage VPC amélioré doit être activé pour le VPC. Pour plus d’informations sur le routage VPC amélioré, consultez [Routage VPC amélioré Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/enhanced-vpc-routing.html).
## Paramètres facultatifs
Vous pouvez éventuellement spécifier les paramètres suivants avec la commande COPY à partir de SSH :
+ [Options de mappage de colonnes](copy-parameters-column-mapping.md)
+ [Paramètres du format de données](copy-parameters-data-format.md#copy-data-format-parameters)
+ [Paramètres de conversion de données](copy-parameters-data-conversion.md)
+ [Opérations de chargement de données](copy-parameters-data-load.md)
## Paramètres non pris en charge
Vous ne pouvez pas utiliser les paramètres suivants avec la commande COPY à partir de SSH :
+ ENCRYPTED
+ MANIFEST
+ READRATIO
# Commande COPY depuis Amazon DynamoDB
Pour charger les données à partir d’une table DynamoDB existante, utilisez la clause FROM pour spécifier le nom de la table DynamoDB.
**Topics**
+ [
## Syntaxe
](#copy-parameters-data-source-dynamodb-syntax)
+ [
## Exemples
](#copy-parameters-data-source-dynamodb-examples)
+ [
## Paramètres facultatifs
](#copy-parameters-data-source-dynamodb-optional-parms)
+ [
## Paramètres non pris en charge
](#copy-parameters-data-source-dynamodb-unsupported-parms)
**Important**
Si la table DynamoDB ne réside pas dans la même région que votre cluster Amazon Redshift, vous devez utiliser le paramètre REGION pour spécifier la région dans laquelle les données se trouvent.
## Syntaxe
```
FROM 'dynamodb://table-name'
authorization
READRATIO ratio
| REGION [AS] 'aws_region'
| optional-parameters
```
## Exemples
L’exemple suivant charge des données à partir d’une table DynamoDB.
```
copy favoritemovies from 'dynamodb://ProductCatalog'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
readratio 50;
```
### Parameters
FROM
Source des données à charger.
’dynamodb://*table-name*’
Nom de la table DynamoDB qui contient les données, par exemple, `'dynamodb://ProductCatalog'`. Pour plus d’informations sur la manière dont les attributs DynamoDB sont mappés aux colonnes Amazon Redshift, consultez [Chargement de données à partir d’une table Amazon DynamoDB](t_Loading-data-from-dynamodb.md).
Le nom d'une table DynamoDB est propre à AWS un compte, qui est identifié par AWS les informations d'identification d'accès.
*authorization*
La commande COPY a besoin de l’autorisation pour accéder aux données dans une autre ressource AWS , y compris Amazon S3, Amazon EMR, Amazon DynamoDB et Amazon EC2. Vous pouvez fournir cette autorisation en référençant un rôle Gestion des identités et des accès AWS (IAM) attaché à votre cluster (contrôle d'accès basé sur les rôles) ou en fournissant les informations d'identification d'accès d'un utilisateur (contrôle d'accès basé sur des clés). Pour plus de sécurité et de flexibilité, nous recommandons d’utiliser contrôle d’accès basé sur les rôles IAM. Pour plus d'informations, consultez [Paramètres d’autorisation](copy-parameters-authorization.md).
READRATIO [AS] *ratio*
Pourcentage du débit alloué à la table DynamoDB à utiliser pour le chargement des données. READRATIO est nécessaire pour exécuter la commande COPY à partir de DynamoDB. Il ne peut pas être utilisé pour exécuter la commande COPY à partir d’Amazon S3. Nous vous recommandons vivement de définir le ratio avec une valeur inférieure au débit moyen alloué non utilisé. Les valeurs valides sont des nombres entiers compris entre 1 et 200.
La définition de READRATIO sur 100 ou plus active Amazon Redshift pour tirer parti de l’intégralité du débit alloué de la table DynamoDB, ce qui dégrade considérablement les performances des opérations de lecture simultanées par rapport à la même table pendant la séance COPY. Le trafic d’écriture n’est pas affecté. Les valeurs supérieures à 100 sont autorisées pour résoudre les scénarios rares où Amazon Redshift ne respecte pas le débit alloué de la table. Si vous chargez les données de DynamoDB vers Amazon Redshift en permanence, pensez à organiser vos tables DynamoDB sous forme de série chronologique pour séparer le trafic en direct de l’opération COPY.
## Paramètres facultatifs
Vous pouvez éventuellement spécifier les paramètres suivants avec la commande COPY à partir d’Amazon DynamoDB :
+ [Options de mappage de colonnes](copy-parameters-column-mapping.md)
+ Les paramètres de conversion de données suivants sont pris en charge :
+ [ACCEPTANYDATE](copy-parameters-data-conversion.md#copy-acceptanydate)
+ [BLANKSASNULL](copy-parameters-data-conversion.md#copy-blanksasnull)
+ [DATEFORMAT](copy-parameters-data-conversion.md#copy-dateformat)
+ [EMPTYASNULL](copy-parameters-data-conversion.md#copy-emptyasnull)
+ [ROUNDEC](copy-parameters-data-conversion.md#copy-roundec)
+ [TIMEFORMAT](copy-parameters-data-conversion.md#copy-timeformat)
+ [TRIMBLANKS](copy-parameters-data-conversion.md#copy-trimblanks)
+ [TRUNCATECOLUMNS](copy-parameters-data-conversion.md#copy-truncatecolumns)
+ [Opérations de chargement de données](copy-parameters-data-load.md)
## Paramètres non pris en charge
Vous ne pouvez pas utiliser les paramètres suivants avec la commande COPY à partir de DynamoDB :
+ Paramètres du format de toutes les données
+ ESCAPE
+ FILLRECORD
+ IGNOREBLANKLINES
+ IGNOREHEADER
+ NULL
+ REMOVEQUOTES
+ ACCEPTINVCHARS
+ MANIFEST
+ ENCRYPTED
# Paramètres d’autorisation
La commande COPY nécessite une autorisation pour accéder aux données d'une autre AWS ressource, notamment Amazon S3, Amazon EMR, Amazon DynamoDB et Amazon EC2. Vous fournissez cette autorisation en référençant un [rôle Gestion des identités et des accès AWS (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) qui est attaché à votre cluster (*contrôle d’accès basé sur le rôle*). Vous pouvez chiffrer vos données de chargement sur Amazon S3.
Les rubriques suivantes fournissent plus de détails et des exemples d’options d’authentification:
+ [Autorisations IAM pour les commandes COPY, UNLOAD et CREATE LIBRARY](copy-usage_notes-access-permissions.md#copy-usage_notes-iam-permissions)
+ [Contrôle d’accès basé sur les rôles](copy-usage_notes-access-permissions.md#copy-usage_notes-access-role-based)
+ [Contrôle d’accès basé sur les clés](copy-usage_notes-access-permissions.md#copy-usage_notes-access-key-based)
Utilisez l’un des paramètres suivants pour autoriser la commande COPY :
+ [Utilisation du paramètre IAM\$1ROLE](#copy-iam-role) paramètre
+ Paramètres dans l’[Utilisation des paramètres ACCESS\$1KEY\$1ID et SECRET\$1ACCESS\$1KEY](#copy-access-key-id)
+ [Utilisation du paramètre CREDENTIALS](#copy-credentials)Clause
## Utilisation du paramètre IAM\$1ROLE
### IAM\$1ROLE
Utilisez le mot clé par défaut pour qu’Amazon Redshift utilise le rôle IAM défini par défaut et associé au cluster lorsque la commande COPY s’exécute.
Utilisez l’Amazon Resource Name (ARN) d’un rôle IAM que votre cluster utilise pour l’authentification et l’autorisation. Si vous spécifiez IAM\$1ROLE, vous ne pouvez pas utiliser ACCESS\$1KEY\$1ID et SECRET\$1ACCESS\$1KEY, SESSION\$1TOKEN ni CREDENTIALS.
L’exemple suivant montre la syntaxe du paramètre IAM\$1ROLE.
```
IAM_ROLE { default | 'arn:aws:iam:::role/' }
```
Pour plus d’informations, consultez [Contrôle d’accès basé sur les rôles](copy-usage_notes-access-permissions.md#copy-usage_notes-access-role-based).
## Utilisation des paramètres ACCESS\$1KEY\$1ID et SECRET\$1ACCESS\$1KEY
### Utilisation de ACCESS\$1KEY\$1ID et SECRET\$1ACCESS\$1KEY
Cette méthode d’autorisation n’est pas recommandée.
**Note**
Plutôt que de fournir des informations d’identification d’accès sous forme de texte brut, nous vous recommandons vivement d’utiliser l’authentification basée sur les rôles en spécifiant le paramètre IAM\$1ROLE. Pour plus d’informations, consultez [Contrôle d’accès basé sur les rôles](copy-usage_notes-access-permissions.md#copy-usage_notes-access-role-based).
### SESSION\$1TOKEN
Le jeton de séance à utiliser avec les informations d’identification d’accès temporaires. Lorsque SESSION\$1TOKEN est spécifié, vous devez également utiliser ACCESS\$1KEY\$1ID et SECRET\$1ACCESS\$1KEY afin de fournir des informations d’identification de clé d’accès temporaire. Si vous spécifiez SESSION\$1TOKEN, vous ne pouvez utiliser ni IAM\$1ROLE, ni CREDENTIALS. Pour plus d’informations, consultez [informations d’identification de sécurité temporaires](copy-usage_notes-access-permissions.md#r_copy-temporary-security-credentials) dans le Guide de l’utilisateur IAM.
**Note**
Plutôt que de créer des informations d’identification de sécurité temporaires, nous vous recommandons vivement d’utiliser l’authentification basée sur les rôles. Lorsque vous autorisez l’accès à l’aide d’un rôle IAM, Amazon Redshift crée automatiquement des informations d’identification utilisateur temporaires à chaque séance. Pour plus d'informations, consultez [Contrôle d’accès basé sur les rôles](copy-usage_notes-access-permissions.md#copy-usage_notes-access-role-based).
L’exemple suivant illustre la syntaxe du paramètre SESSION\$1TOKEN avec les paramètres ACCESS\$1KEY\$1ID et SECRET\$1ACCESS\$1KEY.
```
ACCESS_KEY_ID ''
SECRET_ACCESS_KEY ''
SESSION_TOKEN '';
```
Si vous spécifiez SESSION\$1TOKEN, vous ne pouvez utiliser ni IAM\$1ROLE, ni CREDENTIALS.
## Utilisation du paramètre CREDENTIALS
### CREDENTIALS
Clause qui indique la méthode que votre cluster utilisera pour accéder à d'autres AWS ressources contenant des fichiers de données ou des fichiers manifestes. Vous ne pouvez pas utiliser le paramètre CREDENTIALS avec IAM\$1ROLE ou ACCESS\$1KEY\$1ID et SECRET\$1ACCESS\$1KEY.
L’exemple suivant montre la syntaxe du paramètre CREDENTIALS.
```
[WITH] CREDENTIALS [AS] 'credentials-args'
```
**Note**
Pour une meilleure flexibilité, nous vous recommandons d’utiliser le paramètre [IAM\$1ROLE](#copy-iam-role-iam) plutôt que le paramètre CREDENTIALS.
Le cas échéant, si le paramètre [ENCRYPTED](copy-parameters-data-source-s3.md#copy-encrypted) est utilisé, la chaîne *credentials-args* fournit également la clé de chiffrement.
La chaîne *credentials-args* est sensible à la casse et ne doit pas contenir d’espaces.
Les mots-clés WITH et AS sont facultatifs, et ils sont ignorés.
Vous pouvez spécifier [role-based access control](copy-usage_notes-access-permissions.md#copy-usage_notes-access-role-based.phrase) ou [key-based access control](copy-usage_notes-access-permissions.md#copy-usage_notes-access-key-based.phrase). Dans les deux cas, le rôle IAM ou l’utilisateur doit avoir les autorisations nécessaires pour accéder aux ressources AWS spécifiées. Pour de plus amples informations, veuillez consulter [Autorisations IAM pour les commandes COPY, UNLOAD et CREATE LIBRARY](copy-usage_notes-access-permissions.md#copy-usage_notes-iam-permissions).
**Note**
Pour protéger vos AWS informations d'identification et protéger les données sensibles, nous vous recommandons vivement d'utiliser un contrôle d'accès basé sur les rôles.
Pour spécifier un contrôle d’accès basé sur les rôles, fournissez la chaîne *credentials-args* au format suivant :
```
'aws_iam_role=arn:aws:iam:::role/'
```
Pour utiliser les informations d’identification de jeton temporaires, vous devez fournir l’ID de clé d’accès temporaire, la clé d’accès secrète temporaire et le jeton temporaire. La chaîne *credentials-args* doit être au format suivant.
```
CREDENTIALS
'aws_access_key_id=;aws_secret_access_key=;token='
```
Une commande COPY utilisant le contrôle d’accès basé sur les rôles avec des informations d’identification temporaires ressemblerait à l’exemple suivant :
```
COPY customer FROM 's3://amzn-s3-demo-bucket/mydata'
CREDENTIALS
'aws_access_key_id=;aws_secret_access_key=;token='
```
Pour de plus amples informations, veuillez consulter [informations d’identification de sécurité temporaires](copy-usage_notes-access-permissions.md#r_copy-temporary-security-credentials).
Si le [ENCRYPTED](copy-parameters-data-source-s3.md#copy-encrypted) paramètre est utilisé, la chaîne *credentials-args* est au format suivant, où ** est la valeur de la clé racine utilisée pour chiffrer les fichiers.
```
CREDENTIALS
';master_symmetric_key='
```
Une commande COPY utilisant le contrôle d’accès basé sur les rôles avec une clé de chiffrement ressemblerait à l’exemple suivant :
```
COPY customer FROM 's3://amzn-s3-demo-bucket/mydata'
CREDENTIALS
'aws_iam_role=arn:aws:iam:::role/;master_symmetric_key='
```
# Options de mappage de colonnes
Par défaut, la commande COPY insère des valeurs dans les colonnes de la table cible dans le même ordre que les champs se trouvent dans les fichiers de données. Si l'ordre des colonnes par défaut ne fonctionne pas, vous pouvez spécifier une liste de colonnes ou utiliser des JSONPath expressions pour mapper les champs de données source aux colonnes cibles.
+ [Column List](#copy-column-list)
+ [JSONPaths File](#copy-column-mapping-jsonpaths)
## Liste de colonnes
Vous pouvez spécifier une liste des noms de colonnes séparés par des virgules pour charger les champs de données source dans des colonnes cible spécifiques. Les colonnes peuvent être dans n’importe quel ordre dans l’instruction COPY, mais lors du chargement de fichiers plats, tels que dans un compartiment Amazon S3, leur ordre doit correspondre à celui des données sources.
Lors du chargement d’une table Amazon DynamoDB, l’ordre n’importe pas La commande COPY met en correspondance les noms d’attribut des éléments extraits de la table DynamoDB et les noms de colonne de la table Amazon Redshift. Pour plus d'informations, consultez [Chargement de données à partir d’une table Amazon DynamoDB](t_Loading-data-from-dynamodb.md)
Le format d’une liste de colonnes est le suivant.
```
COPY tablename (column1 [,column2, ...])
```
Si une colonne dans la table cible est absente de la liste de colonnes, la commande COPY charge l’expression [DEFAULT](r_CREATE_TABLE_NEW.md#create-table-default) de la colonne cible.
Si la colonne cible n’a pas de valeur par défaut, la commande COPY tente de charger NULL.
Si la commande COPY tente d’affecter NULL à une colonne qui est définie comme NOT NULL, elle échoue.
Si une colonne [IDENTITY](r_CREATE_TABLE_NEW.md#identity-clause) est incluse dans la liste de colonnes, [EXPLICIT_IDS](copy-parameters-data-conversion.md#copy-explicit-ids) doit également être spécifié ; si une colonne IDENTITY n’est pas spécifiée, EXPLICIT\$1IDS ne peut pas être spécifié. Si aucune liste de la colonne n’est spécifiée, la commande se comporte comme si une liste de colonnes complète, dans l’ordre, a été spécifiée, avec les colonnes IDENTITY omises si EXPLICIT\$1IDS n’a pas non plus été spécifié.
Si une colonne est définie avec GENERATED BY DEFAULT AS IDENTITY, elle peut être copiée. Les valeurs sont générées ou mises à jour avec des valeurs que vous fournissez. L’option EXPLICIT\$1IDS n’est pas obligatoire. COPY ne met pas à jour le filigrane élevé d’identité. Pour de plus amples informations, veuillez consulter [GENERATED BY DEFAULT AS IDENTITY](r_CREATE_TABLE_NEW.md#identity-generated-bydefault-clause).
## JSONPaths fichier
Lors du chargement des fichiers de données au format JSON ou Avro, la commande COPY mappe automatiquement les éléments de données aux données source JSON ou Avro dans les colonnes de la table cible. Pour ce faire, elle met en correspondance les noms de champs du schéma Avro avec les noms de colonnes de la liste de tables ou de colonnes cible.
Dans certains cas, vos noms de colonnes et de champs ne correspondent pas, ou vous devez mapper à des niveaux plus profonds de la hiérarchie de données. Dans ces cas, vous pouvez utiliser un JSONPaths fichier pour mapper explicitement des éléments de données JSON ou Avro à des colonnes.
Pour de plus amples informations, veuillez consulter [JSONPaths fichier](copy-parameters-data-format.md#copy-json-jsonpaths).
# Paramètres du format de données
Par défaut, la commande COPY attend que les données source soient dans un format texte UTF-8 séparé par des caractères. Le délimiteur par défaut est une barre verticale ( \$1 ). Si les données source sont dans un autre format, utilisez les paramètres suivants pour spécifier le format des données:
+ [FORMAT](#copy-format)
+ [CSV](#copy-csv)
+ [DELIMITER](#copy-delimiter)
+ [FIXEDWIDTH](#copy-fixedwidth)
+ [SHAPEFILE](#copy-shapefile)
+ [AVRO](#copy-avro)
+ [JSON format for COPY](#copy-json)
+ [PARQUET](#copy-parquet)
+ [ORC](#copy-orc)
En plus des formats de données standard, COPY prend en charge les formats de données en colonnes suivants pour la commande COPY depuis Amazon S3 :
+ [ORC](#copy-orc)
+ [PARQUET](#copy-parquet)
La commande COPY à partir du format en colonne est pris en charge avec certaines restrictions. Pour plus d'informations, consultez [COPY depuis les formats de données en colonnes](copy-usage_notes-copy-from-columnar.md). Paramètres du format de données
FORMAT [AS]
(Facultatif) Identifie les mots-clés de format des données. Les arguments FORMAT sont décrits ci-après.
CSV [ QUOTE [AS] *’quote\$1character’* ]
Permet l’utilisation du format CSV dans les données d’entrée. Pour insérer automatiquement des délimiteurs, des caractères de saut de ligne et des retours à la ligne, entourez le champ dans le caractère spécifié par le paramètre QUOTE. Le guillemet par défaut correspond aux guillemets doubles ( " ). Lorsque le guillemet simple est utilisé dans un champ, précédez le caractère d’un guillemet simple supplémentaire. Par exemple, si les guillemets sont doubles, pour insérer la chaîne `A "quoted" word` le fichier d’entrée doit inclure la chaîne `"A ""quoted"" word"`. Lorsque le paramètre CSV est utilisé, le délimiteur par défaut est une virgule ( , ). Vous pouvez spécifier un autre délimiteur en utilisant le paramètre DELIMITER.
Lorsqu’un champ est placé entre guillemets, l’espace blanc entre les délimiteurs et les guillemets est ignoré. Si le délimiteur est un caractère d’espace vide, comme un onglet, le délimiteur n’est pas considéré comme un espace vide.
CSV ne peut pas être utilisé avec FIXEDWIDTH, REMOVEQUOTES ou ESCAPE.
QUOTE [AS] *’quote\$1character’*
Facultatif. Spécifie le caractère à utiliser comme guillemet lorsque vous utilisez le paramètre CSV. La valeur par défaut est les guillemets doubles ( " ). Si vous utilisez le paramètre QUOTE pour définir un autre guillemet que des guillemets doubles, vous n’avez pas besoin d’insérer les guillemets doubles dans le champ. Le paramètre QUOTE peut être utilisé uniquement avec le paramètre CSV. Le mot-clé AS est facultatif.
DELIMITER [AS] [’*delimiter\$1char*’]
Spécifie les caractères qui sont utilisés pour séparer les champs dans le fichier d’entrée, tels qu’une barre verticale ( `|` ), une virgule ( `,` ), une tabulation ( `\t` ) ou plusieurs caractères tels que `|~|`. Les caractères non imprimables sont pris en charge. Les caractères peuvent également être représentés en octal sous forme d’unités de code UTF-8. Pour l’octal, utilisez le format « \$1ddd », où « d » est un chiffre octal (de 0 à 7). Le délimiteur par défaut est une barre verticale ( `|` ), à moins que le paramètre CSV soit utilisé, auquel cas le délimiteur par défaut est une virgule ( `,` ). Le mot-clé AS est facultatif. DELIMITER ne peut pas être utilisé avec FIXEDWIDTH.
FIXEDWIDTH ’*fixedwidth\$1spec*’
Charge les données d’un fichier où la largeur de chaque colonne est une longueur fixe, plutôt que des colonnes séparées par un délimiteur. *fixedwidth\$1spec* est une chaîne qui spécifie une étiquette de colonne définie par l’utilisateur et la largeur de la colonne. L’étiquette de colonne peut être une chaîne de texte ou un nombre entier, en fonction de ce que l’utilisateur choisit. L’étiquette de colonne n’a aucun lien avec le nom de la colonne. L'ordre des label/width paires doit correspondre exactement à l'ordre des colonnes du tableau. FIXEDWIDTH ne peut pas être utilisé avec CSV ou DELIMITER. Dans Amazon Redshift la longueur des colonnes CHAR et VARCHAR est exprimée en octets, aussi n’oubliez pas que la largeur de colonne que vous spécifiez correspond à la longueur binaire de caractères sur plusieurs octets lors de la préparation du fichier à charger. Pour plus d'informations, consultez [Types caractères](r_Character_types.md).
Le format de *fixedwidth\$1spec* apparaît comme suit :
```
'colLabel1:colWidth1,colLabel:colWidth2, ...'
```
SHAPEFILE [ SIMPLIFY [AUTO] [*’tolerance’*] ]
Permet l’utilisation du format CSV dans les données d’entrée. Par défaut, la première colonne du shapefile est une colonne `GEOMETRY` ou `IDENTITY`. Toutes les colonnes suivantes suivent l’ordre spécifié dans le shapefile.
Vous ne pouvez pas utiliser SHAPEFILE avec FIXEDWIDTH, REMOVEQUOTES ou ESCAPE.
Pour utiliser des objets `GEOGRAPHY` avec `COPY FROM SHAPEFILE`, intégrez-les d’abord dans une colonne `GEOMETRY`, puis convertissez-les en objets `GEOGRAPHY`.
SIMPLIFY [*tolerance*]
(Facultatif) Simplifie toutes les géométries pendant le processus d'ingestion à l'aide de l' Ramer-Douglas-Peuckeralgorithme et de la tolérance donnée.
SIMPLIFY AUTO [*tolerance*]
(Facultatif) Simplifie uniquement les géométries supérieures à la taille de géométrie maximale. Cette simplification utilise l' Ramer-Douglas-Peuckeralgorithme et la tolérance calculée automatiquement si celle-ci ne dépasse pas la tolérance spécifiée. Cet algorithme calcule la taille pour stocker les objets dans la tolérance spécifiée. La valeur *tolerance* est facultative.
Pour voir des exemples de chargement de shapefiles, consultez [Chargement d’un shapefile dans Amazon Redshift](r_COPY_command_examples.md#copy-example-spatial-copy-shapefile).
AVRO [AS] ’*avro\$1option*’
Spécifie que les données source sont au format Avro.
Le format Avro est pris en charge pour la commande COPY dans les services et protocoles suivants :
+ Amazon S3
+ Amazon EMR
+ Hôtes distants (SSH)
Avro n’est pas pris en charge pour la commande COPY dans DynamoDB.
Avro est un protocole de sérialisation de données. Un fichier source Avro inclut un schéma qui définit la structure des données. Le type de schéma Avro doit être `record`. La commande COPY accepte la création de fichiers Avro à l’aide du codec non compressé par défaut, ainsi que les codecs de compression `deflate` et `snappy`. Pour plus d’informations sur Avro, accédez à [Apache Avro](https://avro.apache.org/).
Les valeurs valides pour *avro\$1option* sont les suivantes :
+ `'auto'`
+ `'auto ignorecase'`
+ `'s3://jsonpaths_file'`
La valeur par défaut est `'auto'`.
COPY mappe automatiquement les éléments de données des données source Avro aux colonnes de la table cible en mettant en correspondance les noms de champs du schéma Avro avec les noms de colonnes dans la table cible. La mise en correspondance est sensible à la casse pour `'auto'` et n’est pas sensible à la casse pour `'auto ignorecase'`.
Les noms de colonnes des tables Amazon Redshift sont toujours en lettres minuscules, aussi lorsque vous utilisez l’option `'auto'`, les noms de champs correspondants doivent être en minuscules. Si les noms de champs ne sont pas tous en minuscules, vous pouvez utiliser l’option `'auto ignorecase'`. Avec l’argument `'auto'` par défaut, la commande COPY ne reconnaît que le premier niveau de champs (ou *champs externes*) dans la structure.
Pour mapper explicitement les noms de colonnes aux noms de champs Avro, vous pouvez utiliser [JSONPaths fichier](#copy-json-jsonpaths).
Par défaut, la commande COPY tente de mettre en correspondance toutes les colonnes de la table cible avec les noms de champs Avro. Pour charger un sous-ensemble de colonnes, vous pouvez éventuellement spécifier une liste de colonnes. Si une colonne dans la table cible est absente de la liste de colonnes, la commande COPY charge l’expression [DEFAULT](r_CREATE_TABLE_NEW.md#create-table-default) de la colonne cible. Si la colonne cible n’a pas de valeur par défaut, la commande COPY tente de charger NULL. Si une colonne est incluse dans la liste de colonnes et que la commande COPY ne trouve pas de champ correspondant dans les données Avro, la commande COPY tente de charger NULL dans la colonne.
Si la commande COPY tente d’affecter NULL à une colonne qui est définie comme NOT NULL, elle échoue.
**Schéma Avro**
Un fichier de données source Avro inclut un schéma qui définit la structure des données. La commande COPY lit le schéma qui fait partie du fichier de données source Avro pour mapper des éléments de données aux colonnes de la table cible. L’exemple suivant illustre un schéma Avro.
```
{
"name": "person",
"type": "record",
"fields": [
{"name": "id", "type": "int"},
{"name": "guid", "type": "string"},
{"name": "name", "type": "string"},
{"name": "address", "type": "string"}]
}
```
Le schéma Avro est défini à l’aide du format JSON. L’objet de niveau supérieur JSON contient trois paires nom-valeur avec les noms ou *clés*, `"name"`, `"type"` et `"fields"`.
La clé `"fields"` s’apparie à un tableau d’objets qui définissent le nom et le type de données de chaque champ dans la structure de données. Par défaut, la commande COPY met automatiquement en correspondance les noms de champs avec les noms de colonnes. Les noms de colonnes sont toujours en minuscules, les noms de champs correspondants doivent donc toujours être en minuscules, sauf si vous spécifiez l’option `‘auto ignorecase’`. Tous les noms de domaines qui ne correspondent pas à un nom de colonne sont ignorés. L’ordre n’a pas d’importance. Dans l’exemple précédent, la commande COPY mappe aux noms de colonnes `id`, `guid`, `name`, et `address`.
Avec l’argument `'auto'` par défaut, la commande COPY met en correspondance uniquement les objets de premier niveau des colonnes. Pour effectuer un mappage vers des niveaux plus profonds du schéma, ou si les noms de champs et de colonnes ne correspondent pas, utilisez un JSONPaths fichier pour définir le mappage. Pour de plus amples informations, veuillez consulter [JSONPaths fichier](#copy-json-jsonpaths).
Si la valeur associée à une clé est un type de données complexe Avro comme octets, tableau, enregistrement, carte ou lien, la commande COPY charge la valeur sous forme de chaîne. Ici, la chaîne est la représentation JSON des données. La commande COPY charge les types de données d’énumération Avro sous forme de chaînes dans lesquelles le contenu est le nom du type. Pour obtenir un exemple, consultez [Exécution de la commande COPY à partir du format JSON](copy-usage_notes-copy-from-json.md).
La taille maximale de l’en-tête du fichier Avro, qui inclut les métadonnées de fichiers et de schéma, est de 1 Mo.
La taille maximale d’un seul bloc de données Avro est de 4 Mo. Ce qui est différent de la taille de ligne maximale. Si la taille maximale d’un seul bloc de données Avro est dépassée, même si la taille de la ligne qui en résulte est inférieure à la limite de taille de ligne de 4 Mo, la commande COPY échoue.
Lors du calcul de la taille des lignes, Amazon Redshift compte deux fois les barres verticales (\$1) en interne. Si les données entrées contiennent un très grand nombre de barres verticales, la taille des lignes peut dépasser 4 Mo même si la taille du bloc de données est inférieure à 4 Mo.
JSON [AS] ’*json\$1option*’
Les données source sont au format JSON.
Le format JSON est pris en charge pour la commande COPY dans ces services et protocoles :
+ Amazon S3
+ Commande COPY depuis Amazon EMR
+ Exécution de la commande COPY depuis SSH
JSON n’est pas pris en charge pour exécuter la commande COPY dans DynamoDB.
Les valeurs valides pour *json\$1option* sont les suivantes :
+ `'auto'`
+ `'auto ignorecase'`
+ `'s3://jsonpaths_file'`
+ `'noshred'`
La valeur par défaut est `'auto'`. Amazon Redshift ne déchiquète pas les attributs des structures JSON en plusieurs colonnes lors du chargement d’un document JSON.
Par défaut, la commande COPY tente de mettre en correspondance toutes les colonnes de la table cible avec les clés de noms de champs JSON. Pour charger un sous-ensemble de colonnes, vous pouvez éventuellement spécifier une liste de colonnes. Si les clés de nom de domaine JSON ne sont pas toutes en minuscules, vous pouvez utiliser l’option `'auto ignorecase'` ou [JSONPaths fichier](#copy-json-jsonpaths) pour mapper explicitement les noms de colonnes aux clés de nom de domaine JSON.
Si une colonne dans la table cible est absente de la liste de colonnes, la commande COPY charge l’expression [DEFAULT](r_CREATE_TABLE_NEW.md#create-table-default) de la colonne cible. Si la colonne cible n’a pas de valeur par défaut, la commande COPY tente de charger NULL. Si une colonne est incluse dans la liste de colonnes et que la commande COPY ne trouve pas de champ correspondant dans les données JSON, la commande COPY tente de charger NULL dans la colonne.
Si la commande COPY tente d’affecter NULL à une colonne qui est définie comme NOT NULL, elle échoue.
La commande COPY mappe les éléments de données dans les données source JSON aux colonnes de la table cible. Pour cela, elle fait correspondre les *clés d’objet* (ou les noms) dans les paires nom-valeur source aux noms des colonnes de la table cible.
Reportez-vous aux informations suivantes sur chaque valeur *json\$1option* :
’auto’
Avec cette option, la mise en correspondance est sensible à la casse. Les noms de colonnes des tables Amazon Redshift sont toujours en lettres minuscules, aussi lorsque vous utilisez l’option `'auto'`, les noms de champs JSON correspondants doivent être en minuscules.
’auto ignorecase’
Avec cette option, la mise en correspondance n’est pas sensible à la casse. Les noms de colonnes des tables Amazon Redshift étant toujours en minuscules, lorsque vous utilisez la commande `'auto ignorecase'`, les noms de champs JSON correspondants peuvent être en minuscules, en majuscules ou en casse mixte.
’s3://*jsonpaths\$1file*’
Avec cette option, COPY utilise le JSONPaths fichier nommé pour mapper les éléments de données des données sources JSON aux colonnes de la table cible. L’argument *`s3://jsonpaths_file`* doit être une clé d’objet Amazon S3 faisant explicitement référence à un seul fichier. Par exemple : `'s3://amzn-s3-demo-bucket/jsonpaths.txt`’. L’argument ne peut pas être un préfixe de clé. Pour plus d'informations sur l'utilisation d'un JSONPaths fichier, consultez[JSONPaths fichier](#copy-json-jsonpaths).
Dans certains cas, le fichier spécifié par `jsonpaths_file` a le même préfixe que le chemin spécifié par `copy_from_s3_objectpath` pour les fichiers de données. Dans ce cas, COPY lit le JSONPaths fichier sous forme de fichier de données et renvoie des erreurs. Supposons, par exemple, que vos fichiers de données utilisent le chemin de l'objet `s3://amzn-s3-demo-bucket/my_data.json` et que votre JSONPaths fichier le soit`s3://amzn-s3-demo-bucket/my_data.jsonpaths`. Dans ce cas, la commande COPY tente de charger `my_data.jsonpaths` en tant que fichier de données.
’noshred’
Avec cette option, Amazon Redshift ne déchiquète pas les attributs des structures JSON en plusieurs colonnes lors du chargement d’un document JSON.
## Fichier de données JSON
Le fichier de données JSON contient un ensemble d’objets ou tableaux. La commande COPY charge chaque objet ou tableau JSON dans une seule ligne de la table cible. Chaque objet ou tableau correspondant à une ligne doit être une structure autonome, de niveau racine, autrement dit, il ne doit être membre d’une autre structure JSON.
Un *objet* JSON commence et finit par des accolades ( \$1 \$1 ) et contient une collection non ordonnée de paires nom-valeur. Chaque paire de nom et de valeur est séparée par deux points, et les paires sont séparées par des virgules. Par défaut, la *clé d’objet*, ou le nom, dans les paires nom-valeur, doit correspondre au nom de la colonne correspondante dans la table. Les noms de colonnes des tables Amazon Redshift étant toujours en minuscules, les clés des noms de champs JSON correspondants doivent également être en minuscules. Si vos noms de colonnes et clés JSON ne correspondent pas, utilisez un [JSONPaths fichier](#copy-json-jsonpaths) pour mapper explicitement les colonnes aux clés.
L’ordre d’un objet JSON n’est pas important. Tous les noms qui ne correspondent pas à un nom de colonne sont ignorés. L’exemple suivant illustre la structure d’un objet JSON simple.
```
{
"column1": "value1",
"column2": value2,
"notacolumn" : "ignore this value"
}
```
Un *tableau* JSON commence et finit par des crochets ( [ ] ) et contient une collection ordonnée de valeurs séparées par des virgules. Si vos fichiers de données utilisent des tableaux, vous devez spécifier un JSONPaths fichier pour faire correspondre les valeurs aux colonnes. L’exemple suivant illustre la structure d’un tableau JSON simple.
```
["value1", value2]
```
Le JSON doit être dans un format correct. Par exemple, les objets ou les tableaux ne peuvent pas être séparés par des virgules ou tout autre caractère à l’exception des espaces vides. Les chaînes doivent être placées entre guillemets doubles. Les guillemets doivent être des guillemets simples (0x22), ni culbutés, ni courbes.
La taille maximale d’un seul objet ou tableau JSON, y compris les accolades ou les crochets, est de 4 Mo. Ce qui est différent de la taille de ligne maximale. Si la taille maximale d’un seul objet ou tableau JSON est dépassée, même si la taille de la ligne qui en résulte est inférieure à la limite de taille de ligne de 4 Mo, la commande COPY échoue.
Lors du calcul de la taille des lignes, Amazon Redshift compte deux fois les barres verticales (\$1) en interne. Si les données entrées contiennent un très grand nombre de barres verticales, la taille des lignes peut dépasser 4 Mo même si la taille de l’objet est inférieure à 4 Mo.
La commande COPY charge `\n` comme un caractère de saut de ligne et charge `\t` comme un caractère de tabulation. Pour charger une barre oblique inverse, précédez-la d’une barre oblique inverse ( `\\` ).
La commande COPY recherche la source JSON spécifiée pour un objet ou tableau JSON bien formé et valide. Si la commande COPY rencontre des caractères qui ne sont pas des espaces vides avant de localiser une structure JSON utilisable, ou entre des objets ou tableaux JSON valides, elle renvoie une erreur pour chaque instance. Ces erreurs sont prises en compte dans le nombre d’erreurs MAXERROR. Lorsque le nombre d’erreurs est égal ou supérieur à MAXERROR, la commande COPY échoue.
Pour chaque erreur, Amazon Redshift enregistre une ligne dans la table système STL\$1LOAD\$1ERRORS. La colonne LINE\$1NUMBER enregistre la dernière ligne de l’objet JSON qui a provoqué l’erreur.
Si IGNOREHEADER est spécifié, la commande COPY ignore le nombre de lignes dans les données JSON spécifiées. Les caractères de saut de ligne dans les données JSON comptent toujours pour les calculs IGNOREHEADER.
La commande COPY charge des chaînes vides dans les champs vides par défaut. Si EMPTYASNULL est spécifié, la commande COPY charge des chaînes vides dans les champs CHAR et VARCHAR comme NULL. Les chaînes vides d’autres types de données, tels que INT, sont toujours chargées avec NULL.
Les options suivantes ne sont pas prises en charge avec JSON :
+ CSV
+ DELIMITER
+ ESCAPE
+ FILLRECORD
+ FIXEDWIDTH
+ IGNOREBLANKLINES
+ NULL AS
+ READRATIO
+ REMOVEQUOTES
Pour plus d'informations, consultez [Exécution de la commande COPY à partir du format JSON](copy-usage_notes-copy-from-json.md). Pour plus d’informations sur les structures de données JSON, accédez à [www.json.org](https://www.json.org/).
## JSONPaths fichier
Si vous chargez depuis des données source au format JSON ou Avro, la commande COPY mappe par défaut les éléments de données de premier niveau dans les données source aux colonnes de la table cible. Pour ce faire, elle met en correspondance chaque nom (ou clé d’objet) dans une paire nom-valeur avec le nom d’une colonne de la table cible.
Si les noms de vos colonnes et vos clés d'objet ne correspondent pas, ou pour les mapper à des niveaux plus profonds de la hiérarchie des données, vous pouvez utiliser un JSONPaths fichier pour mapper explicitement des éléments de données JSON ou Avro à des colonnes. Le JSONPaths fichier mappe les éléments de données JSON aux colonnes en faisant correspondre l'ordre des colonnes dans la table ou la liste de colonnes cible.
Le JSONPaths fichier ne doit contenir qu'un seul objet JSON (pas un tableau). L’objet JSON est une paire nom-valeur. La *clé d’objet*, qui est le nom de la paire nom-valeur, doit être `"jsonpaths"`. *La *valeur* de la paire nom-valeur est un tableau d'JSONPath expressions.* Chaque JSONPath expression fait référence à un seul élément de la hiérarchie de données JSON ou du schéma Avro, de la même manière qu'une XPath expression fait référence aux éléments d'un document XML. Pour de plus amples informations, veuillez consulter [JSONPath expressions](#copy-json-jsonpath-expressions).
Pour utiliser un JSONPaths fichier, ajoutez le mot clé JSON ou AVRO à la commande COPY. Spécifiez le nom du compartiment S3 et le chemin de l'objet du JSONPaths fichier en utilisant le format suivant.
```
COPY tablename
FROM 'data_source'
CREDENTIALS 'credentials-args'
FORMAT AS { AVRO | JSON } 's3://jsonpaths_file';
```
La valeur `s3://jsonpaths_file` doit être une clé d’objet Amazon S3 faisant explicitement référence à un seul fichier, tel que `'s3://amzn-s3-demo-bucket/jsonpaths.txt'`. Elle ne pas être un préfixe de clé.
Dans certains cas, si vous chargez à partir d’Amazon S3, le fichier spécifié par `jsonpaths_file` a le même préfixe que le chemin spécifié par `copy_from_s3_objectpath` pour les fichiers de données. Dans ce cas, COPY lit le JSONPaths fichier sous forme de fichier de données et renvoie des erreurs. Supposons, par exemple, que vos fichiers de données utilisent le chemin de l'objet `s3://amzn-s3-demo-bucket/my_data.json` et que votre JSONPaths fichier le soit`s3://amzn-s3-demo-bucket/my_data.jsonpaths`. Dans ce cas, la commande COPY tente de charger `my_data.jsonpaths` en tant que fichier de données.
Si le nom de clé est une chaîne autre que `"jsonpaths"`, la commande COPY ne renvoie pas d’erreur, mais elle ignore *jsonpaths\$1file* et utilise l’argument `'auto'` à la place.
Si l’une des actions suivantes se produit, la commande COPY échoue :
+ Le JSON est incorrect.
+ Il existe plusieurs objets JSON.
+ Tous les caractères sauf les espaces vides existent en dehors de l’objet.
+ Un élément de tableau est une chaîne vide ou n’est pas une chaîne.
MAXERROR ne s'applique pas au JSONPaths fichier.
Le JSONPaths fichier ne doit pas être chiffré, même si l'[ENCRYPTED](copy-parameters-data-source-s3.md#copy-encrypted)option est spécifiée.
Pour de plus amples informations, veuillez consulter [Exécution de la commande COPY à partir du format JSON](copy-usage_notes-copy-from-json.md).
## JSONPath expressions
Le JSONPaths fichier utilise des JSONPath expressions pour mapper les champs de données aux colonnes cibles. Chaque JSONPath expression correspond à une colonne de la table cible Amazon Redshift. L'ordre des éléments du JSONPath tableau doit correspondre à l'ordre des colonnes de la table cible ou de la liste des colonnes, si une liste de colonnes est utilisée.
Les guillemets doubles sont obligatoires comme illustré, aussi bien pour les noms de champ que pour les valeurs. Les guillemets doivent être des guillemets simples (0x22), ni culbutés, ni courbes.
Si aucun élément d'objet référencé par une JSONPath expression n'est trouvé dans les données JSON, COPY tente de charger une valeur NULL. Si l’objet référencé est incorrect, la commande COPY renvoie une erreur de chargement.
Si aucun élément de tableau référencé par une JSONPath expression n'est trouvé dans les données JSON ou Avro, COPY échoue avec l'erreur suivante : `Invalid JSONPath format: Not an array or index out of range.` Supprimez tous les éléments du tableau JSONPaths qui n'existent pas dans les données sources et vérifiez que les tableaux des données sources sont bien formés.
Les JSONPath expressions peuvent utiliser la notation entre crochets ou la notation par points, mais vous ne pouvez pas mélanger les notations. L'exemple suivant montre des JSONPath expressions utilisant la notation entre crochets.
```
{
"jsonpaths": [
"$['venuename']",
"$['venuecity']",
"$['venuestate']",
"$['venueseats']"
]
}
```
L'exemple suivant montre des JSONPath expressions utilisant la notation par points.
```
{
"jsonpaths": [
"$.venuename",
"$.venuecity",
"$.venuestate",
"$.venueseats"
]
}
```
Dans le contexte de la syntaxe COPY d'Amazon Redshift, une JSONPath expression doit spécifier le chemin explicite vers un élément de nom unique dans une structure de données hiérarchique JSON ou Avro. Amazon Redshift ne prend en charge aucun JSONPath élément, tel que les caractères génériques ou les expressions de filtre, susceptibles de donner lieu à un chemin ambigu ou à plusieurs éléments de nom.
Pour de plus amples informations, veuillez consulter [Exécution de la commande COPY à partir du format JSON](copy-usage_notes-copy-from-json.md).
## Utilisation JSONPaths avec Avro Data
L’exemple suivant illustre un schéma Avro à plusieurs niveaux.
```
{
"name": "person",
"type": "record",
"fields": [
{"name": "id", "type": "int"},
{"name": "guid", "type": "string"},
{"name": "isActive", "type": "boolean"},
{"name": "age", "type": "int"},
{"name": "name", "type": "string"},
{"name": "address", "type": "string"},
{"name": "latitude", "type": "double"},
{"name": "longitude", "type": "double"},
{
"name": "tags",
"type": {
"type" : "array",
"name" : "inner_tags",
"items" : "string"
}
},
{
"name": "friends",
"type": {
"type" : "array",
"name" : "inner_friends",
"items" : {
"name" : "friends_record",
"type" : "record",
"fields" : [
{"name" : "id", "type" : "int"},
{"name" : "name", "type" : "string"}
]
}
}
},
{"name": "randomArrayItem", "type": "string"}
]
}
```
L'exemple suivant montre un JSONPaths fichier qui utilise des AvroPath expressions pour faire référence au schéma précédent.
```
{
"jsonpaths": [
"$.id",
"$.guid",
"$.address",
"$.friends[0].id"
]
}
```
L' JSONPaths exemple inclut les éléments suivants :
jsonpaths
Nom de l'objet JSON qui contient les AvroPath expressions.
[ … ]
Les crochets entourent le tableau JSON qui contient les éléments de chemin d’accès.
\$1
Le symbole du dollar fait référence à l’élément racine du schéma Avro, qui est le tableau `"fields"`.
"\$1.id",
La cible de l' AvroPath expression. Dans ce cas, la cible est l’élément dans le tableau `"fields"` avec le nom `"id"`. Les expressions sont séparées par des virgules.
"\$1.friends[0].id"
Les crochets indiquent un index de tableau. JSONPath les expressions utilisent une indexation basée sur zéro. Cette expression fait donc référence au premier élément du `"friends"` tableau portant le nom. `"id"`
La syntaxe du schéma Avro nécessite l’utilisation de *champs internes* pour définir la structure d’enregistrement et les types de données du tableau. Les champs internes sont ignorés par les AvroPath expressions. Par exemple, le champ `"friends"` définit un tableau nommé `"inner_friends"`, qui définit à son tour un enregistrement nommé `"friends_record"`. L' AvroPath expression faisant référence au champ `"id"` peut ignorer les champs supplémentaires pour référencer directement le champ cible. Les AvroPath expressions suivantes font référence aux deux champs appartenant au `"friends"` tableau.
```
"$.friends[0].id"
"$.friends[0].name"
```
## Paramètres du format des données en colonnes
En plus des formats de données standard, COPY prend en charge les formats de données en colonnes suivants pour la commande COPY depuis Amazon S3. La commande COPY à partir du format en colonne est pris en charge avec certaines restrictions. Pour plus d'informations, consultez [COPY depuis les formats de données en colonnes](copy-usage_notes-copy-from-columnar.md).
ORC
Charge les données à partir d’un fichier qui utilise le format de fichier ORC (Optimized Row Columnar).
PARQUET
Charge les données à partir d’un fichier qui utilise le format de fichier Parquet.
# Paramètres de compression de fichier
Vous pouvez charger à partir de fichiers de données compressés en spécifiant les paramètres suivants. Paramètres de compression de fichier
BZIP2
Valeur qui indique que le ou les fichiers d’entrée sont au format compressé bzip2 (fichiers .bz2). L’opération COPY lit chaque fichier compressé et décompresse les données qu’elle charge.
GZIP
Valeur qui indique que le ou les fichiers d’entrée sont au format compressé gzip (fichiers .gz). L’opération COPY lit chaque fichier compressé et décompresse les données qu’elle charge.
LZOP
Valeur qui indique que le ou les fichiers d’entrée sont au format compressé lzop (fichiers .lzo). L’opération COPY lit chaque fichier compressé et décompresse les données qu’elle charge.
L’opération COPY ne prend pas en charge les fichiers qui sont compressés à l’aide de l’option lzop *--filter*.
ZSTD
Valeur qui indique que le ou les fichiers d’entrée sont au format compressé Zstandard (fichiers .zst). L’opération COPY lit chaque fichier compressé et décompresse les données qu’elle charge.
ZSTD est pris en charge uniquement avec la commande COPY depuis Amazon S3.
# Paramètres de conversion de données
Lorsqu’elle charge la table, la commande COPY tente implicitement de convertir les chaînes dans les données source vers le type de données de la colonne cible. Si vous devez spécifier une conversion qui est différente du comportement par défaut, ou si la conversion par défaut entraîne des erreurs, vous pouvez gérer les conversions de données en spécifiant les paramètres suivants. Pour plus d’informations sur la syntaxe de ces paramètres, consultez [Syntaxe de la commande COPY](https://docs.aws.amazon.com/redshift/latest/dg/r_COPY.html#r_COPY-syntax).
+ [ACCEPTANYDATE](#copy-acceptanydate)
+ [ACCEPTINVCHARS](#copy-acceptinvchars)
+ [BLANKSASNULL](#copy-blanksasnull)
+ [DATEFORMAT](#copy-dateformat)
+ [EMPTYASNULL](#copy-emptyasnull)
+ [ENCODING](#copy-encoding)
+ [ESCAPE](#copy-escape)
+ [EXPLICIT_IDS](#copy-explicit-ids)
+ [FILLRECORD](#copy-fillrecord)
+ [IGNOREBLANKLINES](#copy-ignoreblanklines)
+ [IGNOREHEADER](#copy-ignoreheader)
+ [NULL AS](#copy-null-as)
+ [REMOVEQUOTES](#copy-removequotes)
+ [ROUNDEC](#copy-roundec)
+ [TIMEFORMAT](#copy-timeformat)
+ [TRIMBLANKS](#copy-trimblanks)
+ [TRUNCATECOLUMNS](#copy-truncatecolumns) Paramètres de conversion de données
ACCEPTANYDATE
Autorise n’importe quel format de date, y compris les formats non valides comme `00/00/00 00:00:00`, à charger sans générer d’erreur. Ce paramètre s’applique uniquement aux colonnes TIMESTAMP et DATE. Utilisez toujours ACCEPTANYDATE avec le paramètre DATEFORMAT. Si le format de date pour les données ne correspond pas à la spécification DATEFORMAT, Amazon Redshift insère une valeur NULL dans ce champ.
ACCEPTINVCHARS [AS] [’*replacement\$1char*’]
Autorise le chargement de données dans les colonnes VARCHAR, même si les données contiennent des caractères UTF-8 non valides. Lorsque ACCEPTINVCHARS est spécifié, la commande COPY remplace chaque caractère UTF-8 non valide par une chaîne de la même longueur comprenant le caractère spécifié par *replacement\$1char*. Par exemple, si le caractère de remplacement est ’`^`’, un caractère non valide de trois octets sera remplacé par ’`^^^`’.
Le caractère de remplacement peut être n’importe quel caractère ASCII sauf NULL. La valeur par défaut est un point d’interrogation ( ? ). Pour plus d’informations sur les caractères UTF-8 non valides, consultez [Erreurs de chargement de caractères multioctets](multi-byte-character-load-errors.md).
La commande COPY renvoie le nombre de lignes qui contenaient des caractères UTF-8 non valides, et ajoute une entrée à la table système [STL\$1REPLACEMENTS](r_STL_REPLACEMENTS.md) pour chaque ligne concernée, à concurrence de 100 lignes au maximum pour chaque tranche de nœud. Les caractères UTF-8 non valides supplémentaires sont également remplacés, mais ces événements de remplacement ne sont pas enregistrés.
Si ACCEPTINVCHARS n’est pas spécifié, la commande COPY renvoie une erreur chaque fois qu’elle rencontre un caractère UTF-8 non valide.
ACCEPTINVCHARS est valide uniquement pour les colonnes VARCHAR.
BLANKSASNULL
Charge les champs vides, qui comprennent des espaces vides uniquement, comme NULL. Cette option s’applique uniquement aux colonnes CHAR et VARCHAR. Les champs vides pour d’autres types de données, tels que INT, sont toujours chargés avec NULL. Par exemple, une chaîne qui contient trois espaces à la suite (et aucun autre caractère) est chargée comme une valeur NULL. Le comportement par défaut, sans cette option, consiste à charger les espaces tels quels.
DATEFORMAT [AS] \$1’*dateformat\$1string*’ \$1 ’auto’ \$1
Si aucun DATEFORMAT n’est spécifié, le format par défaut est `'YYYY-MM-DD'`. Par exemple, un autre format valide est `'MM-DD-YYYY'`.
Si la commande COPY ne reconnaît pas le format de vos valeurs de date ou d’heure, ou si vos valeurs de date ou d’heure utilisent des formats différents, utilisez l’argument `'auto'` avec le paramètre DATEFORMAT ou TIMEFORMAT. L’argument `'auto'` reconnaît plusieurs formats qui ne sont pas pris en charge lors de l’utilisation d’une chaîne DATEFORMAT et TIMEFORMAT. Le mot-clé `'auto'` est sensible à la casse. Pour plus d'informations, consultez [Utilisation de la reconnaissance automatique avec DATEFORMAT et TIMEFORMAT](automatic-recognition.md).
Le format de date peut inclure des informations de temps (heure, minutes, secondes), mais ces informations sont ignorées. Le mot-clé AS est facultatif. Pour plus d'informations, consultez [Chaînes DATEFORMAT et TIMEFORMATExemple](r_DATEFORMAT_and_TIMEFORMAT_strings.md).
EMPTYASNULL
Indique que Amazon Redshift doit charger les champs CHAR et VARCHAR vides comme des valeurs NULL. Les champs vides pour d’autres types de données, tels que INT, sont toujours chargés avec NULL. Les champs vides surviennent lorsque les données contiennent deux délimiteurs de suite sans caractère entre les délimiteurs. EMPTYASNULL et NULL AS ’’ (chaîne vide) entraînent le même comportement.
ENCODING [AS] *file\$1encoding*
Spécifie le type d’encodage des données de chargement. La commande COPY convertit les données de l’encodage spécifié dans UTF-8 pendant le chargement.
Les valeurs valides pour *file\$1encoding* sont les suivantes :
+ `UTF8`
+ `UTF16`
+ `UTF16LE`
+ `UTF16BE`
+ `ISO88591`
La valeur par défaut est `UTF8`.
Les noms de fichier source doivent utiliser l’encodage UTF-8.
Les fichiers suivants doivent utiliser l’encodage UTF-8, même si un autre encodage a été spécifié pour les données de chargement :
+ Fichiers manifestes
+ JSONPaths fichiers
Les chaînes d’arguments fournies avec les paramètres suivants doivent utiliser UTF-8 :
+ FIXEDWIDTH ’*fixedwidth\$1spec*’
+ ACCEPTINVCHARS ’*replacement\$1char*’
+ DATEFORMAT ’*dateformat\$1string*’
+ TIMEFORMAT ’*timeformat\$1string*’
+ NULL AS ’*null\$1string*’
Les fichiers de données de largeur fixe doivent utiliser l’encodage UTF-8. Les largeurs des champs dépendent du nombre de caractères, et non du nombre d’octets.
Toutes les données de chargement doivent utiliser l’encodage spécifié. Si la commande COPY rencontre un autre encodage, elle ignore le fichier et renvoie une erreur.
Si vous spécifiez `UTF16`, vos données doivent comporter une marque d’ordre d’octet. Si vous savez que vos données UTF-16 sont de poids faible (Little endian) ou de poids fort (Big endian), vous pouvez utiliser `UTF16LE` ou `UTF16BE`, indépendamment de la présence d’une marque d’ordre d’octet.
Pour utiliser l’encodage ISO-8859-1, spécifiez `ISO88591`. Pour plus d’informations, consultez [ISO/IEC 8859-1](https://en.wikipedia.org/wiki/ISO/IEC_8859-1) sur *Wikipédia*.
ESCAPE
Lorsque ce paramètre est spécifié, la barre oblique inverse (`\`) dans les données d’entrée est considérée comme un caractère d’échappement. Le caractère qui se trouve immédiatement après la barre oblique inverse est chargé dans la table comme faisant partie de la valeur de la colonne actuelle, même s’il s’agit d’un caractère qui a normalement une fonction particulière. Par exemple, vous pouvez utiliser ce paramètre pour insérer le caractère délimiteur, un guillemet anglais, un caractère de saut de ligne intégré, ou le caractère d’échappement lui-même lorsque l’un de ces caractères fait légitimement partie d’une valeur de la colonne.
Si vous spécifiez le paramètre ESCAPE en liaison avec le paramètre REMOVEQUOTES, vous pouvez insérer et conserver des guillemets doubles (`'` ou `"`) qui peuvent être supprimés dans le cas contraire. La chaîne vide par défaut, `\N`, fonctionne telle quelle, mais elle peut également être insérée dans les données d’entrée en tant que `\\N`. Tant que vous ne spécifiez pas d’autre chaîne nulle avec le paramètre NULL AS, `\N` et `\\N` entraînent les mêmes résultats.
Le caractère de contrôle `0x00` (NUL) ne peut pas être inséré et doit être supprimé des données d’entrée ou converti. Ce caractère est considéré comme une marque de fin d’enregistrement, ce qui entraîne la troncation du reste de l’enregistrement.
Vous ne pouvez pas utiliser le paramètre ESCAPE pour les charges FIXEDWIDTH, et vous ne pouvez pas spécifier le caractère d’échappement lui-même ; il s’agit toujours de la barre oblique inverse. En outre, vous devez vous assurer que les données d’entrée contiennent le caractère d’échappement aux endroits appropriés.
Voici des exemples de données d’entrée et des données chargées résultant de celles-ci lorsque le paramètre ESCAPE est spécifié. Le résultat de la ligne 4 part du principe que le paramètre REMOVEQUOTES est également spécifié. Les données d’entrée se composent de deux champs séparés par une barre verticale :
```
1|The quick brown fox\[newline]
jumped over the lazy dog.
2| A\\B\\C
3| A \| B \| C
4| 'A Midsummer Night\'s Dream'
```
Les données chargées dans la colonne 2 ressemblent à ceci :
```
The quick brown fox
jumped over the lazy dog.
A\B\C
A|B|C
A Midsummer Night's Dream
```
L’application du caractère d’échappement aux données d’entrée pour une charge est de la responsabilité de l’utilisateur, sauf lorsque vous rechargez les données qui ont été précédemment déchargées avec le paramètre ESCAPE. Dans ce cas, les données contiennent déjà les caractères d’échappement nécessaires.
Le paramètre ESCAPE n’interprète pas la notation de séquence d’échappement octale, hexadécimale, Unicode, ou autre. Par exemple, si vos données source contiennent la valeur de saut de ligne octale (`\012`) et que vous essayez de charger ces données avec le paramètre ESCAPE, Amazon Redshift charge la valeur `012` dans la table et ne l’interprète pas comme un saut de ligne qui est en cours d’échappement.
Pour insérer des caractère de saut ligne dans les données qui proviennent de plateformes Microsoft Windows, vous devrez peut-être utiliser deux caractères d’échappement : un pour le retour chariot et un autre pour le saut de ligne. Sinon, vous pouvez supprimer les retours chariot avant de charger le fichier (par exemple, en utilisant l’utilitaire dos2unix).
EXPLICIT\$1IDS
Utilisez EXPLICIT\$1IDS avec des tables ayant des colonnes IDENTITY si vous souhaitez remplacer les valeurs générées automatiquement par des valeurs explicites dans les fichiers de données source pour les tables. Si la commande inclut une liste de colonnes, cette liste doit inclure les colonnes IDENTITY pour utiliser ce paramètre. Le format de données pour les valeurs EXPLICIT\$1IDS doit correspondre au format IDENTITY spécifié par la définition CREATE TABLE.
Lorsque vous exécutez une commande COPY sur une table avec l’option EXPLICIT\$1IDS, Amazon Redshift ne vérifie plus l’unicité des colonnes IDENTITY dans la table.
Si une colonne est définie avec GENERATED BY DEFAULT AS IDENTITY, elle peut être copiée. Les valeurs sont générées ou mises à jour avec des valeurs que vous fournissez. L’option EXPLICIT\$1IDS n’est pas obligatoire. COPY ne met pas à jour le filigrane élevé d’identité.
Pour un exemple de commande COPY utilisant EXPLICIT\$1IDS, consultez [Charger la table VENUE avec des valeurs EXPLICIT pour une colonne IDENTITY](r_COPY_command_examples.md#r_COPY_command_examples-load-venue-with-explicit-values-for-an-identity-column).
FILLRECORD
Autorise le chargement des fichiers de données lorsqu’il manque des colonnes contiguës à la fin de certains des enregistrements. Les colonnes manquantes sont chargées en tant que NULLs. Pour les formats texte et CSV, si la colonne manquante est une colonne VARCHAR, des chaînes de longueur nulle sont chargées à la place de. NULLs Pour charger des colonnes NULLs dans VARCHAR à partir de texte et de CSV, spécifiez le mot clé EMPTYASNULL. La substitution NULL ne fonctionne que si la définition de colonne le permet NULLs.
Par exemple, si la définition de table contient quatre colonnes CHAR qui autorisent la valeur Null, et qu’un enregistrement contient les valeurs `apple, orange, banana, mango`, la commande COPY peut charger et remplir un enregistrement qui contient uniquement les valeurs `apple, orange`. Les valeurs CHAR manquantes seraient chargées en tant que valeurs NULL.
IGNOREBLANKLINES
Ignore les lignes vides qui contiennent uniquement un saut de ligne dans un fichier de données et n’essaie pas de les charger.
IGNOREHEADER [ AS ] *number\$1rows*
Traite les *number\$1rows* spécifiées comme un en-tête de fichier et ne les charge pas. Utilisez IGNOREHEADER pour ignorer les en-têtes de fichier dans tous les fichiers d’une charge parallèle.
NULL AS ’*null\$1string*’
Charge les champs qui mettent en correspondance les *null\$1string* comme NULL, où *null\$1string* peut être une chaîne. Si vos données incluent une marque de fin null, également appelée NUL (UTF-8 0000) ou zéro binaire (0x000), la commande COPY la traite comme tout autre caractère. Par exemple, un enregistrement contenant ’1’ \$1\$1 NUL \$1\$1 ’2’ est copié sous la forme d’une chaîne d’une longueur de 3 octets. Si un champ contient uniquement NUL, vous pouvez utiliser NULL AS pour remplacer la marque de fin null par NULL en spécifiant `'\0'` ou `'\000'`, par exemple, `NULL AS '\0'` ou `NULL AS '\000'`. Si un champ qui contient une chaîne qui se termine par NUL et NULL AS est spécifié, la chaîne est insérée avec NUL à la fin. N’utilisez pas ’\$1n’ (saut de ligne) pour la valeur *null\$1string*. Amazon Redshift réserve ’\$1n’ pour l’utiliser en tant que délimiteur de ligne. La valeur par défaut *null\$1string* est `'\N`’.
Si vous essayez de charger les valeurs null dans une colonne définie comme NOT NULL, la commande COPY échoue.
REMOVEQUOTES
Supprime les guillemets des chaînes dans les données entrantes. Tous les caractères compris entre les guillemets, y compris les délimiteurs, sont conservés. Si une chaîne commence par un guillemet anglais ou des guillemets doubles, sans caractère de fin correspondant, la commande COPY échoue à charger cette ligne et renvoie une erreur. Le tableau suivant présente quelques exemples simples de chaînes contenant des guillemets et les valeurs chargées en conséquence.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/copy-parameters-data-conversion.html)
ROUNDEC
Arrondit les valeurs numériques lorsque l’échelle de la valeur d’entrée est supérieure à l’échelle de la colonne. Par défaut, la commande COPY tronque les valeurs lorsque cela est nécessaire pour s’adapter à l’échelle de la colonne. Par exemple, si une valeur de `20.259` est chargée dans une colonne DECIMAL(8,2), la commande COPY tronque la valeur de `20.25` par défaut. Si ROUNDEC est spécifié, la commande COPY arrondit la valeur de `20.26`. La commande INSERT arrondit toujours les valeurs autant que possible afin de les adapter à l’échelle de la colonne. Une commande COPY avec le paramètre ROUNDEC se comporte donc de la même manière qu’une commande INSERT.
TIMEFORMAT [AS] \$1’*timeformat\$1string*’ \$1 ’auto’ \$1 ’epochsecs’ \$1 ’epochmillisecs’ \$1
Spécifie le format de l’heure. Si aucun TIMEFORMAT n’est spécifié, le format par défaut est `YYYY-MM-DD HH:MI:SS` pour les colonnes TIMESTAMP ou `YYYY-MM-DD HH:MI:SSOF` pour les colonnes TIMESTAMPTZ, `OF` correspondant au décalage par rapport à l’heure UTC (Coordinated Universal Time). Vous ne pouvez pas inclure de spécificateur de fuseau horaire dans *timeformat\$1string*. Pour charger les données TIMESTAMPTZ dont le format est différent du format par défaut, spécifiez « auto ». Pour plus d’informations, consultez [Utilisation de la reconnaissance automatique avec DATEFORMAT et TIMEFORMAT](automatic-recognition.md). Pour plus d’informations sur *timeformat\$1string*, consultez [Chaînes DATEFORMAT et TIMEFORMATExemple](r_DATEFORMAT_and_TIMEFORMAT_strings.md).
L’argument `'auto'` reconnaît plusieurs formats qui ne sont pas pris en charge lors de l’utilisation d’une chaîne DATEFORMAT et TIMEFORMAT. Si la commande COPY ne reconnaît pas le format de vos valeurs de date ou d’heure, ou si vos valeurs de date et d’heure utilisent des formats différents les uns des autres, utilisez l’argument `'auto'` avec le paramètre DATEFORMAT ou TIMEFORMAT. Pour plus d'informations, consultez [Utilisation de la reconnaissance automatique avec DATEFORMAT et TIMEFORMAT](automatic-recognition.md).
Si vos données source sont représentées sous la forme de l’heure d’époque, qui est le nombre de secondes ou de millisecondes depuis le 1er janvier 1970, 00:00:00 UTC, précisez `'epochsecs'` ou `'epochmillisecs'`.
Les mots-clés `'auto'`, `'epochsecs'`, et `'epochmillisecs'` sont sensibles à la casse.
Le mot-clé AS est facultatif.
TRIMBLANKS
Supprime les caractères d’espace vide de fin d’une chaîne VARCHAR. Ce paramètre s’applique uniquement aux colonnes avec un type de données VARCHAR.
TRUNCATECOLUMNS
Tronque les données des colonnes avec le nombre de caractères donné afin qu’il corresponde à la spécification de la colonne. S’applique uniquement aux colonnes avec un type de données VARCHAR ou CHAR et des lignes de 4 Mo ou moins.
# Opérations de chargement de données
Gérez le comportement par défaut de l’opération de chargement pour le dépannage ou pour réduire les temps de chargement en spécifiant les paramètres suivants.
+ [COMPROWS](#copy-comprows)
+ [COMPUPDATE](#copy-compupdate)
+ [IGNOREALLERRORS](#copy-ignoreallerrors)
+ [MAXERROR](#copy-maxerror)
+ [NOLOAD](#copy-noload)
+ [STATUPDATE](#copy-statupdate) Parameters
COMPROWS *numrows*
Permet de spécifier le nombre de lignes à utiliser comme taille d’échantillon pour l’analyse de la compression. L’analyse est exécutée sur les lignes de chaque tranche de données. Par exemple, si vous spécifiez `COMPROWS 1000000` (1 000 000) et que le système contient quatre sections totales, pas plus de 250 000 lignes par section sont lues et analysées.
Si le paramètre COMPROWS n’est pas spécifié, la taille de l’échantillon par défaut est de 100 000 par tranche. Les valeurs du paramètre COMPROWS inférieures à la valeur par défaut de 100 000 lignes par tranche sont automatiquement mises à niveau vers la valeur par défaut. Toutefois, la compression automatique n’aura pas lieu si la quantité de données en cours de chargement n’est pas suffisante pour produire un échantillon représentatif.
Si le nombre défini pour le paramètre COMPROWS dépasse le nombre de lignes dans le fichier d’entrée, la commande COPY produit et exécute toujours l’analyse de la compression sur toutes les lignes disponibles. La plage acceptée pour cet argument est un nombre compris entre 1000 et 2147483647 (2 147 483 647).
COMPUPDATE [ PRESET \$1 \$1 ON \$1 TRUE \$1 \$1 \$1 OFF \$1 FALSE \$1 ]
Permet de contrôler si les encodages de compression sont appliqués automatiquement pendant une exécution de la commande COPY.
Lorsque COMPUPDATE utilise PRESET, la commande COPY choisit l’encodage de compression pour chaque colonne si la table de la cible est vide, même si les colonnes ont déjà des encodages autres que RAW. Les encodages de colonne actuellement spécifiés peuvent être remplacés. L’encodage de chaque colonne est basé sur le type de données de la colonne. Aucune donnée échantillonnée. Amazon Redshift attribue automatiquement l’encodage de compression comme suit :
+ Les colonnes qui sont définies comme des clés de tri se voient attribuer une compression RAW.
+ Les colonnes qui sont définies comme des types de données BOOLEAN, REAL ou DOUBLE PRECISION se voient attribuer une compression RAW.
+ Les colonnes définies comme SMALLINT, INTEGER, BIGINT, DECIMAL, DATE, TIMESTAMP ou TIMESTAMPTZ sont compressées. AZ64
+ Les colonnes définies comme CHAR ou VARCHAR sont affectées à la compression LZO.
Lorsque COMPUPDATE est omis, la commande COPY choisit l’encodage de compression pour chaque colonne uniquement si la table de la cible est vide et si vous n’avez pas spécifié d’encodage (autre que BRUT) pour les colonnes. L’encodage pour chaque colonne est déterminé par Amazon Redshift. Aucune donnée échantillonnée.
Lorsque le paramètre COMPUPDATE est défini sur ON (ou TRUE) ou que le paramètre COMPUPDATE est spécifié sans une option, la commande COPY applique la compression automatique si la table est vide, même si les colonnes de la table contiennent déjà des encodages autres que RAW. Les encodages de colonne actuellement spécifiés peuvent être remplacés. L’encodage de chaque colonne est basé sur une analyse des exemples de données. Pour plus d'informations, consultez [Chargement des tables avec compression automatique](c_Loading_tables_auto_compress.md).
Lorsque le paramètre COMPUPDATE est défini sur OFF (ou FALSE), la compression automatique est désactivée. Les encodages de colonne ne sont pas modifiés.
Pour plus de détails sur la table système utilisée pour analyser la compression, consultez [STL\$1ANALYZE\$1COMPRESSION](r_STL_ANALYZE_COMPRESSION.md).
IGNOREALLERRORS
Vous pouvez spécifier cette option pour ignorer toutes les erreurs qui se produisent pendant l’opération de chargement.
Vous ne pouvez pas spécifier l’option IGNOREALLERRORS si vous spécifiez l’option MAXERROR. Vous ne pouvez pas spécifier l’option IGNOREALLERRORS pour les formats de données en colonnes tels que ORC et Parquet.
MAXERROR [AS] *error\$1count*
Si la charge renvoie le nombre d’erreurs *error\$1count* ou un nombre supérieur, la charge échoue. Si la charge renvoie moins d’erreurs, elle continue et renvoie un message INFO qui indique le nombre de lignes qui n’a pas pu être chargé. Utilisez ce paramètre pour permettre aux charges de continuer lorsque certaines lignes échouent à se charger dans la table en raison d’erreurs de mise en forme ou d’autres incohérences dans les données.
Définissez cette valeur sur `0` ou `1` si vous voulez que la charge échoue dès que la première erreur se produit. Le mot-clé AS est facultatif. La valeur par défaut MAXERROR est `0` et la limite est `100000`.
Le nombre d’erreurs réel signalé peut être supérieur à la valeur du paramètre MAXERROR spécifié en raison de la nature parallèle d’Amazon Redshift. Si un nœud dans le cluster Amazon Redshift détecte que la valeur du paramètre MAXERROR a été dépassée, chaque nœud indique toutes les erreurs qu’il a rencontrées.
NOLOAD
Permet de vérifier la validité du fichier de données sans réellement charger les données. Utilisez le paramètre NOLOAD pour vous assurer que votre fichier de données se charge sans erreur avant d’exécuter la charge de données réelle. L’exécution de COPY avec le paramètre NOLOAD est beaucoup plus rapide que le chargement des données, car il analyse uniquement les fichiers.
STATUPDATE [ \$1 ON \$1 TRUE \$1 \$1 \$1 OFF \$1 FALSE \$1 ]
Permet de définir le calcul automatique et l’actualisation des statistiques de l’optimiseur à la fin d’une commande COPY réussie. Par défaut, si le paramètre STATUPDATE n’est pas utilisé, les statistiques sont mises à jour automatiquement si la table est initialement vide.
Chaque fois qu’une intégration de données dans une table non vide modifie considérablement la taille de la table, nous recommandons la mise à jour des statistiques en exécutant une commande [ANALYSE](r_ANALYZE.md) ou en utilisant l’argument STATUPDATE ON.
Avec le paramètre STATUPDATE ON (ou TRUE), les statistiques sont mises à jour automatiquement, que la table soit initialement vide ou non. Si le paramètre STATUPDATE est utilisé, l’utilisateur actuel doit être soit propriétaire de la table soit un super-utilisateur. Si le paramètre STATUPDATE n’est pas spécifié, seule l’autorisation INSERT est obligatoire.
Avec le paramètre STATUPDATE OFF (ou FALSE), les statistiques ne sont jamais mises à jour.
Pour plus d’informations, consultez [Analyse des tables](t_Analyzing_tables.md).
# Liste alphabétique des paramètres
La liste suivante fournit des liens vers chaque description du paramètre de commande COPY, par ordre alphabétique.
+ [ACCEPTANYDATE](copy-parameters-data-conversion.md#copy-acceptanydate)
+ [ACCEPTINVCHARS](copy-parameters-data-conversion.md#copy-acceptinvchars)
+ [Utilisation de ACCESS\$1KEY\$1ID et SECRET\$1ACCESS\$1KEY](copy-parameters-authorization.md#copy-access-key-id-access)
+ [AVRO](copy-parameters-data-format.md#copy-avro)
+ [BLANKSASNULL](copy-parameters-data-conversion.md#copy-blanksasnull)
+ [BZIP2](copy-parameters-file-compression.md#copy-bzip2)
+ [COMPROWS](copy-parameters-data-load.md#copy-comprows)
+ [COMPUPDATE](copy-parameters-data-load.md#copy-compupdate)
+ [CREDENTIALS](copy-parameters-authorization.md#copy-credentials-cred)
+ [CSV](copy-parameters-data-format.md#copy-csv)
+ [DATEFORMAT](copy-parameters-data-conversion.md#copy-dateformat)
+ [DELIMITER](copy-parameters-data-format.md#copy-delimiter)
+ [EMPTYASNULL](copy-parameters-data-conversion.md#copy-emptyasnull)
+ [ENCODING](copy-parameters-data-conversion.md#copy-encoding)
+ [ENCRYPTED](copy-parameters-data-source-s3.md#copy-encrypted)
+ [ESCAPE](copy-parameters-data-conversion.md#copy-escape)
+ [EXPLICIT_IDS](copy-parameters-data-conversion.md#copy-explicit-ids)
+ [FILLRECORD](copy-parameters-data-conversion.md#copy-fillrecord)
+ [FIXEDWIDTH](copy-parameters-data-format.md#copy-fixedwidth)
+ [FORMAT](copy-parameters-data-format.md#copy-format)
+ [FROM](copy-parameters-data-source-s3.md#copy-parameters-from)
+ [GZIP](copy-parameters-file-compression.md#copy-gzip)
+ [IAM\$1ROLE](copy-parameters-authorization.md#copy-iam-role-iam)
+ [IGNOREALLERRORS](copy-parameters-data-load.md#copy-ignoreallerrors)
+ [IGNOREBLANKLINES](copy-parameters-data-conversion.md#copy-ignoreblanklines)
+ [IGNOREHEADER](copy-parameters-data-conversion.md#copy-ignoreheader)
+ [JSON format for COPY](copy-parameters-data-format.md#copy-json)
+ [LZOP](copy-parameters-file-compression.md#copy-lzop)
+ [MANIFEST](copy-parameters-data-source-s3.md#copy-manifest)
+ [MASTER_SYMMETRIC_KEY](copy-parameters-data-source-s3.md#copy-master-symmetric-key)
+ [MAXERROR](copy-parameters-data-load.md#copy-maxerror)
+ [NOLOAD](copy-parameters-data-load.md#copy-noload)
+ [NULL AS](copy-parameters-data-conversion.md#copy-null-as)
+ [READRATIO](copy-parameters-data-source-dynamodb.md#copy-readratio)
+ [REGION](copy-parameters-data-source-s3.md#copy-region)
+ [REMOVEQUOTES](copy-parameters-data-conversion.md#copy-removequotes)
+ [ROUNDEC](copy-parameters-data-conversion.md#copy-roundec)
+ [SESSION\$1TOKEN](copy-parameters-authorization.md#copy-token)
+ [SHAPEFILE](copy-parameters-data-format.md#copy-shapefile)
+ [SSH](copy-parameters-data-source-ssh.md#copy-ssh)
+ [STATUPDATE](copy-parameters-data-load.md#copy-statupdate)
+ [TIMEFORMAT](copy-parameters-data-conversion.md#copy-timeformat)
+ [TRIMBLANKS](copy-parameters-data-conversion.md#copy-trimblanks)
+ [TRUNCATECOLUMNS](copy-parameters-data-conversion.md#copy-truncatecolumns)
+ [ZSTD](copy-parameters-file-compression.md#copy-zstd)
# Notes d’utilisation
**Topics**
+ [
# Autorisations d'accès à d'autres AWS ressources
](copy-usage_notes-access-permissions.md)
+ [
# Utilisation de COPY avec des alias de point d’accès Amazon S3
](copy-usage_notes-s3-access-point-alias.md)
+ [
# Chargement de données multioctets à partir d’Amazon S3
](copy-usage_notes-multi-byte.md)
+ [
# Chargement d’une colonne avec le type de données GEOMETRY ou GEOGRAPHY
](copy-usage_notes-spatial-data.md)
+ [
# Chargement du type de données HLLSKETCH
](copy-usage_notes-hll.md)
+ [
# Chargement d’une colonne avec le type de données VARBYTE
](copy-usage-varbyte.md)
+ [
# Erreurs survenant lors de la lecture de plusieurs fichiers
](copy-usage_notes-multiple-files.md)
+ [
# Exécution de la commande COPY à partir du format JSON
](copy-usage_notes-copy-from-json.md)
+ [
# COPY depuis les formats de données en colonnes
](copy-usage_notes-copy-from-columnar.md)
+ [
# Chaînes DATEFORMAT et TIMEFORMAT
](r_DATEFORMAT_and_TIMEFORMAT_strings.md)
+ [
# Utilisation de la reconnaissance automatique avec DATEFORMAT et TIMEFORMAT
](automatic-recognition.md)
# Autorisations d'accès à d'autres AWS ressources
Pour déplacer des données entre votre cluster et une autre AWS ressource, telle qu'Amazon S3, Amazon DynamoDB, Amazon EMR ou Amazon EC2, votre cluster doit être autorisé à accéder à la ressource et à effectuer les actions nécessaires. Par exemple, pour charger des données depuis Amazon S3, la commande COPY doit disposer de l’accès LIST au compartiment et de l’accès GET pour les objets du compartiment. Pour plus d’informations sur les autorisations minimales, consultez [Autorisations IAM pour les commandes COPY, UNLOAD et CREATE LIBRARY](#copy-usage_notes-iam-permissions).
Pour obtenir l’autorisation d’accéder à la ressource, votre cluster doit être authentifié. Vous pouvez choisir l’une des méthodes d’authentification suivantes :
+ [Contrôle d’accès basé sur les rôles](#copy-usage_notes-access-role-based)— Pour le contrôle d'accès basé sur les rôles, vous spécifiez un rôle Gestion des identités et des accès AWS (IAM) que votre cluster utilise pour l'authentification et l'autorisation. Pour protéger vos AWS informations d'identification et vos données sensibles, nous vous recommandons vivement d'utiliser l'authentification basée sur les rôles.
+ [Contrôle d’accès basé sur les clés](#copy-usage_notes-access-key-based)— Pour le contrôle d'accès par clé, vous fournissez les informations d' AWS accès (ID de clé d'accès et clé d'accès secrète) d'un utilisateur sous forme de texte brut.
## Contrôle d’accès basé sur les rôles
Avec un contrôle d’accès basé sur les rôles, votre cluster assume temporairement un rôle IAM en votre nom. Puis, selon les autorisations accordées au rôle, votre cluster peut accéder aux ressources AWS requises.
La création d’un *rôle* IAM est similaire à l’octroi d’autorisations à un utilisateur, car il s’agit d’une identité AWS avec des politiques d’autorisation qui déterminent ce que l’identité peut et ne peut pas faire dans AWS. En revanche, plutôt que d’être associé de manière unique à un utilisateur, un rôle peut être assumé par toute entité le nécessitant. En outre, aucune information d’identification (mot de passe ou clés d’accès) n’est associée à celui-ci. Au lieu de cela, si un rôle est associé à un cluster, les clés d’accès sont créées de manière dynamique et fournies au cluster.
Nous vous recommandons d'utiliser le contrôle d'accès basé sur les rôles, car il permet un contrôle plus sûr et plus précis de l'accès aux AWS ressources et aux données utilisateur sensibles, en plus de protéger vos informations d'identification. AWS
L’authentification basée sur les rôles offre les avantages suivants :
+ Vous pouvez utiliser les outils IAM AWS standard pour définir un rôle IAM et l'associer à plusieurs clusters. Lorsque vous modifiez la stratégie d’accès d’un rôle, les modifications sont automatiquement appliquées à tous les clusters qui utilisent ce rôle.
+ Vous pouvez définir des politiques IAM détaillées qui accordent des autorisations à des clusters et à des utilisateurs de base de données spécifiques pour accéder à des AWS ressources et à des actions spécifiques.
+ Votre cluster obtient les informations d’identification de séance temporaires au moment de l’exécution et les actualise en fonction des besoins jusqu’à la fin de l’opération. Si vous utilisez les informations d’identification temporaires basées sur la clé, l’opération échoue si celles-ci expirent avant la fin.
+ Votre ID de clé d’accès et ID de clé d’accès secrète ne sont pas stockés ou transmis dans votre code SQL.
Pour utiliser le contrôle d’accès basé sur les rôles, vous devez d’abord créer un rôle IAM à l’aide du type de rôle de service Amazon Redshift, puis attacher le rôle à votre cluster. Le rôle doit avoir, au minimum, les autorisations répertoriées dans [Autorisations IAM pour les commandes COPY, UNLOAD et CREATE LIBRARY](#copy-usage_notes-iam-permissions). Pour savoir comment créer un rôle IAM et l'associer à votre cluster, consultez la section [Autoriser Amazon Redshift à accéder à AWS d'autres services en votre nom dans le guide](https://docs.aws.amazon.com/redshift/latest/mgmt/authorizing-redshift-service.html) de gestion Amazon *Redshift*.
Vous pouvez ajouter un rôle à un cluster ou afficher les rôles associés à un cluster à l’aide de la console de gestion, de la CLI ou de l’API Amazon Redshift. Pour plus d’informations, consultez [Associer un rôle IAM à un cluster](https://docs.aws.amazon.com/redshift/latest/mgmt/copy-unload-iam-role.html) dans le *Guide de gestion Amazon Redshift*.
Lorsque vous créez un rôle IAM, IAM renvoie un Amazon Resource Name (ARN) pour le rôle. Pour spécifier un rôle IAM, indiquez l’ARN de rôle avec le paramètre [Utilisation du paramètre IAM\$1ROLE](copy-parameters-authorization.md#copy-iam-role) ou le paramètre [Utilisation du paramètre CREDENTIALS](copy-parameters-authorization.md#copy-credentials).
Par exemple, supposons que le rôle suivant est attaché au cluster.
```
"IamRoleArn": "arn:aws:iam::0123456789012:role/MyRedshiftRole"
```
L’exemple suivant de commande COPY utilise le paramètre IAM\$1ROLE avec l’ARN dans l’exemple précédent pour l’authentification et l’accès à Amazon S3.
```
copy customer from 's3://amzn-s3-demo-bucket/mydata'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole';
```
L’exemple suivant de commande COPY utilise le paramètre CREDENTIALS pour spécifier le rôle IAM.
```
copy customer from 's3://amzn-s3-demo-bucket/mydata'
credentials
'aws_iam_role=arn:aws:iam::0123456789012:role/MyRedshiftRole';
```
En outre, un super-utilisateur peut accorder le privilège ASSUMEROLE à des utilisateurs et groupes de base de données afin de fournir l’accès à un rôle pour les opérations COPY. Pour plus d'informations, consultez [GRANT](r_GRANT.md).
## Contrôle d’accès basé sur les clés
Avec le contrôle d'accès basé sur les clés, vous fournissez l'ID de clé d'accès et la clé d'accès secrète à un utilisateur IAM autorisé à accéder aux AWS ressources contenant les données. Vous pouvez utiliser les paramètres [Utilisation des paramètres ACCESS\$1KEY\$1ID et SECRET\$1ACCESS\$1KEY](copy-parameters-authorization.md#copy-access-key-id) ensemble ou le paramètre [Utilisation du paramètre CREDENTIALS](copy-parameters-authorization.md#copy-credentials).
**Note**
Nous vous recommandons vivement d’utiliser un rôle IAM pour l’authentification au lieu de fournir une clé d’accès secrète et un ID de clé d’accès en texte brut. Si vous optez pour le contrôle d'accès par clé, n'utilisez jamais les informations d'identification de votre AWS compte (root). Créez toujours un utilisateur IAM et fournissez l’ID de clé d’accès et la clé d’accès secrète de cet utilisateur. Pour connaître les étapes à suivre pour créer un utilisateur IAM, consultez [Création d’un utilisateur IAM dans votre compte AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_create.html).
Pour vous authentifier à l'aide de ACCESS\$1KEY\$1ID et SECRET\$1ACCESS\$1KEY, remplacez et par l'ID de clé d'accès ** et la clé ** d'accès secrète complète d'un utilisateur autorisé, comme indiqué ci-dessous.
```
ACCESS_KEY_ID ''
SECRET_ACCESS_KEY '';
```
Pour vous authentifier à l'aide du paramètre CREDENTIALS, remplacez ** et ** par l'ID de clé d'accès d'un utilisateur autorisé et la clé d'accès secrète complète, comme indiqué ci-dessous.
```
CREDENTIALS
'aws_access_key_id=;aws_secret_access_key=';
```
L’utilisateur IAM doit avoir, au minimum, les autorisations répertoriées dans [Autorisations IAM pour les commandes COPY, UNLOAD et CREATE LIBRARY](#copy-usage_notes-iam-permissions).
### informations d’identification de sécurité temporaires
Si vous utilisez un contrôle d’accès basé sur la clé, vous pouvez limiter davantage l’accès dont disposent les utilisateurs à vos données en utilisant des informations d’identification de sécurité temporaires. L’authentification basée sur les rôles utilise automatiquement des informations d’identification temporaires.
**Note**
Nous vous recommandons vivement d’utiliser [role-based access control](#copy-usage_notes-access-role-based.phrase) plutôt que de créer des identifiants temporaires et de fournir un ID de clé d’accès et une clé d’accès secrète sous forme de texte brut. Le contrôle d’accès basé sur les rôles utilise automatiquement des informations d’identification temporaires.
Les informations d’identification de sécurité temporaires offrent une sécurité améliorée parce qu’elles sont de courte durée et ne peuvent pas être réutilisées après leur expiration. L’ID de clé d’accès et la clé d’accès secrète générés avec le jeton ne peuvent pas être utilisés sans le jeton et un utilisateur qui dispose de ces informations d’identification de sécurité temporaires peut accéder à vos ressources uniquement jusqu’à ce que les informations d’identification expirent.
Pour accorder aux utilisateurs un accès temporaire à vos ressources, vous devez appeler les opérations d'API AWS Security Token Service (AWS STS). Les opérations AWS STS d'API renvoient des informations d'identification de sécurité temporaires composées d'un jeton de sécurité, d'un identifiant de clé d'accès et d'une clé d'accès secrète. Vous pouvez délivrer des informations d’identification de sécurité temporaires aux utilisateurs qui doivent accéder temporairement à vos ressources. Ces utilisateurs peuvent être des utilisateurs IAM existants, ou bien ils peuvent être des utilisateurs non-AWS . Pour plus d’informations sur les informations d’identification de sécurité temporaires, consultez [Informations d’identification de sécurité temporaires](https://docs.aws.amazon.com/STS/latest/UsingSTS/Welcome.html) dans le Guide de l’utilisateur IAM.
Vous pouvez utiliser les paramètres [Utilisation des paramètres ACCESS\$1KEY\$1ID et SECRET\$1ACCESS\$1KEY](copy-parameters-authorization.md#copy-access-key-id) ensemble avec le paramètre [SESSION\$1TOKEN](copy-parameters-authorization.md#copy-token) ou le paramètre [Utilisation du paramètre CREDENTIALS](copy-parameters-authorization.md#copy-credentials). Vous devez également fournir l’ID de clé d’accès et la clé d’accès secrète qui ont été fournis avec le jeton.
Pour vous authentifier à l'aide de ACCESS\$1KEY\$1ID, SECRET\$1ACCESS\$1KEY et SESSION\$1TOKEN, remplacez et comme indiqué ci-dessous. ** ** **
```
ACCESS_KEY_ID ''
SECRET_ACCESS_KEY ''
SESSION_TOKEN '';
```
Pour vous authentifier à l’aide de CREDENTIALS, ajoutez `session_token=` dans la chaîne d’informations d’identification, comme indiqué ci-après.
```
CREDENTIALS
'aws_access_key_id=;aws_secret_access_key=;session_token=';
```
Une commande COPY avec des informations d’identification de sécurité temporaires est indiquée dans l’exemple suivant.
```
copy table-name
from 's3://objectpath'
access_key_id ''
secret_access_key ''
session_token '';
```
L’exemple suivant charge la table LISTING à l’aide des informations d’identification temporaires et de chiffrement de fichier.
```
copy listing
from 's3://amzn-s3-demo-bucket/data/listings_pipe.txt'
access_key_id ''
secret_access_key ''
session_token ''
master_symmetric_key ''
encrypted;
```
L’exemple suivant charge la table LISTING à l’aide du paramètre CREDENTIALS avec des informations d’identification temporaires et de chiffrement de fichier.
```
copy listing
from 's3://amzn-s3-demo-bucket/data/listings_pipe.txt'
credentials
'aws_access_key_id=;aws_secret_access_key=;session_token=;master_symmetric_key='
encrypted;
```
**Important**
Les informations d’identification de sécurité temporaires doivent être valides pour toute la durée de l’opération COPY ou UNLOAD. Si les informations d’identification de sécurité temporaires arrivent à expiration au cours de l’opération, la commande échoue et la transaction est annulée. Par exemple, si les informations d’identification de sécurité temporaires expirent au bout de 15 minutes et que l’opération COPY dure une heure, cette dernière échouera avant d’être terminée. Si vous utilisez l’accès basé sur les rôles, les informations d’identification de sécurité temporaires sont automatiquement actualisées jusqu’à la fin de l’opération.
## Autorisations IAM pour les commandes COPY, UNLOAD et CREATE LIBRARY
Le rôle IAM ou l’utilisateur référencé par le paramètre CREDENTIALS doit disposer, au minimum, des autorisations suivantes :
+ Pour exécuter la commande COPY depuis Amazon S3, l’autorisation d’exécuter LIST sur le compartiment Amazon S3 et d’exécuter GET sur les objets Amazon S3 en cours de chargement, ainsi que le fichier manifeste, le cas échéant.
+ Pour COPIER depuis Amazon S3, Amazon EMR et des hôtes distants (SSH) avec des données au format JSON, autorisation de LISTER et d'OBTENIR le fichier sur JSONPaths Amazon S3, le cas échéant.
+ Pour exécuter la commande COPY depuis DynamoDB, l’autorisation d’exécuter SCAN et DESCRIBE sur la table DynamoDB qui est en cours de chargement.
+ Pour exécuter la commande COPY depuis un cluster Amazon EMR, l’autorisation pour l’action `ListInstances` sur le cluster Amazon EMR.
+ Pour exécuter la commande UNLOAD sur Amazon S3, les autorisations d’exécuter GET, LIST et PUT pour le compartiment Amazon S3 vers lequel les fichiers de données sont en cours de déchargement.
+ Pour exécuter la commande CREATE LIBRARY depuis Amazon S3, l’autorisation d’exécuter LIST sur le compartiment Amazon S3 et d’exécuter GET sur les objets Amazon S3 qui sont importés
**Note**
Si vous recevez le message d’erreur `S3ServiceException: Access Denied`, lorsque vous exécutez une commande COPY, UNLOAD ou CREATE LIBRARY, votre cluster ne dispose pas des autorisations d’accès appropriées pour Amazon S3.
Vous pouvez gérer les autorisations IAM en attachant une politique IAM à un rôle IAM attaché à votre cluster, à votre utilisateur ou au groupe auquel appartient votre utilisateur. Par exemple, la politique gérée par `AmazonS3ReadOnlyAccess` accorde les autorisations LIST et GET aux ressources Amazon S3. Pour plus d’informations sur les politiques IAM, consultez [Gestion des politiques IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage.html) dans le *Guide de l’utilisateur IAM*.
# Utilisation de COPY avec des alias de point d’accès Amazon S3
COPY prend en charge les alias de point d’accès Amazon S3. Pour plus d’informations, consultez [Utilisation d’un alias de type compartiment pour votre point d’accès](https://docs.aws.amazon.com/AmazonS3/latest/userguide/access-points-alias.html) dans le *Guide de l’utilisateur Amazon Simple Storage Service*.
# Chargement de données multioctets à partir d’Amazon S3
Si vos données incluent des caractères non-ASCII codés sur plusieurs octets (par exemple, les caractères chinois ou cyrilliques), vous devez charger les données dans des colonnes VARCHAR. Le type de données VARCHAR prend en charge les caractères UTF-8 codés sur quatre octets, mais le type de données CHAR n’accepte que les caractères ASCII codés sur un octet. Vous ne pouvez pas charger de caractères codés sur cinq octets ou plus dans des tables Amazon Redshift. Pour plus d'informations, consultez [Caractères multioctets](c_Supported_data_types.md#c_Supported_data_types-multi-byte-characters).
# Chargement d’une colonne avec le type de données GEOMETRY ou GEOGRAPHY
Vous ne pouvez exécuter la commande COPY vers des colonnes `GEOMETRY` ou `GEOGRAPHY` qu’à partir de données d’un fichier texte séparé par des caractères, tel qu’un fichier CSV. Les données doivent être sous la forme hexadécimale du format well-known binary (WKB ou EWKB) ou du format well-known text (WKT ou EWKT) et correspondre à la taille maximale d’une ligne d’entrée unique à la commande COPY. Pour plus d'informations, consultez [COPY](r_COPY.md).
Pour plus d’informations sur la façon de charger à partir d’un fichier de formes, consultez [Chargement d’un shapefile dans Amazon Redshift](spatial-copy-shapefile.md).
Pour plus d’informations sur le type de données `GEOMETRY` ou `GEOGRAPHY`, consultez [Interrogation des données spatiales dans Amazon Redshift](geospatial-overview.md).
# Chargement du type de données HLLSKETCH
Vous pouvez copier les esquisses HLL uniquement dans un format fragmenté ou dense pris en charge par Amazon Redshift. Pour utiliser la commande COPY sur HyperLogLog des esquisses, utilisez le format Base64 pour les HyperLogLog esquisses denses et le format JSON pour les esquisses clairsemées. HyperLogLog Pour de plus amples informations, veuillez consulter [HyperLogLog fonctions](hyperloglog-functions.md).
L’exemple suivant importe les données d’un fichier CSV dans une table à l’aide des commandes CREATE TABLE et COPY. Tout d’abord, l’exemple crée la table `t1` à l’aide de la commande CREATE TABLE.
```
CREATE TABLE t1 (sketch hllsketch, a bigint);
```
Ensuite, il utilise la commande COPY pour importer des données d’un fichier CSV dans la table `t1`.
```
COPY t1 FROM s3://amzn-s3-demo-bucket/unload/' IAM_ROLE 'arn:aws:iam::0123456789012:role/MyRedshiftRole' NULL AS 'null' CSV;
```
# Chargement d’une colonne avec le type de données VARBYTE
Vous pouvez charger des données à partir d’un fichier au format CSV, Parquet et ORC. Pour CSV, les données sont chargées à partir d’un fichier en représentation hexadécimale des données VARBYTE. Vous ne pouvez pas charger les données VARBYTE avec l’option `FIXEDWIDTH`. L’option `ADDQUOTES` ou `REMOVEQUOTES` de COPY n’est pas prise en charge. Une colonne VARBYTE ne peut pas être utilisée comme colonne de partition.
# Erreurs survenant lors de la lecture de plusieurs fichiers
La commande COPY est atomique et transactionnelle. En d’autres termes, même lorsque la commande COPY lit des données de plusieurs fichiers, l’ensemble du processus est considéré comme une seule opération. Si la commande COPY rencontre une erreur de lecture d’un fichier, elle refait automatiquement des tentatives jusqu’à ce que le processus expire (voir [statement\$1timeout](r_statement_timeout.md)) ou si les données ne peuvent pas être téléchargées depuis Amazon S3 pendant une période prolongée (entre 15 et 30 minutes), en s’assurant que chaque fichier est chargé une seule fois. En cas d’échec de la commande COPY, l’ensemble de la transaction est annulé et toutes les modifications sont annulées. Pour plus d’informations sur la gestion des erreurs de chargement, consultez [Résolution des problèmes de chargement de données](t_Troubleshooting_load_errors.md).
Une fois qu’une commande COPY est lancée avec succès, elle n’échoue pas si la séance s’arrête, par exemple lorsque le client se déconnecte. Toutefois, si la commande COPY se trouve dans bloc de transaction BEGIN … END qui ne se termine pas, car la séance s’arrête, toute la transaction, y compris la commande COPY, est annulée. Pour plus d’informations sur les transactions, consultez [BEGIN](r_BEGIN.md).
# Exécution de la commande COPY à partir du format JSON
La structure des données JSON se compose d’un ensemble d’objets ou de tableaux. Un *objet* JSON commence et finit par des accolades, et contient une collection non ordonnée de paires nom-valeur. Chaque paire de nom et de valeur est séparée par deux points, et les paires sont séparées par des virgules. Le nom est une chaîne entre guillemets doubles. Les guillemets doivent être des guillemets simples (0x22), ni culbutés, ni courbes.
Un *tableau* JSON commence et finit par des crochets, et contient une collection ordonnée de valeurs séparées par des virgules. Une valeur peut être une chaîne comprise entre des guillemets doubles, un nombre, une valeur booléenne true ou false, null, un objet JSON ou tableau.
Les tableaux et objets JSON peuvent être imbriqués, ce qui permet d’obtenir une structure de données hiérarchique. L’exemple suivant illustre une structure de données JSON avec deux objets valides.
```
{
"id": 1006410,
"title": "Amazon Redshift Database Developer Guide"
}
{
"id": 100540,
"name": "Amazon Simple Storage Service User Guide"
}
```
L’exemple suivant illustre les mêmes données sous forme de deux tableaux JSON.
```
[
1006410,
"Amazon Redshift Database Developer Guide"
]
[
100540,
"Amazon Simple Storage Service User Guide"
]
```
## Options COPY pour JSON
Vous pouvez spécifier les options suivantes lorsque vous utilisez la commande COPY avec des données au format JSON :
+ `'auto' ` – La commande COPY charge automatiquement les champs à partir du fichier JSON.
+ `'auto ignorecase'` – La commande COPY charge automatiquement les champs à partir du fichier JSON tout en ignorant la casse des noms de champs.
+ `s3://jsonpaths_file`— COPY utilise un JSONPaths fichier pour analyser les données source JSON. Un *JSONPaths fichier* est un fichier texte qui contient un seul objet JSON dont le nom est `"jsonpaths"` associé à un tableau d' JSONPath expressions. Si le nom est une chaîne autre que`"jsonpaths"`, COPY utilise l'`'auto'`argument au lieu du JSONPaths fichier.
Pour des exemples montrant comment charger des données à l'aide de `'auto'``'auto ignorecase'`, ou d'un JSONPaths fichier, et à l'aide d'objets ou de tableaux JSON, consultez[Copier à partir d’exemples JSON](r_COPY_command_examples.md#r_COPY_command_examples-copy-from-json).
## JSONPath option
Dans la syntaxe COPY d'Amazon Redshift, une JSONPath expression indique le chemin explicite vers un élément de nom unique dans une structure de données hiérarchique JSON, en utilisant soit la notation entre crochets, soit la notation par points. Amazon Redshift ne prend en charge aucun JSONPath élément, tel que les caractères génériques ou les expressions de filtre, susceptibles de donner lieu à un chemin ambigu ou à plusieurs éléments de nom. Par conséquent, Amazon Redshift ne peut pas analyser des structures de données complexes, à plusieurs niveaux.
Voici un exemple de JSONPaths fichier contenant des JSONPath expressions utilisant la notation entre crochets. Le symbole du dollar (\$1) représente la structure de niveau racine.
```
{
"jsonpaths": [
"$['id']",
"$['store']['book']['title']",
"$['location'][0]"
]
}
```
Dans l’exemple précédent, `$['location'][0]` fait référence au premier élément d’un tableau. JSON utilise l’indexation de tableau de base zéro. Les index du tableau doivent être des nombres entiers positifs (supérieurs ou égaux à zéro).
L'exemple suivant montre le JSONPaths fichier précédent en utilisant la notation par points.
```
{
"jsonpaths": [
"$.id",
"$.store.book.title",
"$.location[0]"
]
}
```
Vous ne pouvez pas combiner la notation d’accolades et la notation de points dans le tableau `jsonpaths`. Les accolades peuvent être utilisées dans la notation d’accolades et la notation de points pour faire référence à un élément du tableau.
Lorsque vous utilisez la notation par points, les JSONPath expressions ne peuvent pas contenir les caractères suivants :
+ Guillemet anglais (’)
+ Point ( . )
+ Crochets ([ ]), sauf pour faire référence à un élément de tableau
Si la valeur de la paire nom-valeur référencée par une JSONPath expression est un objet ou un tableau, l'objet ou le tableau entier est chargé sous forme de chaîne, y compris les accolades. Par exemple, supposons que vos données JSON contiennent l’objet suivant.
```
{
"id": 0,
"guid": "84512477-fa49-456b-b407-581d0d851c3c",
"isActive": true,
"tags": [
"nisi",
"culpa",
"ad",
"amet",
"voluptate",
"reprehenderit",
"veniam"
],
"friends": [
{
"id": 0,
"name": "Martha Rivera"
},
{
"id": 1,
"name": "Renaldo"
}
]
}
```
L' JSONPath expression renvoie `$['tags']` ensuite la valeur suivante.
```
"["nisi","culpa","ad","amet","voluptate","reprehenderit","veniam"]"
```
L' JSONPath expression renvoie `$['friends'][1]` ensuite la valeur suivante.
```
"{"id": 1,"name": "Renaldo"}"
```
Chaque JSONPath expression du `jsonpaths` tableau correspond à une colonne de la table cible Amazon Redshift. L’ordre des éléments du tableau `jsonpaths` doit correspondre à celui des colonnes de la table cible ou de la liste de colonnes, si une liste de colonnes est utilisée.
Pour des exemples montrant comment charger des données à l'aide de l'`'auto'`argument ou d'un JSONPaths fichier, et à l'aide d'objets ou de tableaux JSON, consultez[Copier à partir d’exemples JSON](r_COPY_command_examples.md#r_COPY_command_examples-copy-from-json).
Pour plus d’informations sur la copie de plusieurs fichiers JSON, consultez [Utilisation d’un manifeste pour spécifier les fichiers de données](loading-data-files-using-manifest.md).
## Caractères d’échappement dans JSON
La commande COPY charge `\n` comme un caractère de saut de ligne et charge `\t` comme un caractère de tabulation. Pour charger une barre oblique inverse, précédez-la d’une barre oblique inverse ( `\\` ).
Par exemple, supposons que le JSON suivant se trouve dans un fichier nommé `escape.json` dans le compartiment `s3://amzn-s3-demo-bucket/json/`.
```
{
"backslash": "This is a backslash: \\",
"newline": "This sentence\n is on two lines.",
"tab": "This sentence \t contains a tab."
}
```
Exécutez les commandes suivantes pour créer la table ESCAPES et charger le fichier JSON.
```
create table escapes (backslash varchar(25), newline varchar(35), tab varchar(35));
copy escapes from 's3://amzn-s3-demo-bucket/json/escape.json'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
format as json 'auto';
```
Interrogez la table ESCAPES pour afficher les résultats.
```
select * from escapes;
backslash | newline | tab
------------------------+-------------------+----------------------------------
This is a backslash: \ | This sentence | This sentence contains a tab.
: is on two lines.
(1 row)
```
## Perte de précision numérique
Vous pouvez perdre de la précision lors du chargement de nombres à partir de fichiers de données en format JSON dans une colonne qui est définie comme un type de données numérique. Certaines valeurs en virgule flottantes ne seront pas représentées de manière exacte sur les systèmes informatiques. De ce fait, des données que vous copiez depuis un fichier JSON sont susceptibles de ne pas être arrondies comme vous vous y attendez. Pour éviter une perte de précision, nous recommandons l’utilisation d’une des autres solutions suivantes :
+ Représenter le nombre sous la forme d’une chaîne en plaçant la valeur entre guillemets doubles.
+ Utiliser [ROUNDEC](copy-parameters-data-conversion.md#copy-roundec) pour arrondir le nombre au lieu de le tronquer.
+ Plutôt que des fichiers JSON ou Avro, utiliser des fichiers CSV, délimités par un caractère, ou des fichiers texte à largeur fixe.
# COPY depuis les formats de données en colonnes
COPY peut charger les données depuis Amazon S3 dans les formats en colonnes suivants :
+ ORC
+ Parquet
Pour des exemples d’utilisation de la commande COPY à partir de formats de données en colonnes, consultez [Exemples de commandes COPY](r_COPY_command_examples.md).
La commande COPY prend en charge les données mises en forme en colonnes avec les considérations suivantes :
+ Le compartiment Amazon S3 doit se trouver dans la même AWS région que la base de données Amazon Redshift.
+ Pour accéder à vos données Amazon S3 via un point de terminaison de VPC, configurez l’accès à l’aide de politiques IAM et de rôles IAM, comme décrit dans [Utilisation d’Amazon Redshift Spectrum avec le routage VPC amélioré](https://docs.aws.amazon.com/redshift/latest/mgmt/spectrum-enhanced-vpc.html) dans le *Guide de gestion Amazon Redshift*.
+ La commande COPY n’applique pas automatiquement l’encodage de compression.
+ Seuls les paramètres COPY suivants sont pris en charge :
+ [ACCEPTINVCHARS](copy-parameters-data-conversion.md#copy-acceptinvchars) lors de la copie à partir d’un fichier ORC ou Parquet.
+ [FILLRECORD](copy-parameters-data-conversion.md#copy-fillrecord)
+ [FROM](copy-parameters-data-source-s3.md#copy-parameters-from)
+ [IAM\$1ROLE](copy-parameters-authorization.md#copy-iam-role)
+ [CREDENTIALS](copy-parameters-authorization.md#copy-credentials)
+ [STATUPDATE ](copy-parameters-data-load.md#copy-statupdate)
+ [MANIFEST](copy-parameters-data-source-s3.md#copy-manifest)
+ [EXPLICIT\$1IDS](copy-parameters-data-conversion.md#copy-explicit-ids)
+ Si la commande COPY rencontre une erreur lors du chargement, la commande échoue. ACCEPTANYDATE et MAXERROR ne sont pas pris en charge pour les types de données en colonnes.
+ Les messages d’erreur sont envoyés au client SQL. Certaines erreurs sont consignées dans STL\$1LOAD\$1ERRORS et STL\$1ERROR.
+ La commande COPY insère les valeurs dans les colonnes de la table cible dans le même ordre que celui où les colonnes se trouvent dans les fichiers de données en colonnes. Le nombre de colonnes de la table cible et le nombre de colonnes du fichier de données doivent correspondre.
+ Si le fichier que vous spécifiez pour l’opération COPY inclut l’une des extensions ci-après, nous décompressons les données sans avoir besoin d’ajouter des paramètres :
+ `.gz`
+ `.snappy`
+ `.bz2`
+ La commande COPY à partir des formats de fichiers Parquet et ORC utilise Redshift Spectrum et l’accès au compartiment. Pour utiliser COPY pour ces formats, assurez-vous qu'aucune politique IAM ne bloque l'utilisation d'Amazon S3 URLs présigné. Les fichiers présignés URLs générés par Amazon Redshift sont valides pendant 1 heure afin qu'Amazon Redshift ait suffisamment de temps pour charger tous les fichiers depuis le compartiment Amazon S3. Une URL présignée unique est générée pour chaque fichier scanné par COPY à partir de formats de données en colonnes. Pour les stratégies de compartiment qui incluent une action `s3:signatureAge`, veillez à définir la valeur sur au moins 3 600 000 millisecondes. Pour plus d’informations, consultez [Utilisation d’Amazon Redshift Spectrum avec le routage VPC amélioré](https://docs.aws.amazon.com/redshift/latest/mgmt/spectrum-enhanced-vpc.html).
+ Le paramètre REGION n’est pas pris en charge avec COPY à partir de formats de données en colonnes. Même si votre compartiment Amazon S3 et votre base de données se trouvent dans le même emplacement Région AWS, vous pouvez rencontrer une erreur, telle que l'argument REGION n'est pas pris en charge pour le COPY basé sur PARQUET.
+ COPY à partir de formats colonnaires prend désormais en charge la mise à l’échelle de la simultanéité. Pour activer la mise à l’échelle de la simultanéité, consultez [Configuration des files d’attente de mise à l’échelle de la simultanéité](https://docs.aws.amazon.com/redshift/latest/dg/concurrency-scaling.html#concurrency-scaling-queues).
# Chaînes DATEFORMAT et TIMEFORMAT
La commande COPY utilise les options DATEFORMAT et TIMEFORMAT pour analyser les valeurs de date et d’heure de vos données sources. DATEFORMAT et TIMEFORMAT sont des chaînes formatées qui doivent correspondre au format des valeurs de date et d’heure de vos données source. Par exemple, une commande COPY chargeant des données source avec la valeur de date `Jan-01-1999` doit inclure la chaîne DATEFORMAT suivante :
```
COPY ...
DATEFORMAT AS 'MON-DD-YYYY'
```
Pour plus d’informations sur la gestion des conversions de données COPY, consultez [Paramètres de conversion de données](https://docs.aws.amazon.com/redshift/latest/dg/copy-parameters-data-conversion.html).
Les chaînes DATEFORMAT et TIMEFORMAT peuvent contenir des séparateurs date/heure (tels que « `-` », « `/` » ou « `:` »), ainsi que les formats datepart et timepart présentés dans la table suivante.
**Note**
Si vous ne pouvez pas faire correspondre le format de vos valeurs de date ou d’heure avec les dateparts et timeparts suivants, ou si vos valeurs de date et d’heure utilisent des formats différents les uns des autres, utilisez l’argument `'auto'` avec le paramètre DATEFORMAT ou TIMEFORMAT. L’argument `'auto'` reconnaît plusieurs formats qui ne sont pas pris en charge lors de l’utilisation d’une chaîne DATEFORMAT ou TIMEFORMAT. Pour plus d’informations, consultez [Utilisation de la reconnaissance automatique avec DATEFORMAT et TIMEFORMAT](automatic-recognition.md).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/r_DATEFORMAT_and_TIMEFORMAT_strings.html)
Le format de date par défaut est YYYY-MM-DD. Le format d'horodatage sans fuseau horaire (TIMESTAMP) par défaut est HH:MI:SS. YYYY-MM-DD L'horodatage par défaut avec fuseau horaire (TIMESTAMPTZ) est YYYY-MM-DD HH:MI:SSOF, où OF est le décalage par rapport à UTC (par exemple, - 8:00. Vous ne pouvez pas inclure de spécificateur de fuseau horaire (TZ, tz ou OF) dans le timeformat\$1string. Le champ des secondes (SS) prend également en charge les fractions de secondes jusqu'à un niveau de détail de la microseconde. Pour charger les données TIMESTAMPTZ qui sont dans un format différent du format par défaut, spécifiez « auto ».
Vous trouverez ci-dessous des exemples de dates ou d’heures que vous pouvez trouver dans vos données sources, ainsi que les chaînes DATEFORMAT ou TIMEFORMAT correspondantes.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/r_DATEFORMAT_and_TIMEFORMAT_strings.html)
## Exemple
Pour obtenir un exemple d’utilisation de TIMEFORMAT, consultez [Charger un horodatage ou une datation](r_COPY_command_examples.md#r_COPY_command_examples-load-a-time-datestamp).
# Utilisation de la reconnaissance automatique avec DATEFORMAT et TIMEFORMAT
Si vous spécifiez `'auto'` comme argument pour le paramètre DATEFORMAT ou TIMEFORMAT, Amazon Redshift détecte et convertit automatiquement le format de date ou d’heure de vos données sources. Vous en trouverez un exemple ci-dessous.
```
copy favoritemovies from 'dynamodb://ProductCatalog'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
dateformat 'auto';
```
Lorsqu’elle est utilisée avec l’argument `'auto'` pour DATEFORMAT et TIMEFORMAT, la commande COPY reconnaît et convertit les formats de date et d’heure répertoriés dans la table de [Chaînes DATEFORMAT et TIMEFORMATExemple](r_DATEFORMAT_and_TIMEFORMAT_strings.md). En outre, l’argument `'auto'` reconnaît les formats suivants qui ne sont pas pris en charge lors de l’utilisation d’une chaîne DATEFORMAT et TIMEFORMAT.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/automatic-recognition.html)
La reconnaissance automatique ne prend pas en charge epochsecs et epochmillisecs.
Pour vérifier si une valeur de date ou d’horodatage est automatiquement convertie, utilisez une fonction CAST pour tenter de convertir la chaîne en une valeur de date ou d’horodatage. Par exemple, les commandes suivantes testent la valeur d’horodatage `'J2345678 04:05:06.789'` :
```
create table formattest (test char(21));
insert into formattest values('J2345678 04:05:06.789');
select test, cast(test as timestamp) as timestamp, cast(test as date) as date from formattest;
test | timestamp | date
----------------------+---------------------+------------
J2345678 04:05:06.789 1710-02-23 04:05:06 1710-02-23
```
Si les données source d’une colonne DATE comprennent des informations sur l’heure, le composant est tronqué. Si les données source d’une colonne TIMESTAMP omettent des informations sur l’heure, 00:00:00 est utilisé comme composant d’heure.
# Exemples de commandes COPY
**Note**
Ces exemples contiennent des sauts de ligne pour faciliter la lecture. N’incluez pas de sauts de ligne, ni d’espaces dans votre chaîne *credentials-args*.
**Topics**
+ [
## Charger FAVORITEMOVIES depuis une table DynamoDB
](#r_COPY_command_examples-load-favoritemovies-from-an-amazon-dynamodb-table)
+ [
## Charger la table LISTING depuis un compartiment Amazon S3
](#r_COPY_command_examples-load-listing-from-an-amazon-s3-bucket)
+ [
## Charger la table LISTING depuis un cluster Amazon EMR
](#copy-command-examples-emr)
+ [Example: COPY from Amazon S3 using a manifest](#copy-command-examples-manifest)
+ [
## Charger la table LISTING à partir d’un fichier séparés par une barre verticale (délimiteur par défaut)
](#r_COPY_command_examples-load-listing-from-a-pipe-delimited-file-default-delimiter)
+ [
## Charger LISTING en utilisant des données en colonnes en format Parquet
](#r_COPY_command_examples-load-listing-from-parquet)
+ [
## Chargement du LISTING à l’aide de données en colonnes au format ORC
](#r_COPY_command_examples-load-listing-from-orc)
+ [
## Charger la table EVENT avec des options
](#r_COPY_command_examples-load-event-with-options)
+ [
## Charger la table VENUE à partir d’un fichier de données de largeur fixe
](#r_COPY_command_examples-load-venue-from-a-fixed-width-data-file)
+ [
## Charger la table CATEGORY à partir d’un fichier CSV
](#load-from-csv)
+ [
## Charger la table VENUE avec des valeurs EXPLICIT pour une colonne IDENTITY
](#r_COPY_command_examples-load-venue-with-explicit-values-for-an-identity-column)
+ [
## Charger la table TIME à partir d’un fichier GZIP séparé par une barre verticale
](#r_COPY_command_examples-load-time-from-a-pipe-delimited-gzip-file)
+ [
## Charger un horodatage ou une datation
](#r_COPY_command_examples-load-a-time-datestamp)
+ [
## Charger les données d’un fichier avec des valeurs par défaut
](#r_COPY_command_examples-load-data-from-a-file-with-default-values)
+ [
## Exécuter la commande COPY des données avec l’option ESCAPE
](#r_COPY_command_examples-copy-data-with-the-escape-option)
+ [
## Copier à partir d’exemples JSON
](#r_COPY_command_examples-copy-from-json)
+ [
## Copier depuis des exemples Avro
](#r_COPY_command_examples-copy-from-avro)
+ [
## Préparation de fichiers pour la commande COPY avec l’option ESCAPE
](#r_COPY_preparing_data)
+ [
## Chargement d’un shapefile dans Amazon Redshift
](#copy-example-spatial-copy-shapefile)
+ [
## Commande COPY avec l’option NOLOAD
](#r_COPY_command_examples-load-noload-option)
+ [
## Commande COPY avec un délimiteur multioctet et l’option ENCODING
](#r_COPY_command_examples-load-encoding-multibyte-delimiter-option)
## Charger FAVORITEMOVIES depuis une table DynamoDB
*Ils AWS SDKs incluent un exemple simple de création d'une table DynamoDB appelée Movies.* (Pour cet exemple, consultez [Mise en route avec DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GettingStarted.html).) L’exemple suivant charge la table Amazon Redshift MOVIES avec les données provenant de la table DynamoDB. La table Amazon Redshift doit déjà exister dans la base de données.
```
copy favoritemovies from 'dynamodb://Movies'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
readratio 50;
```
## Charger la table LISTING depuis un compartiment Amazon S3
L’exemple suivant charge la table LISTING depuis un compartiment Amazon S3. La commande COPY charge tous les fichiers dans le dossier `/data/listing/`.
```
copy listing
from 's3://amzn-s3-demo-bucket/data/listing/'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole';
```
## Charger la table LISTING depuis un cluster Amazon EMR
L’exemple suivant charge la table SALES avec les données délimités par des tabulations des fichiers compressés lzop dans un cluster Amazon EMR. La commande COPY charge tous les fichiers du dossier `myoutput/` qui commencent par `part-`.
```
copy sales
from 'emr://j-SAMPLE2B500FC/myoutput/part-*'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
delimiter '\t' lzop;
```
L’exemple suivant charge la table SALES avec des données au format JSON dans un cluster Amazon EMR. La commande COPY charge tous les fichiers du dossier `myoutput/json/`.
```
copy sales
from 'emr://j-SAMPLE2B500FC/myoutput/json/'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
JSON 's3://amzn-s3-demo-bucket/jsonpaths.txt';
```
## Utilisation d’un manifeste pour spécifier les fichiers de données
Vous pouvez utiliser un manifeste pour vous assurer que votre commande COPY charge tous les fichiers requis et uniquement les fichiers requis, à partir d’Amazon S3. Vous pouvez également utiliser un manifeste lorsque vous avez besoin de charger plusieurs fichiers de différents compartiments ou des fichiers qui ne partagent pas le même préfixe.
Par exemple, supposons que vous devez charger les trois fichiers suivants : `custdata1.txt`, `custdata2.txt` et `custdata3.txt`. Vous pouvez utiliser la commande suivante pour charger tous les fichiers qui commencent par `amzn-s3-demo-bucket` dans `custdata` en spécifiant un préfixe :
```
copy category
from 's3://amzn-s3-demo-bucket/custdata'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole';
```
S’il n’existe que deux des fichiers en raison d’une erreur, la commande COPY charge uniquement ces deux fichiers et se termine correctement, ce qui entraîne une charge de données incomplète. Si le compartiment contient également un fichier indésirable qui utilise le même préfixe, par exemple, un fichier nommé `custdata.backup`, la commande COPY charge ce fichier également, ce qui entraîne le chargement de données indésirables.
Pour vous assurer que tous les fichiers nécessaires sont chargés et pour empêcher que des fichiers indésirables soient chargés, vous pouvez utiliser un fichier manifeste. Le manifeste est un fichier texte au format JSON qui répertorie les fichiers à traiter par la commande COPY. Par exemple, le manifeste suivant charge les trois fichiers dans l’exemple précédent.
```
{
"entries":[
{
"url":"s3://amzn-s3-demo-bucket/custdata.1",
"mandatory":true
},
{
"url":"s3://amzn-s3-demo-bucket/custdata.2",
"mandatory":true
},
{
"url":"s3://amzn-s3-demo-bucket/custdata.3",
"mandatory":true
}
]
}
```
L’indicateur `mandatory` facultatif indique si la commande COPY doit s’arrêter si le fichier n’existe pas. La valeur par défaut est `false`. Quels que soient les paramètres obligatoires, la commande COPY s’arrête si aucun fichier n’est trouvé. Dans cet exemple, la commande COPY renvoie une erreur si l’un des fichiers est introuvable. Les fichiers indésirables qui peuvent avoir été collectés si vous avez spécifié uniquement un préfixe de clé, comme `custdata.backup`, sont ignorés, car ils ne sont pas sur le manifeste.
Lors du chargement des fichiers de données au format ORC or Parquet, le champ `meta` est obligatoire, comme illustré dans l’exemple suivant.
```
{
"entries":[
{
"url":"s3://amzn-s3-demo-bucket1/orc/2013-10-04-custdata",
"mandatory":true,
"meta":{
"content_length":99
}
},
{
"url":"s3://amzn-s3-demo-bucket2/orc/2013-10-05-custdata",
"mandatory":true,
"meta":{
"content_length":99
}
}
]
}
```
L’exemple suivant utilise un manifeste nommé `cust.manifest`.
```
copy customer
from 's3://amzn-s3-demo-bucket/cust.manifest'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
format as orc
manifest;
```
Vous pouvez utiliser un manifeste pour charger les fichiers de différents compartiments ou les fichiers qui ne partagent pas le même préfixe. L’exemple suivant illustre le format JSON permettant de charger des données avec des fichiers dont les noms commencent par un horodatage.
```
{
"entries": [
{"url":"s3://amzn-s3-demo-bucket/2013-10-04-custdata.txt","mandatory":true},
{"url":"s3://amzn-s3-demo-bucket/2013-10-05-custdata.txt","mandatory":true},
{"url":"s3://amzn-s3-demo-bucket/2013-10-06-custdata.txt","mandatory":true},
{"url":"s3://amzn-s3-demo-bucket/2013-10-07-custdata.txt","mandatory":true}
]
}
```
Le manifeste peut répertorier les fichiers qui se trouvent dans différents compartiments, à condition que les compartiments se trouvent dans la même AWS région que le cluster.
```
{
"entries": [
{"url":"s3://amzn-s3-demo-bucket1/custdata1.txt","mandatory":false},
{"url":"s3://amzn-s3-demo-bucket2/custdata1.txt","mandatory":false},
{"url":"s3://amzn-s3-demo-bucket2/custdata2.txt","mandatory":false}
]
}
```
## Charger la table LISTING à partir d’un fichier séparés par une barre verticale (délimiteur par défaut)
L’exemple suivant est un cas très simple dans lequel aucune option n’est spécifiée et le fichier d’entrée contient le délimiteur par défaut, une barre verticale (’\$1’).
```
copy listing
from 's3://amzn-s3-demo-bucket/data/listings_pipe.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole';
```
## Charger LISTING en utilisant des données en colonnes en format Parquet
L’exemple suivant charge des données depuis un dossier sur Amazon S3 nommé parquet.
```
copy listing
from 's3://amzn-s3-demo-bucket/data/listings/parquet/'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
format as parquet;
```
## Chargement du LISTING à l’aide de données en colonnes au format ORC
L’exemple suivant charge des données depuis un dossier sur Amazon S3 nommé `orc`.
```
copy listing
from 's3://amzn-s3-demo-bucket/data/listings/orc/'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
format as orc;
```
## Charger la table EVENT avec des options
L’exemple suivant charge des données séparées par une barre verticale dans la table EVENT et applique les règles suivantes :
+ Si des paires de guillemets anglais sont utilisées pour entourer des chaînes de caractères, elles sont supprimées.
+ Les chaînes vides et les chaînes qui contiennent des espaces vides sont chargées en tant que valeurs NULL.
+ La charge échoue si plus de 5 erreurs sont renvoyées.
+ Les valeurs d’horodatage doivent être conformes au format spécifié ; par exemple, un horodatage valide est `2008-09-26 05:43:12`.
```
copy event
from 's3://amzn-s3-demo-bucket/data/allevents_pipe.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
removequotes
emptyasnull
blanksasnull
maxerror 5
delimiter '|'
timeformat 'YYYY-MM-DD HH:MI:SS';
```
## Charger la table VENUE à partir d’un fichier de données de largeur fixe
```
copy venue
from 's3://amzn-s3-demo-bucket/data/venue_fw.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
fixedwidth 'venueid:3,venuename:25,venuecity:12,venuestate:2,venueseats:6';
```
L’exemple précédent suppose un fichier de données au format identique à celui des exemples de données affichés. Dans le prochain exemple, les espaces se comportent comme des espaces réservés afin que toutes les colonnes soient de la même largeur, tel qu’indiqué dans la spécification :
```
1 Toyota Park Bridgeview IL0
2 Columbus Crew Stadium Columbus OH0
3 RFK Stadium Washington DC0
4 CommunityAmerica BallparkKansas City KS0
5 Gillette Stadium Foxborough MA68756
```
## Charger la table CATEGORY à partir d’un fichier CSV
Supposons que vous voulez charger la table CATEGORY avec les valeurs indiquées dans le tableau suivant.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/r_COPY_command_examples.html)
L’exemple suivant montre le contenu d’un fichier texte avec les champs de valeurs séparés par des virgules.
```
12,Shows,Musicals,Musical theatre
13,Shows,Plays,All "non-musical" theatre
14,Shows,Opera,All opera, light, and "rock" opera
15,Concerts,Classical,All symphony, concerto, and choir concerts
```
Si vous chargez le fichier à l’aide du paramètre DELIMITER pour spécifier des entrées séparées par des virgules, la commande COPY échoue parce que certains champs d’entrée contiennent des virgules. Vous pouvez éviter ce problème en utilisant le paramètre CSV et en entourant les champs qui contiennent des virgules de guillemets. Si le guillemet s’affiche au sein d’une chaîne entre guillemets, vous devez doubler le guillemet. Le guillemet par défaut est double. Vous devez donc ajouter à tous les guillemets doubles des guillemets doubles supplémentaires. Votre nouveau fichier d’entrée ressemble à quelque chose comme ça.
```
12,Shows,Musicals,Musical theatre
13,Shows,Plays,"All ""non-musical"" theatre"
14,Shows,Opera,"All opera, light, and ""rock"" opera"
15,Concerts,Classical,"All symphony, concerto, and choir concerts"
```
En supposant que le nom du fichier est `category_csv.txt`, vous pouvez charger le fichier en utilisant la commande COPY suivante :
```
copy category
from 's3://amzn-s3-demo-bucket/data/category_csv.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
csv;
```
Sinon, pour éviter d’avoir à doubler les guillemets doubles de votre entrée, vous pouvez spécifier un guillemet différent à l’aide du paramètre QUOTE AS. Par exemple, la version suivante de `category_csv.txt` utilise ’`%`’ comme caractère de citation :
```
12,Shows,Musicals,Musical theatre
13,Shows,Plays,%All "non-musical" theatre%
14,Shows,Opera,%All opera, light, and "rock" opera%
15,Concerts,Classical,%All symphony, concerto, and choir concerts%
```
La commande COPY suivante utilise QUOTE AS pour charger `category_csv.txt` :
```
copy category
from 's3://amzn-s3-demo-bucket/data/category_csv.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
csv quote as '%';
```
## Charger la table VENUE avec des valeurs EXPLICIT pour une colonne IDENTITY
L’exemple suivant suppose que lorsque la table VENUE a été créée, au moins une colonne (telle que la colonne `venueid`) a été désignée comme colonne IDENTITY. Cette commande se substitue au comportement IDENTITY par défaut pour la génération automatique de valeurs pour une colonne IDENTITY et charge à la place des valeurs explicites depuis le fichier venue.txt. Amazon Redshift ne vérifie pas si des valeurs IDENTITY dupliquées sont chargées dans la table lors de l’utilisation de l’option EXLICIT\$1IDS.
```
copy venue
from 's3://amzn-s3-demo-bucket/data/venue.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
explicit_ids;
```
## Charger la table TIME à partir d’un fichier GZIP séparé par une barre verticale
L’exemple suivant charge la table TIME à partir d’un fichier GZIP séparé par une barre verticale :
```
copy time
from 's3://amzn-s3-demo-bucket/data/timerows.gz'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
gzip
delimiter '|';
```
## Charger un horodatage ou une datation
L’exemple suivant charge les données avec un horodatage formaté.
**Note**
Le TIMEFORMAT de `HH:MI:SS` peut également prendre en charge des fractions de secondes au-delà de `SS` jusqu’aux microsecondes. Le fichier `time.txt` utilisé dans cet exemple contient une seule ligne, `2009-01-12 14:15:57.119568`.
```
copy timestamp1
from 's3://amzn-s3-demo-bucket/data/time.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
timeformat 'YYYY-MM-DD HH:MI:SS';
```
Le résultat de cette copie est le suivant :
```
select * from timestamp1;
c1
----------------------------
2009-01-12 14:15:57.119568
(1 row)
```
## Charger les données d’un fichier avec des valeurs par défaut
L’exemple suivant utilise une variation de la table VENUE dans la base de données TICKIT. Prenons une table VENUE\$1NEW définie avec l’instruction suivante :
```
create table venue_new(
venueid smallint not null,
venuename varchar(100) not null,
venuecity varchar(30),
venuestate char(2),
venueseats integer not null default '1000');
```
Imaginons un fichier de données venue\$1noseats.txt qui ne contient aucune valeur pour la colonne VENUESEATS, comme illustré dans l’exemple suivant :
```
1|Toyota Park|Bridgeview|IL|
2|Columbus Crew Stadium|Columbus|OH|
3|RFK Stadium|Washington|DC|
4|CommunityAmerica Ballpark|Kansas City|KS|
5|Gillette Stadium|Foxborough|MA|
6|New York Giants Stadium|East Rutherford|NJ|
7|BMO Field|Toronto|ON|
8|The Home Depot Center|Carson|CA|
9|Dick's Sporting Goods Park|Commerce City|CO|
10|Pizza Hut Park|Frisco|TX|
```
L’instruction COPY suivante charge correctement la table depuis le fichier et applique la valeur DEFAULT (’1000’) à la colonne omise :
```
copy venue_new(venueid, venuename, venuecity, venuestate)
from 's3://amzn-s3-demo-bucket/data/venue_noseats.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
delimiter '|';
```
Maintenant, affichez la table chargée :
```
select * from venue_new order by venueid;
venueid | venuename | venuecity | venuestate | venueseats
---------+----------------------------+-----------------+------------+------------
1 | Toyota Park | Bridgeview | IL | 1000
2 | Columbus Crew Stadium | Columbus | OH | 1000
3 | RFK Stadium | Washington | DC | 1000
4 | CommunityAmerica Ballpark | Kansas City | KS | 1000
5 | Gillette Stadium | Foxborough | MA | 1000
6 | New York Giants Stadium | East Rutherford | NJ | 1000
7 | BMO Field | Toronto | ON | 1000
8 | The Home Depot Center | Carson | CA | 1000
9 | Dick's Sporting Goods Park | Commerce City | CO | 1000
10 | Pizza Hut Park | Frisco | TX | 1000
(10 rows)
```
Pour l’exemple suivant, en plus de supposer qu’aucune donnée VENUESEATS n’est incluse dans le fichier, supposons également qu’aucune donnée VENUENAME n’est incluse :
```
1||Bridgeview|IL|
2||Columbus|OH|
3||Washington|DC|
4||Kansas City|KS|
5||Foxborough|MA|
6||East Rutherford|NJ|
7||Toronto|ON|
8||Carson|CA|
9||Commerce City|CO|
10||Frisco|TX|
```
A l’aide de la même définition de table, l’instructions COPY suivante échoue, car aucune valeur DEFAULT n’a été spécifié pour VENUENAME et VENUENAME est une colonne NOT NULL :
```
copy venue(venueid, venuecity, venuestate)
from 's3://amzn-s3-demo-bucket/data/venue_pipe.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
delimiter '|';
```
Maintenant, prenons une variation de la table VENUE qui utilise une colonne IDENTITY :
```
create table venue_identity(
venueid int identity(1,1),
venuename varchar(100) not null,
venuecity varchar(30),
venuestate char(2),
venueseats integer not null default '1000');
```
Comme dans l’exemple précédent, supposons que la colonne VENUESEATS n’a aucune valeur correspondante dans le fichier source. L’instruction COPY suivante charge la table avec succès, y compris les valeurs de données IDENTITY prédéfinies au lieu de générer ces valeurs :
```
copy venue(venueid, venuename, venuecity, venuestate)
from 's3://amzn-s3-demo-bucket/data/venue_pipe.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
delimiter '|' explicit_ids;
```
Cette instruction échoue, car elle n’inclut pas la colonne IDENTITY (VENUEID est manquante dans la liste de colonnes) mais inclut un paramètre EXPLICIT\$1IDS :
```
copy venue(venuename, venuecity, venuestate)
from 's3://amzn-s3-demo-bucket/data/venue_pipe.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
delimiter '|' explicit_ids;
```
Cette instruction échoue, car elle n’inclut pas un paramètre EXPLICIT\$1IDS :
```
copy venue(venueid, venuename, venuecity, venuestate)
from 's3://amzn-s3-demo-bucket/data/venue_pipe.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
delimiter '|';
```
## Exécuter la commande COPY des données avec l’option ESCAPE
L’exemple suivant présente le chargement des caractères qui correspondent au délimiteur (dans ce cas, la barre verticale). Dans le fichier d’entrée, assurez-vous qu’une barre oblique inverse (\$1) est ajoutée à toutes les barres verticales (\$1) que vous voulez charger. Puis chargez le fichier avec le paramètre ESCAPE.
```
$ more redshiftinfo.txt
1|public\|event\|dwuser
2|public\|sales\|dwuser
create table redshiftinfo(infoid int,tableinfo varchar(50));
copy redshiftinfo from 's3://amzn-s3-demo-bucket/data/redshiftinfo.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
delimiter '|' escape;
select * from redshiftinfo order by 1;
infoid | tableinfo
-------+--------------------
1 | public|event|dwuser
2 | public|sales|dwuser
(2 rows)
```
Sans le paramètre ESCAPE, cette commande COPY échoue avec une erreur `Extra column(s) found`.
**Important**
Si vous chargez vos données à l’aide d’une commande COPY avec le paramètre ESCAPE, vous devez également spécifier le paramètre ESCAPE avec votre commande UNLOAD pour générer le fichier de sortie réciproque. De même, si vous exécuter la commande UNLOAD à l’aide du paramètre ESCAPE, vous devez utiliser la commande ESCAPE lorsque vous exécutez la commande COPY sur les mêmes données.
## Copier à partir d’exemples JSON
Dans les exemples suivants, vous chargez la table CATEGORY avec les données suivantes.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/r_COPY_command_examples.html)
**Topics**
+ [
### Charger des données JSON à l’aide de l’option ’auto’
](#copy-from-json-examples-using-auto)
+ [
### Charger des données JSON à l’aide de l’option ’auto ignorecase’
](#copy-from-json-examples-using-auto-ignorecase)
+ [
### Charger à partir de données JSON à l'aide d'un JSONPaths fichier
](#copy-from-json-examples-using-jsonpaths)
+ [
### Chargement à partir de tableaux JSON à l'aide d'un JSONPaths fichier
](#copy-from-json-examples-using-jsonpaths-arrays)
### Charger des données JSON à l’aide de l’option ’auto’
Pour charger des données JSON à l’aide de l’option `'auto'`, les données JSON doivent consister en un ensemble d’objets. Les noms de clés doivent correspondre aux noms de colonnes, mais dans ce cas, l’ordre n’a pas d’importance. Ce qui suit montre le contenu d’un fichier nommé `category_object_auto.json`.
```
{
"catdesc": "Major League Baseball",
"catid": 1,
"catgroup": "Sports",
"catname": "MLB"
}
{
"catgroup": "Sports",
"catid": 2,
"catname": "NHL",
"catdesc": "National Hockey League"
}
{
"catid": 3,
"catname": "NFL",
"catgroup": "Sports",
"catdesc": "National Football League"
}
{
"bogus": "Bogus Sports LLC",
"catid": 4,
"catgroup": "Sports",
"catname": "NBA",
"catdesc": "National Basketball Association"
}
{
"catid": 5,
"catgroup": "Shows",
"catname": "Musicals",
"catdesc": "All symphony, concerto, and choir concerts"
}
```
Pour charger depuis le fichier de données JSON dans l’exemple précédent, exécutez la commande COPY suivante.
```
copy category
from 's3://amzn-s3-demo-bucket/category_object_auto.json'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
json 'auto';
```
### Charger des données JSON à l’aide de l’option ’auto ignorecase’
Pour charger des données JSON à l’aide de l’option `'auto ignorecase'`, les données JSON doivent consister en un ensemble d’objets. Le cas des noms de clés n’a pas besoin de correspondre aux noms de colonnes et l’ordre n’a pas d’importance. Ce qui suit montre le contenu d’un fichier nommé `category_object_auto-ignorecase.json`.
```
{
"CatDesc": "Major League Baseball",
"CatID": 1,
"CatGroup": "Sports",
"CatName": "MLB"
}
{
"CatGroup": "Sports",
"CatID": 2,
"CatName": "NHL",
"CatDesc": "National Hockey League"
}
{
"CatID": 3,
"CatName": "NFL",
"CatGroup": "Sports",
"CatDesc": "National Football League"
}
{
"bogus": "Bogus Sports LLC",
"CatID": 4,
"CatGroup": "Sports",
"CatName": "NBA",
"CatDesc": "National Basketball Association"
}
{
"CatID": 5,
"CatGroup": "Shows",
"CatName": "Musicals",
"CatDesc": "All symphony, concerto, and choir concerts"
}
```
Pour charger depuis le fichier de données JSON dans l’exemple précédent, exécutez la commande COPY suivante.
```
copy category
from 's3://amzn-s3-demo-bucket/category_object_auto ignorecase.json'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
json 'auto ignorecase';
```
### Charger à partir de données JSON à l'aide d'un JSONPaths fichier
Si les objets de données JSON ne correspondent pas directement aux noms de colonnes, vous pouvez utiliser un JSONPaths fichier pour mapper les éléments JSON aux colonnes. L'ordre n'a pas d'importance dans les données source JSON, mais l'ordre des expressions de JSONPaths fichier doit correspondre à l'ordre des colonnes. Supposons que vous ayez le fichier de données suivant, nommé `category_object_paths.json`.
```
{
"one": 1,
"two": "Sports",
"three": "MLB",
"four": "Major League Baseball"
}
{
"three": "NHL",
"four": "National Hockey League",
"one": 2,
"two": "Sports"
}
{
"two": "Sports",
"three": "NFL",
"one": 3,
"four": "National Football League"
}
{
"one": 4,
"two": "Sports",
"three": "NBA",
"four": "National Basketball Association"
}
{
"one": 6,
"two": "Shows",
"three": "Musicals",
"four": "All symphony, concerto, and choir concerts"
}
```
Le JSONPaths fichier suivant, nommé`category_jsonpath.json`, met en correspondance les données source avec les colonnes du tableau.
```
{
"jsonpaths": [
"$['one']",
"$['two']",
"$['three']",
"$['four']"
]
}
```
Pour charger depuis le fichier de données JSON dans l’exemple précédent, exécutez la commande COPY suivante.
```
copy category
from 's3://amzn-s3-demo-bucket/category_object_paths.json'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
json 's3://amzn-s3-demo-bucket/category_jsonpath.json';
```
### Chargement à partir de tableaux JSON à l'aide d'un JSONPaths fichier
Pour charger à partir de JSON des données constituées d'un ensemble de tableaux, vous devez utiliser un JSONPaths fichier pour mapper les éléments du tableau aux colonnes. Supposons que vous ayez le fichier de données suivant, nommé `category_array_data.json`.
```
[1,"Sports","MLB","Major League Baseball"]
[2,"Sports","NHL","National Hockey League"]
[3,"Sports","NFL","National Football League"]
[4,"Sports","NBA","National Basketball Association"]
[5,"Concerts","Classical","All symphony, concerto, and choir concerts"]
```
Le JSONPaths fichier suivant, nommé`category_array_jsonpath.json`, met en correspondance les données source avec les colonnes du tableau.
```
{
"jsonpaths": [
"$[0]",
"$[1]",
"$[2]",
"$[3]"
]
}
```
Pour charger depuis le fichier de données JSON dans l’exemple précédent, exécutez la commande COPY suivante.
```
copy category
from 's3://amzn-s3-demo-bucket/category_array_data.json'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
json 's3://amzn-s3-demo-bucket/category_array_jsonpath.json';
```
## Copier depuis des exemples Avro
Dans les exemples suivants, vous chargez la table CATEGORY avec les données suivantes.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/r_COPY_command_examples.html)
**Topics**
+ [
### Charger à partir des données Avro à l’aide de l’option ’auto’
](#copy-from-avro-examples-using-auto)
+ [
### Charger à partir des données Avro à l’aide de l’option ’auto ignorecase’
](#copy-from-avro-examples-using-auto-ignorecase)
+ [
### Charger des données depuis Avro à l'aide d'un fichier JSONPaths
](#copy-from-avro-examples-using-avropaths)
### Charger à partir des données Avro à l’aide de l’option ’auto’
Pour charger à partir des données Avro à l’aide de l’argument `'auto'`, les noms de champs du schéma Avro doivent correspondre aux noms de colonnes. Lorsque vous utilisez l’argument `'auto'`, l’ordre n’est pas important. Ce qui suit montre le schéma d’un fichier nommé `category_auto.avro`.
```
{
"name": "category",
"type": "record",
"fields": [
{"name": "catid", "type": "int"},
{"name": "catdesc", "type": "string"},
{"name": "catname", "type": "string"},
{"name": "catgroup", "type": "string"},
}
```
Les données contenues dans un fichier Avro sont au format binaire, elles ne sont donc pas explicites. L’exemple suivant illustre une représentation JSON des données dans le fichier `category_auto.avro`.
```
{
"catid": 1,
"catdesc": "Major League Baseball",
"catname": "MLB",
"catgroup": "Sports"
}
{
"catid": 2,
"catdesc": "National Hockey League",
"catname": "NHL",
"catgroup": "Sports"
}
{
"catid": 3,
"catdesc": "National Basketball Association",
"catname": "NBA",
"catgroup": "Sports"
}
{
"catid": 4,
"catdesc": "All symphony, concerto, and choir concerts",
"catname": "Classical",
"catgroup": "Concerts"
}
```
Pour charger depuis le fichier de données Avro dans l’exemple précédent, exécutez la commande COPY suivante.
```
copy category
from 's3://amzn-s3-demo-bucket/category_auto.avro'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
format as avro 'auto';
```
### Charger à partir des données Avro à l’aide de l’option ’auto ignorecase’
Pour charger à partir des données Avro à l’aide de l’argument `'auto ignorecase'`, la casse des noms de champs du schéma Avro ne doit pas forcément correspondre à celle des noms de colonnes. Lorsque vous utilisez l’argument `'auto ignorecase'`, l’ordre n’est pas important. Ce qui suit montre le schéma d’un fichier nommé `category_auto-ignorecase.avro`.
```
{
"name": "category",
"type": "record",
"fields": [
{"name": "CatID", "type": "int"},
{"name": "CatDesc", "type": "string"},
{"name": "CatName", "type": "string"},
{"name": "CatGroup", "type": "string"},
}
```
Les données contenues dans un fichier Avro sont au format binaire, elles ne sont donc pas explicites. L’exemple suivant illustre une représentation JSON des données dans le fichier `category_auto-ignorecase.avro`.
```
{
"CatID": 1,
"CatDesc": "Major League Baseball",
"CatName": "MLB",
"CatGroup": "Sports"
}
{
"CatID": 2,
"CatDesc": "National Hockey League",
"CatName": "NHL",
"CatGroup": "Sports"
}
{
"CatID": 3,
"CatDesc": "National Basketball Association",
"CatName": "NBA",
"CatGroup": "Sports"
}
{
"CatID": 4,
"CatDesc": "All symphony, concerto, and choir concerts",
"CatName": "Classical",
"CatGroup": "Concerts"
}
```
Pour charger depuis le fichier de données Avro dans l’exemple précédent, exécutez la commande COPY suivante.
```
copy category
from 's3://amzn-s3-demo-bucket/category_auto-ignorecase.avro'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
format as avro 'auto ignorecase';
```
### Charger des données depuis Avro à l'aide d'un fichier JSONPaths
Si les noms de champs du schéma Avro ne correspondent pas directement aux noms de colonnes, vous pouvez utiliser un JSONPaths fichier pour mapper les éléments du schéma aux colonnes. L'ordre des expressions du JSONPaths fichier doit correspondre à l'ordre des colonnes.
Supposons que vous ayez un fichier de données nommé `category_paths.avro` qui contient les mêmes données que dans l’exemple précédent, mais avec le schéma suivant.
```
{
"name": "category",
"type": "record",
"fields": [
{"name": "id", "type": "int"},
{"name": "desc", "type": "string"},
{"name": "name", "type": "string"},
{"name": "group", "type": "string"},
{"name": "region", "type": "string"}
]
}
```
Le JSONPaths fichier suivant, nommé`category_path.avropath`, met en correspondance les données source avec les colonnes du tableau.
```
{
"jsonpaths": [
"$['id']",
"$['group']",
"$['name']",
"$['desc']"
]
}
```
Pour charger depuis le fichier de données Avro dans l’exemple précédent, exécutez la commande COPY suivante.
```
copy category
from 's3://amzn-s3-demo-bucket/category_object_paths.avro'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
format avro 's3://amzn-s3-demo-bucket/category_path.avropath ';
```
## Préparation de fichiers pour la commande COPY avec l’option ESCAPE
L’exemple suivant décrit comment préparer les données pour insérer des caractères de saut de ligne avant d’importer les données dans une table Amazon Redshift à l’aide de la commande COPY avec le paramètre ESCAPE. Si vous ne préparez pas les données afin de délimiter les caractères de saut ligne, Amazon Redshift renvoie des erreurs de charge lorsque vous exécutez la commande COPY, car le caractère de saut de ligne est généralement utilisé comme séparateur d’enregistrements.
Par exemple, prenons un fichier ou une colonne dans une table externe que vous voulez copier dans une table Amazon Redshift. Si le fichier ou la colonne contient des données de contenu au format XML ou similaires, vous devez vous assurer que tous les caractères de saut de ligne (\$1n) qui font partie du contenu sont insérés avec la barre oblique inverse (\$1).
Si un fichier ou une table contient des caractères de saut de ligne imbriqués, cela offre un modèle relativement facile à mettre en correspondance. Chaque caractère de saut de ligne imbriqué suit presque toujours un caractère `>` avec, potentiellement, des caractères d’espace (`' '` ou une tabulation) entre les deux, comme vous pouvez le voir dans l’exemple suivant d’un fichier texte intitulé `nlTest1.txt`.
```
$ cat nlTest1.txt
|1000
|2000
```
Avec l’exemple suivant, vous pouvez exécuter un utilitaire de traitement de texte permettant de prétraiter le fichier source et d’insérer des caractères d’échappement si nécessaire. (Le caractère `|` est destiné à être utilisé comme délimiteur pour séparer les données de la colonne lorsqu’elles sont copiées dans une table Amazon Redshift.)
```
$ sed -e ':a;N;$!ba;s/>[[:space:]]*\n/>\\\n/g' nlTest1.txt > nlTest2.txt
```
De même, vous pouvez utiliser Perl pour effectuer une opération similaire :
```
cat nlTest1.txt | perl -p -e 's/>\s*\n/>\\\n/g' > nlTest2.txt
```
Pour faciliter le chargement des données à partir du fichier `nlTest2.txt` dans Amazon Redshift, nous avons créé une table à deux colonnes dans Amazon Redshift. La première colonne c1, est une colonne de caractères dont le contenu est au format XML issu du fichier `nlTest2.txt`. La deuxième colonne c2 contient des valeurs de nombres entiers chargés à partir du même fichier.
Après avoir exécuté la commande `sed`, vous pouvez charger correctement des données à partir du fichier `nlTest2.txt` dans une table Amazon Redshift à l’aide du paramètre ESCAPE.
**Note**
Lorsque vous incluez le paramètre ESCAPE avec la commande COPY, il insère un certain nombre de caractères spéciaux, parmi lesquels la barre oblique (ainsi que le saut de ligne).
```
copy t2 from 's3://amzn-s3-demo-bucket/data/nlTest2.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
escape
delimiter as '|';
select * from t2 order by 2;
c1 | c2
-------------+------
| 1000
| 2000
(2 rows)
```
Vous pouvez préparer les fichiers de données exportés à partir de bases de données externes d’une manière similaire. Par exemple, avec une base de données Oracle, vous pouvez utiliser la fonction REPLACE sur chaque colonne concernée dans une table que vous voulez copier dans Amazon Redshift.
```
SELECT c1, REPLACE(c2, \n',\\n' ) as c2 from my_table_with_xml
```
En outre, de nombreux outils d’exportation et d’extraction, de transformation, de chargement (ETL) de la base de données qui traitent régulièrement de grandes quantités de données offrent des options permettant de spécifier des caractères d’échappement et délimiteurs.
## Chargement d’un shapefile dans Amazon Redshift
Les exemples suivants montrent comment charger un shapefile Esri à l’aide de la commande COPY. Pour plus d’informations sur le chargement des fichiers de forme, consultez [Chargement d’un shapefile dans Amazon Redshift](spatial-copy-shapefile.md).
### Chargement d’un shapefile
Les étapes suivantes montrent comment ingérer des OpenStreetMap données depuis Amazon S3 à l'aide de la commande COPY. Cet exemple suppose que l'archive du shapefile de Norvège [provenant du site de téléchargement de](https://download.geofabrik.de/europe.html) Geofabrik a été chargée dans un compartiment Amazon S3 privé de votre région. AWS Les fichiers `.shp`, `.shx` et `.dbf` doivent partager le même préfixe et le même nom de fichier Amazon S3.
#### Intégration des données sans simplification
Les commandes suivantes créent des tables et intègrent des données qui peuvent s’adapter à la taille géométrique maximale sans aucune simplification. Ouvrez `gis_osm_natural_free_1.shp` dans votre logiciel SIG préféré et inspectez les colonnes de cette couche. Par défaut, les colonnes IDENTITY ou GEOMETRY sont les premières. Lorsque la première colonne est une colonne GEOMETRY, vous pouvez créer la table comme indiqué ci-dessous.
```
CREATE TABLE norway_natural (
wkb_geometry GEOMETRY,
osm_id BIGINT,
code INT,
fclass VARCHAR,
name VARCHAR);
```
Sinon, lorsque la première colonne est une colonne IDENTITY, vous pouvez créer la table comme indiqué ci-dessous.
```
CREATE TABLE norway_natural_with_id (
fid INT IDENTITY(1,1),
wkb_geometry GEOMETRY,
osm_id BIGINT,
code INT,
fclass VARCHAR,
name VARCHAR);
```
Maintenant, vous pouvez intégrer les données en utilisant la commande COPY.
```
COPY norway_natural FROM 's3://bucket_name/shapefiles/norway/gis_osm_natural_free_1.shp'
FORMAT SHAPEFILE
CREDENTIALS 'aws_iam_role=arn:aws:iam::123456789012:role/MyRoleName';
INFO: Load into table 'norway_natural' completed, 83891 record(s) loaded successfully
```
Vous pouvez également intégrer les données comme indiqué ci-dessous.
```
COPY norway_natural_with_id FROM 's3://bucket_name/shapefiles/norway/gis_osm_natural_free_1.shp'
FORMAT SHAPEFILE
CREDENTIALS 'aws_iam_role=arn:aws:iam::123456789012:role/MyRoleName';
INFO: Load into table 'norway_natural_with_id' completed, 83891 record(s) loaded successfully.
```
#### Intégration des données avec simplification
Les commandes suivantes créent une table et tentent d’intégrer des données qui ne rentrent pas dans la taille géométrique maximale sans aucune simplification. Inspectez le shapefile `gis_osm_water_a_free_1.shp` et créez la table appropriée comme indiqué ci-dessous.
```
CREATE TABLE norway_water (
wkb_geometry GEOMETRY,
osm_id BIGINT,
code INT,
fclass VARCHAR,
name VARCHAR);
```
Lorsque la commande COPY s’exécute, une erreur est renvoyée.
```
COPY norway_water FROM 's3://bucket_name/shapefiles/norway/gis_osm_water_a_free_1.shp'
FORMAT SHAPEFILE
CREDENTIALS 'aws_iam_role=arn:aws:iam::123456789012:role/MyRoleName';
ERROR: Load into table 'norway_water' failed. Check 'stl_load_errors' system table for details.
```
L’interrogation de `STL_LOAD_ERRORS` indique que la géométrie est trop volumineuse.
```
SELECT line_number, btrim(colname), btrim(err_reason) FROM stl_load_errors WHERE query = pg_last_copy_id();
line_number | btrim | btrim
-------------+--------------+-----------------------------------------------------------------------
1184705 | wkb_geometry | Geometry size: 1513736 is larger than maximum supported size: 1048447
```
Pour résoudre ce problème, le paramètre `SIMPLIFY AUTO` est ajouté à la commande COPY afin de simplifier les géométries.
```
COPY norway_water FROM 's3://bucket_name/shapefiles/norway/gis_osm_water_a_free_1.shp'
FORMAT SHAPEFILE
SIMPLIFY AUTO
CREDENTIALS 'aws_iam_role=arn:aws:iam::123456789012:role/MyRoleName';
INFO: Load into table 'norway_water' completed, 1989196 record(s) loaded successfully.
```
Pour afficher les lignes et les géométries simplifiées, interrogez `SVL_SPATIAL_SIMPLIFY`.
```
SELECT * FROM svl_spatial_simplify WHERE query = pg_last_copy_id();
query | line_number | maximum_tolerance | initial_size | simplified | final_size | final_tolerance
-------+-------------+-------------------+--------------+------------+------------+----------------------
20 | 1184704 | -1 | 1513736 | t | 1008808 | 1.276386653895e-05
20 | 1664115 | -1 | 1233456 | t | 1023584 | 6.11707814796635e-06
```
Lorsque la commande SIMPLIY AUTO *max\$1tolerance* est utilisée avec une tolérance inférieure à celle calculée automatiquement, une erreur d’ingestion est généralement renvoyée. Dans ce cas, utilisez la commande MAXERROR pour ignorer les erreurs.
```
COPY norway_water FROM 's3://bucket_name/shapefiles/norway/gis_osm_water_a_free_1.shp'
FORMAT SHAPEFILE
SIMPLIFY AUTO 1.1E-05
MAXERROR 2
CREDENTIALS 'aws_iam_role=arn:aws:iam::123456789012:role/MyRoleName';
INFO: Load into table 'norway_water' completed, 1989195 record(s) loaded successfully.
INFO: Load into table 'norway_water' completed, 1 record(s) could not be loaded. Check 'stl_load_errors' system table for details.
```
Interrogez à nouveau `SVL_SPATIAL_SIMPLIFY` pour identifier l’enregistrement que la commande COPY n’a pas réussi à charger.
```
SELECT * FROM svl_spatial_simplify WHERE query = pg_last_copy_id();
query | line_number | maximum_tolerance | initial_size | simplified | final_size | final_tolerance
-------+-------------+-------------------+--------------+------------+------------+-----------------
29 | 1184704 | 1.1e-05 | 1513736 | f | 0 | 0
29 | 1664115 | 1.1e-05 | 1233456 | t | 794432 | 1.1e-05
```
Dans cet exemple, le premier enregistrement n’a pas réussi à s’ajuster, c’est pourquoi la colonne `simplified` affiche false. Le deuxième enregistrement a été chargé dans la tolérance donnée. Toutefois, la taille finale est supérieure à l’utilisation de la tolérance calculée automatiquement sans spécifier la tolérance maximale.
### Chargement à partir d’un shapefile compressé
La commande COPY Amazon Redshift prend en charge l’ingestion de données à partir d’un shapefile compressé. Tous les composants de shapefiles doivent avoir le même préfixe Amazon S3 et le même suffixe de compression. Par exemple, supposons que vous souhaitiez charger les données de l’exemple précédent. Dans ce cas, les fichiers `gis_osm_water_a_free_1.shp.gz`, `gis_osm_water_a_free_1.dbf.gz` et `gis_osm_water_a_free_1.shx.gz` doivent partager le même répertoire Amazon S3. La commande COPY nécessite l’option GZIP, et la clause FROM doit spécifier le fichier compressé correct, comme indiqué ci-dessous.
```
COPY norway_natural FROM 's3://bucket_name/shapefiles/norway/compressed/gis_osm_natural_free_1.shp.gz'
FORMAT SHAPEFILE
GZIP
CREDENTIALS 'aws_iam_role=arn:aws:iam::123456789012:role/MyRoleName';
INFO: Load into table 'norway_natural' completed, 83891 record(s) loaded successfully.
```
### Chargement des données dans une table avec un ordre de colonnes différent
Si vous avez une table qui n’a pas `GEOMETRY` comme première colonne, vous pouvez utiliser le mappage de colonnes pour mapper des colonnes à la table cible. Par exemple, créez une table en spécifiant `osm_id` comme première colonne.
```
CREATE TABLE norway_natural_order (
osm_id BIGINT,
wkb_geometry GEOMETRY,
code INT,
fclass VARCHAR,
name VARCHAR);
```
Intégrez ensuite un shapefile à l’aide du mappage de colonnes.
```
COPY norway_natural_order(wkb_geometry, osm_id, code, fclass, name)
FROM 's3://bucket_name/shapefiles/norway/gis_osm_natural_free_1.shp'
FORMAT SHAPEFILE
CREDENTIALS 'aws_iam_role=arn:aws:iam::123456789012:role/MyRoleName';
INFO: Load into table 'norway_natural_order' completed, 83891 record(s) loaded successfully.
```
### Chargement de données dans une table avec une colonne de géographies
Si vous disposez d’une table avec une colonne `GEOGRAPHY`, vous devez d’abord l’intégrer à une colonne `GEOMETRY`, puis convertir les objets en objets `GEOGRAPHY`. Par exemple, après avoir copié votre shapefile dans une colonne `GEOMETRY`, modifiez le tableau pour ajouter une colonne du type de données `GEOGRAPHY`.
```
ALTER TABLE norway_natural ADD COLUMN wkb_geography GEOGRAPHY;
```
Convertissez ensuite les géométries en géographies.
```
UPDATE norway_natural SET wkb_geography = wkb_geometry::geography;
```
Vous pouvez éventuellement supprimer la colonne `GEOMETRY`.
```
ALTER TABLE norway_natural DROP COLUMN wkb_geometry;
```
## Commande COPY avec l’option NOLOAD
Pour valider des fichiers de données avant de charger réellement les données, utilisez l’option NOLOAD avec la commande COPY. Amazon Redshift analyse le fichier d’entrée et affiche les erreurs éventuelles. L’exemple suivant utilise l’option NOLOAD et aucune ligne n’est réellement chargée dans la table.
```
COPY public.zipcode1
FROM 's3://amzn-s3-demo-bucket/mydata/zipcode.csv'
DELIMITER ';'
IGNOREHEADER 1 REGION 'us-east-1'
NOLOAD
CREDENTIALS 'aws_iam_role=arn:aws:iam::123456789012:role/myRedshiftRole';
Warnings:
Load into table 'zipcode1' completed, 0 record(s) loaded successfully.
```
## Commande COPY avec un délimiteur multioctet et l’option ENCODING
L'exemple suivant se charge LATIN1 à partir d'un fichier Amazon S3 contenant des données multioctets. La commande COPY spécifie le délimiteur sous forme octale `\302\246\303\254` pour séparer les champs du fichier d’entrée encodé au format ISO-8859-1. Pour spécifier le même délimiteur en UTF-8, spécifiez `DELIMITER '¦ì'`.
```
COPY latin1
FROM 's3://amzn-s3-demo-bucket/multibyte/myfile'
IAM_ROLE 'arn:aws:iam::123456789012:role/myRedshiftRole'
DELIMITER '\302\246\303\254'
ENCODING ISO88591
```