

 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.

# Description des paramètres de la commande COPY
<a name="r_COPY-parameters"></a>

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
<a name="copy-parameters-data-source"></a>

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
<a name="copy-parameters-data-source-s3"></a>

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
<a name="copy-parameters-data-source-s3-syntax"></a>

```
FROM { 's3://objectpath' | 's3://manifest_file' }
authorization
| MANIFEST
| ENCRYPTED
| REGION [AS] 'aws-region'
| optional-parameters
```

## Exemples
<a name="copy-parameters-data-source-s3-examples"></a>

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
<a name="copy-parameters-data-source-s3-parameters"></a>

FROM  <a name="copy-parameters-from"></a>
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*’   <a name="copy-s3-objectpath"></a>
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*’   <a name="copy-manifest-file"></a>
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  <a name="copy-manifest"></a>
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  <a name="copy-encrypted"></a>
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*’  <a name="copy-master-symmetric-key"></a>
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*’  <a name="copy-region"></a>
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
<a name="copy-parameters-data-source-s3-optional-parms"></a>

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
<a name="copy-parameters-data-source-s3-unsupported-parms"></a>

Vous ne pouvez pas utiliser les paramètres suivants avec la commande COPY à partir d’Amazon S3 : 
+ SSH
+ READRATIO

# Commande COPY depuis Amazon EMR
<a name="copy-parameters-data-source-emr"></a>

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
<a name="copy-parameters-data-source-emr-syntax"></a>

```
FROM 'emr://emr_cluster_id/hdfs_filepath'  
authorization
[ optional_parameters ]
```

## Exemple
<a name="copy-parameters-data-source-emr-example"></a>

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
<a name="copy-parameters-data-source-emr-parameters"></a>

FROM  
Source des données à charger. 

 ’emr://*emr\$1cluster\$1id*/*hdfs\$1file\$1path*’  <a name="copy-emr"></a>
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
<a name="copy-parameters-data-source-emr-optional-parms"></a>

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
<a name="copy-parameters-data-source-emr-unsupported-parms"></a>

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)
<a name="copy-parameters-data-source-ssh"></a>

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
<a name="copy-parameters-data-source-ssh-syntax"></a>

```
FROM 's3://'ssh_manifest_file' }
authorization
SSH
| optional-parameters
```

## Exemples
<a name="copy-parameters-data-source-ssh-examples"></a>

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
<a name="copy-parameters-data-source-ssh-parameters"></a>

FROM  
Source des données à charger. 

’s3://*copy\$1from\$1ssh\$1manifest\$1file*’  <a name="copy-ssh-manifest"></a>
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":"<ssh_endpoint_or_IP>", 
           "command": "<remote_command>",
           "mandatory":true, 
           "publickey": "<public_key>", 
           "username": "<host_user_name>"}, 
	    {"endpoint":"<ssh_endpoint_or_IP>", 
           "command": "<remote_command>",
           "mandatory":true, 
           "publickey": "<public_key>", 
           "username": "<host_user_name>"} 
     ] 
}
```
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  <a name="copy-ssh-manifest-endpoint"></a>
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  <a name="copy-ssh-manifest-command"></a>
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  <a name="copy-ssh-manifest-publickey"></a>
(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  <a name="copy-ssh-manifest-mandatory"></a>
(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  <a name="copy-ssh-manifest-username"></a>
(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  <a name="copy-ssh"></a>
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
<a name="copy-parameters-data-source-ssh-optional-parms"></a>

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
<a name="copy-parameters-data-source-ssh-unsupported-parms"></a>

Vous ne pouvez pas utiliser les paramètres suivants avec la commande COPY à partir de SSH : 
+ ENCRYPTED
+ MANIFEST
+ READRATIO

# Commande COPY depuis Amazon DynamoDB
<a name="copy-parameters-data-source-dynamodb"></a>

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
<a name="copy-parameters-data-source-dynamodb-syntax"></a>

```
FROM 'dynamodb://table-name' 
authorization
READRATIO ratio
| REGION [AS] 'aws_region'  
| optional-parameters
```

## Exemples
<a name="copy-parameters-data-source-dynamodb-examples"></a>

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
<a name="copy-parameters-data-source-dynamodb-parameters"></a>

FROM  
Source des données à charger. 

’dynamodb://*table-name*’  <a name="copy-dynamodb"></a>
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*  <a name="copy-readratio"></a>
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
<a name="copy-parameters-data-source-dynamodb-optional-parms"></a>

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
<a name="copy-parameters-data-source-dynamodb-unsupported-parms"></a>

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
<a name="copy-parameters-authorization"></a>

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
<a name="copy-iam-role"></a>

### IAM\$1ROLE
<a name="copy-iam-role-iam"></a>

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::<Compte AWS-id>:role/<role-name>' }
```

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
<a name="copy-access-key-id"></a>

### Utilisation de ACCESS\$1KEY\$1ID et SECRET\$1ACCESS\$1KEY
<a name="copy-access-key-id-access"></a>

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
<a name="copy-token"></a>

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 '<access-key-id>'
SECRET_ACCESS_KEY '<secret-access-key>'
SESSION_TOKEN '<temporary-token>';
```

Si vous spécifiez SESSION\$1TOKEN, vous ne pouvez utiliser ni IAM\$1ROLE, ni CREDENTIALS. 

## Utilisation du paramètre CREDENTIALS
<a name="copy-credentials"></a>

### CREDENTIALS
<a name="copy-credentials-cred"></a>

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::<aws-account-id>:role/<role-name>'
```

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=<temporary-access-key-id>;aws_secret_access_key=<temporary-secret-access-key>;token=<temporary-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=<temporary-access-key-id>;aws_secret_access_key=<temporary-secret-access-key-id>;token=<temporary-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ù *<root-key>* est la valeur de la clé racine utilisée pour chiffrer les fichiers.

```
CREDENTIALS
'<credentials-args>;master_symmetric_key=<root-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::<account-id>:role/<role-name>;master_symmetric_key=<root-key>'
```

# Options de mappage de colonnes
<a name="copy-parameters-column-mapping"></a>

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
<a name="copy-column-list"></a>

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
<a name="copy-column-mapping-jsonpaths"></a>

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
<a name="copy-parameters-data-format"></a>

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). <a name="copy-data-format-parameters"></a>Paramètres du format de données

FORMAT [AS]  <a name="copy-format"></a>
(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’* ]  <a name="copy-csv"></a>
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’*  <a name="copy-csv-quote"></a>
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*’]   <a name="copy-delimiter"></a>
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*’   <a name="copy-fixedwidth"></a>
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’*] ]  <a name="copy-shapefile"></a>
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*]  <a name="copy-shapefile-simplify"></a>
(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*]  <a name="copy-shapefile-simplify"></a>
(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*’  <a name="copy-avro"></a>
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.   
<a name="copy-avro-schema"></a>**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*’  <a name="copy-json"></a>
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’  <a name="copy-json-auto"></a>
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’  <a name="copy-json-auto-ignorecase"></a>
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*’  <a name="copy-json-pathfile"></a>
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’  <a name="copy-json-noshred"></a>
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
<a name="copy-json-data-file"></a>

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
<a name="copy-json-jsonpaths"></a>

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
<a name="copy-json-jsonpath-expressions"></a>

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
<a name="using-jsonpath-with-avro"></a>

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
<a name="copy-parameters-columnar-data"></a>

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  <a name="copy-orc"></a>
Charge les données à partir d’un fichier qui utilise le format de fichier ORC (Optimized Row Columnar). 

PARQUET  <a name="copy-parquet"></a>
Charge les données à partir d’un fichier qui utilise le format de fichier Parquet. 

# Paramètres de compression de fichier
<a name="copy-parameters-file-compression"></a>

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   <a name="copy-bzip2"></a>
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   <a name="copy-gzip"></a>
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   <a name="copy-lzop"></a>
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   <a name="copy-zstd"></a>
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
<a name="copy-parameters-data-conversion"></a>

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) <a name="copy-data-conversion-parameters"></a>Paramètres de conversion de données

ACCEPTANYDATE   <a name="copy-acceptanydate"></a>
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*’]   <a name="copy-acceptinvchars"></a>
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   <a name="copy-blanksasnull"></a>
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  <a name="copy-dateformat"></a>
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   <a name="copy-emptyasnull"></a>
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*  <a name="copy-encoding"></a>
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   <a name="copy-escape"></a>
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   <a name="copy-explicit-ids"></a>
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   <a name="copy-fillrecord"></a>
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   <a name="copy-ignoreblanklines"></a>
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*   <a name="copy-ignoreheader"></a>
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*’   <a name="copy-null-as"></a>
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   <a name="copy-removequotes"></a>
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   <a name="copy-roundec"></a>
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  <a name="copy-timeformat"></a>
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   <a name="copy-trimblanks"></a>
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   <a name="copy-truncatecolumns"></a>
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
<a name="copy-parameters-data-load"></a>

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) <a name="copy-data-load-parameters"></a>Parameters

COMPROWS *numrows*   <a name="copy-comprows"></a>
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 ]  <a name="copy-compupdate"></a>
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   <a name="copy-ignoreallerrors"></a>
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*   <a name="copy-maxerror"></a>
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   <a name="copy-noload"></a>
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 ]  <a name="copy-statupdate"></a>
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
<a name="r_COPY-alphabetical-parm-list"></a>

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)