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.
# Référence SQL
Amazon Redshift vous permet de tirer parti du SQL pour interroger et analyser efficacement de grandes quantités de données stockées dans votre entrepôt de données. La référence SQL couvre la syntaxe et l’utilisation des commandes SQL, des types de données, des fonctions, des opérateurs, etc., vous permettant d’extraire des informations et de prendre des décisions basées sur les données. Vous pouvez consulter cette référence pour écrire des requêtes optimisées, créer et gérer des objets de base de données et effectuer des transformations de données complexes. La référence suivante fournit des informations complètes sur l’utilisation de SQL dans l’environnement Amazon Redshift pour répondre à vos exigences en matière d’analyse de données.
**Topics**
+ [Amazon Redshift SQL](c_redshift-sql.md)
+ [Utilisation de SQL](c_SQL_reference.md)
+ [Commandes SQL](c_SQL_commands.md)
+ [Référence sur les fonctions SQL](c_SQL_functions.md)
+ [Mots réservés](r_pg_keywords.md)
# Amazon Redshift SQL
**Topics**
+ [Fonctions SQL prises en charge sur le nœud principal](c_sql-functions-leader-node.md)
+ [Amazon Redshift et PostgreSQL](c_redshift-and-postgres-sql.md)
Amazon Redshift repose sur le langage SQL standard, avec des fonctionnalités supplémentaires permettant de gérer de très grands ensembles de données et de prendre en charge des analyses et des rapports performants sur ces données.
**Note**
La taille maximale d’une instruction SQL Amazon Redshift est de 16 Mo.
# Fonctions SQL prises en charge sur le nœud principal
Certaines requêtes Amazon Redshift sont distribuées et exécutées sur les nœuds de calcul, et d’autres requêtes s’exécutent exclusivement sur le nœud principal.
Le nœud principal répartit SQL sur les nœuds de calcul chaque fois qu’une requête fait référence à des tables créées par l’utilisateur ou à des tables système (tables avec le préfixe STL ou STV, et vues système avec le préfixe SVL ou SVV). Une requête qui ne fait référence qu’aux tables catalogue (tables avec le préfixe PG, comme PG\$1TABLE\$1DEF, résidant sur le nœud principal) ou qui ne fait référence à aucune table, s’exécute exclusivement sur le nœud principal.
Certaines fonctions SQL d’Amazon Redshift sont prises en charge uniquement sur le nœud principal et ne le sont pas sur les nœuds de calcul. Une requête qui utilise une fonction de nœud principal doit être exécutée exclusivement sur celui-ci, et non sur les nœuds de calcul, sinon elle renverra une erreur.
La documentation de chaque fonction qui doit s’exécuter exclusivement sur le nœud principal comprend une note indiquant que la fonction renverra une erreur si elle fait référence à des tables définies par l’utilisateur ou à des tables du système Amazon Redshift. Consultez [Fonctions exécutées uniquement sur le nœud principal](c_SQL_functions_leader_node_only.md) pour obtenir la liste des fonctions qui s’exécutent exclusivement sur le nœud principal.
## Exemples
Les exemples suivants utilisent l’exemple de base de données TICKIT. Pour plus d’informations sur l’exemple de base de données, consultez [Exemple de base de données](c_sampledb.md).
**CURRENT\$1SCHEMA**
La fonction CURRENT\$1SCHEMA est une fonction de nœud principal uniquement. Dans cet exemple, comme la requête ne fait pas référence à une table, la fonction s’exécute exclusivement sur le nœud principal.
```
select current_schema();
current_schema
---------------
public
```
Dans l’exemple suivant, comme la requête fait référence à une table catalogue système, la fonction s’exécute exclusivement sur le nœud principal.
```
select * from pg_table_def
where schemaname = current_schema() limit 1;
schemaname | tablename | column | type | encoding | distkey | sortkey | notnull
------------+-----------+--------+----------+----------+---------+---------+---------
public | category | catid | smallint | none | t | 1 | t
```
Dans l’exemple suivant, la requête fait référence à une table système Amazon Redshift qui réside sur les nœuds de calcul, et renvoie donc une erreur.
```
select current_schema(), userid from users;
INFO: Function "current_schema()" not supported.
ERROR: Specified types or functions (one per INFO message) not supported on Amazon Redshift tables.
```
**SUBSTR**
SUBSTR est également une fonction réservée aux nœuds principaux. Dans l’exemple suivant, la requête s’exécute exclusivement sur le nœud principal, car elle ne fait pas référence à une table.
```
SELECT SUBSTR('amazon', 5);
+--------+
| substr |
+--------+
| on |
+--------+
```
Dans l’exemple suivant, la requête fait référence à une table qui réside sur les nœuds de calcul. Cela entraîne une erreur.
```
SELECT SUBSTR(catdesc, 1) FROM category LIMIT 1;
ERROR: SUBSTR() function is not supported (Hint: use SUBSTRING instead)
```
Pour exécuter correctement la requête précédente, utilisez [SUBSTRING](https://docs.aws.amazon.com/redshift/latest/dg/r_SUBSTRING.html).
```
SELECT SUBSTRING(catdesc, 1) FROM category LIMIT 1;
+---------------------------------+
| substring |
+---------------------------------+
| National Basketball Association |
+---------------------------------+
```
**FACTORIAL()**
FACTORIAL() est une fonction qui s’exécute uniquement sur le nœud principal. Dans l’exemple suivant, la requête s’exécute exclusivement sur le nœud principal, car elle ne fait pas référence à une table.
```
SELECT FACTORIAL(5);
factorial
-------------
120
```
Dans l’exemple suivant, la requête fait référence à une table qui réside sur les nœuds de calcul. Cela entraîne une erreur lors de l’exécution à l’aide de l’éditeur de requête v2.
```
create table t(a int);
insert into t values (5);
select factorial(a) from t;
ERROR: Specified types or functions (one per INFO message) not supported on Redshift tables.
Info: Function "factorial(bigint)" not supported.
```
# Amazon Redshift et PostgreSQL
**Topics**
+ [JDBC et ODBC Amazon Redshift et PostgreSQL](c_redshift-postgres-jdbc.md)
+ [Fonctions mises en œuvre différemment](c_redshift-sql-implementated-differently.md)
+ [Fonctions PostgreSQL non prises en charge](c_unsupported-postgresql-features.md)
+ [Types de données PostgreSQL non pris en charge](c_unsupported-postgresql-datatypes.md)
+ [Fonctions PostgreSQL non prises en charge](c_unsupported-postgresql-functions.md)
Amazon Redshift est basé sur PostgreSQL. Amazon Redshift et PostgreSQL présentent un certain nombre de différences très importantes dont vous devez être conscient lorsque vous concevez et développez vos applications d’entrepôt des données.
Amazon Redshift est spécifiquement conçu pour les applications de traitement analytique en ligne (OLAP) et de Business Intelligence (BI), qui nécessitent des requêtes complexes sur de grands ensembles de données. Parce qu’il répond à des exigences très différentes, le schéma de stockage de données spécialisé et le moteur d’exécution de requêtes qu’Amazon Redshift utilise sont complètement différents de l’implémentation PostgreSQL. Par exemple, là où les applications de traitement des transactions en ligne (OLTP) stockent généralement les données dans des lignes, Amazon Redshift stocke les données dans des colonnes, à l’aide d’encodages de compression de données spécialisés pour une utilisation optimale de la mémoire et des I/O disque. Certaines fonctions PostgreSQL adaptées au traitement OLTP à plus petite échelle, telles que les index secondaires et les opérations efficaces de manipulation de données sur une seule ligne, ont été omises pour améliorer les performances.
Consultez [Architecture Amazon Redshift](c_redshift_system_overview.md) pour une explication détaillée de l’architecture du système d’entrepôt des données Amazon Redshift.
PostgreSQL 9.x comprend certaines fonctionnalités qui ne sont pas prises en charge par Amazon Redshift. En outre, il existe des différences importantes entre Amazon Redshift SQL et PostgreSQL dont vous devez être conscient. Cette section souligne les différences entre Amazon Redshift et PostgreSQL et fournit des conseils pour développer un entrepôt des données qui tire pleinement parti de l’implémentation SQL d’Amazon Redshift.
# JDBC et ODBC Amazon Redshift et PostgreSQL
Amazon Redshift étant basé sur PostgreSQL, nous avons précédemment recommandé d'utiliser les pilotes PostgreSQL version 8.4.703 et JDBC4 PSQLodBC version 9.x. Si vous utilisez actuellement ces pilotes, nous vous recommandons de passer aux nouveaux pilotes spécifiques à Amazon Redshift. Pour plus d’informations sur les pilotes et la configuration des connexions, consultez [Pilotes JDBC et ODBC pour Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/configuring-connections.html#connecting-drivers) dans le *Guide de gestion Amazon Redshift*.
Pour éviter les out-of-memory erreurs côté client lors de la récupération de grands ensembles de données à l'aide de JDBC, vous pouvez permettre à votre client de récupérer des données par lots en définissant le paramètre de taille d'extraction JDBC. Pour de plus amples informations, veuillez consulter [Définition du paramètre de taille d’extraction JDBC](set-the-JDBC-fetch-size-parameter.md).
Amazon Redshift ne reconnaît pas le paramètre JDBC maxRows. Spécifiez à la place une clause [LIMIT](r_ORDER_BY_clause.md#order-by-clause-limit) afin de limiter le jeu de résultats. Vous pouvez aussi utiliser une clause [OFFSET](r_ORDER_BY_clause.md#order-by-clause-offset) pour accéder directement à un point de départ spécifique du jeu de résultats.
# Fonctions mises en œuvre différemment
De nombreux éléments du langage SQL d’Amazon Redshift ont des caractéristiques de performance différentes et utilisent une syntaxe et une sémantique très différentes de l’implémentation PostgreSQL équivalente.
**Important**
Ne présumez pas que la sémantique des éléments que Amazon Redshift et PostgreSQL ont en commun est identique. Veillez à consulter la rubrique [Commandes SQL](c_SQL_commands.md) du *Guide du développeur Amazon Redshift* pour comprendre les différences, souvent subtiles.
Un exemple en particulier est celui de la commande [VACUUM](r_VACUUM_command.md), qui permet de nettoyer et de réorganiser les tables. VACUUM fonctionne différemment que dans la version PostgreSQL et utilise un autre jeu de paramètres. Consultez [Exécution de l’opération VACUUM sur les tables](t_Reclaiming_storage_space202.md) pour plus d’informations sur l’utilisation de VACUUM dans Amazon Redshift.
Souvent, les outils et les fonctions de gestion et d’administration de base de données sont également différents. Par exemple, Amazon Redshift maintient un ensemble de tables et de vues système qui fournissent des informations sur le fonctionnement du système. Pour plus d’informatons, consultez [Vues de surveillance SYS](serverless_views-monitoring.md).
La liste suivante comprend quelques exemples de fonctionnalités SQL qui sont implémentées différemment dans Amazon Redshift.
+ [CREATE TABLE](r_CREATE_TABLE_NEW.md)
Amazon Redshift ne prend pas en charge les espaces de table, le partitionnement de table et l’héritage, ainsi que certaines contraintes. L’implémentation Amazon Redshift de CREATE TABLE vous permet de définir les algorithmes de tri et de distribution pour les tables afin d’optimiser le traitement parallèle.
Amazon Redshift Spectrum prend en charge le partitionnement des tables à l’aide de la commande [CREATE EXTERNAL TABLE](r_CREATE_EXTERNAL_TABLE.md).
+ [ALTER TABLE](r_ALTER_TABLE.md)
Seul un sous-ensemble des actions ALTER COLUMN est pris en charge.
ADD COLUMN ne prend en charge que l’ajout d’une seule colonne dans chaque instruction ALTER TABLE.
+ [COPY](r_COPY.md)
La commande Amazon Redshift COPY est hautement spécialisée pour permettre le chargement de données à partir de compartiments Amazon S3 et de tables Amazon DynamoDB et pour faciliter la compression automatique. Consultez la section [Chargement de données dans Amazon Redshift](t_Loading_data.md) et la référence sur la commande COPY pour plus de détails.
+ [VACUUM](r_VACUUM_command.md)
Les paramètres de VACUUM sont entièrement différents. Par exemple, dans PostgreSQL, l’opération VACUUM par défaut récupère simplement de l’espace et le rend disponible en vue de sa réutilisation ; cependant, l’opération VACUUM par défaut dans Amazon Redshift correspond à VACUUM FULL, qui récupère de l’espace disque et retrie toutes les lignes.
+ Les espaces de fin des valeurs VARCHAR sont ignorés lorsque les valeurs de chaîne sont comparées. Pour plus d’informations, consultez [Signification des blancs de fin](r_Character_types.md#r_Character_types-significance-of-trailing-blanks).
# Fonctions PostgreSQL non prises en charge
Ces fonctionnalités PostgreSQL ne sont pas prises en charge par Amazon Redshift.
**Important**
Ne présumez pas que la sémantique des éléments que Amazon Redshift et PostgreSQL ont en commun est identique. Veillez à consulter la rubrique [Commandes SQL](c_SQL_commands.md) du *Guide du développeur Amazon Redshift* pour comprendre les différences, souvent subtiles.
+ L’outil de requête *psql* n’est pas pris en charge. Le client [Amazon Redshift RSQL](https://docs.aws.amazon.com/redshift/latest/mgmt/rsql-query-tool.html) est pris en charge.
+ Partitionnement de table (partitionnement par plage et par liste)
+ Espaces de table
+ Constaintes
+ Unique
+ Clé étrangère
+ Clé primaire
+ Contraintes de validation
+ Contraintes d’exclusion
Les contraintes d’unicité, de clé primaire et de clé étrangère sont autorisées, mais ne le sont qu’à titre informatif. Elles ne sont pas appliquées par le système, mais sont utilisées par le planificateur de requête.
+ Héritage
+ Colonnes système PostgreSQL
Amazon Redshift SQL ne définit pas implicitement les colonnes système. Cependant, les noms de colonne système PostgreSQL suivants ne peuvent pas être utilisés en tant que noms de colonne définis par l’utilisateur : `oid`, `tableoid`, `xmin`, `cmin`, `xmax`, `cmax` et `ctid`. Pour de plus amples informations, veuillez consulter [https://www.postgresql.org/docs/8.0/static/ddl-system-columns.html](https://www.postgresql.org/docs/8.0/static/ddl-system-columns.html).
+ Index
+ Clause NULL dans les fonctions de fenêtrage
+ Classements
Amazon Redshift ne prend pas en charge les séquences de classement spécifiques à une région ou définies par l’utilisateur. Consultez [Séquences de classement](c_collation_sequences.md).
+ Expressions de valeur
+ Expressions indicées
+ Constructeurs de tableau
+ Constructeurs de ligne
+ Triggers
+ Gestion des données externes (SQL/MED)
+ Fonctions de table
+ Liste VALUES utilisée en tant que tables de constantes
+ Séquences
+ Recherche en texte intégral
+ Les autorisations RULE et TRIGGER.
Amazon Redshift accorde ou révoque ces autorisations lorsque vous exécutez GRANT ALL ou REVOKE ALL, mais la présence ou l’absence des autorisations RULE et TRIGGER n’affecte en rien les autorisations d’accès du bénéficiaire.
# Types de données PostgreSQL non pris en charge
En règle générale, si une requête essaie d’utiliser un type de données non pris en charge, y compris les conversions explicites ou implicites, elle retourne une erreur. Cependant, certaines requêtes qui utilisent les types de données non pris en charge s’exécutent sur le nœud principal, mais pas sur les nœuds de calcul. Consultez [Fonctions SQL prises en charge sur le nœud principal](c_sql-functions-leader-node.md).
Pour afficher la liste des types de données pris en charge, consultez [Types de données](c_Supported_data_types.md).
Ces types de données PostgreSQL ne sont pas pris en charge par Amazon Redshift.
+ Arrays (tableaux)
+ BIT, BIT VARYING
+ BYTEA
+ Types composites
+ Types énumérés
+ Types géométriques (l’implémentation des types géométriques par Amazon Redshift est différente de celle de PostgreSQL)
+ HSTORE
+ JSON
+ Types d’adresse réseau
+ Types numériques
+ SERIAL, BIGSERIAL, SMALLSERIAL
+ MONEY
+ Types d’identifiant d’objet
+ Pseudo-types
+ Types de plage
+ Types de caractère spécial
+ "char" – Un type interne à un octet (où le type de données nommé char est placé entre guillemets).
+ name – Un type interne pour les noms d’objets.
Pour plus d’informations sur ces types, consultez [Special Character Types](https://www.postgresql.org/docs/8.0/datatype-character.html) dans la documentation PostgreSQL.
+ Types de recherche de texte
+ TXID\$1SNAPSHOT
+ UUID
+ xml
# Fonctions PostgreSQL non prises en charge
La plupart des fonctions qui ne sont pas exclues ont une sémantique ou utilisation différente. Par exemple, certaines fonctions prises en charge ne s’exécutent que sur le nœud principal. De même, certaines fonctions non prises en charge pas ne renvoient pas une erreur lorsqu’elles s’exécutent sur le nœud principal. Le fait que ces fonctions ne renvoient pas d’erreur dans certains cas ne doit pas être considéré comme une indication que la fonction est prise en charge par Amazon Redshift.
**Important**
Ne présumez pas que la sémantique des éléments que Amazon Redshift et PostgreSQL ont en commun est identique. Veillez à consulter la rubrique [Commandes SQL](c_SQL_commands.md) du *Guide du développeur de bases de données Amazon Redshift* pour comprendre les différences, souvent subtiles.
Pour plus d’informations, consultez [Fonctions SQL prises en charge sur le nœud principal](c_sql-functions-leader-node.md).
Ces fonctions PostgreSQL ne sont pas prises en charge dans Amazon Redshift.
+ Fonctions de demande de privilège d’accès
+ Fonctions de verrou consultatif
+ Fonctions d’agrégation
+ STRING\$1AGG()
+ ARRAY\$1AGG()
+ EVERY()
+ XML\$1AGG()
+ CORR()
+ COVAR\$1POP()
+ COVAR\$1SAMP()
+ REGR\$1AVGX(), REGR\$1AVGY()
+ REGR\$1COUNT()
+ REGR\$1INTERCEPT()
+ REGR\$1R2()
+ REGR\$1SLOPE()
+ REGR\$1SXX(), REGR\$1SXY(), REGR\$1SYY()
+ Opérateurs et fonctions de tableau
+ Fonctions de contrôle de sauvegarde
+ Fonctions d’informations de commentaire
+ Fonctions d’emplacement d’objet de base de données
+ Fonctions de taille d’objet de base de données
+ Fonctions et opérateurs Date/Time
+ CLOCK\$1TIMESTAMP()
+ JUSTIFY\$1DAYS(), JUSTIFY\$1HOURS(), JUSTIFY\$1INTERVAL()
+ PG\$1SLEEP()
+ TRANSACTION\$1TIMESTAMP()
+ Fonctions de prise en charge d’ENUM
+ Fonctions géométriques et opérateurs
+ Fonctions d’accès fichier générique
+ IS DISTINCT FROM
+ Fonctions d’adresse réseau et opérateurs
+ Fonctions mathématiques
+ DIV()
+ SETSEED()
+ WIDTH\$1BUCKET()
+ Fonctions de retour d’ensembles
+ GENERATE\$1SERIES()
+ GENERATE\$1SUBSCRIPTS()
+ Fonctions de plage et opérateurs
+ Fonctions de contrôle de récupération
+ Fonctions d’informations de récupération
+ Fonction ROLLBACK TO SAVEPOINT
+ Fonctions de demande de visibilité de schéma
+ Fonctions de signalisation de serveur
+ Fonctions de synchronisation d’instantané
+ Fonctions de manipulation de séquence
+ Fonctions de chaîne
+ BIT\$1LENGTH()
+ OVERLAY()
+ CONVERT(), CONVERT\$1FROM(), CONVERT\$1TO()
+ ENCODE()
+ FORMAT()
+ QUOTE\$1NULLABLE()
+ REGEXP\$1MATCHES()
+ REGEXP\$1SPLIT\$1TO\$1ARRAY()
+ REGEXP\$1SPLIT\$1TO\$1TABLE()
+ Fonctions d’informations de catalogue système
+ Fonctions d’informations système
+ CURRENT\$1CATALOG CURRENT\$1QUERY()
+ INET\$1CLIENT\$1ADDR()
+ INET\$1CLIENT\$1PORT()
+ INET\$1SERVER\$1ADDR() INET\$1SERVER\$1PORT()
+ PG\$1CONF\$1LOAD\$1TIME()
+ PG\$1IS\$1OTHER\$1TEMP\$1SCHEMA()
+ PG\$1LISTENING\$1CHANNELS()
+ PG\$1MY\$1TEMP\$1SCHEMA()
+ PG\$1POSTMASTER\$1START\$1TIME()
+ PG\$1TRIGGER\$1DEPTH()
+ SHOW VERSION()
+ Fonctions de recherche de texte et opérateurs
+ Fonctions de transaction IDs et d'instantanés
+ Fonctions déclencheur
+ Fonctions XML
# Utilisation de SQL
**Topics**
+ [Conventions du guide de référence SQL](c_SQL_reference_conventions.md)
+ [Éléments de base](c_Basic_elements.md)
+ [Expressions](r_expressions.md)
+ [Conditions](r_conditions.md)
Le langage SQL se compose de commandes et de fonctions que vous utilisez pour travailler avec les bases de données et les objets de base de données. Il applique également les règles concernant l’utilisation des types de données, les expressions et les littéraux.
# Conventions du guide de référence SQL
Cette section explique les conventions utilisées pour écrire la syntaxe des expressions, commandes et fonctions SQL décrites dans la section de référence SQL.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/c_SQL_reference_conventions.html)
# Éléments de base
**Topics**
+ [Noms et identificateurs](r_names.md)
+ [Littéraux](r_Literals.md)
+ [Valeurs null](r_Nulls.md)
+ [Types de données](c_Supported_data_types.md)
+ [Séquences de classement](c_collation_sequences.md)
Cette section concerne les règles d’utilisation des noms d’objet de base de données, des littéraux, des valeurs null et des types de données.
# Noms et identificateurs
Les noms identifient les objets de base de données, y compris les tables et les colonnes, ainsi que les utilisateurs et les mots de passe. Les termes *nom* et *identificateur* peuvent être utilisés indifféremment. Il existe deux types d’identificateurs, les identificateurs standard et les identificateurs entre guillemets ou délimités. Les identificateurs doivent comporter uniquement des caractères imprimables UTF-8. Les lettres ASCII des identificateurs standard et délimités sont insensibles à la casse et sont converties en minuscules dans la base de données. Dans les résultats des requêtes, les noms de colonne sont retournés en minuscules par défaut. Pour retourner les noms de colonne en majuscules, définissez le paramètre de configuration [describe\$1field\$1name\$1in\$1uppercase](r_describe_field_name_in_uppercase.md) sur la valeur **true**.
## Identificateurs standard
Les identificateurs SQL standard se conforment à un ensemble de règles et doivent :
+ Commencer par un caractère alphabétique ou de soulignement ASCII codé sur un octet, ou un caractère multioctet UTF-8 d’une longueur de deux ou quatre octets.
+ Les caractères suivants peuvent être des caractères alphanumériques ou de soulignement ASCII codés sur un octet, des symboles dollar, ou des caractères multioctets UTF-8 d’une longueur de deux ou quatre octets.
+ Avoir une longueur comprise entre 1 et 127 octets, sans les guillemets pour les identifiants délimités.
+ Ne contenir ni guillemets ni espaces.
+ Ne pas être un mot réservé SQL.
## Identificateurs délimités
Les identificateurs délimités (aussi appelés identificateurs entre guillemets) commencent et se terminent par des guillemets ("). Si vous utilisez un identificateur délimité, vous devez utiliser les guillemets pour chaque référence à cet objet. L’identifiant peut contenir tous les caractères imprimables UTF-8 standard autres que les guillemets droits eux-mêmes. Par conséquent, vous pouvez créer des noms de colonne ou de table qui incluent tout caractère autre que les caractères illégaux, tels que les espaces ou le symbole pourcentage (%).
Les lettres ASCII des identificateurs délimités sont insensibles à la casse et sont converties en minuscules. Pour utiliser des guillemets droits dans une chaîne de caractères, vous devez les faire précéder d’un autre caractère de guillemets droits.
## Identifiants sensibles à la casse
Les identifiants sensibles à la casse (également appelés identifiants en casse mixte) peuvent contenir des lettres majuscules et minuscules. Pour utiliser des identifiants sensibles à la casse, vous pouvez définir la configuration `enable_case_sensitive_identifier` sur `true`. Vous pouvez définir cette configuration pour le cluster ou une session. Pour plus d’informations, consultez [Valeurs des paramètres par défaut](https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-parameter-groups.html#default-param-group-values) dans le *Guide de gestion Amazon Redshift* et [enable\$1case\$1sensitive\$1identifier](r_enable_case_sensitive_identifier.md).
## Nom des colonnes système
Les noms de colonnes système PostgreSQL suivants ne peuvent pas être utilisés en tant que noms de colonne définis par l’utilisateur. Pour de plus amples informations, veuillez consulter [https://www.postgresql.org/docs/8.0/static/ddl-system-columns.html](https://www.postgresql.org/docs/8.0/static/ddl-system-columns.html).
+ `oid`
+ `tableoid`
+ `xmin`
+ `cmin`
+ `xmax`
+ `cmax`
+ `ctid`
## Exemples
Ce tableau présente des exemples d’identificateurs délimités, le résultat obtenu et une explication :
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/r_names.html)
Pour créer un groupe nommé table avec une colonne nommée this "is it" :
```
create table "group" (
"This ""IS IT""" char(10));
```
Les requêtes suivantes retournent le même résultat :
```
select "This ""IS IT"""
from "group";
this "is it"
--------------
(0 rows)
```
```
select "this ""is it"""
from "group";
this "is it"
--------------
(0 rows)
```
La syntaxe complète suivante `table.column` renvoie aussi le même résultat :
```
select "group"."this ""is it"""
from "group";
this "is it"
--------------
(0 rows)
```
La commande CREATE TABLE suivante crée une table avec une barre oblique dans un nom de colonne :
```
create table if not exists city_slash_id(
"city/id" integer not null,
state char(2) not null);
```
# Littéraux
Un littéral ou une constante est une valeur de données fixe, composée d’une séquence de caractères ou d’une constante numérique. Amazon Redshift prend en charge plusieurs types de littéraux, notamment :
+ Les littéraux numériques pour les entiers, les décimaux et les nombres à virgule flottante. Pour plus d’informations, consultez [Littéraux entiers et à virgule flottante](r_numeric_literals201.md).
+ Les littéraux caractère, également appelés chaînes, chaînes de caractères ou constantes caractère
+ Les littéraux de type datetime et interval utilisés avec les types de données datetime. Pour plus d’informations, consultez [Littéraux de type date, heure et horodatage](r_Date_and_time_literals.md) et [Types de données et littéraux interval](r_interval_data_types.md).
# Valeurs null
Si une colonne d’une ligne est manquante, inconnue ou non applicable, sa valeur est null ou est dite contenir une valeur null. Les valeurs null peuvent apparaître dans les champs de n’importe quel type de données qui n’est pas limité par les contraintes de clé primaire ou NOT NULL. Une valeur null n’est pas équivalente à la valeur zéro ou à une chaîne vide.
Toute expression arithmétique contenant une valeur null est toujours analysée comme null. Tous les opérateurs retournent une valeur null en cas d’argument ou d’opérande null.
Pour tester les valeurs null, utilisez les conditions de comparaison IS NULL et IS NOT NULL. Comme null représente une absence de données, une valeur null n’est pas égale à une autre valeur, null ou pas.
# Types de données
**Topics**
+ [Caractères multioctets](#c_Supported_data_types-multi-byte-characters)
+ [Types numériques](r_Numeric_types201.md)
+ [Types caractères](r_Character_types.md)
+ [Types datetime](r_Datetime_types.md)
+ [Type Boolean](r_Boolean_type.md)
+ [Type HLLSKETCH](r_HLLSKTECH_type.md)
+ [Type SUPER](r_SUPER_type.md)
+ [Type VARBYTE](r_VARBYTE_type.md)
+ [Compatibilité et conversion de types](#r_Type_conversion)
Chaque valeur qu’Amazon Redshift stocke ou extrait possède un type de données avec un ensemble fixe de propriétés associées. Les types de données sont déclarés lorsque les tables sont créées. Un type de données contraint l’ensemble des valeurs qu’une colonne ou un argument peut contenir.
Le tableau suivant répertorie les types de données que vous pouvez utiliser dans les tables Amazon Redshift.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/c_Supported_data_types.html)
**Note**
Pour plus d’informations sur les types de données non pris en charge, tels que "char" (notez que char est placé entre guillemets), consultez [Types de données PostgreSQL non pris en charge](c_unsupported-postgresql-datatypes.md).
## Caractères multioctets
Le type de données VARCHAR prend en charge les caractères multioctets UTF-8 jusqu’à un maximum de quatre octets. Les caractères de cinq octets ou plus ne sont pas pris en charge. Pour calculer la taille d’une colonne VARCHAR qui contient des caractères multioctets, multipliez le nombre de caractères par le nombre d’octets par caractère. Par exemple, si une chaîne possède quatre caractères chinois et que chaque caractère est long de trois octets, vous avez besoin d’une colonne VARCHAR(12) pour stocker la chaîne.
Le type de données VARCHAR ne prend pas en charge les points de code UTF-8 non valides suivants :
`0xD800 – 0xDFFF` (Séquences d’octets :`ED A0 80` – `ED BF BF`)
Le type de données CHAR ne prend pas en charge les caractères multioctets.
# Types numériques
**Topics**
+ [Types d’entier](#r_Numeric_types201-integer-types)
+ [Type DECIMAL ou NUMERIC](#r_Numeric_types201-decimal-or-numeric-type)
+ [Notes sur l’utilisation des colonnes DECIMAL ou NUMERIC 128 bits](#r_Numeric_types201-notes-about-using-128-bit-decimal-or-numeric-columns)
+ [Types à virgule flottante](#r_Numeric_types201-floating-point-types)
+ [Calculs avec les valeurs numériques](r_numeric_computations201.md)
+ [Littéraux entiers et à virgule flottante](r_numeric_literals201.md)
+ [Exemples avec les types numériques](r_Examples_with_numeric_types201.md)
Les types de données numériques incluent les entiers, les décimaux et les nombres à virgule flottante.
## Types d’entier
Utilisez les types de données SMALLINT, INTEGER et BIGINTpour stocker les nombres entiers de différentes plages. Vous ne pouvez pas stocker de valeurs en dehors de la plage autorisée pour chaque type.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/r_Numeric_types201.html)
## Type DECIMAL ou NUMERIC
Utilisez le type de données DECIMAL ou NUMERIC pour stocker les valeurs avec une *précision définie par l’utilisateur*. Les mots clés DECIMAL et NUMERIC sont interchangeables. Dans ce document, *decimal* est le terme privilégié pour ce type de données. Le terme *numeric* (numérique) est utilisé de façon générique pour faire référence aux types de données integer, decimal et floating-point (entier, décimal et virgule flottante).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/r_Numeric_types201.html)
Définissez une colonne DECIMAL dans une table en spécifiant une *precision (précision)* et une *scale (échelle)* :
```
decimal(precision, scale)
```
*precision*
Le nombre total de chiffres significatifs dans la valeur entière : le nombre de chiffres de chaque côté de la virgule. Par exemple, le nombre `48.2891` a une précision de 6 et une échelle de 4. La précision par défaut, si elle n’est pas spécifiée, est de 18. La précision maximale est de 38.
Si le nombre de chiffres à gauche de la virgule dans une valeur d’entrée dépasse la précision de la colonne moins son échelle, la valeur ne peut pas être copiée dans la colonne (ou insérée ou mise à jour). Cette règle s’applique à toute valeur qui se trouve en dehors de la plage de la définition de la colonne. Par exemple, la plage autorisée de valeurs pour une colonne `numeric(5,2)` s’étend de `-999.99` à `999.99`.
*échelle*
Le nombre de chiffres décimaux de la partie fractionnaire de la valeur, à droite de la virgule. Les entiers possèdent une échelle égale à zéro. Dans une spécification de colonne, la valeur de l’échelle doit être inférieure ou égale à la valeur de la précision. L’échelle par défaut, si elle n’est pas spécifiée, est de 0. L’échelle maximale est de 37.
Si l’échelle d’une valeur d’entrée chargée dans une table est supérieure à l’échelle de la colonne, la valeur est arrondie à l’échelle spécifiée. Par exemple, la colonne PRICEPAID de la table SALES est une colonne DECIMAL(8,2). Si une valeur DECIMAL(8,4) est insérée dans la colonne PRICEPAID, la valeur est arrondie à une échelle de 2.
```
insert into sales
values (0, 8, 1, 1, 2000, 14, 5, 4323.8951, 11.00, null);
select pricepaid, salesid from sales where salesid=0;
pricepaid | salesid
-----------+---------
4323.90 | 0
(1 row)
```
Cependant, les résultats de conversions explicites de valeurs sélectionnées dans les tables ne sont pas arrondis.
**Note**
La valeur positive maximale que vous pouvez insérer dans une colonne DECIMAL(19,0) est `9223372036854775807` (263 -1). La valeur négative maximale est `-9223372036854775808`. Par exemple, une tentative d’insérer la valeur `9999999999999999999` (19 fois le chiffre neuf) entraîne une erreur de dépassement de capacité. Quelque soit le placement de la virgule décimale, la plus grande chaîne qu’Amazon Redshift puisse représenter comme nombre DECIMAL est `9223372036854775807`. Par exemple, la plus grande valeur que vous puissiez charger dans une colonne DECIMAL(19,18) est `9.223372036854775807`.
Ces règles sont dues au fait que les valeurs de type DECIMAL d’une précision de 19 chiffres significatifs ou moins sont stockées en interne sous forme d’entiers de 8 octets, tandis que celles de type DECIMAL d’une précision de 20 à 38 chiffres significatifs sont stockées sous forme d’entiers de 16 octets.
## Notes sur l’utilisation des colonnes DECIMAL ou NUMERIC 128 bits
N’attribuez pas de façon arbitraire une précision maximale aux colonnes DECIMAL, sauf si vous avez la certitude que votre application a besoin de cette précision. Les valeurs 128 bits utilisent deux fois plus d’espace disque que les valeurs 64 bits et peuvent ralentir le temps d’exécution des requêtes.
## Types à virgule flottante
Utilisez les types de données REAL et DOUBLE PRECISION pour stocker les valeurs numériques avec une *précision variable*. Ces types sont des types *inexacts*, ce qui signifie que certaines valeurs sont stockées comme approximations, de telle sorte que le stockage et le retour d’une valeur spécifique peuvent se traduire par de légers écarts. Si vous avez besoin d’un stockage et d’un calcul exacts (pour des montants monétaires, par exemple), utilisez le type de données DECIMAL.
REAL représente le format à virgule flottante simple précision, conformément à la norme IEEE 754 pour l’arithmétique binaire à virgule flottante. Il a une précision d’environ 6 chiffres et une plage d’environ 1E-37 à 1E\$137. Vous pouvez également spécifier ce type de données sous la forme FLOAT4.
DOUBLE PRECISION représente le format de virgule flottante en double précision, conformément à la norme IEEE 754 pour l’arithmétique binaire en virgule flottante. Il a une précision d’environ 15 chiffres et une plage d’environ 1E-307 à 1E\$1308. Vous pouvez également spécifier ce type de données comme FLOAT ou FLOAT8.
Outre les valeurs numériques ordinaires, les types à virgule flottante possèdent plusieurs valeurs spéciales. Quand vous utilisez ces valeurs dans SQL, entourez-les de guillemets simples :
+ `NaN` – not-a-number
+ `Infinity` : infini
+ `-Infinity` : infini négatif
Par exemple, pour insérer not-a-number dans une colonne `day_charge` de table, `customer_activity` exécutez le code SQL suivant :
```
insert into customer_activity(day_charge) values('NaN');
```
# Calculs avec les valeurs numériques
Dans ce contexte, le terme *calcul* fait référence aux opérations mathématiques binaires : addition, soustraction, multiplication et division. Cette section décrit les types de retour attendus pour ces opérations, ainsi que la formule spécifique appliquée pour déterminer la précision et l’échelle lorsque les types de données DECIMAL sont impliqués.
Lorsque des valeurs numériques sont calculées pendant le traitement des requêtes, vous pouvez rencontrer des cas où le calcul est impossible et où la requête renvoie une erreur de dépassement de capacité numérique. Vous pouvez également rencontrer des cas où l’échelle des valeurs calculées varie ou est inattendue. Pour certaines opérations, vous pouvez utiliser un transtypage explicite (promotion de type) ou des paramètres de configuration Amazon Redshift pour contourner ces problèmes.
Pour plus d’informations sur les résultats de calculs similaires avec les fonctions SQL, consultez [Fonctions d’agrégation](c_Aggregate_Functions.md).
## Types de retour pour les calculs
Compte tenu de l’ensemble des types de données numériques pris en charge par Amazon Redshift, le tableau suivant présente les types de retour attendus pour les opérations d’addition, de soustraction, de multiplication et de division. La première colonne sur la gauche du tableau représente le premier opérande dans le calcul et la ligne du haut le second opérande.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/r_numeric_computations201.html)
## Précision et échelle des résultats DECIMAL calculés
Le tableau suivant résume les règles de calcul de la précision et de l’échelle obtenues lorsque les opérations mathématiques retournent des résultats DECIMAL. Dans cette table, `p1` et `s1` représentent la précision et l’échelle du première opérande d’un calcul, tandis que `p2` et `s2` représentent la précision et l’échelle du second opérande. (Quels que soient les calculs, la précision maximale du résultat est de 38 et l’échelle maximale du résultat de 38 également.)
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/r_numeric_computations201.html)
Par exemple, les colonnes PRICEPAID et COMMISSION de la table SALES sont toutes deux des colonnes DECIMAL(8,2). Si vous divisez PRICEPAID par COMMISSION (ou inversement), la formule est appliquée comme suit :
```
Precision = 8-2 + 2 + max(4,2+8-2+1)
= 6 + 2 + 9 = 17
Scale = max(4,2+8-2+1) = 9
Result = DECIMAL(17,9)
```
Le calcul suivant constitue la règle générale pour le calcul de la précision et de l’échelle obtenues dans le cas des opérations effectuées sur les valeurs DECIMAL avec les opérateurs définis tels que UNION, INTERSECT et EXCEPT, ou les fonctions comme COALESCE et DECODE :
```
Scale = max(s1,s2)
Precision = min(max(p1-s1,p2-s2)+scale,19)
```
Par exemple, une DEC1 table avec une colonne DECIMAL (7,2) est jointe à une DEC2 table avec une colonne DECIMAL (15,3) pour créer une table. DEC3 Le schéma de DEC3 montre que la colonne devient une colonne NUMERIC (15,3).
```
create table dec3 as select * from dec1 union select * from dec2;
```
Résultat
```
select "column", type, encoding, distkey, sortkey
from pg_table_def where tablename = 'dec3';
column | type | encoding | distkey | sortkey
-------+---------------+----------+---------+---------
c1 | numeric(15,3) | none | f | 0
```
Dans l’exemple ci-dessus, la formule est appliquée comme suit :
```
Precision = min(max(7-2,15-3) + max(2,3), 19)
= 12 + 3 = 15
Scale = max(2,3) = 3
Result = DECIMAL(15,3)
```
## Remarques sur les opérations de division
Pour les opérations de division, divide-by-zero les conditions renvoient des erreurs.
La limite d’échelle de 100 est appliquée après le calcul de la précision et de l’échelle. Si l’échelle de résultat calculée est supérieure à 100, les résultats de la division sont mis à l’échelle comme suit :
+ Précision = ` precision - (scale - max_scale)`
+ Évolutivité = ` max_scale `
Si la précision calculée est supérieure à la précision maximale (38), la précision est réduite à 38, et l’échelle devient le résultat de : `max((38 + scale - precision), min(4, 100))`
## Conditions de dépassement de capacité
Le dépassement de capacité est contrôlé pour tous les calculs numériques. Les données DECIMAL avec une précision de 19 ou moins sont stockées en tant qu’entiers 64 bits. Les données DECIMAL avec une précision supérieure à 19 sont stockées sous forme d’entiers 128 bits. La précision maximale de toutes les valeurs DECIMAL est 38 et l’échelle maximale 37. Les erreurs de dépassement de capacité se produisent quand une valeur dépasse ces limites, qui s’appliquent aux jeux de résultats intermédiaires et finaux :
+ Le transtypage explicite se traduit par des erreurs de dépassement de capacité à l’exécution lorsque les valeurs de données spécifiques ne correspondent pas à la précision ou à l’échelle spécifiée par la fonction cast. Par exemple, vous ne pouvez pas effectuer une conversion de type de toutes les valeurs de la colonne PRICEPAID de la table SALES (une colonne DECIMAL(8,2)) et retourner un résultat DECIMAL(7,3) :
```
select pricepaid::decimal(7,3) from sales;
ERROR: Numeric data overflow (result precision)
```
Cette erreur se produit, parce que *certaines* des valeurs les plus grandes de la colonne PRICEPAID ne peuvent pas être converties.
+ Les opérations de multiplication produisent des résultats dans lesquels l’échelle du résultat est la somme des échelles de chaque opérande. Si les deux opérandes ont une échelle de 4, par exemple, l’échelle du résultat est 8, ce qui ne laisse que 10 chiffres à gauche de la virgule. Par conséquent, il est relativement facile de se trouver en situation de dépassement de capacité lors de la multiplication de deux grands nombres ayant une échelle significative.
L’exemple suivant entraîne une erreur de dépassement de capacité.
```
SELECT CAST(1 AS DECIMAL(38, 20)) * CAST(10 AS DECIMAL(38, 20));
ERROR: 128 bit numeric data overflow (multiplication)
```
Vous pouvez contourner l’erreur de dépassement de capacité en utilisant la division au lieu de la multiplication. Utilisez l’exemple suivant pour diviser par 1 divisé par le diviseur d’origine.
```
SELECT CAST(1 AS DECIMAL(38, 20)) / (1 / CAST(10 AS DECIMAL(38, 20)));
+----------+
| ?column? |
+----------+
| 10 |
+----------+
```
## Calculs numériques avec les types INTEGER et DECIMAL
Lorsqu’un des opérandes d’un calcul est de type de données INTEGER et que l’autre opérande est DECIMAL, l’opérande INTEGER est implicitement converti en DECIMAL :
+ INT2 (SMALLINT) est converti en DECIMAL (5,0)
+ INT4 (INTEGER) est converti en DECIMAL (10,0)
+ INT8 (BIGINT) est converti en DECIMAL (19,0)
Par exemple, si vous multipliez SALES.COMMISSION, colonne DECIMAL(8,2) et SALES.QTYSOLD, colonne SMALLINT, le calcul est converti comme suit :
```
DECIMAL(8,2) * DECIMAL(5,0)
```
# Littéraux entiers et à virgule flottante
Les littéraux ou constantes qui représentent des nombres peuvent être des entiers ou à virgule flottante.
## Littéraux entiers
Une constante entière est une séquence des chiffres 0-9, avec un signe positif (\$1) ou négatif (-) facultatif devant les chiffres.
## Syntaxe
```
[ + | - ] digit ...
```
## Exemples
Les entiers valides incluent les éléments suivants :
```
23
-555
+17
```
## Littéraux à virgule flottante
Les littéraux à virgule flottante (également appelés littéraux décimaux, numériques ou fractionnaires) sont des séquences de chiffres qui peuvent inclure une virgule décimale et, le cas échéant, le symbole exposant (e).
## Syntaxe
```
[ + | - ] digit ... [ . ] [ digit ...]
[ e | E [ + | - ] digit ... ]
```
## Arguments
e \$1 E
e ou E indique que le nombre est spécifié en notation scientifique.
## Exemples
Les littéraux à virgule flottante incluent les éléments suivants :
```
3.14159
-37.
2.0e19
-2E-19
```
# Exemples avec les types numériques
## Instruction CREATE TABLE
L’instruction CREATE TABLE suivante illustre la déclaration de différents types de données numériques :
```
create table film (
film_id integer,
language_id smallint,
original_language_id smallint,
rental_duration smallint default 3,
rental_rate numeric(4,2) default 4.99,
length smallint,
replacement_cost real default 25.00);
```
## Tentative d’insérer un entier qui est hors de portée
L’exemple suivant tente d’insérer la valeur 33 000 dans une colonne SMALLINT.
```
insert into film(language_id) values(33000);
```
La plage valide pour SMALLINT étant -32768 à \$132767, Amazon Redshift retourne une erreur.
```
An error occurred when executing the SQL command:
insert into film(language_id) values(33000)
ERROR: smallint out of range [SQL State=22003]
```
## Insérer une valeur décimale dans une colonne de type entier
L’exemple suivant insère la valeur décimale a dans une colonne INT.
```
insert into film(language_id) values(1.5);
```
Cette valeur est insérée, mais arrondie à la valeur entière 2.
## Insertion réussie d’une valeur décimale parce que son échelle est arrondie
L’exemple suivant insère une valeur décimale ayant une plus grande précision que la colonne.
```
insert into film(rental_rate) values(35.512);
```
Dans ce cas, la valeur `35.51` est insérée dans la colonne.
## Tentative d’insertion d’une valeur décimale qui est hors de portée
Dans ce cas, la valeur `350.10` est hors de portée. Le nombre de chiffres pour les valeurs de colonnes DECIMAL est égal à la précision de la colonne moins son échelle (4 moins 2 pour la colonne RENTAL\$1RATE). Autrement dit, la plage autorisée pour une colonne `DECIMAL(4,2)` s’étend de `-99.99` à `99.99`.
```
insert into film(rental_rate) values (350.10);
ERROR: numeric field overflow
DETAIL: The absolute value is greater than or equal to 10^2 for field with precision 4, scale 2.
```
## Insérer des valeurs de précision variable dans une colonne REAL
L’exemple suivant insère des valeurs de précision variable dans une colonne REAL.
```
insert into film(replacement_cost) values(1999999.99);
insert into film(replacement_cost) values(1999.99);
select replacement_cost from film;
+------------------+
| replacement_cost |
+------------------+
| 2000000 |
| 1999.99 |
+------------------+
```
La valeur `1999999.99` est convertie en `2000000` pour satisfaire aux exigences de précision pour la colonne `REAL`. La valeur `1999.99` est chargée en l’état.
# Types caractères
**Topics**
+ [Stockage et plages](#r_Character_types-storage-and-ranges)
+ [CHAR ou CHARACTER](#r_Character_types-char-or-character)
+ [VARCHAR ou CHARACTER VARYING](#r_Character_types-varchar-or-character-varying)
+ [Types NCHAR et NVARCHAR](#r_Character_types-nchar-and-nvarchar-types)
+ [Types TEXT et BPCHAR](#r_Character_types-text-and-bpchar-types)
+ [Signification des blancs de fin](#r_Character_types-significance-of-trailing-blanks)
+ [Exemples avec les types caractères](r_Examples_with_character_types.md)
Les types de données caractères incluent CHAR (caractère) et VARCHAR (caractère variable).
## Stockage et plages
Les types de données CHAR et VARCHAR sont définis en termes d’octets, pas de caractères. Comme une colonne CHAR ne peut contenir que des caractères d’un octet, une colonne CHAR(10) peut contenir une chaîne d’une longueur maximale de 10 octets. Une donnée VARCHAR peut contenir des caractères multioctets, jusqu’à un maximum de quatre octets par caractère. Par exemple, une colonne VARCHAR(12) peut contenir 12 caractères codés sur un octet, 6 caractères codés sur deux octets, 4 caractères codés sur trois octets ou 3 caractères codés sur quatre octets.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/r_Character_types.html)
**Note**
La syntaxe CREATE TABLE prend en charge le mot clé MAX pour les types de données character. Par exemple :
```
create table test(col1 varchar(max));
```
Pour CHAR, MAX définit la largeur de colonne comme étant de 4 096 octets.
Pour VARCHAR, MAX définit la largeur de colonne à 65 535 octets dans les instructions CREATE TABLE. Pour les opérations en mémoire, VARCHAR (MAX) prend en charge jusqu'à 16 000 000 octets.
## CHAR ou CHARACTER
Utilisez une colonne CHAR ou CHARACTER pour stocker les chaînes de longueur fixe. Ces chaînes étant remplies de blancs, une colonne CHAR(10) occupe toujours 10 octets de stockage.
```
char(10)
```
Une colonne CHAR sans spécification de longueur se traduit par une colonne CHAR(1).
## VARCHAR ou CHARACTER VARYING
Utilisez une colonne VARCHAR ou CHARACTER VARYING pour stocker des chaînes de longueur variable avec une limite fixe. Comme ces chaînes ne sont pas remplies avec des blancs, une colonne VARCHAR(120) se compose d’un maximum de 120 caractères codés sur un octet, de 60 caractères codés sur deux octets, de 40 caractères codés sur trois octets ou de 30 caractères codés sur quatre octets.
```
varchar(120)
```
Si vous utilisez le type de données VARCHAR sans spécification de la longueur dans une instruction CREATE TABLE, la longueur par défaut est 256.
[Fonctions de chaîne](String_functions_header.md)supporte désormais jusqu'à 16 000 000 octets. Par exemple, la sortie de la fonction CONCAT était auparavant limitée à 65 535 octets, mais prend désormais en charge jusqu'à 16 000 000 octets.
```
SELECT LEN(CONCAT(REPEAT('A', 5000000), REPEAT('B', 5000000))) AS total_length;
total_length
--------------
10000000
```
## Types NCHAR et NVARCHAR
Vous pouvez créer des colonnes avec les types NCHAR et NVARCHAR (aussi appelés types NATIONAL CHARACTER et NATIONAL CHARACTER VARYING). Ces types sont convertis en types CHAR et VARCHAR, respectivement, et sont stockés dans le nombre d’octets spécifié.
Une colonne NCHAR sans spécification de longueur est convertie en colonne CHAR(1).
Une colonne NVARCHAR sans spécification de longueur est convertie en colonne VARCHAR(256).
## Types TEXT et BPCHAR
Vous pouvez créer une table Amazon Redshift avec une colonne TEXT, mais celle-ci est convertie en une colonne VARCHAR(256) qui accepte des valeurs de longueur variable avec un maximum de 256 caractères.
Vous pouvez créer une colonne Amazon Redshift avec un type BPCHAR (blank-padded character), qu’Amazon Redshift convertit en une colonne CHAR(256) de longueur fixe.
## Signification des blancs de fin
Les types de données CHAR et VARCHAR stockent les chaînes de longueur maximale de *n* octets. Une tentative de stocker une chaîne plus longue en une colonne de l’un de ces types entraîne une erreur, sauf si les caractères supplémentaires sont tous des espaces (des blancs), auquel cas la chaîne est tronquée à la longueur maximale. Si la chaîne est plus courte que la longueur maximale, les valeurs CHAR sont remplies de blancs, mais les valeurs VARCHAR stockent la chaîne sans blancs.
Les blancs de fin des valeurs CHAR sont toujours insignifiants sur le plan sémantique. Ils sont ignorés lorsque vous comparez deux valeurs CHAR, ne sont pas inclus dans les calculs LENGTH et sont supprimés lorsque vous convertissez une valeur CHAR en un autre type de chaîne.
Les espaces de fin des valeurs VARCHAR et CHAR sont traités comme sans importance du point de vue sémantique lorsque les valeurs sont comparées.
Les longueurs de calcul retournent la longueur des chaînes de caractères VARCHAR avec les espaces de fin inclus dans la longueur. Les blancs de fin ne comptent pas dans la longueur des chaînes de caractères de longueur fixe.
# Exemples avec les types caractères
## Instruction CREATE TABLE
L’instruction CREATE TABLE suivante illustre l’utilisation de types de données VARCHAR et CHAR :
```
create table address(
address_id integer,
address1 varchar(100),
address2 varchar(50),
district varchar(20),
city_name char(20),
state char(2),
postal_code char(5)
);
```
Les exemples suivants s’appuient sur cette table.
## Blancs de fin dans les chaînes de caractères de longueur variable
Comme il ADDRESS1 s'agit d'une colonne VARCHAR, les derniers blancs de la deuxième adresse insérée sont sémantiquement insignifiants. En d’autres termes, les deux adresses insérées *correspondent*.
```
insert into address(address1) values('9516 Magnolia Boulevard');
insert into address(address1) values('9516 Magnolia Boulevard ');
```
```
select count(*) from address
where address1='9516 Magnolia Boulevard';
count
-------
2
(1 row)
```
Si la ADDRESS1 colonne était une colonne CHAR et que les mêmes valeurs étaient insérées, la requête COUNT (\$1) reconnaîtrait les chaînes de caractères comme étant identiques et renverrait les résultats`2`.
## Résultats de la fonction LENGTH
La fonction LENGTH reconnaît les espaces de fin dans les colonnes VARCHAR :
```
select length(address1) from address;
length
--------
23
25
(2 rows)
```
La valeur `Augusta` dans la colonne CITY\$1NAME, qui est une colonne CHAR, renvoie toujours une longueur de 7 caractères, indépendamment des espaces de fin de la chaîne en entrée.
## Valeurs qui dépassent la longueur de la colonne
Les chaînes de caractères ne sont pas tronquées pour s’adapter à la largeur déclarée de la colonne :
```
insert into address(city_name) values('City of South San Francisco');
ERROR: value too long for type character(20)
```
Une solution pour contourner ce problème consiste à convertir la valeur en la taille de la colonne :
```
insert into address(city_name)
values('City of South San Francisco'::char(20));
```
Dans ce cas, les 20 premiers caractères de la chaîne (`City of South San Fr`) sont chargés dans la colonne.
# Types datetime
**Topics**
+ [Stockage et plages](#r_Datetime_types-storage-and-ranges)
+ [DATE](#r_Datetime_types-date)
+ [TIME](#r_Datetime_types-time)
+ [TIMETZ](#r_Datetime_types-timetz)
+ [TIMESTAMP](#r_Datetime_types-timestamp)
+ [TIMESTAMPTZ](#r_Datetime_types-timestamptz)
+ [Exemples avec les types datetime](r_Examples_with_datetime_types.md)
+ [Littéraux de type date, heure et horodatage](r_Date_and_time_literals.md)
+ [Types de données et littéraux interval](r_interval_data_types.md)
Les types de données datetime incluent DATE, TIMESTAMP et TIMESTAMPTZ.
## Stockage et plages
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/r_Datetime_types.html)
## DATE
Utilisez le type de données DATE pour stocker les dates calendaires simples sans horodatage.
## TIME
TIME est un alias de TIME WITHOUT TIME ZONE.
Utilisez le type de données TIME pour stocker l’heure de la journée.
Les colonnes TIME stockent des valeurs avec un maximum de six digits de précision pour les secondes fractionnées.
Par défaut, les valeurs TIME sont en temps universel coordonné (UTC) dans les tables utilisateur et les tables système Amazon Redshift.
## TIMETZ
TIMETZ est un alias de TIMES WITH TIME ZONE.
Utilisez le type de données TIMETZ pour stocker l’heure de la journée avec un fuseau horaire.
Les colonnes TIMETZ stockent des valeurs avec un maximum de six digits de précision pour les secondes fractionnées.
Par défaut, les valeurs TIPZ sont UTC dans les tables utilisateur et dans les tables système Amazon Redshift.
## TIMESTAMP
TIMESTAMP est un alias de TIMESTAMP WITHOUT TIME ZONE.
Utilisez le type de données TIMESTAMP pour stocker des valeurs d’horodatage complètes incluant la date et l’heure de la journée.
Les colonnes TIMESTAMP stockent des valeurs avec un maximum de six digits de précision pour les secondes fractionnées.
Les colonnes TIMESTAMP stockent des valeurs avec un maximum de six digits de précision pour les secondes fractionnées. Cette valeur d’horodatage complète a des valeurs par défaut (00) pour les heures, minutes et secondes manquantes. Les valeurs de fuseau horaire dans les chaînes d’entrée sont ignorées.
Par défaut, les valeurs TIMESTAMP sont UTC dans les tables utilisateur et dans les tables système Amazon Redshift.
## TIMESTAMPTZ
TIMESTAMPTZ est un alias de TIMESTAMP WITH TIME ZONE.
Utilisez le type de données TIMESTAMPTZ pour saisir des valeurs d’horodatage complètes incluant la date, l’heure de la journée et un fuseau horaire. Lorsqu’une valeur d’entrée comprend un fuseau horaire, Amazon Redshift utilise le fuseau horaire pour convertir la valeur en UTC et stocke la valeur UTC.
Pour afficher la liste des noms de fuseaux horaires pris en charge, exécutez la commande suivante.
```
select pg_timezone_names();
```
Pour afficher la liste des abréviations de fuseaux horaires prises en charge, exécutez la commande suivante.
```
select pg_timezone_abbrevs();
```
Vous pouvez également trouver des informations sur les fuseaux horaires dans la [base de données des fuseaux horaires IANA](https://www.iana.org/time-zones).
Le tableau suivant présente des exemples de formats de fuseaux horaires.
| Format | Exemple |
| --- | --- |
| jj lun hh:mi:ss aaaa tz | 17 déc 07:37:16 1997 PST |
| mm/dd/yyyyhh:mi:ss.ss tz | 12/17/1997 07:37:16.00 PST |
| mm/dd/yyyyhh:mi:ss.ss tz | 12/17/1997 07:37:16.00 États-Unis/Pacifique |
| yyyy-mm-dd hh : mi : ss\$1/-tz | 1997-12-17 07:37:16-08 |
| jj.mm.aaaa hh:mi:ss tz | 17.12.1997 07:37:16.00 PST |
Les colonnes TIMESTAMPTZ stockent des valeurs avec un maximum de six digits de précision pour les secondes fractionnées.
Si vous insérez une date dans une colonne TIMESTAMPTZ, ou une date avec un horodatage partiel, la valeur est implicitement convertie en une valeur d’horodatage complète. Cette valeur d’horodatage complète a des valeurs par défaut (00) pour les heures, minutes et secondes manquantes.
Les valeurs TIMESTAMPTZ sont au format UTC dans les tables utilisateur.
# Exemples avec les types datetime
Vous trouverez ci-dessous des exemples d’utilisation des types datetime pris en charge par Amazon Redshift.
## Exemples de date
Les exemples suivants insèrent des dates qui ont des formats différents et affichent le résultat.
```
create table datetable (start_date date, end_date date);
```
```
insert into datetable values ('2008-06-01','2008-12-31');
insert into datetable values ('Jun 1,2008','20081231');
```
```
select * from datetable order by 1;
start_date | end_date
-----------------------
2008-06-01 | 2008-12-31
2008-06-01 | 2008-12-31
```
Si vous insérez une valeur d’horodatage dans une colonne DATE, la partie temps est ignorée et seule la date est chargée.
## Exemples d’heure
Les exemples suivants insèrent des valeurs TIME et TIMETZ qui n’ont pas le même format et affichent la sortie.
```
create table timetable (start_time time, end_time timetz);
```
```
insert into timetable values ('19:11:19','20:41:19 UTC');
insert into timetable values ('191119', '204119 UTC');
```
```
select * from timetable order by 1;
start_time | end_time
------------------------
19:11:19 | 20:41:19+00
19:11:19 | 20:41:19+00
```
## Exemples d’horodatages
Si vous insérez une date dans une colonne TIMESTAMP ou TIMESTAMPTZ, l’heure par défaut est minuit. Par exemple, si vous insérez le littéral `20081231`, la valeur stockée est `2008-12-31 00:00:00`.
Pour modifier le fuseau horaire de la session en cours, utilisez la commande [SET](r_SET.md) pour définir le paramètre de configuration [timezone](r_timezone_config.md).
L’exemple suivant insère des horodatages qui ont des formats différents et affiche le tableau qui en résulte.
```
create table tstamp(timeofday timestamp, timeofdaytz timestamptz);
insert into tstamp values('Jun 1,2008 09:59:59', 'Jun 1,2008 09:59:59 EST' );
insert into tstamp values('Dec 31,2008 18:20','Dec 31,2008 18:20');
insert into tstamp values('Jun 1,2008 09:59:59 EST', 'Jun 1,2008 09:59:59');
SELECT * FROM tstamp;
+---------------------+------------------------+
| timeofday | timeofdaytz |
+---------------------+------------------------+
| 2008-06-01 09:59:59 | 2008-06-01 14:59:59+00 |
| 2008-12-31 18:20:00 | 2008-12-31 18:20:00+00 |
| 2008-06-01 09:59:59 | 2008-06-01 09:59:59+00 |
+---------------------+------------------------+
```
# Littéraux de type date, heure et horodatage
Vous trouverez ci-dessous les règles d’utilisation des littéraux de type date, heure et horodatage pris en charge par Amazon Redshift.
## Dates
Les dates en entrée suivantes sont toutes des exemples valides de valeurs de dates littérales pour le type de données DATE que vous pouvez charger dans des tables Amazon Redshift. La valeur `MDY DateStyle` par défaut est supposée être en vigueur. Ce mode signifie que la valeur month précède la valeur day dans les chaînes telles que `1999-01-08` et `01/02/00`.
**Note**
Une date ou un horodatage littéral doit être placé entre guillemets lorsque vous le chargez dans une table.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/r_Date_and_time_literals.html)
## Times
Les horodatages en entrée suivants sont tous des exemples valides de valeurs d’heure littérales pour les types de données TIME et TIMETZ que vous pouvez charger dans les tables Amazon Redshift.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/r_Date_and_time_literals.html)
## Horodatages
Les horodatages en entrée suivants sont tous des exemples valides de valeurs d’heure littérales pour les types de données TIMESTAMP et TIMESTAMPTZ que vous pouvez charger dans les tables Amazon Redshift. Tous les littéraux de date valides peuvent être combinés avec les littéraux d’heure suivants.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/r_Date_and_time_literals.html)
## Valeurs datetime spéciales
Les valeurs spéciales suivantes peuvent être utilisées comme littéraux datetime et comme arguments des fonctions date. Elles requièrent des apostrophes droites et sont converties en valeurs timestamp régulières lors du traitement de la requête.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/r_Date_and_time_literals.html)
Les exemples suivants illustrent comment `now` et `today` fonctionnent avec la fonction DATEADD.
```
select dateadd(day,1,'today');
date_add
---------------------
2009-11-17 00:00:00
(1 row)
select dateadd(day,1,'now');
date_add
----------------------------
2009-11-17 10:45:32.021394
(1 row)
```
# Types de données et littéraux interval
Vous pouvez utiliser un type de données interval pour stocker les durées dans des unités telles que `seconds`, `minutes`, `hours`, `days`, `months` et `years`. Les types de données et les littéraux interval peuvent être utilisés dans les calculs de date/heure, tels que l’ajout d’intervalles aux dates et aux horodatages, la somme des intervalles et la soustraction d’un intervalle d’une date ou d’un horodatage. Les littéraux interval peuvent être utilisés comme valeurs d’entrée pour intercaler les colonnes de type de données d’une table.
## Syntaxe du type de données interval
Pour spécifier un type de données interval afin de stocker une durée en années et en mois :
```
INTERVAL year_to_month_qualifier
```
Pour spécifier un type de données interval afin de stocker une durée en jours, heures, minutes et secondes :
```
INTERVAL day_to_second_qualifier [ (fractional_precision) ]
```
## Syntaxe du littéral interval
Pour spécifier un littéral interval afin de définir une durée en années et en mois :
```
INTERVAL quoted-string year_to_month_qualifier
```
Pour spécifier un littéral interval afin de définir une durée en jours, heures, minutes et secondes :
```
INTERVAL quoted-string day_to_second_qualifier [ (fractional_precision) ]
```
## Arguments
*quoted-string*
Spécifie une valeur numérique positive ou négative spécifiant une quantité et l’unité date/heure en tant que chaîne d’entrée. Si *quoted-string* ne contient qu’un chiffre, Amazon Redshift détermine les unités à partir de *year\$1to\$1month\$1qualifier* ou *day\$1to\$1second\$1qualifier*. Par exemple, `'23' MONTH` représente `1 year 11 months`, `'-2' DAY` représente `-2 days 0 hours 0 minutes 0.0 seconds`, `'1-2' MONTH` représente `1 year 2 months` et `'13 day 1 hour 1 minute 1.123 seconds' SECOND` représente `13 days 1 hour 1 minute 1.123 seconds`. Pour plus d’informations sur les formats de sortie d’un intervalle, consultez [Styles d’intervalle](#r_interval_data_types-interval-styles).
*year\$1to\$1month\$1qualifier*
Spécifie la plage de l’intervalle. Si vous utilisez un qualificatif et que vous créez un intervalle dont les unités de temps sont inférieures au qualificatif, Amazon Redshift tronque et supprime les plus petites parties de l’intervalle. Les valeurs valides pour *year\$1to\$1month\$1qualifier* sont les suivantes :
+ `YEAR`
+ `MONTH`
+ `YEAR TO MONTH`
*day\$1to\$1second\$1qualifier*
Spécifie la plage de l’intervalle. Si vous utilisez un qualificatif et que vous créez un intervalle dont les unités de temps sont inférieures au qualificatif, Amazon Redshift tronque et supprime les plus petites parties de l’intervalle. Les valeurs valides pour *day\$1to\$1second\$1qualifier* sont les suivantes :
+ `DAY`
+ `HOUR`
+ `MINUTE`
+ `SECOND`
+ `DAY TO HOUR`
+ `DAY TO MINUTE`
+ `DAY TO SECOND`
+ `HOUR TO MINUTE`
+ `HOUR TO SECOND`
+ `MINUTE TO SECOND`
La sortie du littéral INTERVAL est tronquée au plus petit composant INTERVAL spécifié. Par exemple, lorsque vous utilisez un qualificateur MINUTE, Amazon Redshift supprime les unités de temps inférieures à MINUTE.
```
select INTERVAL '1 day 1 hour 1 minute 1.123 seconds' MINUTE
```
La valeur résultante est tronquée à `'1 day 01:01:00'`.
*fractional\$1precision*
Paramètre facultatif qui spécifie le nombre de chiffres fractionnaires autorisés dans l’intervalle. L’argument *fractional\$1precision* ne doit être spécifié que si votre intervalle contient SECOND. Par exemple, `SECOND(3)` crée un intervalle qui n’autorise que trois chiffres fractionnaires, tels que 1,234 seconde. Le nombre maximum de chiffres fractionnaires est de six.
La configuration de session `interval_forbid_composite_literals` détermine si une erreur est renvoyée lorsqu’un intervalle est spécifié avec les parties YEAR TO MONTH et DAY TO SECOND. Pour plus d’informations, consultez [interval\$1forbid\$1composite\$1literals](r_interval_forbid_composite_literals.md).
## Arithmétique des intervalles
Vous pouvez utiliser des valeurs interval avec d’autres valeurs datetime pour effectuer des opérations arithmétiques. Les tableaux suivants décrivent les opérations disponibles et le type de données résultant de chaque opération.
**Note**
Les opérations qui peuvent produire les résultats `date` et `timestamp` le font en fonction de la plus petite unité de temps impliquée dans l’équation. Par exemple, lorsque vous ajoutez un `interval` à une `date`, le résultat est une `date`, s’il s’agit d’un intervalle YEAR TO MONTH, et un horodatage s’il s’agit d’un intervalle DAY TO SECOND.
Les opérations où le premier opérande est un `interval` produisent les résultats suivants pour le second opérande donné :
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/r_interval_data_types.html)
Les opérations où le premier opérande est une `date` produisent les résultats suivants pour le second opérande donné :
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/r_interval_data_types.html)
Les opérations où le premier opérande est une `timestamp` produisent les résultats suivants pour le second opérande donné :
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/r_interval_data_types.html)
## Styles d’intervalle
Vous pouvez utiliser la commande SQL [SET](r_SET.md) pour modifier le format d’affichage de sortie de vos valeurs interval. Lorsque vous utilisez le type de données interval dans SQL, convertissez-le en texte pour voir le style d’intervalle attendu, par exemple, `YEAR TO MONTH::text`. Les valeurs disponibles pour effectuer SET sur la valeur `IntervalStyle` sont les suivantes :
+ `postgres` : suit le style PostgreSQL. Il s’agit de l’option par défaut.
+ `postgres_verbose` : suit le style détaillé PostgreSQL.
+ `sql_standard` : suit le style des littéraux interval SQL standard.
La commande suivante définit le style d’intervalle sur `sql_standard`.
```
SET IntervalStyle to 'sql_standard';
```
**format de sortie postgres**
Le format de sortie pour le style d’intervalle `postgres` est le suivant. Chaque valeur numérique peut être négative.
```
' [, ...]'
```
```
select INTERVAL '1-2' YEAR TO MONTH::text
varchar
---------------
1 year 2 mons
```
```
select INTERVAL '1 2:3:4.5678' DAY TO SECOND::text
varchar
------------------
1 day 02:03:04.5678
```
**format de sortie postgres\$1verbose**
La syntaxe postgres\$1verbose est similaire à postgres, mais les sorties postgres\$1verbose contiennent également l’unité de temps.
```
'[@] [, ...] [direction]'
```
```
select INTERVAL '1-2' YEAR TO MONTH::text
varchar
-----------------
@ 1 year 2 mons
```
```
select INTERVAL '1 2:3:4.5678' DAY TO SECOND::text
varchar
---------------------------
@ 1 day 2 hours 3 mins 4.56 secs
```
**format de sortie sql\$1standard**
Les valeurs interval year to month sont formatées comme suit. La spécification d’un signe négatif avant l’intervalle indique que l’intervalle est une valeur négative et s’applique à l’ensemble de l’intervalle.
```
'[-]yy-mm'
```
Les valeurs interval day to second sont formatées comme suit.
```
'[-]dd hh:mm:ss.ffffff'
```
```
SELECT INTERVAL '1-2' YEAR TO MONTH::text
varchar
-------
1-2
```
```
select INTERVAL '1 2:3:4.5678' DAY TO SECOND::text
varchar
---------------
1 2:03:04.5678
```
## Exemples de type de données interval
Les exemples suivants montrent comment utiliser les types de données INTERVAL avec des tables.
```
create table sample_intervals (y2m interval month, h2m interval hour to minute);
insert into sample_intervals values (interval '20' month, interval '2 days 1:1:1.123456' day to second);
select y2m::text, h2m::text from sample_intervals;
y2m | h2m
---------------+-----------------
1 year 8 mons | 2 days 01:01:00
```
```
update sample_intervals set y2m = interval '2' year where y2m = interval '1-8' year to month;
select * from sample_intervals;
y2m | h2m
---------+-----------------
2 years | 2 days 01:01:00
```
```
delete from sample_intervals where h2m = interval '2 1:1:0' day to second;
select * from sample_intervals;
y2m | h2m
-----+-----
```
## Exemples de littéraux interval
Les exemples suivants sont exécutés avec le style d’intervalle défini sur `postgres`.
L’exemple suivant montre comment créer un littéral INTERVAL de 1 an.
```
select INTERVAL '1' YEAR
intervaly2m
---------------
1 years 0 mons
```
Si vous spécifiez une *quoted-string* qui dépasse le qualificatif, les unités de temps restantes sont tronquées par rapport à l’intervalle. Dans l’exemple suivant, un intervalle de 13 mois devient 1 an et 1 mois, mais le mois restant est omis en raison du qualificatif YEAR.
```
select INTERVAL '13 months' YEAR
intervaly2m
---------------
1 years 0 mons
```
Si vous utilisez un qualificatif inférieur à votre chaîne d’intervalle, les unités restantes sont incluses.
```
select INTERVAL '13 months' MONTH
intervaly2m
---------------
1 years 1 mons
```
Si vous spécifiez une précision dans votre intervalle, le nombre de chiffres fractionnaires est tronqué à la précision spécifiée.
```
select INTERVAL '1.234567' SECOND (3)
intervald2s
--------------------------------
0 days 0 hours 0 mins 1.235 secs
```
Si vous ne spécifiez aucune précision, Amazon Redshift utilise la précision maximale de 6.
```
select INTERVAL '1.23456789' SECOND
intervald2s
-----------------------------------
0 days 0 hours 0 mins 1.234567 secs
```
L’exemple suivant montre comment créer un intervalle par plage.
```
select INTERVAL '2:2' MINUTE TO SECOND
intervald2s
------------------------------
0 days 0 hours 2 mins 2.0 secs
```
Les qualificatifs dictent les unités que vous spécifiez. Par exemple, même si l’exemple suivant utilise la même *quoted-string* de « 2:2 » que l’exemple précédent, Amazon Redshift reconnaît qu’il utilise des unités de temps différentes en raison du qualificatif.
```
select INTERVAL '2:2' HOUR TO MINUTE
intervald2s
------------------------------
0 days 2 hours 2 mins 0.0 secs
```
Les abréviations et les pluriels de chaque unité sont également pris en charge. Par exemple, `5s`, `5 second` et `5 seconds` sont des intervalles équivalents. Les unités prises en charge sont les années, les mois, les heures, les minutes et les secondes.
```
select INTERVAL '5s' SECOND
intervald2s
------------------------------
0 days 0 hours 0 mins 5.0 secs
```
```
select INTERVAL '5 HOURS' HOUR
intervald2s
------------------------------
0 days 5 hours 0 mins 0.0 secs
```
```
select INTERVAL '5 h' HOUR
intervald2s
------------------------------
0 days 5 hours 0 mins 0.0 secs
```
# Exemples de littéraux interval sans syntaxe de qualificatif
**Note**
Les exemples suivants illustrent l’utilisation d’un littéral interval sans qualificatif `YEAR TO MONTH` ou `DAY TO SECOND`. Pour plus d’informations sur l’utilisation du littéral interval recommandé avec un qualificatif, consultez [Types de données et littéraux interval](r_interval_data_types.md).
Utilisez un littéral de type interval pour identifier les périodes spécifiques, comme `12 hours` ou `6 months`. Vous pouvez utiliser ces littéraux de type interval dans les cas et les calculs qui impliquent des expressions de type datetime.
Un littéral interval est exprimé comme la combinaison du mot clé INTERVAL avec une quantité numérique et d’une partie date prise en charge ; par exemple : `INTERVAL '7 days'` ou `INTERVAL '59 minutes'`. Plusieurs quantités et unités peuvent être associées pour former un intervalle plus précis ; par exemple : `INTERVAL '7 days, 3 hours, 59 minutes'`. Les abréviations et les pluriels de chaque unité sont également pris en charge ; par exemple : `5 s`, `5 second` et `5 seconds` sont des intervalles équivalents.
Si vous ne spécifiez pas une partie date, la valeur de l’intervalle correspond à des secondes. Vous pouvez spécifier la valeur de la quantité sous forme de fraction (par exemple : `0.5 days`).
Les exemples suivants illustrent une série de calculs avec différentes valeurs d’intervalle.
Ce qui suit ajoute 1 seconde à la date spécifiée.
```
select caldate + interval '1 second' as dateplus from date
where caldate='12-31-2008';
dateplus
---------------------
2008-12-31 00:00:01
(1 row)
```
Ce qui suit ajoute 1 minute à la date spécifiée.
```
select caldate + interval '1 minute' as dateplus from date
where caldate='12-31-2008';
dateplus
---------------------
2008-12-31 00:01:00
(1 row)
```
Ce qui suit ajoute 3 heures et 35 minutes à la date spécifiée.
```
select caldate + interval '3 hours, 35 minutes' as dateplus from date
where caldate='12-31-2008';
dateplus
---------------------
2008-12-31 03:35:00
(1 row)
```
Ce qui suit ajoute 52 semaines à la date spécifiée.
```
select caldate + interval '52 weeks' as dateplus from date
where caldate='12-31-2008';
dateplus
---------------------
2009-12-30 00:00:00
(1 row)
```
Ce qui suit ajoute 1 semaine, 1 heure, 1 minute, et 1 seconde à la date spécifiée.
```
select caldate + interval '1w, 1h, 1m, 1s' as dateplus from date
where caldate='12-31-2008';
dateplus
---------------------
2009-01-07 01:01:01
(1 row)
```
Ce qui suit ajoute 12 heures (la moitié d’une journée) à la date spécifiée.
```
select caldate + interval '0.5 days' as dateplus from date
where caldate='12-31-2008';
dateplus
---------------------
2008-12-31 12:00:00
(1 row)
```
Ce qui suit soustrait 4 mois à compter du 15 février 2023 et le résultat est le 15 octobre 2022.
```
select date '2023-02-15' - interval '4 months';
?column?
---------------------
2022-10-15 00:00:00
```
Ce qui suit soustrait 4 mois à compter du 31 mars 2023 et le résultat est le 30 novembre 2022. Le calcul prend en compte le nombre de jours dans un mois.
```
select date '2023-03-31' - interval '4 months';
?column?
---------------------
2022-11-30 00:00:00
```
# Type Boolean
Utilisez le type de données BOOLEAN pour stocker les valeurs true et false dans une colonne codée sur un octet. Le tableau suivant décrit les trois états possibles pour une valeur booléenne et les valeurs littérales qui entraînent cet état. Quelle que soit la chaîne en entrée, une colonne booléenne stocke et émet « t » pour true et « f » pour false.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/r_Boolean_type.html)
Vous pouvez utiliser une comparaison IS pour vérifier une valeur booléenne uniquement sous la forme d’un prédicat dans la clause WHERE. Vous ne pouvez pas utiliser la comparaison IS avec une valeur booléenne dans la liste SELECT.
## Exemples
Vous pouvez utiliser une colonne de type BOOLEAN pour stocker un état « Actif/Inactif » pour chaque client dans une table CUSTOMER.
```
create table customer(
custid int,
active_flag boolean default true);
```
```
insert into customer values(100, default);
```
```
select * from customer;
custid | active_flag
-------+--------------
100 | t
```
Si aucune valeur par défaut (`true` ou `false`) n’est spécifiée dans l’instruction CREATE TABLE, l’insertion d’une valeur par défaut signifie l’insertion d’une valeur null.
Dans cet exemple, la requête sélectionne les utilisateurs de la table USERS qui aiment le sport, mais n’aiment pas le théâtre :
```
select firstname, lastname, likesports, liketheatre
from users
where likesports is true and liketheatre is false
order by userid limit 10;
firstname | lastname | likesports | liketheatre
----------+------------+------------+-------------
Lars | Ratliff | t | f
Mufutau | Watkins | t | f
Scarlett | Mayer | t | f
Shafira | Glenn | t | f
Winifred | Cherry | t | f
Chase | Lamb | t | f
Liberty | Ellison | t | f
Aladdin | Haney | t | f
Tashya | Michael | t | f
Lucian | Montgomery | t | f
(10 rows)
```
L’exemple suivant sélectionne les utilisateurs de la table USERS pour lesquels on ignore s’ils aiment la musique rock.
```
select firstname, lastname, likerock
from users
where likerock is unknown
order by userid limit 10;
firstname | lastname | likerock
----------+----------+----------
Rafael | Taylor |
Vladimir | Humphrey |
Barry | Roy |
Tamekah | Juarez |
Mufutau | Watkins |
Naida | Calderon |
Anika | Huff |
Bruce | Beck |
Mallory | Farrell |
Scarlett | Mayer |
(10 rows)
```
L’exemple suivant renvoie une erreur parce qu’il utilise une comparaison IS dans la liste SELECT.
```
select firstname, lastname, likerock is true as "check"
from users
order by userid limit 10;
[Amazon](500310) Invalid operation: Not implemented
```
L’exemple suivant réussit parce qu’il utilise une comparaison d’égalité ( = ) dans la liste SELECT à la place de la comparaison IS.
```
select firstname, lastname, likerock = true as "check"
from users
order by userid limit 10;
firstname | lastname | check
----------+-----------+------
Rafael | Taylor |
Vladimir | Humphrey |
Lars | Ratliff | true
Barry | Roy |
Reagan | Hodge | true
Victor | Hernandez | true
Tamekah | Juarez |
Colton | Roy | false
Mufutau | Watkins |
Naida | Calderon |
```
# Type HLLSKETCH
Utilisez le type de données HLLSKETCH pour HyperLogLog les esquisses. Amazon Redshift prend en charge les représentations d' HyperLogLog esquisse éparses ou denses. Les esquisses sont d’abord fragmentées, puis deviennent denses lorsque le format dense est plus efficace pour minimiser l’empreinte mémoire utilisée.
Amazon Redshift effectue automatiquement la transition d'une HyperLogLog esquisse fragmentée lors de l'importation, de l'exportation ou de l'impression d'esquisses au format JSON suivant.
```
{"logm":15,"sparse":{"indices":[4878,9559,14523],"values":[1,2,1]}}
```
Amazon Redshift utilise une représentation sous forme de chaîne au format Base64 pour représenter une esquisse dense. HyperLogLog
Amazon Redshift utilise la représentation sous forme de chaîne suivante au format Base64 pour représenter une esquisse dense. HyperLogLog
```
"ABAABA..."
```
La taille maximale d’un objet HLLSKETCH est de 24 580 octets lorsqu’il est utilisé dans la compression brute.
# Type SUPER
Utilisez le type de données SUPER pour stocker des données semi-structurées ou des documents en tant que valeurs. Amazon Redshift est capable de stocker de telles valeurs à l’aide de VARCHAR, mais nous vous recommandons d’utiliser plutôt le type de données SUPER.
Les données semi-structurées ne sont pas conformes à la structure rigide et tabulaire du modèle de données relationnelles utilisé dans les bases de données SQL. Elles contiennent des balises qui font référence à des entités distinctes dans les données. Elles peuvent contenir des valeurs complexes telles que des tableaux, des structures imbriquées et d’autres structures complexes associées à des formats de sérialisation, tels que JSON. Le type de données SUPER est un ensemble de valeurs de tableau et de structure sans schéma qui englobent tous les autres types scalaires d’Amazon Redshift.
Le type de données SUPER prend en charge un maximum de 16 Mo de données pour un objet SUPER individuel. Pour plus d’informations sur le type de données SUPER, y compris des exemples d’implémentation dans une table, consultez [Données semi-structurées dans Amazon Redshift](super-overview.md).
Amazon Redshift fournit un support intégré pour ingérer les formats de données semi-structurés suivants à l’aide de la commande COPY :
+ JSON
+ ARRAY
+ TEXT
+ CSV
Les objets SUPER de plus de 1 Mo ne peuvent être ingérés qu’à partir des formats de fichier suivants :
+ Parquet
+ JSON
+ TEXT
+ CSV
Le type de données SUPER a les propriétés suivantes :
+ Une valeur scalaire Amazon Redshift :
+ Un null
+ Une valeur booléenne
+ Un nombre, par exemple, smallint, entier, bigint, décimal ou virgule flottante (tel que float4 ou float8)
+ Une valeur de chaîne, telle que varchar ou char
+ Une valeur complexe :
+ Un tableau de valeurs, y compris scalaire ou complexe
+ Structure, également appelée tuple ou objet, qui est une carte de noms et de valeurs d’attribut (scalaire ou complexe)
Chacun des deux types de valeurs complexes contient ses propres scalaires ou valeurs complexes sans aucune restriction de régularité.
L’encodage de la compression par défaut pour le type de données SUPER est ZSTD. Pour plus d’informations sur l’encodage de la compression, consultez [encodages de compression](c_Compression_encodings.md).
Le type de données SUPER prend en charge la persistance des données semi-structurées sous une forme sans schéma. Bien que le modèle de données hiérarchique puisse changer, les anciennes versions de données peuvent coexister dans la même colonne SUPER.
Amazon Redshift utilise PartiQL pour activer la navigation dans les tableaux et les structures. Amazon Redshift utilise aussi la syntaxe PartiQL pour itérer dans les tableaux SUPER. Pour plus d’informations, consultez [PartiQL : un langage de requête compatible SQL pour Amazon Redshift](super-partiql.md).
Amazon Redshift utilise le typage dynamique pour traiter les données SUPER sans schéma sans avoir à déclarer les types de données avant qu’elles ne soient utilisées dans votre requête. Pour plus d’informations, consultez [Typage dynamique](query-super.md#dynamic-typing-lax-processing).
Vous pouvez appliquer des politiques de masquage dynamique des données aux valeurs scalaires figurant sur les chemins des colonnes de type SUPER. Pour plus d’informations sur le masquage dynamique des données, consultez [Masquage dynamique des données](t_ddm.md). Pour en savoir plus sur l’utilisation du masquage dynamique des données avec le type de données SUPER, consultez [Utilisation du masquage dynamique des données avec des chemins de type de données SUPER](t_ddm-super.md).
Nous vous recommandons de définir l’option de configuration `r_enable_case_sensitive_super_attribute` sur true lorsque vous utilisez des données SUPER. Pour plus d’informations, consultez [enable\$1case\$1sensitive\$1super\$1attribute](r_enable_case_sensitive_super_attribute.md).
# Type VARBYTE
Utilisez une colonne VARBYTE, VARBINARY ou BINARY VARYING pour stocker une valeur binaire de longueur variable avec une limite fixe.
```
varbyte [ (n) ]
```
Le nombre maximal d’octets (*n*) peut aller de 1 à 16 777 216. La valeur par défaut est 64 000.
Voici quelques exemples dans lesquels vous souhaiterez peut-être utiliser un type de données VARBYTE :
+ Joindre des tables sur des colonnes VARBYTE.
+ Création de vues matérialisées contenant des colonnes VARBYTE. L’actualisation progressive des vues matérialisées contenant des colonnes VARBYTE est prise en charge. Toutefois, les fonctions d’agrégation autres que COUNT, MIN et MAX et GROUP BY sur les colonnes VARBYTE ne prennent pas en charge l’actualisation progressive.
Pour garantir que tous les octets sont des caractères imprimables, Amazon Redshift utilise le format hexadécimal pour imprimer des valeurs VARBYTE. Par exemple, le code SQL suivant convertit la chaîne hexadécimale `6162` en une valeur binaire. Même si la valeur renvoyée est une valeur binaire, les résultats sont imprimés en hexadécimal `6162`.
```
select from_hex('6162');
from_hex
----------
6162
```
Amazon Redshift prend en charge la conversion entre le type de données VARBYTE et les types de données suivants :
+ CHAR
+ VARCHAR
+ SMALLINT
+ INTEGER
+ BIGINT
Lors de la conversion CHAR et VARCHAR, le format UTF-8 est utilisé. Pour plus d’informations sur le format UTF-8, consultez [TO\$1VARBYTE](r_TO_VARBYTE.md). Lors de la conversion à partir de SMALLINT, INTEGER et BIGINT, le nombre d’octets du type de données d’origine est conservé. Il s’agit de deux octets pour SMALLINT, de quatre octets pour INTEGER et de huit octets pour BIGINT.
L’instruction SQL suivante convertit une chaîne VARCHAR en VARBYTE. Même si la valeur renvoyée est une valeur binaire, les résultats sont imprimés en hexadécimal `616263`.
```
select 'abc'::varbyte;
varbyte
---------
616263
```
L’instruction SQL suivante convertit une valeur CHAR dans une colonne en VARBYTE. Cet exemple montre comment créer une table avec une colonne (c) CHAR(10) et insérer des valeurs de caractères inférieures à 10. La conversion résultante bloque le résultat avec des caractères d’espace (hex’20’) à la taille de colonne définie. Même si la valeur renvoyée est une valeur binaire, les résultats sont imprimés en hexadécimal.
```
create table t (c char(10));
insert into t values ('aa'), ('abc');
select c::varbyte from t;
c
----------------------
61612020202020202020
61626320202020202020
```
L’instruction SQL suivante convertit une chaîne SMALLINT en VARBYTE. Même si la valeur renvoyée est une valeur binaire, les résultats sont imprimés en hexadécimal `0005`, soit deux octets ou quatre caractères hexadécimaux.
```
select 5::smallint::varbyte;
varbyte
---------
0005
```
L’instruction SQL suivante convertit un INTEGER en VARBYTE. Même si la valeur renvoyée est une valeur binaire, les résultats sont imprimés en hexadécimal `00000005`, soit quatre octets ou huit caractères hexadécimaux.
```
select 5::int::varbyte;
varbyte
----------
00000005
```
L’instruction SQL suivante convertit un BIGINT en VARBYTE. Même si la valeur renvoyée est une valeur binaire, les résultats sont imprimés en hexadécimal `0000000000000005`, soit 8 octets ou 16 caractères hexadécimaux.
```
select 5::bigint::varbyte;
varbyte
------------------
0000000000000005
```
Les fonctions Amazon Redshift prenant en charge le type de données VARBYTE sont les suivantes :
+ [Opérateurs VARBYTE](r_VARBYTE_OPERATORS.md)
+ [CONCAT](r_CONCAT.md)
+ [LEN](r_LEN.md)
+ [Fonction LENGTH](r_LENGTH.md)
+ [OCTET\$1LENGTH](r_OCTET_LENGTH.md)
+ [Fonction SUBSTRING](r_SUBSTRING.md)
+ [FROM\$1HEX](r_FROM_HEX.md)
+ [TO\$1HEX](r_TO_HEX.md)
+ [FROM\$1VARBYTE](r_FROM_VARBYTE.md)
+ [TO\$1VARBYTE](r_TO_VARBYTE.md)
+ [GETBIT](r_GETBIT.md)
+ [Chargement d’une colonne avec le type de données VARBYTE](copy-usage-varbyte.md)
+ [Déchargement d’une colonne avec le type de données VARBYTE](r_UNLOAD.md#unload-usage-notes)
## Limites lors de l’utilisation du type de données VARBYTE avec Amazon Redshift
Les limites suivantes se présentent lors de l’utilisation du type de données VARBYTE avec Amazon Redshift :
+ Amazon Redshift Spectrum prend en charge le type de données VARBYTE uniquement pour les fichiers Parquet et ORC.
+ L’éditeur de requêtes Amazon Redshift et Amazon Redshift Query Editor V2 ne prennent pas encore entièrement en charge le type de données VARBYTE. Par conséquent, utilisez un client SQL différent lorsque vous utilisez des expressions VARBYTE.
Pour contourner le problème d'utilisation de l'éditeur de requêtes, si la longueur de vos données est égale ou inférieure à 16 000 000 octets et que le contenu est un UTF-8 valide, vous pouvez convertir les valeurs VARBYTE en VARCHAR, par exemple :
```
select to_varbyte('6162', 'hex')::varchar;
```
+ Vous ne pouvez pas utiliser les types de données VARBYTE avec des fonctions définies par l'utilisateur Python ou Lambda (). UDFs
+ Vous ne pouvez pas créer de colonne HLLSKETCH à partir d’une colonne VARBYTE ou utiliser APPROXIMATIVE COUNT DISTINCT sur une colonne VARBYTE.
+ Les valeurs VARBYTE de plus de 1 Mo ne peuvent être ingérés qu’à partir des formats de fichier suivants :
+ Parquet
+ Texte
+ Valeurs séparées par des virgules (CSV)
## Compatibilité et conversion de types
Vous trouverez ci-dessous une discussion sur la façon dont les règles de conversion de type et la compatibilité des types de données fonctionnent dans Amazon Redshift.
### Compatibilité
La correspondance des types de données et la correspondance des valeurs littérales et des constantes avec les types de données se produisent lors de différentes opérations de base de données, dont les suivantes :
+ Opérations DML (Data Manipulation Language) sur les tables
+ Requêtes UNION, INTERSECT et EXCEPT
+ Expressions CASE
+ Evaluation de prédicats, tels que LIKE et IN
+ Evaluation de fonctions SQL qui effectuent des comparaisons ou des extractions de données
+ Comparaisons avec les opérateurs mathématiques
Les résultats de ces opérations dépendent des règles de conversion de types et de la compatibilité des types de données. La *compatibilité* implique que la mise en one-to-one correspondance d'une certaine valeur et d'un certain type de données n'est pas toujours requise. Comme certains types de données sont *compatibles*, une conversion implicite ou *forçage de type*, est possible (pour plus d’informations, consultez [Types de conversion implicite](#implicit-conversion-types)). Lorsque les types de données sont incompatibles, vous pouvez parfois convertir une valeur d’un type de données en un autre à l’aide d’une fonction de conversion explicite.
### Compatibilité générale et règles de conversion
Notez les règles de compatibilité et de conversion suivantes :
+ En général, les types de données qui appartiennent à la même catégorie (comme les différents types de données numériques) sont compatibles et peuvent être convertis implicitement.
Par exemple, avec une conversion implicite, vous pouvez insérer une valeur décimale dans une colonne de type entier. La partie décimale est arrondie pour produire un nombre entier. Ou vous pouvez extraire une valeur numérique, telle que `2008`, d’une date et insérer cette valeur dans une colonne de type entier.
+ Les types de données numériques renforcent les conditions de débordement qui se produisent lorsque vous tentez d'insérer out-of-range des valeurs. Par exemple, une valeur décimale avec une précision de 5 ne peut contenir dans une colonne décimale dont la précision est 4. Un nombre entier ou la partie entière d’un nombre décimal ne sont jamais tronqués ; toutefois, la partie fractionnaire d’un nombre décimal peut être arrondie vers le haut ou vers le bas, selon le cas. Cependant, les résultats de conversions explicites de valeurs sélectionnées dans les tables ne sont pas arrondis.
+ Différents types de chaînes de caractères sont compatibles ; les chaînes de colonnes VARCHAR contenant des données codées sur un seul octet et les chaînes de colonne CHAR sont comparables et implicitement convertibles. Les chaînes VARCHAR qui contiennent des données codées sur plusieurs octets ne sont pas comparables. Vous pouvez également convertir une chaîne de caractères en une date, une heure, un horodatage ou une valeur numérique si la chaîne est une valeur littérale appropriée ; les espaces de début ou de fin sont ignorés. Inversement, vous pouvez convertir une date, une heure, un horodatage ou une valeur numérique en une chaîne de caractères de longueur fixe ou variable.
**Note**
Une chaîne de caractères que vous voulez convertir en type numérique doit comporter la représentation en caractères d’un nombre. Par exemple, vous pouvez convertir les chaînes `'1.0'` ou `'5.9'` en valeurs décimales, mais vous ne pouvez pas convertir la chaîne `'ABC'` en un type numérique.
+ Si vous comparez des valeurs DECIMAL avec des chaînes de caractères, Amazon Redshift tente de convertir la chaîne de caractères en valeur DECIMAL. Lors de la comparaison de toutes les autres valeurs numériques avec des chaînes de caractères, les valeurs numériques sont converties en chaînes de caractères. Pour effectuer la conversion inverse (par exemple, convertir des chaînes de caractères en entiers ou convertir des valeurs DECIMALES en chaînes de caractères), utilisez une fonction explicite, telle que [CAST](r_CAST_function.md).
+ Pour convertir les valeurs DECIMAL ou NUMERIC 64 bits en une plus grande précision, vous devez utiliser une fonction de conversion explicite telle que les fonctions CAST ou CONVERT.
+ Lors de la conversion de DATE ou TIMESTAMP en TIMESTAMPTZ, ou de la conversion de TIME en TIMESTAMP, le fuseau horaire de la session en cours. Le fuseau horaire de session est UTC par défaut. Pour plus d’informations sur le réglage du fuseau horaire de la session, consultez [timezone](r_timezone_config.md).
+ De même, TIMESTAMPTZ est converti en DATE, TIME ou TIMESTAMP en fonction du fuseau horaire de la session en cours. Le fuseau horaire de session est UTC par défaut. Après la conversion, les informations sur les fuseaux horaires sont abandonnées.
+ Les chaînes de caractères qui représentent un horodatage avec un fuseau horaire spécifié sont converties en TIMESTAMPTZ en utilisant le fuseau horaire de la session actuelle, qui est UTC par défaut. De même, les chaînes de caractères qui représentent un fuseau horaire spécifié sont converties en TIPZ à l’aide du fuseau horaire de la session en cours, UTC par défaut.
### Types de conversion implicite
Il existe deux types de conversion implicite :
+ Conversions implicites d’affectations, telles que la définition de valeurs dans les commandes INSERT ou UPDATE.
+ Conversions implicites d’expressions, comme l’exécution de comparaisons dans la clause WHERE.
Le tableau suivant répertorie les types de données qui peuvent être convertis implicitement dans les affectations ou les expressions. Vous pouvez également utiliser une fonction de conversion explicite pour exécuter ces conversions.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/c_Supported_data_types.html)
**Note**
Les conversions implicites entre TIMESTAMPTZ, TIMESTAMP, DATE, TIME, TIMETZ ou les chaînes de caractères utilisent le fuseau horaire actuel de la session. Pour plus d’informations sur la définition du fuseau horaire en cours, consultez [timezone](r_timezone_config.md).
Les types de données GEOMETRY et GEOGRAPHY ne peuvent pas être convertis de façon implicite dans un autre type de données, excepté l’un dans l’autre. Pour plus d’informations, consultez [Fonction CAST](r_CAST_function.md).
Le type de données VARBYTE ne peut pas être converti de façon implicite dans un autre type de données. Pour plus d’informations, consultez [Fonction CAST](r_CAST_function.md).
### Utilisation du typage dynamique pour le type de données SUPER
Amazon Redshift utilise le typage dynamique pour traiter des données SUPER sans schéma sans avoir à déclarer les types de données avant de les utiliser dans votre requête. Le typage dynamique utilise les résultats de la navigation dans les colonnes de données SUPER sans devoir les convertir explicitement en types Amazon Redshift. Pour plus d’informations sur l’utilisation du typage dynamique pour le type de données SUPER, consultez [Typage dynamique](query-super.md#dynamic-typing-lax-processing).
Vous pouvez lancer des valeurs SUPER depuis et vers d’autres types de données, à quelques exceptions près. Pour plus d’informations, consultez [Limitations](limitations-super.md).
# Séquences de classement
Amazon Redshift ne prend pas en charge les séquences de classement spécifiques à une région ou définies par l’utilisateur. En général, les résultats d’un prédicat dans quelque contexte que ce soit peuvent être affectés par l’absence de règles spécifiques aux paramètres régionaux en matière de tri et de comparaison des valeurs de données. Par exemple, les expressions et fonctions ORDER BY telles que MIN, MAX et RANK renvoient des résultats basés sur un UTF8 ordre binaire des données qui ne prend pas en compte les caractères spécifiques aux paramètres régionaux.
# Expressions
**Topics**
+ [Expressions simples](#r_expressions-simple-expressions)
+ [Expressions composées](r_compound_expressions.md)
+ [Listes d’expressions](r_expression_lists.md)
+ [Sous-requêtes scalaires](r_scalar_subqueries.md)
+ [Expressions de fonction](r_function_expressions.md)
Une expression est une combinaison d’un(e) ou de plusieurs valeurs, opérateurs ou fonctions qui correspondent à une valeur. Le type de données d’une expression est généralement celui de ses composants.
## Expressions simples
Une expression simple est l’une des expressions suivantes :
+ Une constante ou une valeur littérale
+ Un nom de colonne ou une référence de colonne
+ Une fonction scalaire
+ Une fonction d’agrégation (ensemble)
+ Une fonction de fenêtre
+ Une sous-requête scalaire
Exemples d’expressions simples :
```
5+12
dateid
sales.qtysold * 100
sqrt (4)
max (qtysold)
(select max (qtysold) from sales)
```
# Expressions composées
Une expression composée est une série d’expressions simples jointes par des opérateurs arithmétiques. Une expression simple utilisée dans une expression composée doit retourner une valeur numérique.
## Syntaxe
```
expression
operator
expression | (compound_expression)
```
## Arguments
*expression*
Une expression simple qui correspond à une valeur.
*opérateur*
Une expression arithmétique composée peut être construite à l’aide des opérateurs suivants, en respectant l’ordre de priorité :
+ () : parenthèses pour contrôler l’ordre de l’évaluation
+ \$1,- : signe/opérateur positif et négatif
+ ^ , \$1/ , \$1\$1 / : élévation à la puissance, racine carrée, racine cubique
+ \$1, /, % : multiplication, division et opérateurs modulo
+ @ : valeur absolue
+ \$1,- : addition et soustraction
+ & , \$1, \$1, \$1, <<, >> : AND, OR, NOT, opérateurs au niveau du bit de décalage gauche, décalage droit
+ \$1\$1 : concaténation
*(expression\$1composée)*
Les expressions composées peuvent être imbriquées à l’aide de parenthèses.
## Exemples
Voici quelques exemples d’expressions composées.
```
('SMITH' || 'JONES')
sum(x) / y
sqrt(256) * avg(column)
rank() over (order by qtysold) / 100
(select (pricepaid - commission) from sales where dateid = 1882) * (qtysold)
```
Certaines fonctions peuvent également être imbriquées dans d’autres fonctions. Par exemple, une fonction scalaire peut être imbriquée dans une autre fonction scalaire. L’exemple suivant retourne la somme des valeurs absolues d’un ensemble de nombres :
```
sum(abs(qtysold))
```
Les fonctions de fenêtrage ne peuvent pas être utilisées comme arguments pour les fonctions d’agrégation ou d’autres fonctions de fenêtrage. L’expression suivante retourne une erreur :
```
avg(rank() over (order by qtysold))
```
Les fonctions de fenêtrage peuvent avoir une fonction d’agrégation imbriquée. L’expression suivante additionne des ensembles de valeurs, puis les classe :
```
rank() over (order by sum(qtysold))
```
# Listes d’expressions
Une liste d’expressions est une combinaison d’expressions et peut apparaître dans les conditions d’appartenance et de comparaison (clauses WHERE) et dans les clauses GROUP BY.
## Syntaxe
```
expression , expression , ... | (expression, expression, ...)
```
## Arguments
*expression*
Une expression simple qui correspond à une valeur. Une liste d’expressions peut contenir une ou plusieurs expressions séparées par des virgules, ou un ou plusieurs ensembles d’expressions séparés par des virgules. Lorsqu’il existe plusieurs ensembles d’expressions, chaque ensemble doit comporter le même nombre d’expressions et être séparée par des parenthèses. Le nombre d’expressions de chaque ensemble doit correspondre au nombre d’expressions avant l’opérateur de la condition.
## Exemples
Exemples de listes d’expressions dans des conditions :
```
(1, 5, 10)
('THESE', 'ARE', 'STRINGS')
(('one', 'two', 'three'), ('blue', 'yellow', 'green'))
```
Le nombre d’expressions de chaque ensemble doit correspondre au nombre dans la première partie de l’instruction :
```
select * from venue
where (venuecity, venuestate) in (('Miami', 'FL'), ('Tampa', 'FL'))
order by venueid;
venueid | venuename | venuecity | venuestate | venueseats
---------+-------------------------+-----------+------------+------------
28 | American Airlines Arena | Miami | FL | 0
54 | St. Pete Times Forum | Tampa | FL | 0
91 | Raymond James Stadium | Tampa | FL | 65647
(3 rows)
```
# Sous-requêtes scalaires
Une sous-requête scalaire est une requête SELECT régulière entre parenthèses qui renvoie exactement une valeur : une seule ligne avec une colonne. La requête est exécutée et la valeur retournée est utilisée dans la requête externe. Si la sous-requête ne renvoie aucune ligne, l’expression de la sous-requête a la valeur null. Si elle renvoie plusieurs lignes, Amazon Redshift renvoie une erreur. La sous-requête peut faire référence aux variables de la requête parente, qui serviront de constantes lors d’une invocation de la sous-requête.
Vous pouvez utiliser des sous-requêtes scalaires dans la plupart des instructions qui appellent une expression. Les sous-requêtes scalaires ne sont pas des expressions valides dans les cas suivants :
+ Comme valeurs par défaut pour les expressions
+ Dans les clauses GROUP BY et HAVING
## Exemple
La sous-requête suivante calcule le prix moyen payé par vente sur toute l’année 2008, puis la requête externe utilise cette valeur dans la sortie pour la comparer au prix moyen par vente par trimestre :
```
select qtr, avg(pricepaid) as avg_saleprice_per_qtr,
(select avg(pricepaid)
from sales join date on sales.dateid=date.dateid
where year = 2008) as avg_saleprice_yearly
from sales join date on sales.dateid=date.dateid
where year = 2008
group by qtr
order by qtr;
qtr | avg_saleprice_per_qtr | avg_saleprice_yearly
-------+-----------------------+----------------------
1 | 647.64 | 642.28
2 | 646.86 | 642.28
3 | 636.79 | 642.28
4 | 638.26 | 642.28
(4 rows)
```
# Expressions de fonction
## Syntaxe
Toute fonction intégrée peut être utilisée en tant qu’expression. La syntaxe d’un appel de fonction est le nom d’une fonction suivi de sa liste d’arguments entre parenthèses.
```
function ( [expression [, expression...]] )
```
## Arguments
*fonction*
Toute fonction intégrée. Pour des exemples de fonctions, consultez [Référence sur les fonctions SQL](c_SQL_functions.md).
*expression*
Toute expression correspondant au type de données et au nombre de paramètres attendu par la fonction.
## Exemples
```
abs (variable)
select avg (qtysold + 3) from sales;
select dateadd (day,30,caldate) as plus30days from date;
```
# Conditions
**Topics**
+ [Syntaxe](#r_conditions-synopsis)
+ [Condition de comparaison](r_comparison_condition.md)
+ [Conditions logiques](r_logical_condition.md)
+ [Conditions de correspondance de modèles](pattern-matching-conditions.md)
+ [Condition de plage BETWEEN](r_range_condition.md)
+ [Condition null](r_null_condition.md)
+ [Condition EXISTS](r_exists_condition.md)
+ [Condition IN](r_in_condition.md)
Une condition est une instruction d’un(e) ou plusieurs expressions et opérateurs logiques qui ont la valeur true, false ou unknown. Les conditions sont également appelées parfois prédicats.
**Note**
Toutes les comparaisons de chaîne et correspondances du modèle LIKE sont sensibles à la casse. Par exemple, « A » et « a » ne correspondent pas. Cependant, vous pouvez effectuer une correspondance de modèle non sensible à la casse à l’aide du prédicat ILIKE.
## Syntaxe
```
comparison_condition
| logical_condition
| range_condition
| pattern_matching_condition
| null_condition
| EXISTS_condition
| IN_condition
```
# Condition de comparaison
Les conditions de comparaison établissent des relations logiques entre deux valeurs. Toutes les conditions de comparaison sont des opérateurs binaires avec un type de retour booléen. Amazon Redshift prend en charge les opérateurs de comparaison décrits dans le tableau suivant :
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/r_comparison_condition.html)
## Notes d’utilisation
= ANY \$1 SOME
Les mots-clés ANY et SOME sont synonymes de la condition *IN*, et renvoient true (vrai) si la comparaison est vraie pour au moins une valeur renvoyée par une sous-requête qui renvoie une ou plusieurs valeurs. Amazon Redshift prend en charge uniquement la condition = (égal) pour ANY et SOME. Les conditions d’inégalité ne sont pas prises en charge.
Le prédicat ALL n’est pas pris en charge.
<> ALL
Le mot-clé ALL est synonyme de NOT IN (voir condition [Condition IN](r_in_condition.md)) et renvoie true (vrai) si l’expression n’est pas incluse dans les résultats de la sous-requête. Amazon Redshift prend en charge uniquement la condition <> ou \$1= (non égal) pour ALL. Les autres conditions de comparaison ne sont pas prises en charge.
EST TRUE/FALSE/UNKNOWN
Les valeurs différentes de zéro correspondent à TRUE, 0 correspond à FALSE et null équivaut à UNKNOWN. Consultez le type de données [Type BooleanType HLLSKETCH](r_Boolean_type.md).
## Exemples
Voici quelques exemples simples de conditions de comparaison :
```
a = 5
a < b
min(x) >= 5
qtysold = any (select qtysold from sales where dateid = 1882
```
La requête suivante retourne les sites de plus de 10 000 places à partir de la table VENUE :
```
select venueid, venuename, venueseats from venue
where venueseats > 10000
order by venueseats desc;
venueid | venuename | venueseats
---------+--------------------------------+------------
83 | FedExField | 91704
6 | New York Giants Stadium | 80242
79 | Arrowhead Stadium | 79451
78 | INVESCO Field | 76125
69 | Dolphin Stadium | 74916
67 | Ralph Wilson Stadium | 73967
76 | Jacksonville Municipal Stadium | 73800
89 | Bank of America Stadium | 73298
72 | Cleveland Browns Stadium | 73200
86 | Lambeau Field | 72922
...
(57 rows)
```
Cet exemple sélectionne les utilisateurs (USERID) de la table USERS qui aiment la musique rock :
```
select userid from users where likerock = 't' order by 1 limit 5;
userid
--------
3
5
6
13
16
(5 rows)
```
Cet exemple sélectionne les utilisateurs (USERID) de la table USERS pour lesquels on ignore s’ils aiment la musique rock :
```
select firstname, lastname, likerock
from users
where likerock is unknown
order by userid limit 10;
firstname | lastname | likerock
----------+----------+----------
Rafael | Taylor |
Vladimir | Humphrey |
Barry | Roy |
Tamekah | Juarez |
Mufutau | Watkins |
Naida | Calderon |
Anika | Huff |
Bruce | Beck |
Mallory | Farrell |
Scarlett | Mayer |
(10 rows
```
## Exemples avec une colonne TIME
La table d'exemple TIME\$1TEST suivante comporte une colonne TIME\$1VAL (type TIME) dans laquelle trois valeurs ont été insérées.
```
select time_val from time_test;
time_val
---------------------
20:00:00
00:00:00.5550
00:58:00
```
L'exemple suivant extrait les heures de chaque timetz\$1val.
```
select time_val from time_test where time_val < '3:00';
time_val
---------------
00:00:00.5550
00:58:00
```
L’exemple suivant compare deux littéraux de type heure.
```
select time '18:25:33.123456' = time '18:25:33.123456';
?column?
----------
t
```
## Exemples avec une colonne TIMETZ
L'exemple de tableau TIMETZ\$1TEST suivant comporte une colonne TIMETZ\$1VAL (type TIMETZ) dans laquelle trois valeurs ont été insérées.
```
select timetz_val from timetz_test;
timetz_val
------------------
04:00:00+00
00:00:00.5550+00
05:58:00+00
```
L’exemple suivant sélectionne uniquement les valeurs TIMETZ inférieures à `3:00:00 UTC`. La comparaison est effectuée après la conversion de la valeur en UTC.
```
select timetz_val from timetz_test where timetz_val < '3:00:00 UTC';
timetz_val
---------------
00:00:00.5550+00
```
L’exemple suivant compare deux littéraux TIMETZ. Le fuseau horaire n’est pas pris en compte pour la comparaison.
```
select time '18:25:33.123456 PST' < time '19:25:33.123456 EST';
?column?
----------
t
```
# Conditions logiques
Les conditions logiques combinent le résultat de deux conditions pour produire un résultat unique. Toutes les conditions logiques sont des opérateurs binaires avec un type de retour booléen.
## Syntaxe
```
expression
{ AND | OR }
expression
NOT expression
```
Les conditions logiques utilisent une logique booléenne à trois valeurs où la valeur nulle représente une relation inconnue. Le tableau suivant décrit les résultats des conditions logiques, où `E1` et `E2` représentent des expressions :
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/r_logical_condition.html)
L’opérateur NOT est analysé avant AND et l’opérateur AND est évalué avant l’opérateur OR. Les parenthèses utilisées peuvent remplacer cet ordre d’évaluation par défaut.
### Exemples
L’exemple suivant retourne USERID et USERNAME de la table USERS où l’utilisateur aime à la fois Las Vegas et les sports :
```
select userid, username from users
where likevegas = 1 and likesports = 1
order by userid;
userid | username
--------+----------
1 | JSG99FHE
67 | TWU10MZT
87 | DUF19VXU
92 | HYP36WEQ
109 | FPL38HZK
120 | DMJ24GUZ
123 | QZR22XGQ
130 | ZQC82ALK
133 | LBN45WCH
144 | UCX04JKN
165 | TEY68OEB
169 | AYQ83HGO
184 | TVX65AZX
...
(2128 rows)
```
L’exemple suivant retourne USERID et USERNAME de la table USERS où l’utilisateur aime Las Vegas, ou les sports, ou les deux. Cette requête renvoie toutes les données de sortie de l’exemple précédent, plus les utilisateurs qui aiment uniquement Las Vegas ou le sport.
```
select userid, username from users
where likevegas = 1 or likesports = 1
order by userid;
userid | username
--------+----------
1 | JSG99FHE
2 | PGL08LJI
3 | IFT66TXU
5 | AEB55QTM
6 | NDQ15VBM
9 | MSD36KVR
10 | WKW41AIW
13 | QTF33MCG
15 | OWU78MTR
16 | ZMG93CDD
22 | RHT62AGI
27 | KOY02CVE
29 | HUH27PKK
...
(18968 rows)
```
La requête suivante utilise des parenthèses autour de la condition `OR` pour trouver les salles de New York ou de Californie où Macbeth a été joué :
```
select distinct venuename, venuecity
from venue join event on venue.venueid=event.venueid
where (venuestate = 'NY' or venuestate = 'CA') and eventname='Macbeth'
order by 2,1;
venuename | venuecity
----------------------------------------+---------------
Geffen Playhouse | Los Angeles
Greek Theatre | Los Angeles
Royce Hall | Los Angeles
American Airlines Theatre | New York City
August Wilson Theatre | New York City
Belasco Theatre | New York City
Bernard B. Jacobs Theatre | New York City
...
```
La suppression des parenthèses de cet exemple modifie la logique et les résultats de la requête.
Les exemples suivants utilisent l’opérateur `NOT` :
```
select * from category
where not catid=1
order by 1;
catid | catgroup | catname | catdesc
-------+----------+-----------+--------------------------------------------
2 | Sports | NHL | National Hockey League
3 | Sports | NFL | National Football League
4 | Sports | NBA | National Basketball Association
5 | Sports | MLS | Major League Soccer
...
```
L’exemple suivant utilise une condition `NOT` suivie d’une condition `AND` :
```
select * from category
where (not catid=1) and catgroup='Sports'
order by catid;
catid | catgroup | catname | catdesc
-------+----------+---------+---------------------------------
2 | Sports | NHL | National Hockey League
3 | Sports | NFL | National Football League
4 | Sports | NBA | National Basketball Association
5 | Sports | MLS | Major League Soccer
(4 rows)
```
# Conditions de correspondance de modèles
**Topics**
+ [LIKE](r_patternmatching_condition_like.md)
+ [SIMILAR TO](pattern-matching-conditions-similar-to.md)
+ [Opérateurs POSIX](pattern-matching-conditions-posix.md)
Un opérateur de correspondance de modèle recherche une chaîne d’un modèle spécifié dans l’expression conditionnelle et retourne true ou false selon qu’il a trouvé ou non une correspondance. Amazon Redshift utilise trois méthodes pour la correspondance des modèles :
+ Expressions LIKE
L’opérateur LIKE compare une expression de chaîne, comme un nom de colonne, avec un modèle qui utilise les caractères génériques `%` (pourcentage) et `_` (soulignement). La correspondance de modèle LIKE couvre toute la chaîne. LIKE effectue une correspondance sensible à la casse et ILIKE effectue une correspondance non sensible à la casse.
+ Expressions régulières SIMILAR TO
L’opérateur SIMILAR TO correspond à une expression de chaîne avec un modèle d’expression régulière SQL standard, ce qui peut inclure un ensemble de métacaractères de correspondance de modèle incluant les deux pris en charge par l’opérateur LIKE. SIMILAR TO correspond à la totalité de la chaîne et effectue une correspondance sensible à la casse.
+ Expressions régulières POSIX
Les expressions régulières POSIX fournissent un moyen plus puissant pour la correspondance de modèles que les opérateurs LIKE et SIMILAR TO. Les modèles d’expressions régulières POSIX peuvent correspondre à n’importe quelle partie de la chaîne et effectuent une correspondance sensible à la casse.
La correspondance d’expressions régulières, à l’aide des opérateurs SIMILAR TO ou POSIX, est coûteuse en termes de calcul. Nous vous conseillons d’utiliser LIKE autant que possible, notamment lors du traitement d’un très grand nombre de lignes. Par exemple, les requêtes suivantes sont fonctionnellement identiques, mais la requête qui utilise LIKE s’exécute infiniment plus vite que la requête qui utilise une expression régulière :
```
select count(*) from event where eventname SIMILAR TO '%(Ring|Die)%';
select count(*) from event where eventname LIKE '%Ring%' OR eventname LIKE '%Die%';
```
# LIKE
L’opérateur LIKE compare une expression de chaîne, comme un nom de colonne, avec un modèle qui utilise les caractères génériques % (pourcentage) et \$1 (soulignement). La correspondance de modèle LIKE couvre toute la chaîne. Pour faire correspondre une séquence à n’importe quel emplacement au sein d’une chaîne, le modèle doit commencer et finir par un signe %.
LIKE est sensible à la casse, ILIKE ne l’est pas.
## Syntaxe
```
expression [ NOT ] LIKE | ILIKE pattern [ ESCAPE 'escape_char' ]
```
## Arguments
*expression*
Expression de caractère UTF-8 valide, comme un nom de colonne.
LIKE \$1 ILIKE
LIKE effectue une correspondance sensible à la casse. ILIKE effectue une correspondance de modèle non sensible à la casse pour les caractères UTF-8 (ASCII) codés sur un octet. Pour effectuer une correspondance de modèle non sensible à la casse pour les caractères codés sur plusieurs octets, utilisez la fonction [LOWER](r_LOWER.md) sur *expression* et *pattern* avec une condition LIKE.
Contrairement aux prédicats de comparaison, tels que = et <>, les prédicats LIKE et ILIKE n’ignorent pas implicitement les espaces de fin. Pour ignorer les espaces de fin, utilisez RTRIM ou convertissez explicitement une colonne CHAR en VARCHAR.
L’opérateur `~~` est équivalent à LIKE et `~~*` est équivalent à ILIKE. Les opérateurs `!~~` et `!~~*` sont également équivalents à NOT LIKE et NOT ILIKE.
*pattern*
Expression de caractère UTF-8 valide avec le modèle à mettre en correspondance.
*escape\$1char*
Expression de caractère qui utilise une séquence d’échappement pour les méta-caractères du modèle. La valeur par défaut est deux barres obliques inverses (’\$1\$1 »).
Si *pattern* ne contient pas de méta-caractères, le modèle représente uniquement la chaîne elle-même ; dans ce cas, LIKE agit de même que l’opérateur d’égalité.
Les expressions de caractère peuvent avoir CHAR ou VARCHAR comme type de données. En cas de différence, Amazon Redshift convertit *pattern* au type de données de l’*expression*.
LIKE prend en charge les méta-caractères de correspondance de modèle suivants :
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/r_patternmatching_condition_like.html)
## Exemples
Le tableau suivant montre des exemples de correspondance de modèle avec LIKE :
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/r_patternmatching_condition_like.html)
L’exemple suivant recherche toutes les villes dont le nom commence par « E » :
```
select distinct city from users
where city like 'E%' order by city;
city
---------------
East Hartford
East Lansing
East Rutherford
East St. Louis
Easthampton
Easton
Eatontown
Eau Claire
...
```
L’exemple suivant recherche les utilisateurs dont le nom contient « ten » :
```
select distinct lastname from users
where lastname like '%ten%' order by lastname;
lastname
-------------
Christensen
Wooten
...
```
L’exemple suivant montre comment associer plusieurs modèles.
```
select distinct lastname from tickit.users
where lastname like 'Chris%' or lastname like '%Wooten' order by lastname;
lastname
-------------
Christensen
Christian
Wooten
...
```
L’exemple suivant recherche villes dont les troisième et quatrième caractères sont « ea ». La commande utilise ILIKE pour démontrer l’insensibilité à la casse :
```
select distinct city from users where city ilike '__EA%' order by city;
city
-------------
Brea
Clearwater
Great Falls
Ocean City
Olean
Wheaton
(6 rows)
```
L’exemple suivant utilise la chaîne d’échappement par défaut (\$1\$1) pour rechercher les chaînes qui incluent « start\$1» (texte `start` suivi d’un trait de soulignement `_`) :
```
select tablename, "column" from pg_table_def
where "column" like '%start\\_%'
limit 5;
tablename | column
-------------------+---------------
stl_s3client | start_time
stl_tr_conflict | xact_start_ts
stl_undone | undo_start_ts
stl_unload_log | start_time
stl_vacuum_detail | start_row
(5 rows)
```
L’exemple suivant spécifie « ^ » comme caractère d’échappement, puis utilise ce dernier pour rechercher des chaînes qui incluent « start\$1 » (texte `start` suivi d’un trait de soulignement `_`) :
```
select tablename, "column" from pg_table_def
where "column" like '%start^_%' escape '^'
limit 5;
tablename | column
-------------------+---------------
stl_s3client | start_time
stl_tr_conflict | xact_start_ts
stl_undone | undo_start_ts
stl_unload_log | start_time
stl_vacuum_detail | start_row
(5 rows)
```
L’exemple suivant utilise l’opérateur `~~*` pour effectuer une recherche non sensible à la casse (ILIKE) pour les villes commençant par « Ag ».
```
select distinct city from users where city ~~* 'Ag%' order by city;
city
------------
Agat
Agawam
Agoura Hills
Aguadilla
```
# SIMILAR TO
L’opérateur SIMILAR TO met en correspondance une expression de chaîne, comme un nom de colonne, avec un modèle d’expression régulière SQL standard. Un modèle d’expression régulière SQL peut inclure un ensemble de méta-caractères de correspondance de modèle, y compris les deux pris en charge par l’opérateur [LIKE](r_patternmatching_condition_like.md).
L’opérateur SIMILAR TO retourne true uniquement si son modèle correspond à l’ensemble de la chaîne, à la différence du comportement de l’expression régulière POSIX, où le modèle peut correspondre à n’importe quelle partie de la chaîne.
SIMILAR TO effectue une correspondance sensible à la casse.
**Note**
La correspondance d’expression régulière à l’aide de SIMILAR TO est coûteuse en termes de calcul. Nous vous conseillons d’utiliser LIKE autant que possible, notamment lors du traitement d’un très grand nombre de lignes. Par exemple, les requêtes suivantes sont fonctionnellement identiques, mais la requête qui utilise LIKE s’exécute infiniment plus vite que la requête qui utilise une expression régulière :
```
select count(*) from event where eventname SIMILAR TO '%(Ring|Die)%';
select count(*) from event where eventname LIKE '%Ring%' OR eventname LIKE '%Die%';
```
## Syntaxe
```
expression [ NOT ] SIMILAR TO pattern [ ESCAPE 'escape_char' ]
```
## Arguments
*expression*
Expression de caractère UTF-8 valide, comme un nom de colonne.
SIMILAR TO
SIMILAR TO effectue une correspondance sensible à la casse pour toute la chaîne de l’*expression*.
*pattern*
Expression de caractères UTF-8 valide représentant un modèle d’expression régulière SQL standard.
*escape\$1char*
Expression de caractères qui utilise une séquence d’échappement pour les méta-caractères du modèle. La valeur par défaut est deux barres obliques inverses (’\$1\$1 »).
Si *pattern* ne contient pas de méta-caractères, le modèle représente uniquement la chaîne elle-même.
Les expressions de caractère peuvent avoir CHAR ou VARCHAR comme type de données. En cas de différence, Amazon Redshift convertit *pattern* au type de données de l’*expression*.
SIMILAR TO prend en charge les méta-caractères de correspondance de modèle suivants :
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/pattern-matching-conditions-similar-to.html)
## Exemples
Le tableau suivant illustre des exemples de correspondance de modèle à l’aide de SIMILAR TO :
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/pattern-matching-conditions-similar-to.html)
L’exemple suivant recherche toutes les villes dont le nom contient « E » ou « H » :
```
SELECT DISTINCT city FROM users
WHERE city SIMILAR TO '%E%|%H%' ORDER BY city LIMIT 5;
city
-----------------
Agoura Hills
Auburn Hills
Benton Harbor
Beverly Hills
Chicago Heights
```
L’exemple suivant utilise la chaîne d’échappement par défaut (« `\\` ») pour rechercher les chaînes qui incluent « `_` » :
```
SELECT tablename, "column" FROM pg_table_def
WHERE "column" SIMILAR TO '%start\\_%'
ORDER BY tablename, "column" LIMIT 5;
tablename | column
--------------------------+---------------------
stcs_abort_idle | idle_start_time
stcs_abort_idle | txn_start_time
stcs_analyze_compression | start_time
stcs_auto_worker_levels | start_level
stcs_auto_worker_levels | start_wlm_occupancy
```
Les exemples suivants spécifient « `^` » comme caractère d’échappement, puis utilise le caractère d’échappement pour rechercher des chaînes qui incluent « `_` » :
```
SELECT tablename, "column" FROM pg_table_def
WHERE "column" SIMILAR TO '%start^_%' ESCAPE '^'
ORDER BY tablename, "column" LIMIT 5;
tablename | column
--------------------------+---------------------
stcs_abort_idle | idle_start_time
stcs_abort_idle | txn_start_time
stcs_analyze_compression | start_time
stcs_auto_worker_levels | start_level
stcs_auto_worker_levels | start_wlm_occupancy
```
# Opérateurs POSIX
Une expression régulière POSIX est une séquence de caractères qui spécifie un modèle de correspondance. Une chaîne correspond à une expression régulière si elle fait partie du jeu régulier décrit par l’expression régulière.
Les expressions régulières POSIX fournissent un moyen plus puissant pour la correspondance de modèle que les opérateurs [LIKE](r_patternmatching_condition_like.md) et [SIMILAR TO](pattern-matching-conditions-similar-to.md). Les modèles d’expressions régulières POSIX peuvent correspondre à une partie quelconque d’une chaîne, contrairement à l’opérateur SIMILAR TO, qui retourne true uniquement si son modèle correspond à la totalité de la chaîne.
**Note**
La correspondance d’expressions régulières à l’aide des opérateurs POSIX est coûteuse en termes de calcul. Nous vous conseillons d’utiliser LIKE autant que possible, notamment lors du traitement d’un très grand nombre de lignes. Par exemple, les requêtes suivantes sont fonctionnellement identiques, mais la requête qui utilise LIKE s’exécute infiniment plus vite que la requête qui utilise une expression régulière :
```
select count(*) from event where eventname ~ '.*(Ring|Die).*';
select count(*) from event where eventname LIKE '%Ring%' OR eventname LIKE '%Die%';
```
## Syntaxe
```
expression [ ! ] ~ pattern
```
## Arguments
*expression*
Expression de caractère UTF-8 valide, comme un nom de colonne.
\$1
Opérateur de négation. Ne correspond pas à l’expression régulière.
\$1
Effectuez une correspondance sensible à la casse pour une sous-chaîne d’*expression*.
`~~` est un synonyme pour [LIKE](r_patternmatching_condition_like.md).
*pattern*
Chaîne littérale qui représente un modèle d’expression régulière.
Si *pattern* ne contient pas de caractères génériques, le modèle représente uniquement la chaîne elle-même.
Pour rechercher des chaînes qui incluent des méta-caractères, tels que « `. * | ? ` », et ainsi de suite, faites précéder le caractère de la séquence d’échappement composée de deux barres obliques inverses « ` \\` »). Contrairement à `SIMILAR TO` et `LIKE`, la syntaxe des expressions régulières POSIX ne gère pas de caractère d’échappement défini par l’utilisateur.
Les expressions de caractère peuvent avoir CHAR ou VARCHAR comme type de données. En cas de différence, Amazon Redshift convertit *pattern* au type de données de l’*expression*.
Toutes les expressions de caractères peuvent avoir CHAR ou VARCHAR comme type de données. Si les expressions diffèrent par le type de données, Amazon Redshift les convertit au type de données de l’*expression*.
Le modèle de correspondance POSIX prend en charge les méta-caractères suivants :
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/pattern-matching-conditions-posix.html)
Amazon Redshift prend en charge les classes de caractères POSIX suivantes.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/pattern-matching-conditions-posix.html)
Amazon Redshift prend en charge les opérateurs suivants, influencés par Perl, dans les expressions régulières. Échappez l’opérateur à l’aide de deux barres obliques inverses (« »). (‘`\\`’).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/pattern-matching-conditions-posix.html)
## Exemples
Le tableau suivant montre des exemples de correspondance de modèle à l’aide des opérateurs POSIX :
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/pattern-matching-conditions-posix.html)
L’exemple suivant recherche toutes les villes dont le nom contient `E` ou `H` :
```
SELECT DISTINCT city FROM users
WHERE city ~ '.*E.*|.*H.*' ORDER BY city LIMIT 5;
city
-----------------
Agoura Hills
Auburn Hills
Benton Harbor
Beverly Hills
Chicago Heights
```
L’exemple suivant recherche toutes les villes dont le nom ne contient pas `E` ou `H` :
```
SELECT DISTINCT city FROM users WHERE city !~ '.*E.*|.*H.*' ORDER BY city LIMIT 5;
city
-----------------
Aberdeen
Abilene
Ada
Agat
Agawam
```
L’exemple suivant utilise la chaîne d’échappement (« `\\` ») pour rechercher les chaînes qui incluent un point.
```
SELECT venuename FROM venue
WHERE venuename ~ '.*\\..*'
ORDER BY venueid;
venuename
------------------------------
St. Pete Times Forum
Jobing.com Arena
Hubert H. Humphrey Metrodome
U.S. Cellular Field
Superpages.com Center
E.J. Nutter Center
Bernard B. Jacobs Theatre
St. James Theatre
```
# Condition de plage BETWEEN
Une condition `BETWEEN` teste les expressions pour l’inclusion dans une plage de valeurs, à l’aide des mots-clés `BETWEEN` et `AND`.
## Syntaxe
```
expression [ NOT ] BETWEEN expression AND expression
```
Les expressions peuvent être de type de données numeric, character ou datetime, mais elles doivent être compatibles. La plage est inclusive.
## Exemples
Le premier exemple comptabilise le nombre de transactions ayant enregistré des ventes de 2, 3 ou 4 billets :
```
select count(*) from sales
where qtysold between 2 and 4;
count
--------
104021
(1 row)
```
La condition de la plage comprend les valeurs de début et de fin.
```
select min(dateid), max(dateid) from sales
where dateid between 1900 and 1910;
min | max
-----+-----
1900 | 1910
```
La première expression d’une condition de plage doit être la valeur inférieure et la deuxième expression la valeur supérieure. L’exemple suivant retourne toujours zéro ligne en raison des valeurs des expressions :
```
select count(*) from sales
where qtysold between 4 and 2;
count
-------
0
(1 row)
```
Cependant, l’application du modificateur NOT inverse la logique et génère le nombre de toutes les lignes :
```
select count(*) from sales
where qtysold not between 4 and 2;
count
--------
172456
(1 row)
```
La requête suivante retourne une liste des salles avec 20 000 à 50 000 places :
```
select venueid, venuename, venueseats from venue
where venueseats between 20000 and 50000
order by venueseats desc;
venueid | venuename | venueseats
---------+-------------------------------+------------
116 | Busch Stadium | 49660
106 | Rangers BallPark in Arlington | 49115
96 | Oriole Park at Camden Yards | 48876
...
(22 rows)
```
L’exemple suivant illustre l’utilisation de BETWEEN pour les valeurs de date :
```
select salesid, qtysold, pricepaid, commission, saletime
from sales
where eventid between 1000 and 2000
and saletime between '2008-01-01' and '2008-01-03'
order by saletime asc;
salesid | qtysold | pricepaid | commission | saletime
--------+---------+-----------+------------+---------------
65082 | 4 | 472 | 70.8 | 1/1/2008 06:06
110917 | 1 | 337 | 50.55 | 1/1/2008 07:05
112103 | 1 | 241 | 36.15 | 1/2/2008 03:15
137882 | 3 | 1473 | 220.95 | 1/2/2008 05:18
40331 | 2 | 58 | 8.7 | 1/2/2008 05:57
110918 | 3 | 1011 | 151.65 | 1/2/2008 07:17
96274 | 1 | 104 | 15.6 | 1/2/2008 07:18
150499 | 3 | 135 | 20.25 | 1/2/2008 07:20
68413 | 2 | 158 | 23.7 | 1/2/2008 08:12
```
Notez que même si la plage de BETWEEN est inclusive, les dates ont par défaut une valeur horaire de 00:00:00. La seule ligne valide du 3 janvier pour l’exemple de requête serait une ligne dont saletime est `1/3/2008 00:00:00`.
# Condition null
La condition null teste les valeurs null, lorsqu’une valeur est manquante ou inconnue.
## Syntaxe
```
expression IS [ NOT ] NULL
```
## Arguments
*expression*
N’importe quelle expression telle qu’une colonne.
IS NULL
Condition vraie lorsque la valeur de l’expression est null et fausse quand elle a une valeur.
IS NOT NULL
Condition fausse lorsque la valeur de l’expression est null et vraie quand elle a une valeur.
## Exemple
Cet exemple indique le nombre de fois où la table SALES contient null dans le champ QTYSOLD :
```
select count(*) from sales
where qtysold is null;
count
-------
0
(1 row)
```
# Condition EXISTS
Les conditions EXIST testent l’existence de lignes dans une sous-requête et retournent la valeur true si la requête renvoie au moins une ligne. Si NOT n’est pas spécifié, la condition retourne true si une sous-requête ne renvoie aucune ligne.
## Syntaxe
```
[ NOT ] EXISTS (table_subquery)
```
## Arguments
EXISTS
Est vraie lorsque la *table\$1subquery* retourne au moins une ligne.
NOT EXISTS
Est vraie lorsque la *table\$1subquery* ne retourne pas de lignes.
*table\$1subquery*
Une sous-requête qui analyse une table avec une ou plusieurs colonnes et une ou plusieurs lignes.
## Exemple
Cet exemple retourne tous les identificateurs de date, une fois chacun, pour chaque date où une vente a eu lieu :
```
select dateid from date
where exists (
select 1 from sales
where date.dateid = sales.dateid
)
order by dateid;
dateid
--------
1827
1828
1829
...
```
# Condition IN
Une condition IN teste une valeur d’adhésion dans une sous-requête ou un ensemble de valeurs.
## Syntaxe
```
expression [ NOT ] IN (expr_list | table_subquery)
```
## Arguments
*expression*
Une expression de type numeric, character ou datetime évaluée par rapport à *expr\$1list* ou *table\$1subquery* et qui doit être compatible avec le type de données de cette liste ou sous-requête.
*expr\$1list*
Une ou plusieurs expressions délimitées par des virgules, ou un ou plusieurs ensembles d’expressions délimitées par des virgules et entourées par des parenthèses.
*table\$1subquery*
Une sous-requête qui correspond à une table avec une ou plusieurs lignes, mais est limitée à une seule colonne dans la liste de sélection.
IN \$1 NOT IN
IN retourne la valeur true si l’expression est membre de la liste d’expressions ou de la requête. NOT IN retourne la valeur true si l’expression n’est pas membre. IN et NOT IN retournent la valeur NULL et aucune ligne n’est retournée dans les cas suivants : si *expression* génère null, s’il n’y a aucune *expr\$1list* correspondante ou si les valeurs de *table\$1subquery* et au moins l’une de ces lignes de comparaison entraînent une valeur null.
## Exemples
Les conditions suivantes sont vraies uniquement pour les valeurs répertoriées :
```
qtysold in (2, 4, 5)
date.day in ('Mon', 'Tues')
date.month not in ('Oct', 'Nov', 'Dec')
```
## Optimisation pour les grandes listes IN
Afin d’optimiser les performances des requêtes, une liste IN qui inclut plus de 10 valeurs est analysée en interne comme un ensemble (array) scalaire. Les listes IN avec moins de 10 valeurs sont évaluées comme une série de prédicats OR. Cette optimisation est prise en charge pour les types de données SMALLINT, INTEGER, BIGINT, REAL, DOUBLE PRECISION, BOOLEAN, CHAR, VARCHAR, DATE, TIMESTAMP et TIMESTAMPTZ.
Examinez la sortie EXPLAIN de la requête pour voir l’effet de cette optimisation. Par exemple :
```
explain select * from sales
QUERY PLAN
--------------------------------------------------------------------
XN Seq Scan on sales (cost=0.00..6035.96 rows=86228 width=53)
Filter: (salesid = ANY ('{1,2,3,4,5,6,7,8,9,10,11}'::integer[]))
(2 rows)
```
# Commandes SQL
Le langage SQL se compose des commandes que vous utilisez pour créer et manipuler des objets de base de données, exécuter des requêtes, charger des tables et modifier les données des tables.
Amazon Redshift est basé sur PostgreSQL. Amazon Redshift et PostgreSQL présentent un certain nombre de différences importantes dont vous devez être conscient lorsque vous concevez et développez vos applications d’entrepôt des données. Pour plus d’informations sur les différences entre Amazon Redshift SQL et PostgreSQL, consultez [Amazon Redshift et PostgreSQL](c_redshift-and-postgres-sql.md).
**Note**
La taille maximale d’une instruction SQL est de 16 Mo.
**Topics**
+ [ABORT](r_ABORT.md)
+ [ALTER DATABASE](r_ALTER_DATABASE.md)
+ [ALTER DATASHARE](r_ALTER_DATASHARE.md)
+ [ALTER DEFAULT PRIVILEGES](r_ALTER_DEFAULT_PRIVILEGES.md)
+ [ALTER EXTERNAL SCHEMA](r_ALTER_EXTERNAL_SCHEMA.md)
+ [ALTER EXTERNAL VIEW](r_ALTER_EXTERNAL_VIEW.md)
+ [ALTER FUNCTION](r_ALTER_FUNCTION.md)
+ [ALTER GROUP](r_ALTER_GROUP.md)
+ [ALTER IDENTITY PROVIDER](r_ALTER_IDENTITY_PROVIDER.md)
+ [MODIFIER LA POLITIQUE DE MASQUAGE](r_ALTER_MASKING_POLICY.md)
+ [ALTER MATERIALIZED VIEW](r_ALTER_MATERIALIZED_VIEW.md)
+ [ALTER RLS POLICY](r_ALTER_RLS_POLICY.md)
+ [ALTER ROLE](r_ALTER_ROLE.md)
+ [ALTER PROCEDURE](r_ALTER_PROCEDURE.md)
+ [ALTER SCHEMA](r_ALTER_SCHEMA.md)
+ [ALTER SYSTEM](r_ALTER_SYSTEM.md)
+ [ALTER TABLE](r_ALTER_TABLE.md)
+ [ALTER TABLE APPEND](r_ALTER_TABLE_APPEND.md)
+ [MODIFIER LE MODÈLE](r_ALTER_TEMPLATE.md)
+ [ALTER USER](r_ALTER_USER.md)
+ [ANALYSE](r_ANALYZE.md)
+ [ANALYZE COMPRESSION](r_ANALYZE_COMPRESSION.md)
+ [ATTACH MASKING POLICY](r_ATTACH_MASKING_POLICY.md)
+ [ATTACH RLS POLICY](r_ATTACH_RLS_POLICY.md)
+ [BEGIN](r_BEGIN.md)
+ [CALL](r_CALL_procedure.md)
+ [ANNULER](r_CANCEL.md)
+ [CLOSE](close.md)
+ [COMMENT](r_COMMENT.md)
+ [COMMIT](r_COMMIT.md)
+ [COPY](r_COPY.md)
+ [CREATE DATABASE](r_CREATE_DATABASE.md)
+ [CREATE DATASHARE](r_CREATE_DATASHARE.md)
+ [CREATE EXTERNAL FUNCTION](r_CREATE_EXTERNAL_FUNCTION.md)
+ [CREATE EXTERNAL MODEL](r_create_external_model.md)
+ [CREATE EXTERNAL SCHEMA](r_CREATE_EXTERNAL_SCHEMA.md)
+ [CREATE EXTERNAL TABLE](r_CREATE_EXTERNAL_TABLE.md)
+ [CREATE EXTERNAL VIEW](r_CREATE_EXTERNAL_VIEW.md)
+ [CREATE FUNCTION](r_CREATE_FUNCTION.md)
+ [CREATE GROUP](r_CREATE_GROUP.md)
+ [CREATE IDENTITY PROVIDER](r_CREATE_IDENTITY_PROVIDER.md)
+ [CREATE LIBRARY](r_CREATE_LIBRARY.md)
+ [CREATE MASKING POLICY](r_CREATE_MASKING_POLICY.md)
+ [CREATE MATERIALIZED VIEW](materialized-view-create-sql-command.md)
+ [CREATE MODEL](r_CREATE_MODEL.md)
+ [CREATE PROCEDURE](r_CREATE_PROCEDURE.md)
+ [CREATE RLS POLICY](r_CREATE_RLS_POLICY.md)
+ [CREATE ROLE](r_CREATE_ROLE.md)
+ [CREATE SCHEMA](r_CREATE_SCHEMA.md)
+ [CREATE TABLE](r_CREATE_TABLE_NEW.md)
+ [CREATE TABLE AS](r_CREATE_TABLE_AS.md)
+ [CRÉER UN MODÈLE](r_CREATE_TEMPLATE.md)
+ [CREATE USER](r_CREATE_USER.md)
+ [CREATE VIEW](r_CREATE_VIEW.md)
+ [DEALLOCATE](r_DEALLOCATE.md)
+ [DECLARE](declare.md)
+ [DELETE](r_DELETE.md)
+ [DESC DATASHARE](r_DESC_DATASHARE.md)
+ [DESC IDENTITY PROVIDER](r_DESC_IDENTITY_PROVIDER.md)
+ [DETACH MASKING POLICY](r_DETACH_MASKING_POLICY.md)
+ [DETACH RLS POLICY](r_DETACH_RLS_POLICY.md)
+ [DROP DATABASE](r_DROP_DATABASE.md)
+ [DROP DATASHARE](r_DROP_DATASHARE.md)
+ [DROP EXTERNAL VIEW](r_DROP_EXTERNAL_VIEW.md)
+ [DROP FUNCTION](r_DROP_FUNCTION.md)
+ [DROP GROUP](r_DROP_GROUP.md)
+ [DROP IDENTITY PROVIDER](r_DROP_IDENTITY_PROVIDER.md)
+ [DROP LIBRARY](r_DROP_LIBRARY.md)
+ [DROP MASKING POLICY](r_DROP_MASKING_POLICY.md)
+ [DROP MODEL](r_DROP_MODEL.md)
+ [DROP MATERIALIZED VIEW](materialized-view-drop-sql-command.md)
+ [DROP PROCEDURE](r_DROP_PROCEDURE.md)
+ [DROP RLS POLICY](r_DROP_RLS_POLICY.md)
+ [DROP ROLE](r_DROP_ROLE.md)
+ [DROP SCHEMA](r_DROP_SCHEMA.md)
+ [DROP TABLE](r_DROP_TABLE.md)
+ [MODÈLE DE DÉPÔT](r_DROP_TEMPLATE.md)
+ [DROP USER](r_DROP_USER.md)
+ [DROP VIEW](r_DROP_VIEW.md)
+ [FIN](r_END.md)
+ [EXECUTE](r_EXECUTE.md)
+ [EXPLAIN](r_EXPLAIN.md)
+ [FETCH](fetch.md)
+ [GRANT](r_GRANT.md)
+ [INSERT](r_INSERT_30.md)
+ [INSERT (table externe)](r_INSERT_external_table.md)
+ [LOCK](r_LOCK.md)
+ [MERGE](r_MERGE.md)
+ [PREPARE](r_PREPARE.md)
+ [REFRESH MATERIALIZED VIEW](materialized-view-refresh-sql-command.md)
+ [RESET](r_RESET.md)
+ [REVOKE](r_REVOKE.md)
+ [ROLLBACK](r_ROLLBACK.md)
+ [SELECT](r_SELECT_synopsis.md)
+ [SELECT INTO](r_SELECT_INTO.md)
+ [SET](r_SET.md)
+ [SET SESSION AUTHORIZATION](r_SET_SESSION_AUTHORIZATION.md)
+ [SET SESSION CHARACTERISTICS](r_SET_SESSION_CHARACTERISTICS.md)
+ [MONTRER](r_SHOW.md)
+ [AFFICHER LES SUBVENTIONS DANS LA COLONNE](r_SHOW_COLUMN_GRANTS.md)
+ [SHOW COLUMNS](r_SHOW_COLUMNS.md)
+ [AFFICHER LES CONTRAINTES](r_SHOW_CONSTRAINTS.md)
+ [SHOW EXTERNAL TABLE](r_SHOW_EXTERNAL_TABLE.md)
+ [SHOW DATABASES](r_SHOW_DATABASES.md)
+ [AFFICHER LES FONCTIONS](r_SHOW_FUNCTIONS.md)
+ [SHOW GRANTS](r_SHOW_GRANTS.md)
+ [SHOW MODEL](r_SHOW_MODEL.md)
+ [SHOW DATASHARES](r_SHOW_DATASHARES.md)
+ [AFFICHER LES PARAMÈTRES](r_SHOW_PARAMETERS.md)
+ [AFFICHER LES POLITIQUES](r_SHOW_POLICIES.md)
+ [SHOW PROCEDURE](r_SHOW_PROCEDURE.md)
+ [AFFICHER LES PROCÉDURES](r_SHOW_PROCEDURES.md)
+ [SHOW SCHEMAS](r_SHOW_SCHEMAS.md)
+ [SHOW TABLE](r_SHOW_TABLE.md)
+ [SHOW TABLES](r_SHOW_TABLES.md)
+ [AFFICHER LE MODÈLE](r_SHOW_TEMPLATE.md)
+ [AFFICHER LES MODÈLES](r_SHOW_TEMPLATES.md)
+ [SHOW VIEW](r_SHOW_VIEW.md)
+ [START TRANSACTION](r_START_TRANSACTION.md)
+ [TRUNCATE](r_TRUNCATE.md)
+ [UNLOAD](r_UNLOAD.md)
+ [UPDATE](r_UPDATE.md)
+ [USE](r_USE_command.md)
+ [VACUUM](r_VACUUM_command.md)
# ABORT
Arrête la transaction en cours d’exécution et ignore toutes les mises à jour effectuées par cette transaction. ABORT n’a aucun effet sur les transactions déjà terminées.
Cette commande effectue la même fonction que la commande ROLLBACK. Pour obtenir des informations, consultez [ROLLBACK](r_ROLLBACK.md).
## Syntaxe
```
ABORT [ WORK | TRANSACTION ]
```
## Parameters
WORK
Mot-clé facultatif.
TRANSACTION
Mot-clé facultatif ; WORK et TRANSACTION sont synonymes.
## Exemple
L’exemple suivant crée une table, puis démarre une transaction où les données sont insérées dans la table. La commande ABORT annule ensuite l’insertion des données pour laisser la table vide.
La commande suivante crée un exemple de table appelée MOVIE\$1GROSS :
```
create table movie_gross( name varchar(30), gross bigint );
```
La prochaine série de commandes démarre une transaction qui insère deux lignes de données dans la table :
```
begin;
insert into movie_gross values ( 'Raiders of the Lost Ark', 23400000);
insert into movie_gross values ( 'Star Wars', 10000000 );
```
Puis, la commande suivante sélectionne les données de la table pour montrer qu’elles ont été correctement insérées :
```
select * from movie_gross;
```
La sortie de la commande montre que les deux lignes ont été insérées avec succès :
```
name | gross
------------------------+----------
Raiders of the Lost Ark | 23400000
Star Wars | 10000000
(2 rows)
```
Cette commande restaure les modifications des données à l’emplacement où la transaction a commencé :
```
abort;
```
La sélection de données de la table affiche maintenant une table vide :
```
select * from movie_gross;
name | gross
------+-------
(0 rows)
```
# ALTER DATABASE
Modifie les attributs d’une base de données.
## Privilèges requis
Pour utiliser ALTER DATABASE, l’un des privilèges suivants est requis.
+ Superuser
+ Utilisateurs disposant du privilège ALTER DATABASE
+ Propriétaire de la base de données
## Syntaxe
```
ALTER DATABASE database_name
{
RENAME TO new_name
| OWNER TO new_owner
| [ CONNECTION LIMIT { limit | UNLIMITED } ]
[ COLLATE { CASE_SENSITIVE | CS | CASE_INSENSITIVE | CI } ]
[ ISOLATION LEVEL { SNAPSHOT | SERIALIZABLE } ]
| INTEGRATION
{
REFRESH { { ALL | INERROR } TABLES [ IN SCHEMA schema [, ...] ] | TABLE schema.table [, ...] }
| SET
[ QUERY_ALL_STATES [=] { TRUE | FALSE } ]
[ ACCEPTINVCHARS [=] { TRUE | FALSE } ]
[ REFRESH_INTERVAL ]
[ TRUNCATECOLUMNS [=] { TRUE | FALSE } ]
[ HISTORY_MODE [=] {TRUE | FALSE} [ FOR { {ALL} TABLES [IN SCHEMA schema [, ...] ] | TABLE schema.table [, ...] } ] ]
}
}
```
## Parameters
*database\$1name*
Nom de la base de données à modifier. Généralement, vous modifiez une base de données à laquelle vous n’êtes pas connecté ; quoi qu’il en soit, les modifications ne prennent effet que lors des séances suivantes. Vous pouvez modifier le propriétaire de la base de données, mais vous ne pouvez pas le renommer :
```
alter database tickit rename to newtickit;
ERROR: current database may not be renamed
```
RENAME TO
Renomme la base de données spécifiée. Pour plus d’informations sur les noms valides, consultez [Noms et identificateurs](r_names.md). Vous ne pouvez pas renommer les bases de données dev, padb\$1harvest, template0, template1 ou sys:internal, et vous ne pouvez pas renommer la base de données active. Seul le propriétaire de la base de données ou un [superuser](r_superusers.md#def_superusers) peut renommer une base de données ; les propriétaires qui ne sont pas des super-utilisateurs doivent aussi avoir le privilège CREATEDB.
*nouveau\$1nom*
Nouveau nom de la base de données.
OWNER TO
Modifie le propriétaire de la base de données spécifiée. Vous pouvez modifier le propriétaire de la base de données active ou d’une autre base de données. Seul un super-utilisateur peut changer le propriétaire.
*nouveau\$1propriétaire*
Nouveau propriétaire de la base de données. Le nouveau propriétaire doit être un utilisateur de base de données existant avec des privilèges en écriture. Pour plus d’informations sur les privilèges d’utilisateur, consultez [GRANT](r_GRANT.md).
CONNECTION LIMIT \$1 *limite* \$1 UNLIMITED \$1
Le nombre maximum de connexions à la base de données que les utilisateurs sont autorisés à ouvrir simultanément. La limite n’est pas appliquée pour les super-utilisateurs. Utilisez le mot-clé UNLIMITED pour autoriser le nombre maximum de connexions simultanées. Une limite sur le nombre de connexions pour chaque utilisateur peut également s’appliquer. Pour plus d'informations, consultez [CREATE USER](r_CREATE_USER.md). La valeur par défaut est UNLIMITED. Pour afficher les connexions en cours, interrogez la vue système [STV\$1SESSIONS](r_STV_SESSIONS.md).
Si les deux limites de connexion (utilisateurs et base de données) s’appliquent, un emplacement de connexion inutilisé situé entre les deux limites doit également être disponible lorsqu’un utilisateur tente de se connecter.
COLLATE \$1 CASE\$1SENSITIVE \$1 CS \$1 CASE\$1INSENSITIVE \$1 CI \$1
Clause spécifiant si la recherche de chaînes ou la comparaison est sensible à la casse ou non.
Vous pouvez modifier la sensibilité à la casse de la base de données active même si elle est vide.
Vous devez disposer de l’autorisation ALTER sur la base de données active pour modifier la sensibilité à la casse. Les super-utilisateurs ou propriétaires de base de données disposant de l’autorisation CREATE DATABASE peuvent également modifier la sensibilité à la casse de la base de données.
CASE\$1SENSITIVE et CS sont interchangeables et donnent les mêmes résultats. De même, CASE\$1INSENSITIVE et CI sont interchangeables et donnent les mêmes résultats.
ISOLATION LEVEL \$1 SNAPSHOT \$1 SERIALIZABLE \$1
Clause qui spécifie le niveau d’isolation utilisé lorsque les requêtes sont exécutées sur une base de données. Pour de plus amples informations sur les niveaux d’isolation, consultez [Niveaux d’isolement dans Amazon Redshift](c_serial_isolation.md).
+ Isolation SNAPSHOT : offre un niveau d’isolation avec protection contre les conflits de mise à jour et de suppression
+ Isolation SERIALIZABLE : offre une mise en série complète pour les transactions simultanées.
Tenez compte des éléments suivants lorsque vous modifiez le niveau d’isolation d’une base de données :
+ Vous devez disposer du privilège super-utilisateur ou CREATE DATABASE sur la base de données active pour modifier le niveau d’isolation de la base de données.
+ Vous ne pouvez pas modifier le niveau d’isolation de la base de données `dev`.
+ Vous ne pouvez pas modifier le niveau d’isolation au sein d’un bloc de transaction.
+ La commande de modification du niveau d’isolation échoue si d’autres utilisateurs sont connectés à la base de données.
+ La commande de modification du niveau d’isolation peut modifier les paramètres de niveau d’isolation de la séance en cours.
INTEGRATION
Modification d’une base de données d’intégration zéro ETL.
REFRESH \$1\$1 ALL \$1 INERROR \$1 TABLES [IN SCHEMA *schema* [, ...]] \$1 TABLE *schema.table* [, ...]\$1
Clause spécifiant si Amazon Redshift actualisera toutes les tables ou les tables présentant des erreurs dans le schéma ou la table spécifiés. L’actualisation déclenchera la réplication complète des tables du schéma ou de la table spécifiés à partir de la base de données source.
Pour plus d’informations, consultez [Intégrations zéro ETL](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.html) dans le *Guide de gestion Amazon Redshift*. Pour plus d’informations sur les statuts d’intégration, consultez [SVV\$1INTEGRATION\$1TABLE\$1STATE](r_SVV_INTEGRATION_TABLE_STATE.md) et [SVV\$1INTEGRATION](r_SVV_INTEGRATION.md).
QUERY\$1ALL\$1STATES [=] \$1 TRUE \$1 FALSE \$1
La clause QUERY\$1ALL\$1STATES indique si les tables d’intégration zéro ETL peuvent être interrogées dans tous les états (`Synced`, `Failed`, `ResyncRequired` et `ResyncInitiated`). Par défaut, une table d’intégration zéro ETL ne peut être interrogée que dans son état `Synced`.
ACCEPTINVCHARS [=] \$1 TRUE \$1 FALSE \$1
La clause ACCEPTINVCHARS indique si les tables d’intégration zéro ETL continuent à être ingérées lorsque des caractères non valides sont détectés pour le type de données VARCHAR. Lorsque des caractères non valides sont détectés, ils sont remplacés par un caractère `?` par défaut.
REFRESH\$1INTERVAL
La clause REFRESH\$1INTERVAL définit l’intervalle de temps approximatif, en secondes, pour actualiser les données de la source zéro ETL vers la base de données cible. La valeur `interval` peut être définie entre 0 et 432 000 secondes (5 jours) pour les intégrations zéro ETL dont le type de source est Aurora MySQL, Aurora PostgreSQL ou RDS for MySQL. Pour les intégrations zéro ETL Amazon DynamoDB, la valeur `interval` peut être définie entre 900 et 432 000 secondes (15 minutes et 5 jours).
Pour plus d’informations sur la création de bases de données avec des intégrations zéro ETL, consultez [Création de bases de données de destination dans Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.creating-db.html) dans le *Guide de gestion Amazon Redshift*.
TRUNCATECOLUMNS [=] \$1 TRUE \$1 FALSE \$1
La clause TRUNCATECOLUMNS indique si les tables d’intégration zéro ETL continuent à être ingérées lorsque les valeurs des attributs de colonne VARCHAR ou SUPER dépassent les limites. Avec `TRUE`, les valeurs sont tronquées pour tenir dans la colonne et les valeurs des attributs JSON débordants sont tronquées pour tenir dans la colonne SUPER.
HISTORY\$1MODE [=] \$1TRUE \$1 FALSE\$1 [ FOR \$1 \$1ALL\$1 TABLES [IN SCHEMA schema [, ...]] \$1 TABLE schema.table [, ...]\$1 ]
Clause spécifiant si Amazon Redshift définira le mode historique pour toutes les tables ou les tables du schéma spécifié participant à l’intégration zéro ETL. Cette option s’applique uniquement aux bases de données créées pour une intégration zéro ETL.
La clause HISTORY\$1MODE peut être définie sur `TRUE` ou `FALSE`. La valeur par défaut est `FALSE`. L’activation ou la désactivation du mode historique ne s’applique qu’aux tables en état `Synced`. Pour plus d’informations sur HISTORY\$1MODE, consultez [Mode historique](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-history-mode.html) dans le *Guide de gestion Amazon Redshift*.
## Notes d’utilisation
Les commandes ALTER DATABASE s’appliquent aux séances ultérieures, pas aux séances en cours. Vous devez vous reconnecter à la base de données modifiée pour voir l’effet de la modification.
## Exemples
L’exemple suivant renomme une base de données nommée TICKIT\$1SANDBOX en TICKIT\$1TEST :
```
alter database tickit_sandbox rename to tickit_test;
```
L’exemple suivant modifie le propriétaire de la base de données TICKIT (la base de données active) en DWUSER :
```
alter database tickit owner to dwuser;
```
L’exemple suivant modifie la sensibilité à la casse de la base de données sampledb :
```
ALTER DATABASE sampledb COLLATE CASE_INSENSITIVE;
```
L’exemple suivant montre comment modifier une base de données nommée **sampledb** avec un niveau d’isolation SNAPSHOT.
```
ALTER DATABASE sampledb ISOLATION LEVEL SNAPSHOT;
```
L’exemple suivant actualise les tables **schema1.sample\$1table1** et **schema2.sample\$1table2** dans la base de données **sample\$1integration\$1db** dans le cadre de votre intégration zéro ETL.
```
ALTER DATABASE sample_integration_db INTEGRATION REFRESH TABLE schema1.sample_table1, schema2.sample_table2;
```
L’exemple suivant actualise toutes les tables synchronisées et défaillantes au sein de votre intégration zéro ETL.
```
ALTER DATABASE sample_integration_db INTEGRATION REFRESH ALL tables;
```
L’exemple suivant définit l’intervalle d’actualisation pour les intégrations zéro ETL à 600 secondes.
```
ALTER DATABASE sample_integration_db INTEGRATION SET REFRESH_INTERVAL 600;
```
L’exemple suivant actualise toutes les tables en `ErrorState` dans le schéma **sample\$1schema**.
```
ALTER DATABASE sample_integration_db INTEGRATION REFRESH INERROR TABLES in SCHEMA sample_schema;
```
L’exemple suivant active le mode historique pour la table `myschema.table1`.
```
ALTER DATABASE sample_integration_db INTEGRATION SET HISTORY_MODE = true FOR TABLE myschema.table1
```
L’exemple suivant active le mode historique pour toutes les tables dans `myschema`.
```
ALTER DATABASE sample_integration_db INTEGRATION SET HISTORY_MODE = true for ALL TABLES IN SCHEMA myschema
```
# ALTER DATASHARE
Modifie la définition d’une unité de partage des données. Vous pouvez ajouter ou supprimer des objets à l’aide de la commande ALTER DATASHARE. Vous ne pouvez modifier une unité de partage des données que dans la base de données actuelle. Ajoutez ou supprimez des objets de la base de données associée à une unité de partage des données. Le propriétaire de l’unité de partage des données disposant des autorisations requises sur les objets d’unité de partage des données à ajouter ou à supprimer peut modifier l’unité de partage des données.
## Privilèges requis
Les privilèges suivants sont requis pour ALTER DATASHARE :
+ Super-utilisateur.
+ Utilisateur disposant du privilège ALTER DATASHARE.
+ Utilisateurs disposant du privilège ALTER ou ALL sur l’unité de partage des données.
+ Pour ajouter des objets spécifiques à une unité de partage des données, les utilisateurs doivent avoir le privilège sur les objets. Dans ce cas, les utilisateurs doivent être les propriétaires des objets ou disposer des privilèges SELECT, USAGE ou ALL sur les objets.
## Syntaxe
La syntaxe suivante illustre comment ajouter ou supprimer des objets à l’unité de partage des données.
```
ALTER DATASHARE datashare_name { ADD | REMOVE } {
TABLE schema.table [, ...]
| SCHEMA schema [, ...]
| FUNCTION schema.sql_udf (argtype,...) [, ...]
| ALL TABLES IN SCHEMA schema [, ...]
| ALL FUNCTIONS IN SCHEMA schema [, ...] }
```
La syntaxe suivante montre la manière de configurer les propriétés de l’unité de partage des données.
```
ALTER DATASHARE datashare_name {
[ SET PUBLICACCESSIBLE [=] TRUE | FALSE ]
[ SET INCLUDENEW [=] TRUE | FALSE FOR SCHEMA schema ] }
```
## Parameters
*datashare\$1name*
Nom de l’unité de partage des données à modifier.
ADD \$1 REMOVE
Clause spécifiant s’il faut ajouter ou supprimer des objets de l’unité de partage des données.
TABLE *schema*.*table* [, ...]
Nom de la table ou de la vue dans le schéma spécifié à ajouter à l’unité de partage des données.
SCHEMA *schema* [, ...]
Nom du schéma à ajouter à l’unité de partage des données.
FUNCTION *schema*.*sql\$1udf* (argtype,...) [, ...]
Nom de la fonction SQL définie par l’utilisateur avec des types d’arguments à ajouter à l’unité de partage des données.
ALL TABLES IN SCHEMA *schéma* [, ...]
Clause spécifiant s’il faut ajouter toutes les tables et vues du schéma spécifié à l’unité de partage des données.
ALL FUNCTIONS IN SCHEMA *schema* [, ...] \$1
Clause spécifiant l’ajout de toutes les fonctions du schéma spécifié à l’unité de partage des données.
[ SET PUBLICACCESSIBLE [=] TRUE \$1 FALSE ]
Clause spécifiant si une unité de partage des données peut être partagée avec des clusters accessibles au public.
[ SET INCLUDENEW [=] TRUE \$1 FALSE FOR SCHEMA *schema* ]
Clause qui indique s'il faut ajouter au partage de données les futures tables, vues ou fonctions SQL définies par l'utilisateur (UDFs) créées dans le schéma spécifié. Les tables, les vues ou le code SQL UDFs actuels du schéma spécifié ne sont pas ajoutés au partage de données. Seuls les super-utilisateurs peuvent modifier cette propriété pour chaque paire de datashare-schéma. Par défaut, la clause INCLUDENEW est false.
## Notes d’utilisation d’ALTER DATASHARE
+ Les utilisateurs suivants peuvent modifier une unité de partage des données :
+ Super-utilisateur
+ Le propriétaire de l’unité de partage des données
+ Les utilisateurs disposant du privilège ALTER ou ALL sur l’unité de partage des données
+ Pour ajouter des objets spécifiques à une unité de partage des données, ces utilisateurs doivent avoir le privilège adéquat sur les objets. Les utilisateurs doivent être les propriétaires des objets ou avoir les privilèges SELECT, USAGE ou ALL sur les objets.
+ Vous pouvez partager des schémas, des tables, des vues standard, des vues à liaison tardive, des vues matérialisées et des fonctions SQL définies par l'utilisateur (). UDFs Ajoutez d’abord un schéma à une unité de partage des données avant d’ajouter d’autres objets dans le schéma.
Lorsque vous ajoutez un schéma, Amazon Redshift n’ajoute pas tous les objets qu’il contient. Vous devez les ajouter explicitement.
+ Nous vous recommandons de créer des AWS Data Exchange partages de données avec le paramètre accessible au public activé.
+ En général, nous vous recommandons de ne pas modifier un partage de AWS Data Exchange données pour désactiver l'accessibilité publique à l'aide de l'instruction ALTER DATASHARE. Si vous le faites, les Comptes AWS qui ont accès à l’unité de partage des données perdent l’accès si leurs clusters sont accessibles au public. L'exécution de ce type de modification peut enfreindre les termes des produits de données dans AWS Data Exchange. Pour une exception à cette recommandation, reportez-vous à ce qui suit.
L'exemple suivant montre une erreur lorsqu'un partage de AWS Data Exchange données est créé alors que le paramètre est désactivé.
```
ALTER DATASHARE salesshare SET PUBLICACCESSIBLE FALSE;
ERROR: Alter of ADX-managed datashare salesshare requires session variable datashare_break_glass_session_var to be set to value 'c670ba4db22f4b'
```
Pour autoriser la modification d'un AWS Data Exchange partage de données afin de désactiver le paramètre accessible au public, définissez la variable suivante et réexécutez l'instruction ALTER DATASHARE.
```
SET datashare_break_glass_session_var to 'c670ba4db22f4b';
```
```
ALTER DATASHARE salesshare SET PUBLICACCESSIBLE FALSE;
```
Dans ce cas, Amazon Redshift génère une valeur aléatoire à usage unique pour définir la variable de séance afin d’autoriser ALTER DATASHARE SET PUBLICACCESSIBLE FALSE pour une unité de partage des données AWS Data Exchange .
## Exemples
L’exemple suivant ajoute le schéma `public` à l’unité de partage des données `salesshare`.
```
ALTER DATASHARE salesshare ADD SCHEMA public;
```
L’exemple suivant ajoute la table `public.tickit_sales_redshift` à l’unité de partage des données `salesshare`.
```
ALTER DATASHARE salesshare ADD TABLE public.tickit_sales_redshift;
```
L’exemple suivant ajoute toutes les tables à l’unité de partage des données `salesshare`.
```
ALTER DATASHARE salesshare ADD ALL TABLES IN SCHEMA PUBLIC;
```
L’exemple suivant supprime la table `public.tickit_sales_redshift` de l’exemple de l’unité de partage des données `salesshare`.
```
ALTER DATASHARE salesshare REMOVE TABLE public.tickit_sales_redshift;
```
# ALTER DEFAULT PRIVILEGES
Définit le jeu par défaut des autorisations d’accès à appliquer aux objets créés à l’avenir par l’utilisateur spécifié. Par défaut, les utilisateurs peuvent ne modifier que leurs propres autorisations d’accès par défaut. Seul un super-utilisateur peut spécifier les autorisations par défaut d’autres utilisateurs.
Vous pouvez appliquer les privilèges par défaut à des rôles, des utilisateurs ou des groupes d’utilisateurs. Vous pouvez définir les autorisations par défaut globalement pour tous les objets créés dans la base de données active ou pour les objets créés uniquement dans les schémas spécifiés.
Les autorisations par défaut s’appliquent uniquement aux nouveaux objets. L’exécution d’ALTER DEFAULT PRIVILEGES ne modifie pas les autorisations sur les objets existants. Pour accorder des autorisations sur tous les objets actuels et futurs créés par n’importe quel utilisateur au sein d’une base de données ou d’un schéma, consultez [Autorisations étendues](https://docs.aws.amazon.com/redshift/latest/dg/t_scoped-permissions.html).
Pour afficher les informations sur les privilèges par défaut des utilisateurs de base de données, interrogez la table catalogue système [PG\$1DEFAULT\$1ACL](r_PG_DEFAULT_ACL.md).
Pour plus d’informations sur les privilèges, consultez [GRANT](r_GRANT.md).
## Privilèges requis
Les privilèges suivants sont requis pour ALTER DEFAULT PRIVILEGES :
+ Superuser
+ Utilisateurs disposant du privilège ALTER DEFAULT PRIVILEGES
+ Utilisateurs modifiant leurs propres privilèges d’accès par défaut
+ Utilisateurs définissant des privilèges pour les schémas pour lesquels ils disposent de privilèges d’accès
## Syntaxe
```
ALTER DEFAULT PRIVILEGES
[ FOR USER target_user [, ...] ]
[ IN SCHEMA schema_name [, ...] ]
grant_or_revoke_clause
where grant_or_revoke_clause is one of:
GRANT { { SELECT | INSERT | UPDATE | DELETE | DROP | REFERENCES | TRUNCATE } [,...] | ALL [ PRIVILEGES ] }
ON TABLES
TO { user_name [ WITH GRANT OPTION ] | ROLE role_name | GROUP group_name | PUBLIC } [, ...]
GRANT { EXECUTE | ALL [ PRIVILEGES ] }
ON FUNCTIONS
TO { user_name [ WITH GRANT OPTION ] | ROLE role_name | GROUP group_name | PUBLIC } [, ...]
GRANT { EXECUTE | ALL [ PRIVILEGES ] }
ON PROCEDURES
TO { user_name [ WITH GRANT OPTION ] | ROLE role_name | GROUP group_name | PUBLIC } [, ...]
REVOKE [ GRANT OPTION FOR ] { { SELECT | INSERT | UPDATE | DELETE | REFERENCES | TRUNCATE } [,...] | ALL [ PRIVILEGES ] }
ON TABLES
FROM user_name [, ...] [ RESTRICT ]
REVOKE { { SELECT | INSERT | UPDATE | DELETE | REFERENCES | TRUNCATE } [,...] | ALL [ PRIVILEGES ] }
ON TABLES
FROM { ROLE role_name | GROUP group_name | PUBLIC } [, ...] [ RESTRICT ]
REVOKE [ GRANT OPTION FOR ] { EXECUTE | ALL [ PRIVILEGES ] }
ON FUNCTIONS
FROM user_name [, ...] [ RESTRICT ]
REVOKE { EXECUTE | ALL [ PRIVILEGES ] }
ON FUNCTIONS
FROM { ROLE role_name | GROUP group_name | PUBLIC } [, ...] [ RESTRICT ]
REVOKE [ GRANT OPTION FOR ] { EXECUTE | ALL [ PRIVILEGES ] }
ON PROCEDURES
FROM user_name [, ...] [ RESTRICT ]
REVOKE { EXECUTE | ALL [ PRIVILEGES ] }
ON PROCEDURES
FROM { ROLE role_name | GROUP group_name | PUBLIC } [, ...] [ RESTRICT ]
```
## Parameters
FOR USER *utilisateur\$1cible*
Facultatif. Nom de l’utilisateur pour lequel les privilèges par défaut sont définis. Seul un super-utilisateur peut spécifier les privilèges par défaut d’autres utilisateurs. La valeur par défaut est l’utilisateur actif.
IN SCHEMA *nom\$1schéma*
Facultatif. Si une clause IN SCHEMA s’affiche, les privilèges par défaut spécifiés s’appliquent aux nouveaux objets créés dans le *nom\$1schéma* spécifié. Dans ce cas, l’utilisateur ou groupe d’utilisateurs qui est la cible d’ALTER DEFAULT PRIVILEGES doit avoir le privilège CREATE pour le schéma spécifié. Les privilèges par défaut qui sont spécifiques à un schéma sont ajoutés aux privilèges par défaut globaux existants. Par défaut, les privilèges par défaut sont appliqués globalement à l’ensemble de la base de données.
GRANT
Ensemble des privilèges à accorder aux utilisateurs ou groupes spécifiés pour toutes les nouvelles tables et vues, fonctions ou procédures stockées créées par l’utilisateur spécifié. Vous pouvez définir les mêmes privilèges et options avec la clause GRANT qu’avec la commande [GRANT](r_GRANT.md).
WITH GRANT OPTION
Clause indiquant que l’utilisateur qui reçoit les privilèges peut à son tour accorder les mêmes privilèges à d’autres personnes. Vous ne pouvez pas accorder WITH GRANT OPTION à un groupe ou à PUBLIC.
TO *user\$1name* \$1 ROLE *role\$1name* \$1 GROUP *group\$1name*
Nom de l’utilisateur, du rôle ou du groupe d’utilisateurs auquel les privilèges par défaut spécifiés s’appliquent.
REVOKE
Ensemble des privilèges à retirer aux utilisateurs ou groupes spécifiés pour toutes les nouvelles tables, fonctions ou procédures stockées créées par l’utilisateur spécifié. Vous pouvez définir les mêmes privilèges et options avec la clause REVOKE qu’avec la commande [REVOKE](r_REVOKE.md).
GRANT OPTION FOR
Clause qui retire uniquement la possibilité d’accorder un privilège spécifié à d’autres utilisateurs et qui ne retire pas le privilège lui-même. Vous ne pouvez pas retirer GRANT OPTION d’un groupe ou de PUBLIC.
FROM *user\$1name* \$1 ROLE *role\$1name* \$1 GROUP *group\$1name*
Le nom de l’utilisateur, du rôle ou du groupe d’utilisateurs à partir duquel les privilèges spécifiés sont révoqués par défaut.
RESTRICT
L’option RESTRICT révoque uniquement les privilèges que l’utilisateur a directement accordés. Il s’agit de l’option par défaut.
## Exemples
Supposons que vous vouliez permettre à un utilisateur du groupe d’utilisateurs `report_readers` d’afficher toutes les tables et vues créées par l’utilisateur `report_admin`. Dans ce cas, exécutez la commande suivante en tant que super-utilisateur.
```
alter default privileges for user report_admin grant select on tables to group report_readers;
```
Dans l’exemple suivant, la première commande accorde les privilèges SELECT sur toutes les nouvelles tables que vous créez. Chaque fois que vous créez une nouvelle vue, vous devez explicitement accorder des privilèges à la vue ou réexécuter la commande `alter default privileges`.
```
alter default privileges grant select on tables to public;
```
L’exemple suivant accorde le privilège INSERT au groupe d’utilisateurs `sales_admin` pour toutes les nouvelles tables et vues que vous créez dans le schéma `sales`.
```
alter default privileges in schema sales grant insert on tables to group sales_admin;
```
L’exemple suivant inverse la commande ALTER DEFAULT PRIVILEGES de l’exemple précédent.
```
alter default privileges in schema sales revoke insert on tables from group sales_admin;
```
Par défaut, le groupe d’utilisateurs PUBLIC a l’autorisation d’exécution pour toutes les nouvelles fonctions définies par l’utilisateur. Pour retirer les autorisations d’exécution `public` de vos nouvelles fonctions, puis n’accorder l’autorisation d’exécution qu’au groupe d’utilisateurs `dev_test`, exécutez les commandes suivantes.
```
alter default privileges revoke execute on functions from public;
alter default privileges grant execute on functions to group dev_test;
```
# ALTER EXTERNAL SCHEMA
Modifie un schéma externe existant dans la base de données actuelle. Seuls les propriétaires du schéma, les super-utilisateurs ou les utilisateurs disposant des privilèges ALTER sur le schéma peuvent le modifier. Seuls les schémas externes créés à partir de DATA CATALOG, KAFKA ou MSK peuvent être modifiés.
Le propriétaire de ce schéma est l’auteur de la commande CREATE EXTERNAL SCHEMA. Pour transférer la propriété d’un schéma externe, utilisez ALTER SCHEMA pour modifier le propriétaire. Utilisez la commande GRANT pour autoriser d’autres utilisateurs ou groupes d’utilisateurs à accéder au schéma.
Vous ne pouvez pas utiliser les commandes GRANT ou REVOKE pour des autorisations concernant une table externe. Vous pouvez en revanche accorder ou révoquer les autorisations pour le schéma externe.
Pour plus d’informations, consultez les ressources suivantes :
+ [ALTER SCHEMA](r_ALTER_SCHEMA.md)
+ [GRANT](r_GRANT.md)
+ [REVOKE](r_REVOKE.md)
+ [CREATE EXTERNAL SCHEMA](r_CREATE_EXTERNAL_SCHEMA.md)
+ [Activation de l’authentification mTLS pour un schéma externe existant](materialized-view-streaming-ingestion-mtls.md#materialized-view-streaming-ingestion-mtls-alter)
Pour afficher les détails relatifs aux schémas externes, interrogez la vue système SVV\$1EXTERNAL\$1SCHEMAS . Pour plus d’informations, consultez [SVV\$1EXTERNAL\$1SCHEMAS](r_SVV_EXTERNAL_SCHEMAS.md).
## Syntaxe
```
ALTER EXTERNAL SCHEMA schema_name
[ IAM_ROLE [ default | 'SESSION' | 'arn:aws:iam:::role/' ] ]
[ AUTHENTICATION [ none | iam | mtls] ]
[ AUTHENTICATION_ARN 'acm-certificate-arn' | SECRET_ARN 'asm-secret-arn' ]
[ URI 'Kafka bootstrap URL' ]
```
Si vous utilisez un schéma externe pour l’ingestion en streaming et que vous souhaitez implémenter le protocole mTLS pour l’authentification, vous pouvez exécuter une commande telle que la suivante, qui spécifie l’authentification mTLS et l’ARN du certificat ACM dans ACM.
```
ALTER EXTERNAL SCHEMA schema_name
AUTHENTICATION mtls
AUTHENTICATION_ARN 'arn:aws:acm:us-east-1:444455556666:certificate/certificate_ID';
```
Vous pouvez également modifier l’authentification mTLS, en référence à l’ARN secret dans Secrets Manager.
```
ALTER EXTERNAL SCHEMA schema_name
AUTHENTICATION mtls
SECRET_ARN 'arn:aws:secretsmanager:us-east-1:012345678910:secret:myMTLSSecret';
```
L’exemple suivant montre comment modifier l’URI pour ALTER EXTERNAL SCHEMA :
```
ALTER EXTERNAL SCHEMA schema_name
URI 'lkc-ghidef-67890.centralus.azure.glb.confluent.cloud:9092';
```
L’exemple suivant montre comment modifier le rôle IAM pour ALTER EXTERNAL SCHEMA :
```
ALTER EXTERNAL SCHEMA schema_name
IAM_ROLE 'arn:aws:iam::012345678901:role/testrole';
```
## Parameters
IAM\$1ROLE [par défaut \$1 'SESSION' \$1 'arn:aws:iam : :< account-id>:role/ ']AWS
Utilisez le mot clé `default` pour qu’Amazon Redshift utilise le rôle IAM défini par défaut.
Utilisez `'SESSION'` si vous vous connectez à votre cluster Amazon Redshift à l’aide d’une identité fédérée et que vous accédez aux tables à partir du schéma externe créé à l’aide de cette commande.
Pour plus d’informations, consultez [CREATE EXTERNAL SCHEMA](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_SCHEMA.html).
AUTHENTICATION
Type d’authentification défini pour l’ingestion en streaming. L’ingestion en streaming assortie de types d’authentification fonctionne avec Apache Kafka, Confluent Cloud et Amazon Managed Streaming pour Apache Kafka. Pour plus d’informations, consultez [ CREATE EXTERNAL SCHEMA](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_SCHEMA.html).
AUTHENTICATION\$1ARN
L'ARN du AWS Certificate Manager certificat utilisé par Amazon Redshift pour l'authentification MTLS avec Apache Kafka, Confluent Cloud ou Amazon Managed Streaming for Apache Kafka (Amazon MSK). L’ARN est disponible dans la console ACM lorsque vous choisissez le certificat émis.
SECRET\$1ARN
Le nom de ressource Amazon (ARN) d'un secret pris en charge créé à l'aide de AWS Secrets Manager. Pour plus d’informations sur la création et la récupération d’un ARN pour un secret, consultez [Gérer les secrets avec AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/manage_create-basic-secret.html) dans le *Guide de l’utilisateur AWS Secrets Manager * et [Récupération de l’Amazon Resource Name (ARN) du secret dans Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-secrets-manager-integration-retrieving-secret.html).
URI
L’URL d’amorçage du cluster Apache Kafka, Confluent Cloud ou Amazon Managed Streaming pour Apache Kafka (Amazon MSK). Le point de terminaison doit être accessible (routable) à partir du cluster Amazon Redshift. Pour plus d’informations, consultez [CREATE EXTERNAL SCHEMA](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_SCHEMA.html).
# ALTER EXTERNAL VIEW
Utilisez la commande ALTER EXTERNAL VIEW pour mettre à jour votre vue externe. Selon les paramètres que vous utilisez, d’autres moteurs SQL comme Amazon Athena et Amazon EMR Spark, qui peuvent également référencer cette vue, peuvent être affectés. Pour plus d’informations sur les vues du Catalogue de données, consultez [Vues AWS Glue Data Catalog](https://docs.aws.amazon.com/redshift/latest/dg/data-catalog-views-overview.html).
## Syntaxe
```
ALTER EXTERNAL VIEW schema_name.view_name
{catalog_name.schema_name.view_name | awsdatacatalog.dbname.view_name | external_schema_name.view_name}
[FORCE] { AS (query_definition) | REMOVE DEFINITION }
```
## Parameters
*schema\$1name.view\$1name*
Le schéma attaché à votre AWS Glue base de données, suivi du nom de la vue.
catalog\$1name.schema\$1name.view\$1name \$1 awsdatacatalog.dbname.view\$1name \$1 external\$1schema\$1name.view\$1name
Notation du schéma à utiliser lors d’une modification de la vue. Vous pouvez spécifier d'utiliser une base de AWS Glue Data Catalog données Glue que vous avez créée ou un schéma externe que vous avez créé. Consultez [CREATE DATABASE](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_DATABASE.html) et [CREATE EXTERNAL SCHEMA](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_SCHEMA.html) pour plus d’informations.
FORCE
Si la définition de la vue AWS Lake Formation doit être mise à jour même si les objets référencés dans le tableau sont incompatibles avec les autres moteurs SQL. Si Lake Formation met à jour la vue, celle-ci est considérée comme obsolète pour les autres moteurs SQL jusqu’à ce que ces moteurs soient également mis à jour.
*AS query\$1definition*
Définition de la requête SQL exécutée par Amazon Redshift pour modifier la vue.
REMOVE DEFINITION
S’il faut supprimer et recréer les vues. Les vues doivent être supprimées et recréées pour les marquer comme `PROTECTED`.
## Exemples
L’exemple suivant modifie une vue du catalogue de données nommée sample\$1schema.glue\$1data\$1catalog\$1view.
```
ALTER EXTERNAL VIEW sample_schema.glue_data_catalog_view
FORCE
REMOVE DEFINITION
```
# ALTER FUNCTION
Renomme une fonction ou modifie le propriétaire. Le nom de la fonction et les types de données sont obligatoires. Seul le propriétaire ou un super-utilisateur peut renommer une fonction. Seul un super-utilisateur peut changer le propriétaire d’une fonction.
## Syntaxe
```
ALTER FUNCTION function_name ( { [ py_arg_name py_arg_data_type | sql_arg_data_type } [ , ... ] ] )
RENAME TO new_name
```
```
ALTER FUNCTION function_name ( { [ py_arg_name py_arg_data_type | sql_arg_data_type } [ , ... ] ] )
OWNER TO { new_owner | CURRENT_USER | SESSION_USER }
```
## Parameters
*function\$1name*
Nom de la fonction à modifier. Spécifiez le nom de la fonction dans le chemin de recherche actuel ou choisissez le format `schema_name.function_name` pour utiliser un schéma spécifique.
*py\$1arg\$1name py\$1arg\$1data\$1type \$1 sql\$1arg\$1data\$1type*
Facultatif. Une liste de noms d’arguments et de types de données d’entrée pour la fonction Python définie par l’utilisateur, ou une liste de types de données d’arguments d’entrée pour la fonction SQL définie par l’utilisateur.
*nouveau\$1nom*
Un nouveau nom pour la fonction définie par l’utilisateur.
*new\$1owner* \$1 CURRENT\$1USER \$1 SESSION\$1USER
Un nouveau propriétaire pour la fonction définie par l’utilisateur.
## Exemples
L’exemple suivant remplace le nom `first_quarter_revenue` d’une fonction par `quarterly_revenue`.
```
ALTER FUNCTION first_quarter_revenue(bigint, numeric, int)
RENAME TO quarterly_revenue;
```
L’exemple suivant remplace le propriétaire de la fonction `quarterly_revenue` par `etl_user`.
```
ALTER FUNCTION quarterly_revenue(bigint, numeric) OWNER TO etl_user;
```
# ALTER GROUP
Modifie un groupe d’utilisateurs. Utilisez cette commande pour ajouter des utilisateurs au groupe, en supprimer ou renommer le groupe.
## Syntaxe
```
ALTER GROUP group_name
{
ADD USER username [, ... ] |
DROP USER username [, ... ] |
RENAME TO new_name
}
```
## Parameters
*nom\$1groupe*
Nom du groupe d’utilisateurs à modifier.
ADD
Ajoute un utilisateur à un groupe d’utilisateurs.
DROP
Supprime un utilisateur d’un groupe d’utilisateurs.
*nom d’utilisateur*
Nom de l’utilisateur à ajouter au groupe ou à supprimer du groupe.
RENAME TO
Renomme le groupe d’utilisateurs. Les noms de groupe commençant par deux tirets bas sont réservés pour un usage Amazon Redshift interne. Pour plus d’informations sur les noms valides, consultez [Noms et identificateurs](r_names.md).
*nouveau\$1nom*
Nouveau nom du groupe d’utilisateurs.
## Exemples
L’exemple suivant ajoute un utilisateur nommé DWUSER au groupe ADMIN\$1GROUP.
```
ALTER GROUP admin_group
ADD USER dwuser;
```
L’exemple suivant renomme le groupe ADMIN\$1GROUP en ADMINISTRATORS.
```
ALTER GROUP admin_group
RENAME TO administrators;
```
L’exemple suivant ajoute deux utilisateurs au groupe ADMIN\$1GROUP.
```
ALTER GROUP admin_group
ADD USER u1, u2;
```
L’exemple suivant supprime deux utilisateurs du groupe ADMIN\$1GROUP.
```
ALTER GROUP admin_group
DROP USER u1, u2;
```
# ALTER IDENTITY PROVIDER
Modifie un fournisseur d’identité pour attribuer de nouveaux paramètres et de nouvelles valeurs. Lorsque vous exécutez cette commande, toutes les valeurs de paramètre précédemment définies sont supprimées avant que les nouvelles valeurs ne soient attribuées. Seul un super-utilisateur peut modifier un fournisseur d’identité.
## Syntaxe
```
ALTER IDENTITY PROVIDER identity_provider_name
[PARAMETERS parameter_string]
[NAMESPACE namespace]
[IAM_ROLE iam_role]
[AUTO_CREATE_ROLES
[ TRUE [ { INCLUDE | EXCLUDE } GROUPS LIKE filter_pattern] |
FALSE
]
[DISABLE | ENABLE]
```
## Parameters
*identity\$1provider\$1name*
Nom du nouveau fournisseur d’identité. Pour plus d’informations sur les noms valides, consultez [Noms et identificateurs](r_names.md).
*parameter\$1string*
Chaîne contenant un objet JSON correctement formaté qui contient des paramètres et des valeurs requis pour le fournisseur d’identité spécifique.
*espace de nom*
Espace de noms de l’organisation.
*iam\$1role*
Rôle IAM qui fournit des autorisations pour la connexion à IAM Identity Center. Ce paramètre n'est applicable que lorsque le type de fournisseur d'identité est. AWSIDC
*auto\$1create\$1roles*
Active ou désactive la fonction de création automatique de rôle. Si la valeur est TRUE, Amazon Redshift active la fonctionnalité de création automatique des rôles. Si la valeur est FALSE, Amazon Redshift désactive la fonctionnalité de création automatique des rôles. Si la valeur de ce paramètre n’est pas spécifiée, Amazon Redshift détermine la valeur selon la logique suivante :
+ Si `AUTO_CREATE_ROLES` est fourni mais que la valeur n’est pas spécifiée, la valeur est définie sur TRUE.
+ Si `AUTO_CREATE_ROLES` ce n'est pas le cas et que le fournisseur d'identité l'est AWSIDC, la valeur est définie sur FALSE.
+ Si `AUTO_CREATE_ROLES` n’est pas fourni et que le fournisseur d’identité est Azure, la valeur est définie sur TRUE.
Pour inclure des groupes, spécifiez `INCLUDE`. La valeur par défaut est vide, ce qui signifie inclure tous les groupes si `AUTO_CREATE_ROLES` est activé.
Pour exclure des groupes, spécifiez `EXCLUDE`. La valeur par défaut est vide, ce qui signifie qu’il ne faut exclure aucun groupe si `AUTO_CREATE_ROLES` est activé.
*filter\$1pattern*
Expression de caractères UTF-8 valide constituée d’un modèle à mettre en correspondance avec les noms de groupes. L’option LIKE effectue une mise en correspondance sensible à la casse qui prend en charge les métacaractères de mise en correspondance de modèle suivants :
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/r_ALTER_IDENTITY_PROVIDER.html)
Si *filter\$1pattern* ne contient pas de métacaractères, le modèle représente uniquement la chaîne elle-même ; dans ce cas, LIKE a la même fonction que l’opérateur d’égalité.
*filter\$1pattern* prend en charge les caractères suivants :
+ Caractères alphabétiques en majuscules et minuscules (A-Z et a-z)
+ Chiffres (0-9)
+ Les caractères spéciaux suivants :
```
_ % ^ * + ? { } , $
```
*DISABLE ou ENABLE*
Active ou désactive un fournisseur d’identité. La valeur par défaut est ENABLE.
## Exemples
L’exemple suivant montre comment modifier un fournisseur d’identité nommé *oauth\$1standard*. Cela s’applique spécifiquement aux cas où Microsoft Azure AD est le fournisseur d’identité.
```
ALTER IDENTITY PROVIDER oauth_standard
PARAMETERS '{"issuer":"https://sts.windows.net/2sdfdsf-d475-420d-b5ac-667adad7c702/",
"client_id":"87f4aa26-78b7-410e-bf29-57b39929ef9a",
"client_secret":"BUAH~ewrqewrqwerUUY^%tHe1oNZShoiU7",
"audience":["https://analysis.windows.net/powerbi/connector/AmazonRedshift"]
}'
```
L’exemple suivant montre comment définir l’espace de noms du fournisseur d’identité. Cela peut s’appliquer à Microsoft Azure AD, s’il suit une instruction comme dans l’exemple précédent, ou à un autre fournisseur d’identité. Cela peut également s’appliquer au cas où vous connectez un cluster alloué Amazon Redshift existant ou un groupe de travail Amazon Redshift sans serveur à IAM Identity Center, si vous avez établi une connexion via une application gérée.
```
ALTER IDENTITY PROVIDER "my-redshift-idc-application"
NAMESPACE 'MYCO';
```
L’exemple suivant définit le rôle IAM et fonctionne dans le cas d’utilisation pour configurer l’intégration de Redshift avec IAM Identity Center.
```
ALTER IDENTITY PROVIDER "my-redshift-idc-application"
IAM_ROLE 'arn:aws:iam::123456789012:role/myadministratorrole';
```
Pour plus d’informations sur la configuration d’une connexion à IAM Identity Center depuis Redshift, consultez [Connexion de Redshift à IAM Identity Center pour offrir aux utilisateurs une expérience d’authentification unique](https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-iam-access-control-idp-connect.html).
**Désactivation d’un fournisseur d’identité**
L’exemple d’instruction suivant montre comment désactiver un fournisseur d’identité. Lorsque le fournisseur est désactivé, les utilisateurs fédérés du fournisseur d’identité ne peuvent pas se connecter au cluster tant qu’il n’est pas réactivé.
```
ALTER IDENTITY PROVIDER "redshift-idc-app" DISABLE;
```
# MODIFIER LA POLITIQUE DE MASQUAGE
Modifie une politique de masquage dynamique des données existante. Pour plus d’informations sur le masquage dynamique des données, consultez [Masquage dynamique des données](t_ddm.md).
Les superutilisateurs et les utilisateurs ou rôles qui disposent du rôle sys:secadmin peuvent modifier une politique de masquage.
## Syntaxe
```
ALTER MASKING POLICY
{ policy_name | database_name.policy_name }
USING (masking_expression);
```
## Parameters
*policy\$1name*
Nom de la politique de masquage. Il doit s’agir du nom d’une politique de masquage qui existe déjà dans la base de données.
database\$1name
Nom de la base de données à partir de laquelle la politique est créée. La base de données peut être la base de données connectée ou une base de données qui prend en charge les autorisations fédérées Amazon Redshift.
*masking\$1expression*
Expression SQL utilisée pour transformer les colonnes cibles. Elle peut être écrite à l’aide de fonctions de manipulation des données, telles que des fonctions de manipulation de chaînes, ou en conjonction avec des fonctions définies par l’utilisateur écrites en SQL, Python ou avec AWS Lambda.
L’expression doit correspondre aux colonnes et aux types de données de l’expression originale. Par exemple, si les colonnes d’entrée de la politique de masquage originale sont `sample_1 FLOAT` et `sample_2 VARCHAR(10)`, vous ne pourrez pas modifier la politique de masquage pour prendre une troisième colonne, ou faire en sorte que la politique prenne une instruction FLOAT et une instruction BOOLEAN. Si vous utilisez une constante comme expression de masquage, vous devez la convertir explicitement en un type correspondant au type d’entrée.
Vous devez disposer de l’autorisation USAGE sur toutes les fonctions définies par l’utilisateur que vous utilisez dans l’expression du masquage.
Pour en savoir plus sur l'utilisation d'ALTER MASKING POLICY sur le catalogue d'autorisations fédérées Amazon Redshift, [consultez la section Gestion du contrôle d'accès avec les autorisations fédérées Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/dg/federated-permissions-managing-access.html).
# ALTER MATERIALIZED VIEW
Modifie les attributs d’une vue matérialisée.
## Syntaxe
```
ALTER MATERIALIZED VIEW mv_name
{
AUTO REFRESH { YES | NO }
| ALTER DISTKEY column_name
| ALTER DISTSTYLE ALL
| ALTER DISTSTYLE EVEN
| ALTER DISTSTYLE KEY DISTKEY column_name
| ALTER DISTSTYLE AUTO
| ALTER [COMPOUND] SORTKEY ( column_name [,...] )
| ALTER SORTKEY AUTO
| ALTER SORTKEY NONE
| ROW LEVEL SECURITY { ON | OFF } [ CONJUNCTION TYPE { AND | OR } ] [FOR DATASHARES]
};
```
## Parameters
*mv\$1name*
Nom de la vue matérialisée à modifier.
AUTO REFRESH \$1 YES \$1 NO \$1
Clause qui active ou désactive l’actualisation automatique d’une vue matérialisée. Pour en savoir plus sur l’actualisation automatique des vues matérialisées, consultez [Actualisation d’une vue matérialisée](materialized-view-refresh.md).
ALTER DISTSTYLE ALL
Clause qui modifie le style de distribution existant d’une relation en `ALL`. Éléments à prendre en compte :
+ ALTER DISTSYTLE, ALTER SORTKEY et VACUUM ne peuvent pas s’exécuter simultanément sur la même relation.
+ Si VACUUM est en cours d’exécution, l’exécution de ALTER DISTSTYLE ALL renvoie une erreur.
+ Si ALTER DISTSTYLE ALL est en cours d’exécution, une opération VACCUM en arrière-plan ne démarre pas sur une relation.
+ La commande ALTER DISTSTYLE ALL n’est pas prise en charge pour les relations ayant des clés de tri entrelacées et les tables temporaires.
+ Si le style de distribution était précédemment défini sur AUTO, la relation n’est plus candidate à l’optimisation automatique.
Pour plus d’informations sur DISTSTYLE ALL, consultez [CREATE MATERIALIZED VIEW](materialized-view-create-sql-command.md).
ALTER DISTSTYLE EVEN
Clause qui modifie le style de distribution existant d’une relation en `EVEN`. Éléments à prendre en compte :
+ ALTER DISTSTYLE, ALTER SORTKEY et VACUUM ne peuvent pas être exécutés simultanément sur la même table.
+ Si VACUUM est en cours d’exécution, l’exécution d’ALTER DISTSTYLE EVEN renvoie une erreur.
+ Si ALTER DISTSTYLE EVEN est en cours d’exécution, une opération VACCUM en arrière-plan ne démarre pas sur une relation.
+ La commande ALTER DISTSTYLE EVEN n’est pas prise en charge pour les relations ayant des clés de tri entrelacées et les tables temporaires.
+ Si le style de distribution était précédemment défini sur AUTO, la relation n’est plus candidate à l’optimisation automatique.
Pour plus d’informations sur DISTSTYLE EVEN, consultez [CREATE MATERIALIZED VIEW](materialized-view-create-sql-command.md).
ALTER DISTKEY *nom\$1colonne* ou ALTER DISTSTYLE KEY DISTKEY *nom\$1colonne*
Clause qui modifie la colonne utilisée en tant que clé de distribution d’une relation. Éléments à prendre en compte :
+ VACUUM et ALTER DISTKEY ne peuvent pas s’exécuter simultanément sur la même relation.
+ Si VACUUM est déjà en cours d’exécution, ALTER DISTKEY renvoie une erreur.
+ Si ALTER DISTKEY est en cours d’exécution, l’opération VACCUM en arrière-plan ne démarre pas sur une relation.
+ Si ALTER DISTKEY est en cours d’exécution, l’opération VACCUM au premier plan renvoie une erreur.
+ Vous pouvez exécuter une seule commande ALTER DISTKEY sur une relation simultanément.
+ La commande ALTER DISTKEY n’est pas prise en charge pour les relations ayant des clés de tri entrelacées.
+ Si le style de distribution était précédemment défini sur AUTO, la relation n’est plus candidate à l’optimisation automatique.
Lorsque DISTSTYLE KEY est spécifié, les données sont distribuées par les valeurs figurant dans la colonne DISTKEY. Pour plus d’informations sur DISTSTYLE, consultez [CREATE MATERIALIZED VIEW](materialized-view-create-sql-command.md).
ALTER DISTSTYLE AUTO
Clause qui modifie le style de distribution existant d’une relation en AUTO.
Lorsque vous modifiez un style de distribution sur AUTO, le style de distribution de la relation est défini comme suit :
+ Une petite relation avec DISTSTYLE ALL est convertie en AUTO(ALL).
+ Une petite relation avec DISTSTYLE EVEN est convertie en AUTO(ALL).
+ Une petite relation avec DISTSTYLE KEY est convertie en AUTO(ALL).
+ Une grande relation avec DISTSTYLE ALL est convertie en AUTO(EVEN).
+ Une grande relation avec DISTSTYLE EVEN est convertie en AUTO(EVEN).
+ Une grande relation avec DISTSTYLE KEY est convertie en AUTO(KEY) et la DISTKEY est conservée. Dans ce cas, Amazon Redshift ne modifie pas la relation.
Si Amazon Redshift détermine qu’un nouveau style de distribution ou une nouvelle clé améliorera les performances des requêtes, Amazon Redshift peut modifier le style de distribution ou la clé de votre relation à l’avenir. Par exemple, Amazon Redshift peut convertir une relation avec DISTSTYLE pour AUTO(KEY) en AUTO(EVEN), ou vice versa. Pour en savoir plus sur le comportement dans le cas où des clés de distribution sont modifiées, notamment sur le plan de la redistribution des données et des verrous, consultez [Recommandations Amazon Redshift Advisor](https://docs.aws.amazon.com/redshift/latest/dg/advisor-recommendations.html#alter-diststyle-distkey-recommendation).
Pour plus d’informations sur DISTSTYLE AUTO, consultez [CREATE MATERIALIZED VIEW](materialized-view-create-sql-command.md).
Pour afficher le style de distribution appliqué à une relation, interrogez la vue du catalogue système SVV\$1TABLE\$1INFO. Pour plus d’informations, consultez la section concernant [SVV\$1TABLE\$1INFO](r_SVV_TABLE_INFO.md). Pour afficher les recommandations Amazon Redshift Advisor pour les relations, recherchez la vue catalogue système SVV\$1ALTER\$1TABLE\$1RECOMMENDATIONS. Pour plus d’informations, consultez la section concernant [SVV\$1ALTER\$1TABLE\$1RECOMMENDATIONS](r_SVV_ALTER_TABLE_RECOMMENDATIONS.md). Pour afficher les actions effectuées par Amazon Redshift, interrogez la vue catalogue système SVL\$1AUTO\$1WORKER\$1ACTION. Pour plus d’informations, consultez la section concernant [SVL\$1AUTO\$1WORKER\$1ACTION](r_SVL_AUTO_WORKER_ACTION.md).
ALTER [COMPOUND] SORTKEY ( *column\$1name* [,...] )
Clause qui modifie ou ajoute la clé de tri utilisée pour une relation. ALTER SORTKEY n’est pas pris en charge pour les tables temporaires.
Lorsque vous modifiez une clé de tri, l’encodage par compression des colonnes de la nouvelle clé de tri ou de la clé de tri originale peut changer. Si aucun encodage n’est explicitement défini pour la relation, Amazon Redshift attribue automatiquement les codages 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, TIME, TIMETZ, TIMESTAMP ou TIMESTAMPTZ sont soumises à une compression. AZ64
+ Les colonnes définies comme CHAR ou VARCHAR sont affectées à la compression LZO.
Éléments à prendre en compte :
+ Vous pouvez définir 400 colonnes au maximum par relation pour une clé de tri.
+ Vous pouvez modifier une clé de tri entrelacée en clé de tri composée ou en aucune clé de tri. Toutefois, vous ne pouvez pas modifier une clé de tri composée par une clé de tri entrelacée.
+ Si la clé de tri était précédemment définie sur AUTO, la relation n’est plus candidate à l’optimisation automatique.
+ Amazon Redshift recommande d’utiliser l’encodage RAW (sans compression) pour les colonnes définies comme des clés de tri. Lorsque vous modifiez une colonne pour la choisir comme clé de tri, la compression de la colonne passe en compression RAW (sans compression). Cela peut augmenter la quantité de stockage requise par la relation. L’augmentation de la taille de la relation dépend de la définition et du contenu spécifiques de la relation. Pour plus d’informations sur la compression, consultez [encodages de compression](c_Compression_encodings.md).
Les données sont chargées dans une relation en fonction de la clé de tri. Lorsque vous modifiez la clé de tri, Amazon Redshift modifie l’ordre des données. Pour plus d’informations sur SORTKEY, consultez [CREATE MATERIALIZED VIEW](materialized-view-create-sql-command.md).
ALTER TRUTKEY AUTO
Clause qui modifie ou ajoute la clé de tri de la relation cible à AUTO. ALTER SORTKEY AUTO n’est pas pris en charge pour les tables temporaires.
Lorsque vous modifiez une clé de tri en AUTO, Amazon Redshift conserve la clé de tri existante de la relation.
Si Amazon Redshift détermine qu’une nouvelle clé de tri améliorera les performances des requêtes, Amazon Redshift peut modifier la clé de tri de votre relation à l’avenir.
Pour plus d’informations sur SORTKEY AUTO, consultez [CREATE MATERIALIZED VIEW](materialized-view-create-sql-command.md).
Pour afficher la clé de tri d’une relation, interrogez la vue catalogue système SVV\$1\$1TABLE\$1INFO. Pour plus d’informations, consultez la section concernant [SVV\$1TABLE\$1INFO](r_SVV_TABLE_INFO.md). Pour afficher les recommandations Amazon Redshift Advisor pour les relations, recherchez la vue catalogue système SVV\$1ALTER\$1TABLE\$1RECOMMENDATIONS. Pour plus d’informations, consultez la section concernant [SVV\$1ALTER\$1TABLE\$1RECOMMENDATIONS](r_SVV_ALTER_TABLE_RECOMMENDATIONS.md). Pour afficher les actions effectuées par Amazon Redshift, interrogez la vue catalogue système SVL\$1AUTO\$1WORKER\$1ACTION. Pour plus d’informations, consultez la section concernant [SVL\$1AUTO\$1WORKER\$1ACTION](r_SVL_AUTO_WORKER_ACTION.md).
ALTER SORTKEY NONE
Clause qui supprime la clé de tri de la relation cible.
Si la clé de tri était précédemment définie sur AUTO, la relation n’est plus candidate à l’optimisation automatique.
ROW LEVEL SECURITY \$1 ON \$1 OFF \$1 [ CONJUNCTION TYPE \$1 AND \$1 OR \$1 ] [ FOR DATASHARES ]
Clause qui active ou désactive la sécurité au niveau des lignes pour une relation.
Lorsque la sécurité au niveau des lignes est activée pour une relation, vous pouvez lire uniquement les lignes auxquelles cette politique vous autorise à accéder. Si aucune politique ne vous accorde l’accès à la relation, vous ne pouvez voir aucune ligne pour la relation. Seuls les super-utilisateurs et les utilisateurs ou les rôles dotés du rôle `sys:secadmin` peuvent définir la clause ROW LEVEL SECURITY. Pour plus d’informations, consultez [Sécurité au niveau des lignes](t_rls.md).
+ [ CONJUNCTION TYPE \$1 AND \$1 OR \$1 ]
Clause qui vous permet de choisir le type de conjonction de la politique de sécurité au niveau des lignes pour une relation. Lorsque plusieurs politiques de sécurité au niveau des lignes sont associées à une relation, vous pouvez les combiner avec la clause AND ou OR. Par défaut, Amazon Redshift associe les politiques RLS à la clause AND. Les super-utilisateurs, utilisateurs ou rôles disposant du rôle `sys:secadmin` peuvent utiliser cette clause pour définir le type de conjonction de la politique de sécurité au niveau des lignes pour une relation. Pour plus d’informations, consultez [Association de plusieurs politiques par utilisateur](t_rls_combine_policies.md).
+ FOR DATASHARES
Clause qui détermine s’il est possible d’accéder à une relation protégée par RLS sur les unités de partage des données. Par défaut, une relation protégée par RLS n’est pas accessible sur une unité de partage des données. Une commande ALTER MATERIALIZED VIEW ROW LEVEL SECURITY exécutée avec cette clause affecte uniquement la propriété d’accessibilité de l’unité de partage des données de la relation. La propriété ROW LEVEL SECURITY n’est pas modifiée.
Si vous rendez accessible une relation protégée par RLS via des unités de partage des données, la relation n’est pas sécurisée au niveau des lignes dans la base de données de l’unité de partage des données côté consommateur. La relation conserve sa propriété RLS du côté producteur.
## Exemples
L’exemple suivant active la vue matérialisée `tickets_mv` à actualiser automatiquement.
```
ALTER MATERIALIZED VIEW tickets_mv AUTO REFRESH YES
```
# Exemples de DISTSTYLE et SORTKEY pour ALTER MATERIALIZED VIEW
Les exemples présentés dans cette rubrique vous montrent comment effectuer les modifications DISTSTYLE et SORTKEY à l’aide de ALTER MATERIALIZED VIEW.
Les exemples de requêtes suivants montrent comment modifier une colonne DISTSTYLE KEY DISTKEY à l’aide d’un exemple de table de base :
```
CREATE TABLE base_inventory(
inv_date_sk int4 NOT NULL,
inv_item_sk int4 NOT NULL,
inv_warehouse_sk int4 NOT NULL,
inv_quantity_on_hand int4
);
INSERT INTO base_inventory VALUES(1,1,1,1);
CREATE materialized VIEW inventory diststyle even AS SELECT * FROM base_inventory;
SELECT "table", diststyle FROM svv_table_info WHERE "table" = 'inventory';
ALTER materialized VIEW inventory ALTER diststyle KEY distkey inv_warehouse_sk;
SELECT "table", diststyle FROM svv_table_info WHERE "table" = 'inventory';
ALTER materialized VIEW inventory ALTER distkey inv_item_sk;
SELECT "table", diststyle FROM svv_table_info WHERE "table" = 'inventory';
DROP TABLE base_inventory CASCADE;
```
Modifier une vue matérialisée en DISTSTYLE ALL :
```
CREATE TABLE base_inventory(
inv_date_sk int4 NOT NULL,
inv_item_sk int4 NOT NULL,
inv_warehouse_sk int4 NOT NULL,
inv_quantity_on_hand int4
);
INSERT INTO base_inventory VALUES(1,1,1,1);
CREATE materialized VIEW inventory diststyle even AS SELECT * FROM base_inventory;
SELECT "table", diststyle FROM svv_table_info WHERE "table" = 'inventory';
ALTER MATERIALIZED VIEW inventory ALTER diststyle ALL;
SELECT "table", diststyle FROM svv_table_info WHERE "table" = 'inventory';
DROP TABLE base_inventory CASCADE;
```
Les commandes suivantes présentent des exemples ALTER MATERIALIZED VIEW SORTKEY utilisant un exemple de table de base :
```
CREATE TABLE base_inventory (c0 int, c1 int);
INSERT INTO base_inventory VALUES(1,1);
CREATE materialized VIEW inventory interleaved sortkey(c0, c1) AS SELECT * FROM base_inventory;
SELECT "table", sortkey1 FROM svv_table_info WHERE "table" = 'inventory';
ALTER materialized VIEW inventory ALTER sortkey(c0, c1);
SELECT "table", diststyle, sortkey_num FROM svv_table_info WHERE "table" = 'inventory';
ALTER materialized VIEW inventory ALTER sortkey NONE;
SELECT "table", diststyle, sortkey_num FROM svv_table_info WHERE "table" = 'inventory';
ALTER materialized VIEW inventory ALTER sortkey(c0);
SELECT "table", diststyle, sortkey_num FROM svv_table_info WHERE "table" = 'inventory';
DROP TABLE base_inventory CASCADE;
```
# ALTER RLS POLICY
Modifie une politique de sécurité existante au niveau des lignes sur une table.
Les super-utilisateurs et les utilisateurs ou les rôles dotés du rôle `sys:secadmin` peuvent modifier une politique.
## Syntaxe
```
ALTER RLS POLICY
{ policy_name | database_name.policy_name }
USING ( using_predicate_exp );
```
## Parameters
*policy\$1name*
Nom de la politique .
database\$1name
Nom de la base de données à partir de laquelle la politique est créée. La base de données peut être la base de données connectée ou une base de données qui prend en charge les autorisations fédérées Amazon Redshift.
USING (* using\$1predicate\$1exp *)
Spécifie un filtre qui est appliqué à la clause WHERE de la requête. Amazon Redshift applique un prédicat de politique avant les prédicats utilisateur au niveau de la requête. Par exemple, **current\$1user = ‘joe’ and price > 10** permet à Joe de ne voir que les enregistrements dont le prix est supérieur à 10 \$1.
L’expression a accès aux variables déclarées dans la clause WITH de l’instruction CREATE RLS POLICY qui a été utilisée pour créer la politique nommée policy\$1name.
Pour l'utilisation de la politique ALTER RLS sur le catalogue d'autorisations fédérées Amazon Redshift, [consultez la section Gestion du contrôle d'accès avec les autorisations fédérées Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/dg/federated-permissions-managing-access.html).
## Exemples
L’exemple suivant modifie une politique RLS.
```
-- First create an RLS policy that limits access to rows where catgroup is 'concerts'.
CREATE RLS POLICY policy_concerts
WITH (catgroup VARCHAR(10))
USING (catgroup = 'concerts');
-- Then, alter the RLS policy to only show rows where catgroup is 'piano concerts'.
ALTER RLS POLICY policy_concerts
USING (catgroup = 'piano concerts');
```
# ALTER ROLE
Renomme un rôle ou modifie le propriétaire. Pour obtenir une liste des rôles définis par le système Amazon Redshift, consultez [Rôles définis par le système Amazon Redshift](r_roles-default.md).
## Autorisations requises
Voici les autorisations requises pour ALTER ROLE :
+ Superuser
+ Utilisateurs disposant des autorisations ALTER ROLE
## Syntaxe
```
ALTER ROLE role [ WITH ]
{ { RENAME TO role } | { OWNER TO user_name } }[, ...]
[ EXTERNALID TO external_id ]
```
## Parameters
*rôle*
Nom du rôle à modifier.
RENAME TO
Nouveau nom du rôle.
OWNER TO *user\$1name*
Nouveau propriétaire du rôle.
EXTERNALID TO *external\$1id*
Nouvel ID externe pour le rôle, associé à un fournisseur d’identité. Pour plus d’informations, consultez [Fédération de fournisseur d’identité natif pour Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-iam-access-control-native-idp.html).
## Exemples
L’exemple suivant remplace le nom `sample_role1` d’un rôle par `sample_role2`.
```
ALTER ROLE sample_role1 RENAME TO sample_role2;
```
L’exemple suivant remplace le propriétaire du rôle.
```
ALTER ROLE sample_role1 WITH OWNER TO user1
```
La syntaxe de ALTER ROLE est semblable à celle de ALTER PROCEDURE, reprise ci-après.
```
ALTER PROCEDURE first_quarter_revenue(bigint, numeric) RENAME TO quarterly_revenue;
```
L’exemple suivant remplace le propriétaire d’une procédure par `etl_user`.
```
ALTER PROCEDURE quarterly_revenue(bigint, numeric) OWNER TO etl_user;
```
L’exemple suivant montre comment mettre à jour un rôle `sample_role1` avec un nouvel ID externe associé à un fournisseur d’identité.
```
ALTER ROLE sample_role1 EXTERNALID TO "XYZ456";
```
# ALTER PROCEDURE
Renomme une procédure ou modifie le propriétaire. Le nom de la procédure et les types de données, ou signature, sont requis. Seul le propriétaire ou un super-utilisateur peut renommer une procédure. Seul un super-utilisateur peut changer le propriétaire d’une procédure.
## Syntaxe
```
ALTER PROCEDURE sp_name [ ( [ [ argname ] [ argmode ] argtype [, ...] ] ) ]
RENAME TO new_name
```
```
ALTER PROCEDURE sp_name [ ( [ [ argname ] [ argmode ] argtype [, ...] ] ) ]
OWNER TO { new_owner | CURRENT_USER | SESSION_USER }
```
## Parameters
*sp\$1name*
Nom de la procédure à modifier. Spécifiez simplement le nom de la procédure dans le chemin de recherche actuel ou choisissez le format `schema_name.sp_procedure_name` pour utiliser un schéma spécifique.
*[argname] [argmode] argtype*
Liste de noms d’arguments, de modes d’argument et de types de données. Seuls les types de données d’entrée sont requis. Ils sont utilisés pour identifier la procédure stockée. Vous pouvez également indiquer la procédure complète utilisée pour créer la procédure, en incluant les paramètres d’entrée et de sortie avec leurs modes.
*nouveau\$1nom*
Nouveau nom pour la procédure stockée.
*new\$1owner* \$1 CURRENT\$1USER \$1 SESSION\$1USER
Nouveau propriétaire pour la procédure stockée.
## Exemples
L’exemple suivant remplace le nom `first_quarter_revenue` d’une procédure par `quarterly_revenue`.
```
ALTER PROCEDURE first_quarter_revenue(volume INOUT bigint, at_price IN numeric,
result OUT int) RENAME TO quarterly_revenue;
```
Cet exemple équivaut à l’exemple suivant :
```
ALTER PROCEDURE first_quarter_revenue(bigint, numeric) RENAME TO quarterly_revenue;
```
L’exemple suivant remplace le propriétaire d’une procédure par `etl_user`.
```
ALTER PROCEDURE quarterly_revenue(bigint, numeric) OWNER TO etl_user;
```
# ALTER SCHEMA
Modifie la définition d’un schéma existant. Utilisez cette commande pour renommer un schéma ou en modifier le propriétaire. Par exemple, renommez un schéma existant pour en conserver une copie de sauvegarde lorsque vous prévoyez d’en créer une nouvelle version. Pour plus d’informations sur les schémas, consultez [CREATE SCHEMA](r_CREATE_SCHEMA.md).
Pour afficher les quotas de schéma configurés, consultez [SVV\$1SCHEMA\$1QUOTA\$1STATE](r_SVV_SCHEMA_QUOTA_STATE.md).
Pour afficher les enregistrements où les quotas de schéma ont été dépassés, consultez [STL\$1SCHEMA\$1QUOTA\$1VIOLATIONS](r_STL_SCHEMA_QUOTA_VIOLATIONS.md).
## Privilèges requis
Les privilèges suivants sont requis pour ALTER SCHEMA :
+ Superuser
+ Utilisateurs disposant du privilège ALTER SCHEMA
+ Propriétaire du schéma
Lorsque vous modifiez le nom d’un schéma, notez que les objets utilisant l’ancien nom, tels que les procédures stockées ou les vues matérialisées, doivent être mis à jour pour utiliser le nouveau nom.
## Syntaxe
```
ALTER SCHEMA schema_name
{
RENAME TO new_name |
OWNER TO new_owner |
QUOTA { quota [MB | GB | TB] | UNLIMITED }
}
```
## Parameters
*nom\$1schéma*
Nom du schéma de base de données à modifier.
RENAME TO
Clause qui renomme le schéma.
*nouveau\$1nom*
Nouveau nom du schéma. Pour plus d’informations sur les noms valides, consultez [Noms et identificateurs](r_names.md).
OWNER TO
Clause qui modifie le propriétaire du schéma.
*nouveau\$1propriétaire*
Nouveau propriétaire du schéma.
QUOTA
Quantité maximale d’espace disque que le schéma spécifié peut utiliser. Cet espace correspond à la taille collective de toutes les tables sous le schéma spécifié. Amazon Redshift convertit la valeur sélectionnée en mégaoctets. Le gigaoctet est l’unité de mesure par défaut lorsque vous ne spécifiez pas de valeur.
Pour plus d’informations sur la configuration des quotas de schéma, consultez [CREATE SCHEMA](r_CREATE_SCHEMA.md).
## Exemples
L’exemple suivant renomme le schéma SALES en US\$1SALES.
```
alter schema sales
rename to us_sales;
```
L’exemple suivant attribue la propriété du schéma US\$1SALES à l’utilisateur DWUSER.
```
alter schema us_sales
owner to dwuser;
```
L’exemple suivant modifie le quota à 300 Mo et le supprime.
```
alter schema us_sales QUOTA 300 GB;
alter schema us_sales QUOTA UNLIMITED;
```
# ALTER SYSTEM
Modifie une option de configuration au niveau du système pour le cluster Amazon Redshift ou le groupe de travail Redshift sans serveur.
## Privilèges requis
La commande ALTER SYSTEM peut être exécutée par l’un des types d’utilisateurs suivants :
+ Superuser
+ Utilisateur administrateur
## Syntaxe
```
ALTER SYSTEM SET system-level-configuration = {true| t | on | false | f | off}
```
## Parameters
*system-level-configuration*
Configuration au niveau du système. Valeurs valides : `data_catalog_auto_mount` et `metadata_security`.
\$1true\$1 t \$1 on \$1 false \$1 f \$1 off\$1
Valeur permettant d’activer ou de désactiver la configuration au niveau du système. Les valeurs `true`, `t` et `on` indiquent que la configuration doit être activée. Les valeurs `false`, `f` et `off` indiquent que la configuration doit être désactivée.
## Notes d’utilisation
Pour un cluster provisionné, toute modification apportée à `data_catalog_auto_mount` prend effet au prochain redémarrage du cluster. Pour en savoir plus, consultez [Redémarrage d’un cluster](https://docs.aws.amazon.com/redshift/latest/mgmt/managing-clusters-console.html#reboot-cluster) dans *Amazon Redshift Management Guide*.
Pour un groupe de travail sans serveur, les modifications apportées à `data_catalog_auto_mount` ne prennent pas effet immédiatement.
## Exemples
L’exemple suivant active le montage automatique du AWS Glue Data Catalog.
```
ALTER SYSTEM SET data_catalog_auto_mount = true;
```
L’exemple suivant active la sécurité des métadonnées.
```
ALTER SYSTEM SET metadata_security = true;
```
### Définition d’un espace de noms d’identité par défaut
Cet exemple est spécifique à l’utilisation d’un fournisseur d’identité. Vous pouvez intégrer Redshift à IAM Identity Center et à un fournisseur d'identité afin de centraliser la gestion des identités pour Redshift et d'autres services. AWS
L’exemple suivant montre comment définir l’espace de noms d’identité par défaut pour le système. Cela simplifie ensuite l’exécution des instructions GRANT et CREATE, car il n’est pas nécessaire d’inclure l’espace de noms comme préfixe pour chaque identité.
```
ALTER SYSTEM SET default_identity_namespace = 'MYCO';
```
Après avoir exécuté la commande, vous pouvez exécuter des instructions comme les suivantes :
```
GRANT SELECT ON TABLE mytable TO alice;
GRANT UPDATE ON TABLE mytable TO salesrole;
CREATE USER bob password 'md50c983d1a624280812631c5389e60d48c';
```
La définition de l’espace de noms d’identité par défaut a pour effet que chaque identité ne l’exige pas comme préfixe. Dans cet exemple, `alice` est remplacé par `MYCO:alice`. Cela se produit avec n’importe quelle identité incluse. Pour plus d’informations sur l’utilisation d’un fournisseur d’identité avec Redshift, consultez [Connexion de Redshift à IAM Identity Center pour offrir aux utilisateurs une expérience d’authentification unique](https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-iam-access-control-idp-connect.html).
Pour plus d’informations sur les paramètres relatifs à la configuration Redshift avec IAM Identity Center, consultez [SET](r_SET.md) et [ALTER IDENTITY PROVIDER](r_ALTER_IDENTITY_PROVIDER.md).
# ALTER TABLE
Cette commande modifie la définition d’une table Amazon Redshift ou d’une table externe Amazon Redshift Spectrum. Cette commande met à jour les valeurs et les propriétés définies par [CREATE TABLE](r_CREATE_TABLE_NEW.md) ou [CREATE EXTERNAL TABLE](r_CREATE_EXTERNAL_TABLE.md). Vous pouvez utiliser ALTER TABLE sur une vue pour la sécurité au niveau des lignes (RLS).
Vous ne pouvez pas exécuter ALTER TABLE sur une table externe au sein d’un bloc de transaction (BEGIN ... END). Pour plus d’informations sur les transactions, consultez [Niveaux d’isolement dans Amazon Redshift](c_serial_isolation.md).
ALTER TABLE verrouille la table pour les opérations de lecture et d’écriture jusqu’à la fin de la transaction englobant l’opération ALTER TABLE, sauf s’il est indiqué spécifiquement dans la documentation que vous pouvez interroger des données ou effectuer d’autres opérations sur la table pendant sa modification.
## Privilèges requis
L’utilisateur qui modifie une table doit disposer des privilèges appropriés pour que la commande aboutisse. Selon la commande ALTER TABLE, l’un des privilèges suivants est requis.
+ Superuser
+ Utilisateurs disposant du privilège ALTER TABLE
+ Propriétaire de table disposant du privilège USAGE sur le schéma
## Syntaxe
```
ALTER TABLE table_name
{
ADD table_constraint
| DROP CONSTRAINT constraint_name [ RESTRICT | CASCADE ]
| OWNER TO new_owner
| RENAME TO new_name
| RENAME COLUMN column_name TO new_name
| ALTER COLUMN column_name TYPE updated_varchar_data_type_size
| ALTER COLUMN column_name ENCODE new_encode_type
| ALTER COLUMN column_name ENCODE encode_type,
| ALTER COLUMN column_name ENCODE encode_type, .....;
| ALTER DISTKEY column_name
| ALTER DISTSTYLE ALL
| ALTER DISTSTYLE EVEN
| ALTER DISTSTYLE KEY DISTKEY column_name
| ALTER DISTSTYLE AUTO
| ALTER [COMPOUND] SORTKEY ( column_name [,...] )
| ALTER SORTKEY AUTO
| ALTER SORTKEY NONE
| ALTER ENCODE AUTO
| ADD [ COLUMN ] column_name column_type
[ DEFAULT default_expr ]
[ ENCODE encoding ]
[ NOT NULL | NULL ]
[ COLLATE { CASE_SENSITIVE | CS | CASE_INSENSITIVE | CI } ] |
| DROP [ COLUMN ] column_name [ RESTRICT | CASCADE ]
| ROW LEVEL SECURITY { ON | OFF } [ CONJUNCTION TYPE { AND | OR } ] [ FOR DATASHARES ]
| MASKING { ON | OFF } FOR DATASHARES }
where table_constraint is:
[ CONSTRAINT constraint_name ]
{ UNIQUE ( column_name [, ... ] )
| PRIMARY KEY ( column_name [, ... ] )
| FOREIGN KEY (column_name [, ... ] )
REFERENCES reftable [ ( refcolumn ) ]}
The following options apply only to external tables:
SET LOCATION { 's3://bucket/folder/' | 's3://bucket/manifest_file' }
| SET FILE FORMAT format |
| SET TABLE PROPERTIES ('property_name'='property_value')
| PARTITION ( partition_column=partition_value [, ...] )
SET LOCATION { 's3://bucket/folder' |'s3://bucket/manifest_file' }
| ADD [IF NOT EXISTS]
PARTITION ( partition_column=partition_value [, ...] ) LOCATION { 's3://bucket/folder' |'s3://bucket/manifest_file' }
[, ... ]
| DROP PARTITION ( partition_column=partition_value [, ...] )
```
Pour réduire le temps d’exécution de la commande ALTER TABLE, vous pouvez combiner certaines clauses de la commande ALTER TABLE.
Amazon Redshift prend en charge les combinaisons suivantes des clauses ALTER TABLE :
```
ALTER TABLE tablename ALTER SORTKEY (column_list), ALTER DISTKEY column_Id;
ALTER TABLE tablename ALTER DISTKEY column_Id, ALTER SORTKEY (column_list);
ALTER TABLE tablename ALTER SORTKEY (column_list), ALTER DISTSTYLE ALL;
ALTER TABLE tablename ALTER DISTSTYLE ALL, ALTER SORTKEY (column_list);
```
## Parameters
*table\$1name*
Nom de la table à modifier. Spécifiez simplement le nom de la table ou choisissez le format *nom\$1schéma.nom\$1table* pour utiliser un schéma spécifique. Les tables externes doivent être qualifiées à l’aide d’un nom de schéma externe. Vous pouvez aussi spécifier un nom de vue si vous utilisez l’instruction ALTER TABLE pour renommer une vue ou modifier son propriétaire. La longueur maximale d’un nom de table est de 127 octets ; les noms plus longs sont tronqués à 127 octets. Vous pouvez utiliser des caractères multioctets UTF-8 jusqu’à un maximum de quatre octets. Pour plus d’informations sur les noms valides, consultez [Noms et identificateurs](r_names.md).
ADD *contrainte\$1table*
Clause qui ajoute la contrainte spécifiée à la table. Pour obtenir les descriptions des valeurs de *contrainte\$1table* valides, consultez [CREATE TABLE](r_CREATE_TABLE_NEW.md).
Vous ne pouvez pas ajouter une contrainte de clé primaire à une colonne acceptant la valeur null. Si la colonne a été créée à l’origine avec la contrainte NOT NULL, vous pouvez ajouter la contrainte de clé primaire.
DROP CONSTRAINT *nom\$1contrainte*
Clause qui supprime la contrainte nommée de la table. Pour supprimer une contrainte, spécifiez son nom et non son type. Pour afficher le nom des contraintes de la table, exécutez la requête suivante.
```
select constraint_name, constraint_type
from information_schema.table_constraints;
```
RESTRICT
Clause qui supprime uniquement la contrainte spécifiée. RESTRICT est une option de DROP CONSTRAINT. RESTRICT ne peut pas être utilisée avec CASCADE.
CASCADE
Clause qui supprime la contrainte spécifiée ainsi que tout ce qui en dépend. CASCADE est une option de DROP CONSTRAINT. CASCADE ne peut pas être utilisée avec RESTRICT.
OWNER TO *nouveau\$1propriétaire*
Clause qui modifie le propriétaire de la table (ou de la vue) avec la valeur *nouveau\$1propriétaire*.
RENAME TO *nouveau\$1nom*
Clause qui renomme une table (ou une vue) selon la valeur spécifiée dans *nouveau\$1nom*. La longueur maximale d’un nom de table est de 127 octets ; les noms plus longs sont tronqués à 127 octets.
Vous ne pouvez pas renommer une table permanente en un nom commençant par « \$1 ». Un nom de table commençant par « \$1 » indique une table temporaire.
Vous ne pouvez pas renommer une table externe.
ALTER COLUMN *column\$1name* TYPE *updated\$1varchar\$1data\$1type\$1size*
Clause qui modifie la taille d’une colonne définie en tant que type de données VARCHAR. Cette clause permet uniquement de modifier la taille d’un type de données VARCHAR. Prenez en compte les restrictions suivantes :
+ Vous ne pouvez pas modifier une colonne avec les codages de compression BYTEDICT, RUNLENGTH ou K. TEXT255 TEXT32
+ Vous ne pouvez pas réduire la taille en dessous de la taille maximale des données existantes.
+ Vous ne pouvez pas modifier des colonnes avec des valeurs par défaut.
+ Vous ne pouvez pas modifier des colonnes avec UNIQUE, PRIMARY KEY ou FOREIGN KEY.
+ Vous ne pouvez pas modifier des colonnes dans un bloc de transaction (BEGIN ... END). Pour plus d’informations sur les transactions, consultez [Niveaux d’isolement dans Amazon Redshift](c_serial_isolation.md).
ALTER COLUMN *column\$1name* ENCODE *new\$1encode\$1type*
Clause qui modifie l’encodage de compression d’une colonne. Si vous spécifiez le codage de compression pour une colonne, la table n’est plus définie sur ENCODE AUTO. Pour obtenir des informations sur l’encodage de la compression, consultez [Compression de colonnes pour réduire la taille des données stockées](t_Compressing_data_on_disk.md).
Lorsque vous modifiez l’encodage de compression pour une colonne, la table reste disponible à des fins d’interrogation.
Prenez en compte les restrictions suivantes :
+ Vous ne pouvez pas modifier une colonne avec le même encodage que celui actuellement défini pour la colonne.
+ Vous ne pouvez pas modifier l’encodage d’une colonne dans une table avec une clé de tri entrelacée.
ALTER COLUMN *column\$1name* ENCODE *encode\$1type*, ALTER COLUMN *column\$1name* ENCODE *encode\$1type*, .....;
Clause qui modifie le codage de compression de plusieurs colonnes dans une seule commande. Pour obtenir des informations sur l’encodage de la compression, consultez [Compression de colonnes pour réduire la taille des données stockées](t_Compressing_data_on_disk.md).
Lorsque vous modifiez l’encodage de compression pour une colonne, la table reste disponible à des fins d’interrogation.
Prenez en compte les restrictions suivantes :
+ Vous ne pouvez pas modifier une colonne pour un type de codage identique ou différent plusieurs fois dans une seule commande.
+ Vous ne pouvez pas modifier une colonne avec le même encodage que celui actuellement défini pour la colonne.
+ Vous ne pouvez pas modifier l’encodage d’une colonne dans une table avec une clé de tri entrelacée.
ALTER DISTSTYLE ALL
Clause qui modifie le style de distribution existant d’une table en `ALL`. Éléments à prendre en compte :
+ ALTER DISTSYTLE, ALTER SORTKEY et VACUUM ne peuvent pas s’exécuter simultanément sur la même table.
+ Si VACUUM est en cours d’exécution, l’exécution de ALTER DISTSTYLE ALL renvoie une erreur.
+ Si ALTER DISTSTYLE ALL est en cours d’exécution, une opération VACCUM en arrière-plan ne démarre pas sur une table.
+ La commande ALTER DISTSTYLE ALL n’est pas prise en charge pour les tables ayant des clés de tri entrelacées et les tables temporaires.
+ Si le style de distribution était précédemment défini sur AUTO, la table n’est plus candidate à l’optimisation automatique.
Pour plus d’informations sur DISTSTYLE ALL, consultez [CREATE TABLE](r_CREATE_TABLE_NEW.md).
ALTER DISTSTYLE EVEN
Clause qui modifie le style de distribution existant d’une table en `EVEN`. Éléments à prendre en compte :
+ ALTER DISTSYTLE, ALTER SORTKEY et VACUUM ne peuvent pas être exécutés simultanément sur la même table.
+ Si VACUUM est en cours d’exécution, l’exécution d’ALTER DISTSTYLE EVEN renvoie une erreur.
+ Si ALTER DISTSTYLE EVEN est en cours d’exécution, une opération VACUUM en arrière-plan ne démarre pas sur une table.
+ La commande ALTER DISTSTYLE EVEN n’est pas prise en charge pour les tables ayant des clés de tri entrelacées et des tables temporaires.
+ Si le style de distribution était précédemment défini sur AUTO, la table n’est plus candidate à l’optimisation automatique.
Pour plus d’informations sur DISTSTYLE ALL, consultez [CREATE TABLE](r_CREATE_TABLE_NEW.md).
ALTER DISTKEY *nom\$1colonne* ou ALTER DISTSTYLE KEY DISTKEY *nom\$1colonne*
Clause qui modifie la colonne utilisée en tant que clé de distribution d’une table. Éléments à prendre en compte :
+ VACUUM et ALTER DISTKEY ne peuvent pas s’exécuter simultanément sur la même table.
+ Si VACUUM est déjà en cours d’exécution, ALTER DISTKEY renvoie une erreur.
+ Si ALTER DISTKEY est en cours d’exécution, l’opération VACCUM en arrière-plan ne démarre pas sur une table.
+ Si ALTER DISTKEY est en cours d’exécution, l’opération VACCUM au premier plan renvoie une erreur.
+ Vous pouvez exécuter une seule commande ALTER DISTKEY sur une table simultanément.
+ La commande ALTER DISTKEY n’est pas prise en charge pour les tables ayant des clés de tri entrelacées.
+ Si le style de distribution était précédemment défini sur AUTO, la table n’est plus candidate à l’optimisation automatique.
Lorsque DISTSTYLE KEY est spécifié, les données sont distribuées par les valeurs figurant dans la colonne DISTKEY. Pour plus d’informations sur DISTSTYLE, consultez [CREATE TABLE](r_CREATE_TABLE_NEW.md).
ALTER DISTSTYLE AUTO
Clause qui modifie le style de distribution existant d’une table en AUTO.
Lorsque vous modifiez un style de distribution sur AUTO, le style de distribution de la table est défini comme suit :
+ Une petite table avec DISTSTYLE ALL est convertie en AUTO(ALL).
+ Une petite table avec DISTSTYLE EVEN est convertie en AUTO(ALL).
+ Une petite table avec DISTSTYLE KEY est convertie en AUTO(ALL).
+ Une grande table avec DISTSTYLE ALL est convertie en AUTO(EVEN).
+ Une grande table avec DISTSTYLE EVEN est convertie en AUTO(EVEN).
+ Une grande table avec DISTSTYLE KEY est convertie en AUTO(KEY) et la DISTKEY est conservée. Dans ce cas, Amazon Redshift ne modifie pas la table.
Si Amazon Redshift détermine qu’un nouveau style de distribution ou une nouvelle clé améliorera les performances des requêtes, Amazon Redshift peut modifier le style de distribution ou la clé de votre table à l’avenir. Par exemple, Amazon Redshift peut convertir une table avec DISTSTYLE pour AUTO(KEY) en AUTO(EVEN), ou vice versa. Pour en savoir plus sur le comportement dans le cas où des clés de distribution sont modifiées, notamment sur le plan de la redistribution des données et des verrous, consultez [Recommandations Amazon Redshift Advisor](https://docs.aws.amazon.com/redshift/latest/dg/advisor-recommendations.html#alter-diststyle-distkey-recommendation).
Pour plus d’informations sur DISTSTYLE AUTO, consultez [CREATE TABLE](r_CREATE_TABLE_NEW.md).
Pour afficher le style de distribution appliqué à une table, interrogez la vue du catalogue système SVV\$1TABLE\$1INFO. Pour plus d'informations, consultez [SVV\$1TABLE\$1INFO](r_SVV_TABLE_INFO.md). Pour afficher les recommandations Amazon Redshift Advisor pour les tables, recherchez la vue catalogue système SVV\$1ALTER\$1TABLE\$1RECOMMENDATIONS. Pour plus d'informations, consultez [SVV\$1ALTER\$1TABLE\$1RECOMMENDATIONS](r_SVV_ALTER_TABLE_RECOMMENDATIONS.md). Pour afficher les actions effectuées par Amazon Redshift, interrogez la vue catalogue système SVL\$1AUTO\$1WORKER\$1ACTION. Pour plus d'informations, consultez [SVL\$1AUTO\$1WORKER\$1ACTION](r_SVL_AUTO_WORKER_ACTION.md).
ALTER [COMPOUND] SORTKEY ( *column\$1name* [,...] )
Clause qui modifie ou ajoute la clé de tri utilisée pour une table. ALTER SORTKEY n’est pas pris en charge pour les tables temporaires.
Lorsque vous modifiez une clé de tri, l’encodage par compression des colonnes de la nouvelle clé de tri ou de la clé de tri originale peut changer. Si aucun encodage n’est explicitement défini pour la table, Amazon Redshift attribue automatiquement les codages 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, TIME, TIMETZ, TIMESTAMP ou TIMESTAMPTZ sont soumises à une compression. AZ64
+ Les colonnes définies comme CHAR ou VARCHAR sont affectées à la compression LZO.
Éléments à prendre en compte :
+ Vous pouvez définir 400 colonnes au maximum par table pour une clé de tri.
+ Vous pouvez modifier une clé de tri entrelacée en clé de tri composée ou en aucune clé de tri. Toutefois, vous ne pouvez pas modifier une clé de tri composée par une clé de tri entrelacée.
+ Si la clé de tri était précédemment définie sur AUTO, la table n’est plus candidate à l’optimisation automatique.
+ Amazon Redshift recommande d’utiliser l’encodage RAW (sans compression) pour les colonnes définies comme des clés de tri. Lorsque vous modifiez une colonne pour la choisir comme clé de tri, la compression de la colonne passe en compression RAW (sans compression). Cela peut augmenter la quantité de stockage requise par la table. L’augmentation de la taille de la table dépend de la définition et du contenu spécifiques de la table. Pour plus d’informations sur la compression, consultez [encodages de compression](c_Compression_encodings.md).
Les données sont chargées dans une table en fonction de la clé de tri. Lorsque vous modifiez la clé de tri, Amazon Redshift modifie l’ordre des données. Pour plus d’informations sur SORTKEY, consultez [CREATE TABLE](r_CREATE_TABLE_NEW.md).
ALTER TRUTKEY AUTO
Clause qui modifie ou ajoute la clé de tri de la table cible à AUTO. ALTER SORTKEY AUTO n’est pas pris en charge pour les tables temporaires.
Lorsque vous modifiez une clé de tri en AUTO, Amazon Redshift conserve la clé de tri existante de la table.
Si Amazon Redshift détermine qu’une nouvelle clé de tri améliorera les performances des requêtes, Amazon Redshift peut modifier la clé de tri de votre table à l’avenir.
Pour plus d’informations sur SORTKEY AUTO, consultez [CREATE TABLE](r_CREATE_TABLE_NEW.md).
Pour afficher la clé de tri d'une table, interrogez la vue catalogue système SVV\$1TABLE\$1INFO. Pour plus d'informations, consultez [SVV\$1TABLE\$1INFO](r_SVV_TABLE_INFO.md). Pour afficher les recommandations Amazon Redshift Advisor pour les tables, recherchez la vue catalogue système SVV\$1ALTER\$1TABLE\$1RECOMMENDATIONS. Pour plus d'informations, consultez [SVV\$1ALTER\$1TABLE\$1RECOMMENDATIONS](r_SVV_ALTER_TABLE_RECOMMENDATIONS.md). Pour afficher les actions effectuées par Amazon Redshift, interrogez la vue catalogue système SVL\$1AUTO\$1WORKER\$1ACTION. Pour plus d'informations, consultez [SVL\$1AUTO\$1WORKER\$1ACTION](r_SVL_AUTO_WORKER_ACTION.md).
ALTER SORTKEY NONE
Clause qui supprime la clé de tri de la table cible.
Si la clé de tri était précédemment définie sur AUTO, la table n’est plus candidate à l’optimisation automatique.
ALTER ENCODE AUTO
Clause qui modifie le type d’encodage des colonnes de la table cible en AUTO. Lorsque vous modifiez l’encodage en AUTO, Amazon Redshift conserve le type d’encodage existant des colonnes de la table. Ensuite, si Amazon Redshift détermine qu’un nouveau type d’encodage peut améliorer les performances de la requête, Amazon Redshift peut modifier le type d’encodage des colonnes de la table.
Si vous modifiez une ou plusieurs colonnes pour spécifier un encodage, Amazon Redshift n’ajuste plus automatiquement l’encodage pour toutes les colonnes de la table. Les colonnes conservent les paramètres d’encodage actuels.
Les actions suivantes n’affectent pas le paramètre ENCODE AUTO pour la table :
+ Renommage de la table.
+ Modification du paramètre DISTSTYLE ou SORTKEY pour la table.
+ Ajout ou suppression d’une colonne avec un paramètre ENCODE.
+ Utilisation de l’option COMPUPDATE de la commande COPY. Pour plus d'informations, consultez [Opérations de chargement de données](copy-parameters-data-load.md).
Pour afficher l’encodage d’une table, interrogez la vue catalogue système SVV\$1TABLE\$1INFO. Pour plus d'informations, consultez [SVV\$1TABLE\$1INFO](r_SVV_TABLE_INFO.md).
RENAME COLUMN *nom\$1colonne* TO *nouveau\$1nom*
Clause qui renomme une colonne selon la valeur spécifiée dans *nouveau\$1nom*. La longueur maximale d’un nom de colonne est de 127 octets ; les noms plus longs sont tronqués à 127 octets. Pour plus d’informations sur les noms valides, consultez [Noms et identificateurs](r_names.md).
ADD [ COLUMN ] *nom\$1colonne*
Clause qui ajoute une colonne avec le nom spécifié à la table. Vous ne pouvez ajouter qu’une seule colonne à chaque instruction ALTER TABLE.
Vous ne pouvez pas ajouter une colonne qui soit la clé de distribution (DISTKEY) ou une clé de tri (SORTKEY) de la table.
Vous ne pouvez pas utiliser une commande ALTER TABLE ADD COLUMN pour modifier les attributs de table et de colonne suivants :
+ UNIQUE
+ PRIMARY KEY
+ REFERENCES (clé étrangère)
+ IDENTITY ou GENERATED BY DEFAULT AS IDENTITY
La longueur maximale d’un nom de colonne est de 127 octets ; les noms plus longs sont tronqués à 127 octets. Le nombre maximal de colonnes que vous pouvez définir dans une seule table est de 1 600.
Les restrictions suivantes s’appliquent lorsque vous ajoutez une colonne à une table externe :
+ Vous ne pouvez pas ajouter une colonne à une table externe dont les contraintes de table sont DEFAULT, ENCODE, NOT NULL ou NULL.
+ Vous ne pouvez pas ajouter des colonnes à une table externe définie à l’aide du format de fichier AVRO.
+ Si les pseudo-colonnes sont activées, le nombre maximal de colonnes que vous pouvez définir dans une seule table externe est 1 598. Si les pseudo-colonnes ne sont pas activées, le nombre maximal de colonnes que vous pouvez définir dans une seule table est 1 600.
Pour plus d'informations, consultez [CREATE EXTERNAL TABLE](r_CREATE_EXTERNAL_TABLE.md).
*type\$1colonne*
Type de données de la colonne ajoutée. Pour les colonnes CHAR et VARCHAR, vous pouvez utiliser le mot-clé MAX au lieu de déclarer une longueur maximale. MAX définit la longueur maximale sur 4 096 octets pour CHAR ou 65 535 octets pour VARCHAR. La taille maximum d’un objet GEOMETRY est de 1 048 447 octets.
Pour obtenir des informations sur les types de données pris en charge par Amazon Redshift, consultez [Types de données](c_Supported_data_types.md).
DEFAULT *expr\$1défaut*
Clause qui attribue une valeur de données par défaut à la colonne. Le type de données de *expr\$1défaut* doit correspondre au type de données de la colonne. La valeur DEFAULT doit être une expression exempte de variable. Les sous-requêtes, les références croisées aux autres colonnes de la table active et les fonctions définies par l’utilisateur ne sont pas autorisées.
*expr\$1défaut* est utilisé dans toute opération INSERT qui ne spécifie pas une valeur pour la colonne. Si aucune valeur par défaut n’est spécifiée, la valeur par défaut de la colonne est la valeur null.
Si une opération COPY rencontre un champ null dans une colonne qui a une valeur DEFAULT et une contrainte NOT NULL, la commande COPY insère la valeur de *expr\$1défaut*.
DEFAULT n’est pas pris en charge pour les tables externes.
ENCODE *encodage*
Encodage de compression pour une colonne. Par défaut, Amazon Redshift gère automatiquement l’encodage de compression pour toutes les colonnes d’une table si vous ne spécifiez pas d’encodage de compression pour une colonne de la table ou si vous spécifiez l’option ENCODE AUTO pour la table.
Si vous spécifiez l’encodage de compression pour une colonne de la table ou si vous ne spécifiez pas l’option ENCODE AUTO pour la table, Amazon Redshift attribue automatiquement l’encodage de compression aux colonnes pour lesquelles vous ne spécifiez pas l’encodage de compression comme suit :
+ Toutes les colonnes de tables temporaires se voient attribuer une compression RAW par défaut.
+ 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, DOUBLE PRECISION ou GEOMETRY ou GEOGRAPHY se voient attribuer une compression RAW.
+ Les colonnes définies comme SMALLINT, INTEGER, BIGINT, DECIMAL, DATE, TIME, TIMETZ, TIMESTAMP ou TIMESTAMPTZ sont soumises à une compression. AZ64
+ Les colonnes définies comme CHAR, VARCHAR ou VARBYTE sont affectées à la compression LZO.
Si vous ne souhaitez pas qu’une colonne soit compressée, spécifiez explicitement un encodage RAW (brut).
Les encodages [compression encodings](c_Compression_encodings.md#compression-encoding-list) suivants sont pris en charge :
+ AZ64
+ BYTEDICT
+ DELTA
+ DELTA32 K
+ LZO
+ MOSTLY8
+ MOSTLY16
+ MOSTLY32
+ RAW (aucune compression)
+ RUNLENGTH
+ TEXT255
+ TEXT32 K
+ ZSTD
ENCODE n’est pas pris en charge pour les tables externes.
NOT NULL \$1 NULL
NOT NULL spécifie que la colonne n’est pas autorisée à contenir des valeurs null. NULL, valeur par défaut, spécifie que la colonne accepte les valeurs null.
NOT NULL et NULL ne sont pas pris en charge pour les tables externes.
COLLATE \$1 CASE\$1SENSITIVE \$1 CS \$1 CASE\$1INSENSITIVE \$1 CI \$1
Clause qui spécifie si la recherche de chaîne ou la comparaison sur la colonne est sensible à la casse ou insensible à la casse. La valeur par défaut est la même que la configuration actuelle de sensibilité à la casse de la base de données.
Pour rechercher les informations de classement de la base de données, utilisez la commande suivante :
```
SELECT db_collation();
db_collation
----------------
case_sensitive
(1 row)
```
CASE\$1SENSITIVE et CS sont interchangeables et donnent les mêmes résultats. De même, CASE\$1INSENSITIVE et CI sont interchangeables et donnent les mêmes résultats.
DROP [ COLUMN ] *nom\$1colonne*
Nom de la colonne à supprimer de la table.
Vous ne pouvez pas supprimer la dernière colonne d’une table. Une table doit avoir au moins une colonne.
Vous ne pouvez pas supprimer une colonne qui est la clé de distribution (DISTKEY) ou une clé de tri (SORTKEY) de la table. Le comportement par défaut pour DROP COLUMN est RESTRICT si la colonne a des objets dépendants, tels qu’une vue, une clé primaire, une clé étrangère ou une restriction UNIQUE.
Les restrictions suivantes s’appliquent lors de la suppression d’une colonne d’une table externe :
+ Par ailleurs, vous ne pouvez pas supprimer une colonne d’une table externe si cette colonne est utilisée comme partition.
+ Vous ne pouvez pas supprimer une colonne d’une table externe définie à l’aide du format de fichier AVRO.
+ RESTRICT et CASCADE sont ignorés pour les tables externes.
+ Vous ne pouvez pas supprimer les colonnes de la table de politique référencée dans la définition de la politique à moins de supprimer ou de dissocier la stratégie. Cela s’applique également lorsque l’option CASCADE est spécifiée. Vous pouvez supprimer d’autres colonnes dans le tableau des politiques.
Pour plus d’informations, consultez [CREATE EXTERNAL TABLE](r_CREATE_EXTERNAL_TABLE.md).
RESTRICT
Lorsque RESTRICT est utilisé avec DROP COLUMN, cela signifie que la colonne à supprimer n’est pas supprimée dans les cas suivants :
+ Si une vue définie référence la colonne en cours de suppression
+ Si une clé étrangère référence la colonne
+ Si la colonne fait partie d’une clé en plusieurs parties
RESTRICT ne peut pas être utilisée avec CASCADE.
RESTRICT et CASCADE sont ignorés pour les tables externes.
CASCADE
Lorsqu’il est utilisé avec DROP COLUMN, supprime la colonne spécifiée et tout ce qui dépend de cette colonne. CASCADE ne peut pas être utilisée avec RESTRICT.
RESTRICT et CASCADE sont ignorés pour les tables externes.
Les options suivantes s’appliquent uniquement aux tables externes.
SET LOCATION \$1 ’s3://*compartiment/dossier*/’ \$1 ’s3://*compartiment/fichier\$1manifeste*’ \$1
Chemin menant au dossier Amazon S3 qui contient les fichiers de données ou un fichier manifeste qui contient une liste de chemins d’objets Amazon S3. Les compartiments doivent se trouver dans la même région AWS que le cluster Amazon Redshift. Pour obtenir la liste des AWS régions prises en charge, consultez[Limitations propres à Amazon Redshift Spectrum](c-spectrum-considerations.md). Pour plus d’informations sur l’utilisation d’un fichier manifeste, consultez l’option LOCATION dans la référence [Parameters](r_CREATE_EXTERNAL_TABLE.md#r_CREATE_EXTERNAL_TABLE-parameters) CREATE EXTERNAL TABLE.
SET FILE FORMAT *format*
Format des fichiers de données externes.
Les formats valides sont les suivants :
+ AVRO
+ PARQUET
+ RCFILE
+ SEQUENCEFILE
+ TEXTFILE
SET TABLE PROPERTIES ( ’*nom\$1propriété*’=’*valeur\$1propriété*’)
Clause qui définit la définition de table pour des propriétés de table d’une table externe.
Les propriétés de table sont sensibles à la casse.
’numRows’=’*nombre\$1lignes*’
Propriété qui définit la valeur numRows de la définition de table. Afin de mettre à jour explicitement les statistiques d’une table externe, définissez la propriété numRows pour indiquer la taille de la table. Amazon Redshift n'analyse pas les tables externes pour générer les statistiques de table utilisées par l'optimiseur de requête afin de générer un plan de requête. Si des statistiques de table ne sont pas définies pour une table externe, Amazon Redshift génère un plan d’exécution de requête. Ce plan se base sur une hypothèse selon laquelle les tables externes sont les tables les plus volumineuses et les tables locales les tables les plus petites.
’skip.header.line.count’=’*nombre\$1lignes*’
Propriété qui définit le nombre de lignes à ignorer au début de chaque fichier source.
PARTITION ( *colonne\$1partition*=*valeur\$1partition* [, ...] SET LOCATION \$1 ’s3://*compartiment*/*dossier*’ \$1 ’s3://*compartiment*/*fichier\$1manifeste*’ \$1
Clause qui définit un nouvel emplacement pour une ou plusieurs colonnes de partition.
ADD [ IF NOT EXISTS ] PARTITION ( *partition\$1column*=*partition\$1value* [, ...] ) LOCATION \$1 ’s3://*bucket*/*folder*’ \$1 ’s3://*bucket*/*manifest\$1file*’ \$1 [, ... ]
Clause qui ajoute une ou plusieurs partitions. Vous pouvez spécifier plusieurs clauses PARTITION à l’aide d’une seule instruction ALTER TABLE … ADD.
Si vous utilisez le AWS Glue catalogue, vous pouvez ajouter jusqu'à 100 partitions à l'aide d'une seule instruction ALTER TABLE.
La clause IF NOT EXISTS indique que si la partition spécifiée existe déjà, la commande ne doit effectuer aucun changement. Elle indique également que la commande doit renvoyer un message indiquant que la partition existe, plutôt que s’arrêter avec une erreur. Comme cette clause est utile à l’écriture de scripts, ce script n’échoue pas si ALTER TABLE tente d’ajouter une partition qui existe déjà.
DROP PARTITION (*colonne\$1partition*=*valeur\$1partition* [, ...] )
Clause qui supprime la partition spécifiée. La suppression d’une partition modifie uniquement les métadonnées des tables externes. Ceci n’a aucun impact sur les données sur Amazon S3.
ROW LEVEL SECURITY \$1 ON \$1 OFF \$1 [ CONJUNCTION TYPE \$1 AND \$1 OR \$1 ] [ FOR DATASHARES ]
Clause qui active ou désactive la sécurité au niveau des lignes pour une relation.
Lorsque la sécurité au niveau des lignes est activée pour une relation, vous pouvez lire uniquement les lignes auxquelles cette politique vous autorise à accéder. Si aucune politique ne vous accorde l’accès à la relation, vous ne pouvez voir aucune ligne pour la relation. Seuls les super-utilisateurs et les utilisateurs ou les rôles dotés du rôle `sys:secadmin` peuvent définir la clause ROW LEVEL SECURITY. Pour de plus amples informations, veuillez consulter [Sécurité au niveau des lignes](t_rls.md). Cette instruction est prise en charge sur la base de données connectée ou sur une base de données dotée d'autorisations fédérées Amazon Redshift. La clause FOR DATASHARES n'est pas prise en charge sur une base de données dotée d'autorisations fédérées Amazon Redshift.
+ [ CONJUNCTION TYPE \$1 AND \$1 OR \$1 ]
Clause qui vous permet de choisir le type de conjonction de la politique de sécurité au niveau des lignes pour une relation. Lorsque plusieurs politiques de sécurité au niveau des lignes sont associées à une relation, vous pouvez les combiner avec la clause AND ou OR. Par défaut, Amazon Redshift associe les politiques RLS à la clause AND. Les super-utilisateurs, utilisateurs ou rôles disposant du rôle `sys:secadmin` peuvent utiliser cette clause pour définir le type de conjonction de la politique de sécurité au niveau des lignes pour une relation. Pour plus d’informations, consultez [Association de plusieurs politiques par utilisateur](t_rls_combine_policies.md).
+ FOR DATASHARES
Clause qui détermine s’il est possible d’accéder à une relation protégée par RLS sur les unités de partage des données. Par défaut, une relation protégée par RLS n’est pas accessible sur une unité de partage des données. Une commande ALTER TABLE ROW LEVEL SECURITY exécutée avec cette clause affecte uniquement la propriété d’accessibilité de l’unité de partage des données de la relation. La propriété ROW LEVEL SECURITY n’est pas modifiée.
Si vous rendez accessible une relation protégée par RLS via des unités de partage des données, la relation n’est pas sécurisée au niveau des lignes dans la base de données de l’unité de partage des données côté consommateur. La relation conserve sa propriété RLS du côté producteur.
MASKING \$1 ON \$1 OFF \$1 FOR DATASHARES
Clause qui détermine s’il est possible d’accéder à une relation protégée par DDM sur les unités de partage des données. Par défaut, une relation protégée par DDM n’est pas accessible sur une unité de partage des données. Si vous rendez accessible une relation protégée par DDM via des unités de partage des données, la relation ne sera pas protégée par masquage dans la base de données de l’unité de partage des données côté consommateur. La relation conserve sa propriété de masquage du côté producteur. Seuls les super-utilisateurs et les utilisateurs ou les rôles dotés du rôle `sys:secadmin` peuvent définir la clause MASKING FOR DATASHARES. Pour plus d’informations, consultez [Masquage dynamique des données](t_ddm.md).
## Exemples
Les exemples suivants montrent comment utiliser la commande ALTER TABLE.
+ [Exemples ALTER TABLE](r_ALTER_TABLE_examples_basic.md)
+ [Exemples de modification d’une table externe](r_ALTER_TABLE_external-table.md)
+ [Exemples ALTER TABLE ADD et DROP COLUMN](r_ALTER_TABLE_COL_ex-add-drop.md)
# Exemples ALTER TABLE
Les exemples suivants illustrent l’utilisation de base de la commande ALTER TABLE.
## Renommer une table ou une vue
La commande suivante permet de renommer la table USERS en USERS\$1BKUP :
```
alter table users
rename to users_bkup;
```
Vous pouvez également utiliser ce type de commande pour renommer une vue.
## Modifier le propriétaire d’une table ou d’une vue
La commande suivante remplace le propriétaire de la table VENUE par l’utilisateur DWUSER :
```
alter table venue
owner to dwuser;
```
Les commandes suivantes créent une vue, puis modifient son propriétaire :
```
create view vdate as select * from date;
alter table vdate owner to vuser;
```
## Renommer une colonne
La commande suivante renomme la colonne VENUESEATS de la table VENUE en VENUESIZE :
```
alter table venue
rename column venueseats to venuesize;
```
## Supprimer une contrainte de table
Pour supprimer une contrainte de table, telle qu’une contrainte de clé primaire, de clé étrangère ou unique, commencez par rechercher le nom interne de la contrainte. Ensuite, spécifiez le nom de la contrainte dans la commande ALTER TABLE. L’exemple suivant recherche les contraintes de la table CATEGORY, puis supprime la clé principale avec le nom `category_pkey`.
```
select constraint_name, constraint_type
from information_schema.table_constraints
where constraint_schema ='public'
and table_name = 'category';
constraint_name | constraint_type
----------------+----------------
category_pkey | PRIMARY KEY
alter table category
drop constraint category_pkey;
```
## Modifier une colonne VARCHAR
Pour conserver le stockage, vous pouvez définir une table initialement avec des colonnes VARCHAR dotées de la taille minimale nécessaire pour vos données actives. Vous pouvez modifier ultérieurement la table afin d’augmenter la taille de la colonne si plus tard vous avez besoin d’accueillir plus de chaînes.
L’exemple suivant augmente la taille de la colonne EVENTNAME à VARCHAR (300).
```
alter table event alter column eventname type varchar(300);
```
## Modifier une colonne VARBYTE
Pour conserver le stockage, vous pouvez définir une table initialement avec des colonnes VARBYTE dotées de la taille minimale nécessaire pour vos données actives. Vous pouvez modifier ultérieurement la table afin d’augmenter la taille de la colonne si plus tard vous avez besoin d’accueillir plus de chaînes.
L’exemple suivant augmente la taille de la colonne EVENTNAME à VARBYTE(300).
```
alter table event alter column eventname type varbyte(300);
```
## Modifier l’encodage de la compression d’une colonne
Vous pouvez modifier le codage de compression d’une colonne. Vous trouverez ci-dessous une série d’exemples illustrant cette approche. La définition de table pour ces exemples est la suivante.
```
create table t1(c0 int encode lzo, c1 bigint encode zstd, c2 varchar(16) encode lzo, c3 varchar(32) encode zstd);
```
L'instruction suivante modifie le codage de compression de la colonne c0 du codage LZO au codage. AZ64
```
alter table t1 alter column c0 encode az64;
```
L'instruction suivante modifie le codage de compression de la colonne c1 du codage standard Z au AZ64 codage.
```
alter table t1 alter column c1 encode az64;
```
L’instruction suivante modifie l’encodage de compression pour la colonne c2 de l’encodage LZO à l’encodage Byte-dictionary.
```
alter table t1 alter column c2 encode bytedict;
```
L’instruction suivante modifie l’encodage de compression pour la colonne c3 de l’encodage Zstandard à l’encodage Runlength.
```
alter table t1 alter column c3 encode runlength;
```
## Modifier une colonne DISTSTYLE KEY DISTKEY
Les exemples suivants montre comment modifier les colonnes DISTSTYLE et DISTKEY d’une table.
Créez une table avec un style de distribution EVEN. La vue SVV\$1TABLE\$1INFO montre que la colonne DISTSTYLE est EVEN.
```
create table inventory(
inv_date_sk int4 not null ,
inv_item_sk int4 not null ,
inv_warehouse_sk int4 not null ,
inv_quantity_on_hand int4
) diststyle even;
Insert into inventory values(1,1,1,1);
select "table", "diststyle" from svv_table_info;
table | diststyle
-----------+----------------
inventory | EVEN
```
Modifiez la table DISTKEY en `inv_warehouse_sk`. La vue SVV\$1TABLE\$1INFO montre la colonne `inv_warehouse_sk` en tant que clé de distribution résultante.
```
alter table inventory alter diststyle key distkey inv_warehouse_sk;
select "table", "diststyle" from svv_table_info;
table | diststyle
-----------+-----------------------
inventory | KEY(inv_warehouse_sk)
```
Modifiez la table DISTKEY en `inv_item_sk`. La vue SVV\$1TABLE\$1INFO montre la colonne `inv_item_sk` en tant que clé de distribution résultante.
```
alter table inventory alter distkey inv_item_sk;
select "table", "diststyle" from svv_table_info;
table | diststyle
-----------+-----------------------
inventory | KEY(inv_item_sk)
```
## Modifier une table en DISTSTYLE ALL
Les exemples suivants montrent comment modifier une table en DISTSTYLE ALL.
Créez une table avec un style de distribution EVEN. La vue SVV\$1TABLE\$1INFO montre que la colonne DISTSTYLE est EVEN.
```
create table inventory(
inv_date_sk int4 not null ,
inv_item_sk int4 not null ,
inv_warehouse_sk int4 not null ,
inv_quantity_on_hand int4
) diststyle even;
Insert into inventory values(1,1,1,1);
select "table", "diststyle" from svv_table_info;
table | diststyle
-----------+----------------
inventory | EVEN
```
Modifiez la table DISTSTYLE en ALL. La vue SVV\$1TABLE\$1INFO affiche le DISTSYTLE modifié.
```
alter table inventory alter diststyle all;
select "table", "diststyle" from svv_table_info;
table | diststyle
-----------+----------------
inventory | ALL
```
## Modifier une table SORTKEY
Vous pouvez modifier une table pour avoir une clé de tri composée ou aucune clé de tri.
Dans la définition de table suivante, la table `t1` est définie par une clé de tri entrelacée.
```
create table t1 (c0 int, c1 int) interleaved sortkey(c0, c1);
```
La commande suivante modifie la table d’une clé de tri entrelacée en une clé de tri composée.
```
alter table t1 alter sortkey(c0, c1);
```
La commande suivante modifie la table pour supprimer la clé de tri entrelacée.
```
alter table t1 alter sortkey none;
```
Dans la définition de table suivante, la table `t1` est définie avec une colonne `c0` comme clé de tri.
```
create table t1 (c0 int, c1 int) sortkey(c0);
```
La commande suivante modifie la table `t1` en clé de tri composée.
```
alter table t1 alter sortkey(c0, c1);
```
## Modifier une table en ENCODE AUTO
L’exemple suivant montre comment modifier une table en ENCODE AUTO.
La définition de table pour cet exemple est la suivante. `c0`La colonne est définie avec le type de codage AZ64, et la colonne `c1` est définie avec le type de codage LZO.
```
create table t1(c0 int encode AZ64, c1 varchar encode LZO);
```
Pour cette table, l’instruction suivante modifie l’encodage en AUTO.
```
alter table t1 alter encode auto;
```
L’exemple suivant illustre comment modifier une table pour supprimer le paramètre ENCODE AUTO.
La définition de table pour cet exemple est la suivante. Les colonnes de la table sont définies sans encodage. Dans ce cas, l’encodage est par défaut ENCODE AUTO.
```
create table t2(c0 int, c1 varchar);
```
Pour cette table, l’instruction suivante modifie l’encodage de la colonne c0 en LZO. L’encodage de la table n’est plus défini sur ENCODE AUTO.
```
alter table t2 alter column c0 encode lzo;;
```
## Modifier le contrôle de sécurité au niveau des lignes
La commande suivante désactive la politique RLS pour la table :
```
ALTER TABLE tickit_category_redshift ROW LEVEL SECURITY OFF;
```
La commande suivante active RLS pour la table :
```
ALTER TABLE tickit_category_redshift ROW LEVEL SECURITY ON;
```
La commande suivante active RLS pour la table et la rend accessible sur les unités de partage des données :
```
ALTER TABLE tickit_category_redshift ROW LEVEL SECURITY ON;
ALTER TABLE tickit_category_redshift ROW LEVEL SECURITY FOR DATASHARES OFF;
```
La commande suivante active RLS pour la table et la rend inaccessible sur les unités de partage des données :
```
ALTER TABLE tickit_category_redshift ROW LEVEL SECURITY ON;
ALTER TABLE tickit_category_redshift ROW LEVEL SECURITY FOR DATASHARES ON;
```
La commande suivante active RLS et définit le type de conjonction RLS sur OR pour la table :
```
ALTER TABLE tickit_category_redshift ROW LEVEL SECURITY ON CONJUNCTION TYPE OR;
```
La commande suivante active RLS et définit le type de conjonction RLS sur AND pour la table :
```
ALTER TABLE tickit_category_redshift ROW LEVEL SECURITY ON CONJUNCTION TYPE AND;
```
# Exemples de modification d’une table externe
Les exemples suivants utilisent un compartiment Amazon S3 situé dans la région USA Est (Virginie du Nord) (`us-east-1`) Région AWS et les exemples de tables créés [Exemples](r_CREATE_EXTERNAL_TABLE_examples.md) pour CREATE TABLE. Pour plus d’informations sur l’utilisation des partitions avec des tables externes, consultez [Partitionnement des tables externes Redshift Spectrum](c-spectrum-external-tables.md#c-spectrum-external-tables-partitioning).
L’exemple suivant définit la propriété de table numRows pour la table externe SPECTRUM.SALES sur 170 000 lignes.
```
alter table spectrum.sales
set table properties ('numRows'='170000');
```
L’exemple suivant modifie l’emplacement de la table externe SPECTRUM.SALES.
```
alter table spectrum.sales
set location 's3://redshift-downloads/tickit/spectrum/sales/';
```
L’exemple suivant définit le format de la table externe SPECTRUM.SALES sur Parquet.
```
alter table spectrum.sales
set file format parquet;
```
L’exemple suivant ajoute une partition pour la table SPECTRUM.SALES\$1PART.
```
alter table spectrum.sales_part
add if not exists partition(saledate='2008-01-01')
location 's3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-01/';
```
L’exemple suivant ajoute trois partitions pour la table SPECTRUM.SALES\$1PART.
```
alter table spectrum.sales_part add if not exists
partition(saledate='2008-01-01')
location 's3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-01/'
partition(saledate='2008-02-01')
location 's3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-02/'
partition(saledate='2008-03-01')
location 's3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-03/';
```
L’exemple suivant modifie SPECTRUM.SALES\$1PART afin de supprimer la partition avec `saledate='2008-01-01''`.
```
alter table spectrum.sales_part
drop partition(saledate='2008-01-01');
```
L’exemple suivant définit un nouveau chemin d’accès Amazon S3 pour la partition avec `saledate='2008-01-01'`.
```
alter table spectrum.sales_part
partition(saledate='2008-01-01')
set location 's3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-01-01/';
```
L’exemple suivant remplace le nom de `sales_date` par `transaction_date`.
```
alter table spectrum.sales rename column sales_date to transaction_date;
```
L’exemple suivant définit le mappage de colonne sur le mappage par position pour une table externe qui utilise le format Optimized Row Columnar (ORC).
```
alter table spectrum.orc_example
set table properties('orc.schema.resolution'='position');
```
L’exemple suivant définit le mappage de colonne sur le mappage par nom pour une table externe qui utilise le format ORC.
```
alter table spectrum.orc_example
set table properties('orc.schema.resolution'='name');
```
# Exemples ALTER TABLE ADD et DROP COLUMN
Les exemples suivants montrent comment utiliser ALTER TABLE pour ajouter, puis supprimer une colonne de table de base, ainsi que pour supprimer une colonne avec un objet dépendant.
## ADD puis DROP une colonne de base
L’exemple suivant ajoute une colonne FEEDBACK\$1SCORE autonome à la table USERS. Cette colonne contient simplement un nombre entier et la valeur par défaut de cette colonne est NULL (pas de score de commentaire).
Commencez par interroger la table du catalogue PG\$1TABLE\$1DEF pour afficher le schéma de la table USERS :
```
column | type | encoding | distkey | sortkey
--------------+------------------------+----------+---------+--------
userid | integer | delta | true | 1
username | character(8) | lzo | false | 0
firstname | character varying(30) | text32k | false | 0
lastname | character varying(30) | text32k | false | 0
city | character varying(30) | text32k | false | 0
state | character(2) | bytedict | false | 0
email | character varying(100) | lzo | false | 0
phone | character(14) | lzo | false | 0
likesports | boolean | none | false | 0
liketheatre | boolean | none | false | 0
likeconcerts | boolean | none | false | 0
likejazz | boolean | none | false | 0
likeclassical | boolean | none | false | 0
likeopera | boolean | none | false | 0
likerock | boolean | none | false | 0
likevegas | boolean | none | false | 0
likebroadway | boolean | none | false | 0
likemusicals | boolean | none | false | 0
```
Maintenant, ajoutez la colonne feedback\$1score :
```
alter table users
add column feedback_score int
default NULL;
```
Sélectionnez la colonne FEEDBACK\$1SCORE de la table USERS pour vérifier qu’elle a été ajoutée :
```
select feedback_score from users limit 5;
feedback_score
----------------
NULL
NULL
NULL
NULL
NULL
```
Supprimez la colonne pour rétablir le DDL d’origine :
```
alter table users drop column feedback_score;
```
## Suppression d’une colonne avec un objet dépendant
L’exemple suivant supprime une colonne qui a un objet dépendant. En conséquence, l’objet dépendant est également supprimé.
Pour commencer, ajoutez à nouveau la colonne FEEDBACK\$1SCORE à la table USERS :
```
alter table users
add column feedback_score int
default NULL;
```
Ensuite, créez une vue de la table USERS appelée USERS\$1VIEW :
```
create view users_view as select * from users;
```
Maintenant, essayez de supprimer la colonne FEEDBACK\$1SCORE de la table USERS. Cette instruction DROP utilise le comportement par défaut (RESTRICT) :
```
alter table users drop column feedback_score;
```
Amazon Redshift affiche un message d’erreur indiquant que la colonne ne peut pas être supprimée, car un autre objet en dépend.
Essayez à nouveau de supprimer la colonne FEEDBACK\$1SCORE, cette fois en spécifiant CASCADE pour supprimer tous les objets dépendants :
```
alter table users
drop column feedback_score cascade;
```
# ALTER TABLE APPEND
Ajoute des lignes à une table cible en déplaçant les données à partir d’une table source existante. Les données de la table source sont déplacées vers les colonnes correspondantes de la table cible. L’ordre des colonnes n’importe pas. Une fois que les données ont été correctement ajoutées à la table cible, la table source est vide. ALTER TABLE APPEND est généralement beaucoup plus rapide qu’une opération [CREATE TABLE AS](r_CREATE_TABLE_AS.md) ou [INSERT](r_INSERT_30.md) INTO semblable, car les données sont déplacées, pas dupliquées.
**Note**
ALTER TABLE APPEND déplace des blocs de données entre la table source et la table cible. Pour améliorer les performances, ALTER TABLE APPEND ne condense pas le stockage dans le cadre de l’opération d’ajout. Par conséquent, le stockage utilisé augmente provisoirement. Pour récupérer de l’espace, exécutez une opération [VACUUM](r_VACUUM_command.md).
Les colonnes ayant le même nom doivent aussi avoir des attributs de colonne identiques. Si la table source ou la table cible contient des colonnes qui n’existent pas dans l’autre table, utilisez les paramètres IGNOREEXTRA ou FILLTARGET pour spécifier comment les colonnes supplémentaires doivent être gérées.
Vous ne pouvez pas ajouter une colonne d’identité. Si les deux tables incluent une colonne d’identité, la commande échoue. Si une seule table dispose d’une colonne d’identité, incluez le paramètre FILLTARGET ou IGNOREEXTRA. Pour plus d'informations, consultez [Notes d’utilisation d’ALTER TABLE APPEND](#r_ALTER_TABLE_APPEND_usage).
Vous pouvez ajouter une colonne GENERATED BY DEFAULT AS IDENTITY. Vous pouvez mettre à jour des colonnes définies comme GENERATED BY DEFAULT AS IDENTITY avec des valeurs que vous fournissez. Pour plus d’informations, consultez [Notes d’utilisation d’ALTER TABLE APPEND](#r_ALTER_TABLE_APPEND_usage).
La table cible doit être une table permanente. Toutefois, la source peut être une table permanente ou une vue matérialisée configurée pour l’ingestion en streaming. Les deux objets doivent utiliser les mêmes style de distribution et clé de distribution, si l’un ou l’autre a été défini. Si les objets sont triés, les deux objets doivent utiliser le même style de tri et définir les mêmes colonnes comme clés de tri.
Une commande ALTER TABLE APPEND valide automatiquement aussitôt l’opération terminée. Elle ne peut pas être annulée. Vous ne pouvez pas exécuter ALTER TABLE APPEND au sein d’un bloc de transaction (BEGIN ... END). Pour plus d’informations sur les transactions, consultez [Niveaux d’isolement dans Amazon Redshift](c_serial_isolation.md).
## Privilèges requis
Selon la commande ALTER TABLE APPEND, l’un des privilèges suivants est requis :
+ Superuser
+ Utilisateurs disposant du privilège système ALTER TABLE
+ Utilisateurs disposant des privilèges DELETE et SELECT sur la table source, et des privilèges INSERT sur la table cible.
## Syntaxe
```
ALTER TABLE target_table_name APPEND FROM [ source_table_name | source_materialized_view_name ]
[ IGNOREEXTRA | FILLTARGET ]
```
L’ajout à partir d’une vue matérialisée fonctionne uniquement dans le cas où votre vue matérialisée est configurée pour [Ingestion en streaming vers une vue matérialisée](materialized-view-streaming-ingestion.md).
## Parameters
*nom\$1table\$1cible*
Nom de la table à laquelle les lignes sont ajoutées. Spécifiez simplement le nom de la table ou choisissez le format *nom\$1schéma.nom\$1table* pour utiliser un schéma spécifique. La table cible doit être une table permanente existante.
FROM *nom\$1table\$1source*
Nom de la table qui fournit les lignes à ajouter. Spécifiez simplement le nom de la table ou choisissez le format *nom\$1schéma.nom\$1table* pour utiliser un schéma spécifique. La table source doit être une table permanente existante.
FROM *source\$1materialized\$1view\$1name*
Nom de la vue matérialisée qui fournit les lignes à ajouter. L’ajout à partir d’une vue matérialisée fonctionne uniquement dans le cas où votre vue matérialisée est configurée pour [Ingestion en streaming vers une vue matérialisée](materialized-view-streaming-ingestion.md). La vue matérialisée source doit déjà exister.
IGNOREEXTRA
Mot-clé qui spécifie que si la table source inclut des colonnes qui ne sont pas présentes dans la table cible, les données des colonnes supplémentaires doivent être ignorées. Vous ne pouvez pas utiliser IGNOREEXTRA avec FILLTARGET.
FILLTARGET
Mot-clé qui spécifie que si la table cible inclut des colonnes qui ne sont pas présentes dans la table source, les colonnes doivent être remplies avec la valeur de colonne [DEFAULT](r_CREATE_TABLE_NEW.md#create-table-default), s’il en a été défini une, ou avec la valeur NULL. Vous ne pouvez pas utiliser IGNOREEXTRA avec FILLTARGET.
## Notes d’utilisation d’ALTER TABLE APPEND
+ ALTER TABLE APPEND déplace uniquement les colonnes identiques de la table source vers la table cible. L’ordre des colonnes n’importe pas.
+ Si la table source ou la table cible contient des colonnes supplémentaires, utilisez FILLTARGET ou IGNOREEXTRA selon les règles suivantes :
+ Si la table source contient des colonnes qui n’existent pas dans la table cible, incluez IGNOREEXTRA. La commande ignore les colonnes supplémentaires de la table source.
+ Si la table cible contient des colonnes qui n’existent pas dans la table source, incluez FILLTARGET. La commande remplit les colonnes supplémentaires de la table cible avec la valeur de colonne par défaut ou la valeur IDENTITY, s’il en a été défini une, ou la valeur NULL.
+ Si la table source et la table cible contiennent des colonnes supplémentaires, la commande échoue. Vous ne pouvez pas utiliser FILLTARGET et IGNOREEXTRA.
+ Si une colonne ayant le même nom, mais des attributs différents, existe dans les deux tables, la commande échoue. Les colonnes aux noms similaires doivent avoir en commun les attributs suivants :
+ Type de données
+ Taille de colonne
+ Encodage de compression
+ Non null
+ Style de tri
+ Colonnes de clé de tri
+ Style de distribution
+ Colonnes de clé de distribution
+ Vous ne pouvez pas ajouter une colonne d’identité. Si la table source et la table cible possèdent des colonnes d’identité, la commande échoue. Si seule la table source contient une colonne d’identité, incluez le paramètre IGNOREEXTRA afin que la colonne d’identité soit ignorée. Si seule la table cible comporte une colonne d’identité, incluez le paramètre FILLTARGET afin que la colonne d’identité soit renseignée selon la clause IDENTITY définie pour la table. Pour plus d'informations, consultez [DEFAULT](r_CREATE_TABLE_NEW.md#create-table-default).
+ Vous pouvez ajouter une colonne d’identité par défaut avec l’instruction ALTER TABLE APPEND. Pour plus d’informations, consultez [CREATE TABLE](r_CREATE_TABLE_NEW.md).
+ Les opérations ALTER TABLE APPEND sont verrouillées exclusivement lorsqu’elles sont exécutées sur des vues matérialisées en streaming Amazon Redshift associées à l’un des éléments suivants :
+ Un flux de données Amazon Kinesis
+ Une rubrique Amazon Managed Streaming pour Apache Kafka
+ Un flux externe pris en charge, tel qu’une rubrique Confluent Cloud Kafka
Pour plus d’informations, consultez [Ingestion en streaming vers une vue matérialisée](materialized-view-streaming-ingestion.md).
## Exemples ALTER TABLE APPEND
Supposons que votre organisation gère une table, SALES\$1MONTHLY, pour capturer les transactions commerciales actuelles. Vous voulez, chaque mois, déplacer les données de la table des transactions vers la table SALES.
Vous pouvez utiliser les commandes INSERT INTO et TRUNCATE suivantes pour accomplir la tâche.
```
insert into sales (select * from sales_monthly);
truncate sales_monthly;
```
Cependant, vous pouvez effectuer la même opération bien plus efficacement en utilisant une commande ALTER TABLE APPEND.
D’abord, interrogez la table catalogue système [PG\$1TABLE\$1DEF](r_PG_TABLE_DEF.md) pour vérifier que les deux tables ont les mêmes colonnes avec des attributs de colonne identiques.
```
select trim(tablename) as table, "column", trim(type) as type,
encoding, distkey, sortkey, "notnull"
from pg_table_def where tablename like 'sales%';
table | column | type | encoding | distkey | sortkey | notnull
-----------+------------+-----------------------------+----------+---------+---------+--------
sales | salesid | integer | lzo | false | 0 | true
sales | listid | integer | none | true | 1 | true
sales | sellerid | integer | none | false | 2 | true
sales | buyerid | integer | lzo | false | 0 | true
sales | eventid | integer | mostly16 | false | 0 | true
sales | dateid | smallint | lzo | false | 0 | true
sales | qtysold | smallint | mostly8 | false | 0 | true
sales | pricepaid | numeric(8,2) | delta32k | false | 0 | false
sales | commission | numeric(8,2) | delta32k | false | 0 | false
sales | saletime | timestamp without time zone | lzo | false | 0 | false
salesmonth | salesid | integer | lzo | false | 0 | true
salesmonth | listid | integer | none | true | 1 | true
salesmonth | sellerid | integer | none | false | 2 | true
salesmonth | buyerid | integer | lzo | false | 0 | true
salesmonth | eventid | integer | mostly16 | false | 0 | true
salesmonth | dateid | smallint | lzo | false | 0 | true
salesmonth | qtysold | smallint | mostly8 | false | 0 | true
salesmonth | pricepaid | numeric(8,2) | delta32k | false | 0 | false
salesmonth | commission | numeric(8,2) | delta32k | false | 0 | false
salesmonth | saletime | timestamp without time zone | lzo | false | 0 | false
```
Ensuite, regardez la taille de chaque table.
```
select count(*) from sales_monthly;
count
-------
2000
(1 row)
select count(*) from sales;
count
-------
412,214
(1 row)
```
Maintenant, exécutez la commande ALTER TABLE APPEND suivante.
```
alter table sales append from sales_monthly;
```
Regardez à nouveau la taille de chaque table. La table SALES\$1MONTHLY a maintenant 0 ligne et la table SALES a augmenté de 2000 lignes.
```
select count(*) from sales_monthly;
count
-------
0
(1 row)
select count(*) from sales;
count
-------
414214
(1 row)
```
Si la table source a plus de colonnes que la table cible, spécifiez le paramètre IGNOREEXTRA. L’exemple suivant utilise le paramètre IGNOREEXTRA pour ignorer les colonnes supplémentaires de la table SALES\$1LISTING lors de l’ajout à la table SALES.
```
alter table sales append from sales_listing ignoreextra;
```
Si la table cible a plus de colonnes que la table source, spécifiez le paramètre FILLTARGET. L’exemple suivant utilise le paramètre FILLTARGET pour remplir les colonnes de la table SALES\$1REPORT qui n’existent pas dans la table SALES\$1MONTH.
```
alter table sales_report append from sales_month filltarget;
```
L’exemple suivant montre comment utiliser ALTER TABLE APPEND avec une vue matérialisée en tant que source.
```
ALTER TABLE target_tbl APPEND FROM my_streaming_materialized_view;
```
Les noms de table et de vue matérialisée de cet exemple sont des exemples. L’ajout à partir d’une vue matérialisée fonctionne uniquement dans le cas où votre vue matérialisée est configurée pour [Ingestion en streaming vers une vue matérialisée](materialized-view-streaming-ingestion.md). Cela déplace tous les enregistrements de la vue matérialisée source vers une table cible avec le même schéma que la vue matérialisée et laisse la vue matérialisée intacte. Il s’agit du même comportement que lorsque la source des données est une table.
# MODIFIER LE MODÈLE
Modifie la définition d'un modèle existant. Utilisez cette commande pour renommer un modèle, modifier le propriétaire d'un modèle, ajouter ou supprimer des paramètres dans la définition du modèle ou définir des valeurs de paramètres.
## Privilèges requis
Pour modifier un modèle, vous devez disposer de l'un des éléments suivants :
+ Privilèges de superutilisateur
+ Privilège ALTER TEMPLATE et privilège USAGE sur le schéma contenant le modèle
## Syntaxe
```
ALTER TEMPLATE [database_name.][schema_name.]template_name
{
RENAME TO new_name
| OWNER TO new_owner
| ADD parameter [AS] [value]
| DROP parameter
| SET parameter TO value1 [, parameter2 TO value2 , ...]
};
```
## Parameters
*database\$1name*
(Facultatif) Nom de la base de données dans laquelle le modèle est créé. Si elle n'est pas spécifiée, la base de données actuelle est utilisée.
*nom\$1schéma*
(Facultatif) Nom du schéma dans lequel le modèle est créé. S'il n'est pas spécifié, le modèle est recherché dans le chemin de recherche actuel.
*nom\$1modèle*
Nom du modèle à modifier.
RENAME TO
Clause qui renomme le modèle.
*nouveau\$1nom*
Le nouveau nom du modèle. Pour plus d’informations sur les noms valides, consultez [Noms et identificateurs](r_names.md).
OWNER TO
Clause qui modifie le propriétaire du modèle.
*nouveau\$1propriétaire*
Le nouveau propriétaire du modèle.
*Paramètre* ADD [AS] [*valeur*]
Ajoute un nouveau paramètre au modèle.
+ Pour les paramètres contenant uniquement des mots clés (tels que CSV ou GZIP), spécifiez uniquement le nom du paramètre.
+ Pour les paramètres qui nécessitent des valeurs, spécifiez le nom du paramètre suivi de la valeur. Vous pouvez éventuellement inclure AS entre le paramètre et la valeur.
*Paramètre* DROP
Supprime le paramètre spécifié du modèle. Impossible de supprimer plusieurs paramètres avec une seule commande DROP.
*RÉGLER le *paramètre SUR* *valeur1* [, *paramètre2 SUR valeur2*,...]*
Met à jour les valeurs des paramètres de modèle existants. À utiliser uniquement pour les paramètres qui ont déjà des valeurs. Plusieurs paramètres peuvent être mis à jour en une seule commande.
## Exemples
L'exemple suivant renomme le modèle test\$1template en demo\$1template.
```
ALTER TEMPLATE test_template
RENAME TO demo_template;
```
L'exemple suivant attribue la propriété du schéma demo\$1template à l'utilisateur bob.
```
ALTER TEMPLATE demo_template
OWNER TO bob;
```
L'exemple suivant ajoute un paramètre `CSV` au modèle demo\$1template
```
ALTER TEMPLATE demo_template
ADD CSV;
```
L'exemple suivant ajoute un paramètre `TIMEFORMAT 'auto'` au modèle demo\$1template
```
ALTER TEMPLATE demo_template
ADD TIMEFORMAT 'auto';
```
L'exemple suivant supprime le paramètre `ENCRYPTED` du modèle demo\$1template
```
ALTER TEMPLATE demo_template
DROP ENCRYPTED;
```
L'exemple suivant définit le `DELIMITER` paramètre sur `'|'` et le `TIMEFORMAT` paramètre sur `'epochsecs'` :
```
ALTER TEMPLATE demo_template
SET DELIMITER TO '|', TIMEFORMAT TO 'epochsecs';
```
# ALTER USER
Modifie un utilisateur de base de données.
## Privilèges requis
Les privilèges suivants sont requis pour ALTER USER :
+ Superuser
+ Utilisateurs disposant du privilège ALTER USER
+ Utilisateur actuel qui souhaite modifier son propre mot de passe
## Syntaxe
```
ALTER USER username [ WITH ] option [, ... ]
where option is
CREATEDB | NOCREATEDB
| CREATEUSER | NOCREATEUSER
| SYSLOG ACCESS { RESTRICTED | UNRESTRICTED }
| PASSWORD { 'password' | 'md5hash' | 'sha256hash' | DISABLE }
[ VALID UNTIL 'expiration_date' ]
| RENAME TO new_name |
| CONNECTION LIMIT { limit | UNLIMITED }
| SESSION TIMEOUT limit | RESET SESSION TIMEOUT
| SET parameter { TO | = } { value | DEFAULT }
| RESET parameter
| EXTERNALID external_id
```
## Parameters
*nom d’utilisateur*
Nom de l’utilisateur.
WITH
Mot-clé facultatif.
CREATEDB \$1 NOCREATEDB
L’option CREATEDB permet à l’utilisateur de créer de nouvelles bases de données. NOCREATEDB est la valeur par défaut.
CREATEUSER \$1 NOCREATEUSER
L’option CREATEUSER crée un super-utilisateur avec tous les privilèges de base de données, y compris CREATE USER. La valeur par défaut est NOCREATEUSER. Pour plus d'informations, consultez [Super-utilisateurs](r_superusers.md).
SYSLOG ACCESS \$1 RESTRICTED \$1 UNRESTRICTED \$1
Clause qui spécifie le niveau d’accès de l’utilisateur sur les tableaux système et les vues Amazon Redshift.
Les utilisateurs ordinaires disposant de l’autorisation SYSLOG ACCESS RESTRICTED peuvent voir uniquement les lignes qu’ils ont générées dans les tables et vues systèmes visibles par l’utilisateur. La valeur par défaut est RESTRICTED.
Les utilisateurs standards ayant l’autorisation SYSLOG ACCESS UNRESTRICTED peuvent voir toutes les lignes des tables et vues systèmes visibles par l’utilisateur, y compris les lignes générées par un autre utilisateur. UNRESTRICTED ne permet pas à un utilisateur standard d’avoir accès aux tableaux visibles du super-utilisateur. Seuls les super-utilisateurs peuvent afficher les données des tableaux visibles des super-utilisateurs.
Accorder à un utilisateur un accès illimité aux tableaux système permet à celui-ci de voir les données générées par d’autres utilisateurs. Par exemple, STL\$1QUERY et STL\$1QUERYTEXT contiennent le texte complet des instructions INSERT, UPDATE et DELETE, qui peuvent contenir des données confidentielles générées par l’utilisateur.
Toutes les lignes de SVV\$1TRANSACTIONS sont visibles de tous les utilisateurs.
Pour plus d’informations, consultez [Visibilité des données dans les tables et vues système](cm_chap_system-tables.md#c_visibility-of-data).
PASSWORD \$1 ’*password*’ \$1 ’*md5hash*’ \$1 ’*sha256hash*’ \$1 DISABLE \$1
Définit le mot de passe de l’utilisateur.
Par défaut, les utilisateurs peuvent modifier leurs propres mots de passe, sauf si le mot de passe est désactivé. Pour désactiver le mot de passe d’un utilisateur, spécifiez DISABLE. Lorsque le mot de passe d'un utilisateur est désactivé, il est supprimé du système et l'utilisateur ne peut se connecter qu'à l'aide d'informations d'identification utilisateur temporaires Gestion des identités et des accès AWS (IAM). Pour plus d’informations, consultez [Utilisation de l’authentification IAM pour générer des informations d’identification de l’utilisateur de base de données](https://docs.aws.amazon.com/redshift/latest/mgmt/generating-user-credentials.html). Seul un super-utilisateur peut activer ou désactiver des mots de passe. Vous ne pouvez pas désactiver le mot de passe d’un super-utilisateur. Pour activer un mot de passe, exécutez ALTER USER et spécifiez un mot de passe.
Pour en savoir plus sur l’utilisation du paramètre PASSWORD, consultez [CREATE USER](r_CREATE_USER.md).
VALID UNTIL ’*date\$1expiration*’
Spécifie que le mot de passe a une date d’expiration. Utilisez la valeur `'infinity'` pour éviter d’avoir une date d’expiration. Le type de données valide pour ce paramètre est timestamp.
Seuls les super-utilisateurs peuvent utiliser ce paramètre.
RENAME TO
Renomme l’utilisateur.
*nouveau\$1nom*
Nouveau nom de l’utilisateur. Pour plus d’informations sur les noms valides, consultez [Noms et identificateurs](r_names.md).
Lorsque vous renommez un utilisateur, vous devez aussi modifier son mot de passe. Le mot de passe de réinitialisation ne doit pas nécessairement être différent du mot de passe précédent. Comme le nom d’utilisateur est utilisé dans le cadre du chiffrement du mot de passe, quand un utilisateur est renommé, le mot de passe est effacé. L’utilisateur ne sera pas en mesure de se connecter tant que le mot de passe n’aura pas été réinitialisé. Par exemple :
```
alter user newuser password 'EXAMPLENewPassword11';
```
CONNECTION LIMIT \$1 *limite* \$1 UNLIMITED \$1
Le nombre maximum de connexions à la base de données que l’utilisateur est autorisé à ouvrir simultanément. La limite se s’applique pas aux super-utilisateurs. Utilisez le mot-clé UNLIMITED pour autoriser le nombre maximum de connexions simultanées. Une limite sur le nombre de connexions pour chaque base de données peut également s’appliquer. Pour plus d'informations, consultez [CREATE DATABASE](r_CREATE_DATABASE.md). La valeur par défaut est UNLIMITED. Pour afficher les connexions en cours, interrogez la vue système [STV\$1SESSIONS](r_STV_SESSIONS.md).
Si les deux limites de connexion (utilisateurs et base de données) s’appliquent, un emplacement de connexion inutilisé situé entre les deux limites doit également être disponible lorsqu’un utilisateur tente de se connecter.
SESSION TIMEOUT *limit* \$1 RESET SESSION TIMEOUT
Durée maximale en secondes pendant laquelle une séance reste inactive ou en veille. La plage est comprise entre 60 secondes (une minute) et 1 728 000 secondes (20 jours). Si aucun délai d’expiration de séance n’est défini pour l’utilisateur, le paramètre de cluster s’applique. Pour plus d’informations, consultez [Quotas et limites dans Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) dans le *Guide de gestion Amazon Redshift*.
Lorsque vous définissez le délai d’expiration de séance, il s’applique uniquement aux nouvelles séances.
Pour afficher des informations sur les séances utilisateur actives, y compris l’heure de début, le nom d’utilisateur et le délai d’expiration de la séance, interrogez la vue système [STV\$1SESSIONS](r_STV_SESSIONS.md). Pour afficher des informations sur l’historique des séances utilisateur, interrogez la vue [STL\$1SESSIONS](r_STL_SESSIONS.md). Pour récupérer des informations sur les utilisateurs de la base de données, y compris les valeurs de délai d’expiration de séance, interrogez la vue [SVL\$1USER\$1INFO](r_SVL_USER_INFO.md).
SET
Définit un paramètre de configuration avec une nouvelle valeur par défaut pour toutes les séances exécutées par l’utilisateur spécifié.
RESET
Réinitialise un paramètre de configuration à la valeur par défaut d’origine de l’utilisateur spécifié.
*paramètre*
Nom du paramètre à définir ou à réinitialiser.
*valeur*
Nouvelle valeur du paramètre.
DEFAULT
Définit le paramètre de configuration avec la valeur par défaut pour toutes les séances exécutées par l’utilisateur spécifié.
EXTERNALID *external\$1id*
Identificateur de l’utilisateur associé à un fournisseur d’identité. Le mot de passe de l’utilisateur doit être désactivé. Pour plus d’informations, consultez [Fédération de fournisseur d’identité natif pour Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-iam-access-control-native-idp.html).
## Notes d’utilisation
+ **Tentative de modification de rdsdb** : vous ne pouvez pas modifier l’utilisateur nommé `rdsdb`.
+ **Création d'un mot de passe inconnu** — Lorsque vous utilisez l'authentification Gestion des identités et des accès AWS (IAM) pour créer des informations d'identification d'utilisateur de base de données, vous souhaiterez peut-être créer un superutilisateur capable de se connecter uniquement à l'aide d'informations d'identification temporaires. Vous ne pouvez pas désactiver le mot de passe d'un superutilisateur, mais vous pouvez créer un mot de passe inconnu à l'aide d'une chaîne de MD5 hachage générée aléatoirement.
```
alter user iam_superuser password 'md51234567890123456780123456789012';
```
+ **Définition de search\$1path** : lorsque vous définissez le paramètre [search\$1path](r_search_path.md) avec la commande ALTER USER, la modification prend effet à la prochaine connexion de l’utilisateur spécifié. Si vous voulez modifier la valeur search\$1path de l’utilisateur et de la séance en cours, utilisez une commande SET.
+ **Définition du fuseau horaire** : lorsque vous utilisez SET TIMEZONE avec la commande ALTER USER, la modification prend effet à la prochaine connexion de l’utilisateur spécifié.
+ **Utilisation de politiques de masquage dynamique des données et de sécurité au niveau des lignes** : lorsque votre cluster provisionné ou votre espace de noms sans serveur est soumis à des politiques de masquage dynamique des données ou de sécurité au niveau des lignes, les commandes suivantes sont bloquées pour les utilisateurs standard :
```
ALTER SET enable_case_sensitive_super_attribute/enable_case_sensitive_identifier/downcase_delimited_identifier
```
Seuls les super-utilisateurs et les utilisateurs disposant du privilège ALTER USER peuvent définir ces options de configuration. Pour plus d’informations sur la sécurité au niveau des lignes, consultez [Sécurité au niveau des lignes](t_rls.md). Pour plus d’informations sur le masquage dynamique des données, consultez [Masquage dynamique des données](t_ddm.md).
## Exemples
L’exemple suivant donne à l’utilisateur ADMIN le privilège de créer des bases de données :
```
alter user admin createdb;
```
L’exemple suivant définit le mot de passe de l’utilisateur ADMIN avec la valeur `adminPass9` et définit une heure et une date d’expiration pour le mot de passe :
```
alter user admin password 'adminPass9'
valid until '2017-12-31 23:59';
```
L’exemple suivant renomme l’utilisateur ADMIN en SYSADMIN :
```
alter user admin rename to sysadmin;
```
L’exemple suivant met à jour le délai d’expiration de la séance en veille pour un utilisateur à 300 secondes.
```
ALTER USER dbuser SESSION TIMEOUT 300;
```
Réinitialise le délai d’expiration de la séance en veille de l’utilisateur. Lorsque vous le réinitialisez, le paramètre de cluster s’applique. Vous devez être un super-utilisateur de la base de données pour exécuter cette commande. Pour plus d’informations, consultez [Quotas et limites dans Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) dans le *Guide de gestion Amazon Redshift*.
```
ALTER USER dbuser RESET SESSION TIMEOUT;
```
L’exemple suivant met à jour l’ID externe d’un utilisateur nommé `bob`. Cet espace de noms est `myco_aad`. Si l’espace de noms n’est pas associé à un fournisseur d’identité enregistré, il en résulte une erreur.
```
ALTER USER myco_aad:bob EXTERNALID "ABC123" PASSWORD DISABLE;
```
L’exemple suivant définit le fuseau horaire pour toutes les sessions exécutées par un utilisateur de base de données spécifique. Il modifie le fuseau horaire pour les sessions ultérieures, mais pas pour celle en cours.
```
ALTER USER odie SET TIMEZONE TO 'Europe/Zurich';
```
L’exemple suivant définit le nombre maximal de connexions à la base de données que l’utilisateur `bob` est autorisé à ouvrir.
```
ALTER USER bob CONNECTION LIMIT 10;
```
# ANALYSE
Met à jour les statistiques de table pour une utilisation par le planificateur de requête.
## Privilèges requis
Les privilèges suivants sont requis pour ANALYZE :
+ Superuser
+ Utilisateurs disposant du privilège ANALYZE
+ Propriétaire de la relation
+ Propriétaire de la base de données avec qui la table est partagée
## Syntaxe
```
ANALYZE [ VERBOSE ]
[ [ table_name [ ( column_name [, ...] ) ] ]
[ PREDICATE COLUMNS | ALL COLUMNS ]
```
## Parameters
VERBOSE
Clause qui renvoie des messages d’information d’avancement relatifs à l’opération ANALYZE. Cette option est utile lorsque vous ne spécifiez pas une table.
*table\$1name*
Vous pouvez analyser des tables spécifiques, y compris les tables temporaires. Vous pouvez qualifier la table avec son nom de schéma. Vous pouvez le cas échéant spécifier un nom\$1table pour analyser une seule table. Vous ne pouvez pas spécifier plus d’un *nom\$1table* avec une seule instruction ANALYZE *nom\$1table*. Si vous ne spécifiez pas un *table\$1name*, toutes les tables de la base de données actuellement connectée sont analysées, y compris les tables persistantes du catalogue système. Amazon Redshift ignore l’analyse d’une table si le pourcentage de lignes qui ont été modifiées depuis la dernière opération ANALYZE est inférieur au seuil d’analyse. Pour plus d'informations, consultez [Seuil d’analyse](#r_ANALYZE-threshold).
Vous n’avez pas besoin d’analyser les tables système Amazon Redshift (tables STL et STV).
*column\$1name*
Si vous spécifiez un *nom\$1table*, vous pouvez également spécifier une ou plusieurs colonnes de la table (au forme de liste de colonnes séparées entre parenthèses). Si une liste de colonnes est spécifiée, seules les colonnes de la liste sont analysées.
PREDICATE COLUMNS \$1 ALL COLUMNS
Clauses qui indiquent si ANALYZE doit inclure uniquement les colonnes de prédicat. Spécifiez PREDICATE COLUMNS pour analyser uniquement les colonnes qui ont été utilisées comme prédicats dans des requêtes précédentes ou qui sont susceptibles d’être utilisées comme prédicats. Spécifiez ALL COLUMNS pour analyser toutes les colonnes. La valeur par défaut est ALL COLUMNS.
Une colonne est incluse dans l’ensemble de colonnes de prédicat si l’une des conditions suivantes est vraie :
+ La colonne a été utilisée dans une requête dans le cadre d’un filtre, d’une condition de jointure ou d’une clause group by.
+ La colonne est une clé de distribution.
+ La colonne fait partie d’une clé de tri.
Si aucune colonne n’est marquée comme colonne de prédicat, par exemple, parce que la table n’a pas encore été interrogée, toutes les colonnes sont analysées même si PREDICATE COLUMNS est spécifié. Dans ce cas, Amazon Redshift peut répondre par un message tel que Aucune colonne de prédicat trouvée pour « ». *table-name* Analyse de toutes les colonnes. Pour plus d’informations sur les colonnes de prédicat, consultez [Analyse des tables](t_Analyzing_tables.md).
## Notes d’utilisation
Amazon Redshift exécute automatiquement les tables que vous créez avec les commandes suivantes :
+ CREATE TABLE AS
+ CREATE TEMP TABLE AS
+ SELECT INTO
Vous ne pouvez pas analyser une table externe.
Vous n’avez pas besoin d’exécuter la commande ANALYZE sur ces tables lorsqu’elles sont créées initialement. Si vous les modifiez, vous devez les analyser de la même manière que les autres tables.
### Seuil d’analyse
Pour réduire le temps de traitement et améliorer les performances globales du système, Amazon Redshift ignore ANALYZE pour une table si le pourcentage de lignes qui ont été modifiées depuis l’exécution de la dernière opération ANALYZE est inférieur au seuil d’analyse spécifié par le paramètre [analyze\$1threshold\$1percent](r_analyze_threshold_percent.md). Par défaut, `analyze_threshold_percent` est 10. Pour modifier `analyze_threshold_percent` de la séance en cours, exécutez la commande [SET](r_SET.md). L’exemple suivant passe de `analyze_threshold_percent` à 20 %.
```
set analyze_threshold_percent to 20;
```
Pour analyser des tables lorsque seul un petit nombre de lignes a changé, définissez `analyze_threshold_percent` sur un petit nombre arbitraire. Par exemple, si vous définissez `analyze_threshold_percent` sur 0,01, une table avec 100 000 000 lignes n’est pas ignorée si au moins 10 000 lignes ont été modifiées.
```
set analyze_threshold_percent to 0.01;
```
Si ANALYZE ignore une table, car il ne respecte pas le seuil d’analyse, Amazon Redshift renvoie le message suivant.
```
ANALYZE SKIP
```
Pour analyser toutes les tables même si aucune ligne n’a été modifiée, définissez `analyze_threshold_percent` sur 0.
Pour afficher les résultats des opérations ANALYZE, interrogez la table système [STL\$1ANALYZE](r_STL_ANALYZE.md).
Pour plus d’informations sur l’analyse des tables, consultez [Analyse des tables](t_Analyzing_tables.md).
## Exemples
Analysez toutes les tables de la base de données TICKIT et renvoyez les informations d’avancement.
```
analyze verbose;
```
Analysez la table LISTING uniquement.
```
analyze listing;
```
Analysez les colonnes VENUEID et VENUENAME de la table VENUE.
```
analyze venue(venueid, venuename);
```
Analysez uniquement les colonnes de prédicat de la table VENUE.
```
analyze venue predicate columns;
```
# ANALYZE COMPRESSION
Effectue l’analyse de compression et produit un rapport avec l’encodage de suppression suggéré pour les tables analysées. Pour chaque colonne, le rapport inclut une estimation de la réduction potentielle sur l’espace du disque par rapport à l’encodage RAW.
## Syntaxe
```
ANALYZE COMPRESSION
[ [ table_name ]
[ ( column_name [, ...] ) ] ]
[COMPROWS numrows]
```
## Parameters
*table\$1name*
Vous pouvez analyser la compression pour des tables spécifiques, y compris les tables temporaires. Vous pouvez qualifier la table avec son nom de schéma. Vous pouvez le cas échéant spécifier un *nom\$1table* pour analyser une seule table. Si vous ne spécifiez pas un *nom\$1table*, toutes les tables de la base de données actuellement connectée sont analysées. Vous ne pouvez pas spécifier plus d’un *nom\$1table* avec une seule instruction ANALYZE COMPRESSION.
*column\$1name*
Si vous spécifiez un *nom\$1table*, vous pouvez également spécifier une ou plusieurs colonnes de la table (au forme de liste de colonnes séparées entre parenthèses).
COMPROWS
Nombre de lignes à utiliser comme taille de l’é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 en tout 4 tranches, pas plus de 250 000 lignes par tranche ne sont lues et analysées. Si COMPROWS n’est pas spécifié, la taille de l’échantillon par défaut est de 100 000 par tranche. Les valeurs COMPROWS inférieures à la valeur par défaut de 100 000 lignes par tranche sont automatiquement mises à niveau avec la valeur par défaut. Cependant, l’analyse de compression ne génère pas de recommandations si la quantité de données dans la table n’est pas suffisante pour produire un échantillon significatif. Si le nombre COMPROWS est supérieur au nombre de lignes de la table, la commande ANALYZE COMPRESSION continue de se poursuivre et exécute l’analyse de la compression sur toutes les lignes disponibles. L’utilisation de COMPROWS entraîne une erreur si aucune table n’est spécifiée.
*numrows*
Nombre de lignes à utiliser comme taille de l’échantillon pour l’analyse de la compression. La plage acceptée pour *numrows* est un nombre compris entre 1000 et 1000000000 (1 000 000 000).
## Notes d’utilisation
ANALYSER COMPRESSION acquiert un verrou de table exclusif, qui empêche les lectures et les écritures simultanées sur la table. Exécutez uniquement la commande COMPRESSION lorsque la table est inactive.
Exécutez ANALYZE COMPRESSION afin d’obtenir des recommandations pour les schémas d’encodage de colonne, en fonction d’un échantillon du contenu de la table. ANALYZE COMPRESSION est un outil consultatif et ne modifie pas les encodages de colonne de la table. Vous pouvez appliquer l’encodage suggéré en recréant la table ou en créant une nouvelle table avec le même schéma. La recréation d’une table non compressée à l’aide de schémas de codage appropriés peut réduire considérablement son encombrement sur le disque. Cette approche permet d’économiser de l’espace disque et d’améliorer les performances des requêtes pour les charges de travail liées aux I/O.
ANALYZE COMPRESSION ignore la phase d’analyse réelle et renvoie directement le type d’encodage d’origine sur n’importe quelle colonne désignée comme SORTKEY. En effet, les analyses limitées à la plage peuvent fonctionner de façon médiocre lorsque les colonnes SORTKEY sont compressées beaucoup plus fortement que les autres colonnes.
## Exemples
L’exemple suivant affiche l’encodage et le pourcentage estimé de réduction pour les colonnes de la table LISTING uniquement :
```
analyze compression listing;
Table | Column | Encoding | Est_reduction_pct
---------+----------------+----------+-------------------
listing | listid | az64 | 40.96
listing | sellerid | az64 | 46.92
listing | eventid | az64 | 53.37
listing | dateid | raw | 0.00
listing | numtickets | az64 | 65.66
listing | priceperticket | az64 | 72.94
listing | totalprice | az64 | 68.05
listing | listtime | az64 | 49.74
```
L’exemple suivant analyse les colonnes QTYSOLD, COMMISSION et SALETIME de la table SALES.
```
analyze compression sales(qtysold, commission, saletime);
Table | Column | Encoding | Est_reduction_pct
-------+------------+----------+-------------------
sales | salesid | N/A | 0.00
sales | listid | N/A | 0.00
sales | sellerid | N/A | 0.00
sales | buyerid | N/A | 0.00
sales | eventid | N/A | 0.00
sales | dateid | N/A | 0.00
sales | qtysold | az64 | 83.06
sales | pricepaid | N/A | 0.00
sales | commission | az64 | 71.85
sales | saletime | az64 | 49.63
```
# ATTACH MASKING POLICY
Attache une politique de masquage dynamique des données existante à une colonne. Pour plus d’informations sur le masquage dynamique des données, consultez [Masquage dynamique des données](t_ddm.md).
Les super-utilisateurs et les utilisateurs ou les rôles disposant du rôle sys:secadmin peuvent attacher une politique de masquage.
## Syntaxe
```
ATTACH MASKING POLICY
{
policy_name ON relation_name
| database_name.policy_name ON database_name.schema_name.relation_name
}
( { output_column_names | output_path } )
[ USING ( { input_column_names | input_path } ) ]
TO { user_name | ROLE role_name | PUBLIC }
[ PRIORITY priority ];
```
## Parameters
*policy\$1name*
Nom de la politique de masquage à attacher.
database\$1name
Nom de la base de données dans laquelle la politique et la relation sont créées. La politique et la relation doivent figurer dans la même base de données. La base de données peut être la base de données connectée ou une base de données qui prend en charge les autorisations fédérées Amazon Redshift.
nom\$1schéma
Nom du schéma auquel appartient la relation.
*relation\$1name*
Nom de la relation à laquelle attacher la politique de masquage.
*output\$1column\$1names*
Noms des colonnes auxquelles la politique de masquage s’appliquera.
*output\$1paths*
Chemin complet de l’objet SUPER auquel la politique de masquage s’appliquera, y compris le nom de colonne. Par exemple, pour une relation avec une colonne de type SUPER nommée `person`, *output\$1path* peut être `person.name.first_name`.
*input\$1column\$1names*
Noms des colonnes que la politique de masquage prendra comme entrées. Ce paramètre est facultatif. S’il n’est pas spécifié, la politique de masquage utilise *output\$1column\$1names* comme entrées.
*input\$1paths*
Chemin complet de l’objet SUPER que la politique de masquage prendra comme entrée. Ce paramètre est facultatif. S’il n’est pas spécifié, la politique de masquage utilise *output\$1path* pour les entrées.
*user\$1name*
Nom de l’utilisateur auquel la politique de masquage s’attachera. Vous ne pouvez pas attacher deux politiques à la même combinaison d’utilisateur et de colonne, ou de rôle et de colonne. Vous pouvez attacher une politique à un utilisateur et une autre politique au rôle de l’utilisateur. Dans ce cas, la politique ayant la priorité la plus élevée s’applique.
Vous ne pouvez définir qu’un seul user\$1name, role\$1name et PUBLIC dans une seule commande ATTACH MASKING POLICY.
*role\$1name*
Nom du rôle auquel la politique de masquage s’attachera. Vous ne pouvez pas associer deux politiques à la même column/role paire. Vous pouvez attacher une politique à un utilisateur et une autre politique au rôle de l’utilisateur. Dans ce cas, la politique ayant la priorité la plus élevée s’applique.
Vous ne pouvez définir qu’un seul user\$1name, role\$1name et PUBLIC dans une seule commande ATTACH MASKING POLICY.
*PUBLIC*
Attache la politique de masquage à tous les utilisateurs accédant à la table. Pour qu'elles s'appliquent, vous devez accorder aux autres politiques de masquage attachées à des column/role paires column/user ou à des spécifiques une priorité supérieure à la politique PUBLIQUE.
Vous ne pouvez définir qu’un seul user\$1name, role\$1name et PUBLIC dans une seule commande ATTACH MASKING POLICY.
*priority*
Priorité de la politique de masquage. Lorsque plusieurs politiques de masquage s’appliquent à la requête d’un utilisateur donné, la politique de priorité la plus élevée s’applique.
Vous ne pouvez pas attacher deux politiques différentes à la même colonne avec la même priorité, même si les deux politiques sont attachées à différents utilisateurs ou rôles. Vous pouvez associer la même politique plusieurs fois au même ensemble de paramètres de table, de colonne de sortie, de colonne d’entrée et de priorité, à condition que l’utilisateur ou le rôle auquel la politique est attachée soit différent à chaque fois.
Vous ne pouvez pas appliquer de politique à une colonne ayant la même priorité qu’une autre politique attachée à cette colonne, même si elles concernent des rôles différents. Ce champ est facultatif. Si vous ne spécifiez pas de priorité, la politique de masquage attache par défaut une priorité de 0.
Pour l'utilisation de la politique de masquage des pièces jointes dans le catalogue d'autorisations fédérées Amazon Redshift, [consultez la section Gestion du contrôle d'accès avec les autorisations fédérées Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/dg/federated-permissions-managing-access.html).
# ATTACH RLS POLICY
Attachez une politique de sécurité au niveau des lignes sur une table à un ou plusieurs utilisateurs ou rôles.
Les super-utilisateurs et les utilisateurs ou les rôles qui disposent du rôle `sys:secadmin` peuvent attacher une stratégie.
## Syntaxe
```
ATTACH RLS POLICY
{
policy_name ON [TABLE] table_name [, ...]
| database_name.policy_name ON [TABLE] database_name.schema_name.table_name [, ...]
}
TO { user_name | ROLE role_name | PUBLIC } [, ...]
```
## Parameters
*policy\$1name*
Nom de la politique .
database\$1name
Nom de la base de données dans laquelle la politique et la relation sont créées. La politique et la relation doivent figurer dans la même base de données. La base de données peut être la base de données connectée ou une base de données qui prend en charge les autorisations fédérées Amazon Redshift.
nom\$1schéma
Nom du schéma auquel appartient la relation.
table\$1name
Relation à laquelle la politique de sécurité au niveau des lignes est attachée.
TO \$1 *user\$1name* \$1 ROLE *role\$1name* \$1 PUBLIC\$1 [, ...]
Spécifie si la politique est attachée à un ou plusieurs utilisateurs ou rôles spécifiés.
Pour l'utilisation de la POLITIQUE RLS ATTACH sur le catalogue d'autorisations fédérées Amazon Redshift, [consultez la section Gestion du contrôle d'accès avec les autorisations fédérées Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/dg/federated-permissions-managing-access.html).
## Notes d’utilisation
Lorsque vous utilisez l’instruction ATTACH RLS POLICY, tenez compte des points suivants :
+ La table attachée doit contenir toutes les colonnes répertoriées dans la clause WITH de l’instruction de création de la stratégie.
+ Amazon Redshift RLS permet d’attacher des politiques RLS aux objets suivants :
+ Tables
+ Vues
+ Vues à liaison tardive
+ Vues matérialisées
+ Amazon Redshift RLS ne permet pas d’associer des politiques RLS aux objets suivants :
+ Tables de catalogue
+ Relations entre bases de données
+ Tables externes
+ Tables temporaires
+ Tables de recherche de politiques
+ Tables de base de vues matérialisées
+ Les politiques RLS attachées à des super-utilisateurs ou à des utilisateurs disposant de l’autorisation `sys:secadmin` sont ignorées.
## Exemples
L’exemple suivant attache une politique RLS à la table et aux combinaisons de rôles spécifiées. La politique RLS s’applique à tous les utilisateurs ayant le rôle `analyst` ou `dbadmin` accédant à la table tickit\$1category\$1redshift.
```
ATTACH RLS POLICY policy_concerts ON tickit_category_redshift TO ROLE analyst, ROLE dbadmin;
```
# BEGIN
Démarre une transaction. Synonyme de START TRANSACTION.
Une transaction est une même unité de travail logique qui se compose d’une commande ou de plusieurs commandes. En général, toutes les commandes d’une transaction s’exécutent sur un instantané de la base de données dont l’heure de démarrage est déterminée par la valeur définie pour le paramètre de configuration `transaction_snapshot_begin`.
Par défaut, les opérations Amazon Redshift (requêtes, instructions DDL, charges) sont automatiquement validées sur la base de données. Si vous souhaitez suspendre la validation d’une opération jusqu’à la fin de la tâche suivante, vous devez ouvrir une transaction avec l’instruction BEGIN, exécuter les commandes nécessaires et fermer la transaction avec une instruction [COMMIT](r_COMMIT.md) ou [FIN](r_END.md). Si nécessaire, vous pouvez utiliser une instruction [ROLLBACK](r_ROLLBACK.md) pour arrêter une transaction en cours. Une exception à ce comportement est la commande [TRUNCATE](r_TRUNCATE.md), qui valide la transaction dans laquelle elle est exécutée et ne peut pas être annulée.
## Syntaxe
```
BEGIN [ WORK | TRANSACTION ] [ ISOLATION LEVEL option ] [ READ WRITE | READ ONLY ]
START TRANSACTION [ ISOLATION LEVEL option ] [ READ WRITE | READ ONLY ]
Where option is
SERIALIZABLE
| READ UNCOMMITTED
| READ COMMITTED
| REPEATABLE READ
Note: READ UNCOMMITTED, READ COMMITTED, and REPEATABLE READ have no
operational impact and map to SERIALIZABLE in Amazon Redshift. You can see database isolation levels on your cluster
by querying the stv_db_isolation_level table.
```
## Parameters
WORK
Mot-clé facultatif.
TRANSACTION
Mot-clé facultatif ; WORK et TRANSACTION sont synonymes.
ISOLATION LEVEL SERIALIZABLE
Comme l’isolement sérialisable est pris en charge par défaut, le comportement de la transaction est le même, que cette syntaxe soit incluse ou pas dans l’instruction. Pour plus d'informations, consultez [Gestion des opérations d’écriture simultanées](c_Concurrent_writes.md). Aucun autre niveau d’isolement n’est pris en charge.
Le langage SQL standard définit quatre niveaux d’isolement des transactions afin d’éviter les *lectures non validées* (où une transaction lit les données écrites par une transaction simultanée non validée), les *lectures non reproductibles* (où une transaction relit les données qu’elle a lues précédemment et découvre que les données ont été modifiées par une autre transaction qui les a validées depuis la lecture initiale), et les *lectures fantôme* (où une opération ré-exécute une requête, renvoie un ensemble de lignes qui satisfont à une condition de recherche et découvre que l’ensemble des lignes a changé en raison d’une autre transaction récemment validée) :
+ Lecture non validée : lectures non validées, lectures non reproductibles et lectures fantôme possibles.
+ Lecture validée : lectures non reproductibles et lectures fantôme possibles.
+ Lecture reproductible : lectures fantôme possibles.
+ Sérialisable : empêche les lectures non validées, les lectures non reproductibles et les lectures fantôme.
Même si vous pouvez utiliser n’importe lequel des quatre niveaux d’isolement des transactions, Amazon Redshift traite tous les niveaux d’isolement comme sérialisables.
READ WRITE
Accorde à la transaction les autorisations en lecture et en écriture.
READ ONLY
Accorde à la transaction les autorisations en lecture seule.
## Exemples
L’exemple suivant démarre un bloc de transaction sérialisable :
```
begin;
```
L’exemple suivant démarre le bloc de transaction par un niveau d’isolement sérialisable, et les autorisations en lecture et écriture :
```
begin read write;
```
# CALL
Exécute une procédure stockée. La commande CALL doit inclure le nom de la procédure ainsi que les valeurs des arguments en entrée. Vous devez appeler une procédure stockée à l’aide de l’instruction CALL.
**Note**
CALL ne peut pas faire partie d’une requête classique.
## Syntaxe
```
CALL sp_name ( [ argument ] [, ...] )
```
## Parameters
*sp\$1name*
Nom de la procédure à exécuter.
*argument*
Type de valeur de l’argument en entrée. Ce paramètre peut également être un nom de fonction, par exemple `pg_last_query_id()`. Vous pouvez utiliser les requêtes en tant qu’arguments CALL.
## Notes d’utilisation
Les procédures stockées Amazon Redshift prennent en charge les appels imbriqués et récursifs, comme décrit ci-dessous. En outre, assurez-vous que l'assistance de votre chauffeur est up-to-date également décrite ci-dessous.
**Topics**
+ [Appels imbriqués](#r_CALL_procedure-nested-calls)
+ [Prise en charge du pilote](#r_CALL_procedure-driver-support)
### Appels imbriqués
Les procédures stockées Amazon Redshift prennent en charge les appels imbriqués et récursifs. Le nombre maximal de niveaux d’imbrication autorisé est 16. Les appels imbriqués peuvent encapsuler la logique métier en procédures plus petites, pouvant être partagées par plusieurs appelants.
Si vous appelez une procédure imbriquée comportant des paramètres de sortie, la procédure interne doit définir des arguments INOUT. Dans ce cas, la procédure interne est transmise dans une variable non constante. Les arguments OUT ne sont pas autorisés. Ce comportement se produit car une variable est nécessaire pour contenir la sortie de l’appel interne.
Cette relation entre les procédures internes et externes est enregistrée dans la colonne `from_sp_call` de [SVL\$1STORED\$1PROC\$1CALL](r_SVL_STORED_PROC_CALL.md).
L’exemple suivant illustre la transmission de variables à un appel de procédure imbriquée via des arguments INOUT.
```
CREATE OR REPLACE PROCEDURE inner_proc(INOUT a int, b int, INOUT c int) LANGUAGE plpgsql
AS $$
BEGIN
a := b * a;
c := b * c;
END;
$$;
CREATE OR REPLACE PROCEDURE outer_proc(multiplier int) LANGUAGE plpgsql
AS $$
DECLARE
x int := 3;
y int := 4;
BEGIN
DROP TABLE IF EXISTS test_tbl;
CREATE TEMP TABLE test_tbl(a int, b varchar(256));
CALL inner_proc(x, multiplier, y);
insert into test_tbl values (x, y::varchar);
END;
$$;
CALL outer_proc(5);
SELECT * from test_tbl;
a | b
----+----
15 | 20
(1 row)
```
### Prise en charge du pilote
Nous vous recommandons de mettre à niveau vos pilotes JDBC (Java Database Connectivity) et OBDC (Open Database Connectivity) avec la dernière version, qui prend en charge les procédures stockées Amazon Redshift.
Vous pourrez peut-être utiliser votre pilote existant si votre outil client utilise les opération d’API transmises au serveur via l’instruction CALL. Les paramètres de sortie, le cas échéant, sont renvoyés sous la forme d’un ensemble de résultats d’une ligne.
Les dernières versions des pilotes JDBC et ODBC Amazon Redshift prennent en charge les métadonnées pour la détection de procédures stockées. Elles offrent également une prise en charge `CallableStatement` pour les applications Java personnalisées. Pour plus d’informations sur les pilotes, consultez [Connexion à un cluster Amazon Redshift à l’aide des outils clients SQL](https://docs.aws.amazon.com/redshift/latest/mgmt/connecting-to-cluster.html) dans le *Guide de gestion Amazon Redshift*.
Les exemples suivants montrent comment utiliser différentes opérations d’API du pilote JDBC pour les appels de procédures stockées.
```
void statement_example(Connection conn) throws SQLException {
statement.execute("CALL sp_statement_example(1)");
}
void prepared_statement_example(Connection conn) throws SQLException {
String sql = "CALL sp_prepared_statement_example(42, 84)";
PreparedStatement pstmt = conn.prepareStatement(sql);
pstmt.execute();
}
void callable_statement_example(Connection conn) throws SQLException {
CallableStatement cstmt = conn.prepareCall("CALL sp_create_out_in(?,?)");
cstmt.registerOutParameter(1, java.sql.Types.INTEGER);
cstmt.setInt(2, 42);
cstmt.executeQuery();
Integer out_value = cstmt.getInt(1);
}
```
## Exemples
L’exemple suivant appelle le nom de procédure `test_spl`.
```
call test_sp1(3,'book');
INFO: Table "tmp_tbl" does not exist and will be skipped
INFO: min_val = 3, f2 = book
```
L’exemple suivant appelle le nom de procédure `test_spl2`.
```
call test_sp2(2,'2019');
f2 | column2
---------------------+---------
2019+2019+2019+2019 | 2
(1 row)
```
# ANNULER
Annule une requête de base de données qui s’exécute simultanément.
La commande CANCEL nécessite l’ID de processus ou l’ID de session de la requête en cours d’exécution et affiche un message de confirmation pour vérifier que la requête a été annulée.
## Privilèges requis
Les privilèges suivants sont requis pour CANCEL :
+ Super-utilisateur annulant sa propre requête
+ Super-utilisateur annulant la requête d’un utilisateur
+ Utilisateurs disposant du privilège CANCEL et annulant la requête d’un utilisateur
+ Utilisateur annulant sa propre requête
## Syntaxe
```
CANCEL process_id [ 'message' ]
```
## Parameters
*process\$1id*
Pour annuler une requête exécutée dans un cluster Amazon Redshift, utilisez l’`pid` (ID de processus) du [STV\$1RECENTS](r_STV_RECENTS.md) correspondant à la requête que vous souhaitez annuler.
Pour annuler une requête exécutée dans un groupe de travail Amazon Redshift sans serveur, utilisez l’`session_id` du [SYS\$1QUERY\$1HISTORY](SYS_QUERY_HISTORY.md) correspondant à la requête que vous souhaitez annuler.
’*message*’
Message de confirmation facultatif qui s’affiche lorsque l’annulation de la requête est terminée. Si vous ne spécifiez pas un message, Amazon Redshift affiche le message par défaut en tant que vérification. Vous devez placer le message entre guillemets simples.
## Notes d’utilisation
Vous ne pouvez pas annuler une requête en spécifiant un *ID de requête* ; vous devez spécifier l’*ID de processus* (PID) ou l’*ID de session* de la requête. Vous pouvez uniquement annuler les requêtes exécutées simultanément par votre utilisateur. Les super-utilisateurs peuvent annuler toutes les requêtes.
Si les requêtes de plusieurs séances maintiennent des verrous sur la même table, vous pouvez utiliser la fonction [PG\$1TERMINATE\$1BACKEND](PG_TERMINATE_BACKEND.md) pour mettre fin à l’une des séances. Cela oblige toutes les transactions en cours d’exécution dans la séance terminée à libérer tous les verrous et à restaurer la transaction. Interrogez la table système [STV\$1LOCKS](r_STV_LOCKS.md) pour afficher les verrous actuellement détenus.
Suite à certains événements internes, Amazon Redshift peut redémarrer une séance active et attribuer un nouveau PID. Si le PID a été modifié, vous pourriez recevoir le message d’erreur suivant :
```
Session does not exist. The session PID might have changed. Check the stl_restarted_sessions system table for details.
```
Pour trouver le nouveau PID, interrogez la table système [STL\$1RESTARTED\$1SESSIONS](r_STL_RESTARTED_SESSIONS.md) et filtrez sur la colonne `oldpid`.
```
select oldpid, newpid from stl_restarted_sessions where oldpid = 1234;
```
## Exemples
Pour annuler une requête en cours d’exécution dans un cluster Amazon Redshift, récupérez d’abord l’ID de processus de la requête que vous voulez annuler. Pour déterminer le processus IDs de toutes les requêtes en cours d'exécution, tapez la commande suivante :
```
select pid, starttime, duration,
trim(user_name) as user,
trim (query) as querytxt
from stv_recents
where status = 'Running';
pid | starttime | duration | user | querytxt
-----+----------------------------+----------+----------+-----------------
802 | 2008-10-14 09:19:03.550885 | 132 | dwuser | select
venuename from venue where venuestate='FL', where venuecity not in
('Miami' , 'Orlando');
834 | 2008-10-14 08:33:49.473585 | 1250414 | dwuser | select *
from listing;
964 | 2008-10-14 08:30:43.290527 | 326179 | dwuser | select
sellerid from sales where qtysold in (8, 10);
```
Vérifiez le texte de la requête pour déterminer quel identifiant de processus (PID) correspond à la requête que vous voulez annuler.
Tapez la commande suivante pour utiliser le PID 802 afin d’annuler cette requête :
```
cancel 802;
```
La séance au cours de laquelle la requête était en cours d’exécution affiche le message suivant :
```
ERROR: Query (168) cancelled on user's request
```
où `168` est l’ID de la requête (pas l’ID du processus utilisé pour annuler la requête).
Sinon, vous pouvez spécifier un message de confirmation personnalisé à afficher à la place du message par défaut. Pour spécifier un message personnalisé, incluez votre message entre guillemets simples à la fin de la commande CANCEL :
```
cancel 802 'Long-running query';
```
La séance au cours de laquelle la requête était en cours d’exécution affiche le message suivant :
```
ERROR: Long-running query
```
# CLOSE
(Facultatif) Ferme toutes les ressources disponibles associées à un curseur ouvert. Comme [COMMIT](r_COMMIT.md), [FIN](r_END.md) et [ROLLBACK](r_ROLLBACK.md) ferment automatiquement le curseur, il n’est pas nécessaire d’utiliser la commande CLOSE pour fermer explicitement le curseur.
Pour plus d’informations, consultez [DECLARE](declare.md), [FETCH](fetch.md).
## Syntaxe
```
CLOSE cursor
```
## Parameters
*curseur*
Nom du curseur à fermer.
## Exemple CLOSE
Les commandes suivantes ferment le curseur et effectuent une validation, ce qui met fin à la transaction :
```
close movie_cursor;
commit;
```
# COMMENT
Crée ou modifie un commentaire relatif à un objet de base de données.
## Syntaxe
```
COMMENT ON
{
TABLE object_name |
COLUMN object_name.column_name |
CONSTRAINT constraint_name ON table_name |
DATABASE object_name |
VIEW object_name
}
IS 'text' | NULL
```
## Parameters
*nom d’objet*
Nom de l’objet de base de données auquel s’applique le commentaire. Vous pouvez ajouter un commentaire aux objets suivants :
+ TABLE
+ COLUMN (accepte également un *nom\$1colonne*).
+ CONSTRAINT (accepte également un *nom\$1contrainte* et un *nom\$1table*).
+ DATABASE
+ VIEW
+ SCHEMA (SCHÉMA)
IS ’*text*’ \$1 NULL
Le texte du commentaire que vous souhaitez ajouter ou remplacer pour l’objet spécifié. La chaîne de *texte* est de type TEXT. Placez le commentaire entre guillemets simples. Spécifiez la valeur sur NULL pour supprimer le texte du commentaire.
*column\$1name*
Nom de la colonne commentée. Paramètre de COLUMN. Suit une table spécifiée dans `object_name`.
*nom\$1contrainte*
Nom de la contrainte commentée. Paramètre de CONSTRAINT.
*table\$1name*
Nom d’une table contenant la contrainte. Paramètre de CONSTRAINT.
## Notes d’utilisation
Vous devez être un superutilisateur ou le propriétaire d’un objet de la base de données pour ajouter ou mettre à jour un commentaire.
Les commentaires sur les bases de données ne peuvent s’appliquer qu’à la base de données en cours. Un message d’avertissement s’affiche si vous essayez de faire un commentaire sur une autre base de données. Le même avertissement s’affiche pour les commentaires sur les bases de données qui n’existent pas.
Les commentaires sur les tables externes, les colonnes externes et les colonnes des vues à liaison tardive ne sont pas pris en charge.
## Exemples
L’exemple suivant ajoute un commentaire à la table SALES.
```
COMMENT ON TABLE sales IS 'This table stores tickets sales data';
```
L’exemple suivant affiche le commentaire sur la table SALES.
```
select obj_description('public.sales'::regclass);
obj_description
-------------------------------------
This table stores tickets sales data
```
L’exemple suivant supprime un commentaire de la table SALES.
```
COMMENT ON TABLE sales IS NULL;
```
L’exemple suivant ajoute un commentaire à la colonne EVENTID de la table SALES.
```
COMMENT ON COLUMN sales.eventid IS 'Foreign-key reference to the EVENT table.';
```
L’exemple suivant affiche un commentaire sur la colonne EVENTID (colonne numéro 5) de la table SALES.
```
select col_description( 'public.sales'::regclass, 5::integer );
col_description
-----------------------------------------
Foreign-key reference to the EVENT table.
```
L’exemple suivant ajoute un commentaire descriptif à la table EVENT.
```
comment on table event is 'Contains listings of individual events.';
```
Pour afficher les commentaires, interrogez le catalogue système PG\$1DESCRIPTION. L’exemple suivant renvoie la description de la table EVENT.
```
select * from pg_catalog.pg_description
where objoid =
(select oid from pg_class where relname = 'event'
and relnamespace =
(select oid from pg_catalog.pg_namespace where nspname = 'public') );
objoid | classoid | objsubid | description
-------+----------+----------+----------------------------------------
116658 | 1259 | 0 | Contains listings of individual events.
```
# COMMIT
Valide la transaction actuelle sur la base de données. Cette commande rend permanentes les mises à jour de base de données de la transaction.
## Syntaxe
```
COMMIT [ WORK | TRANSACTION ]
```
## Parameters
WORK
Mot-clé facultatif. Ce mot-clé n’est pas pris en charge dans une procédure stockée.
TRANSACTION
Mot-clé facultatif. WORK et TRANSACTION sont synonymes. Aucun des deux n’est pris en charge dans une procédure stockée.
Pour obtenir des informations sur l’utilisation de l’instruction COMMIT dans une procédure stockée, consultez [Gestion des transactions](stored-procedure-transaction-management.md).
## Exemples
Chacun des exemples suivants valide la transaction en cours sur la base de données :
```
commit;
```
```
commit work;
```
```
commit transaction;
```
# COPY
| |
| --- |
| Le chiffrement côté client pour les commandes COPY et UNLOAD ne sera plus ouvert aux nouveaux clients à compter du 30 avril 2025. Si vous avez utilisé le chiffrement côté client avec les commandes COPY et UNLOAD au cours des 12 mois précédant le 30 avril 2025, vous pouvez continuer à utiliser le chiffrement côté client avec les commandes COPY ou UNLOAD jusqu’au 30 avril 2026. Après le 30 avril 2026, vous ne pourrez plus utiliser le chiffrement côté client pour COPY et UNLOAD. Nous vous recommandons de passer au chiffrement côté serveur pour COPY et UNLOAD dès que possible. Si vous utilisez déjà le chiffrement côté serveur pour COPY et UNLOAD, il n’y a aucun changement et vous pouvez continuer à l’utiliser sans modifier vos requêtes. Pour plus d’informations sur le chiffrement pour COPY et UNLOAD, consultez le paramètre ENCRYPTED ci-dessous. |
Charge des données dans une table depuis des fichiers de données ou une table Amazon DynamoDB. Les fichiers peuvent être situés dans un compartiment Amazon Simple Storage Service (Amazon S3), un cluster Amazon EMR ou un hôte distant auquel on accède à l’aide d’une connexion SSH (Secure Shell).
**Note**
Les tables externes d’Amazon Redshift Spectrum sont en lecture seule. Vous ne pouvez pas copier (COPY) une table externe.
La commande COPY ajoute les données d’entrée à la table sous forme de lignes supplémentaires.
La taille maximale d’une seule ligne d’entrée à partir de n’importe quelle source est de 4 Mo.
**Topics**
+ [Autorisations requises](#r_COPY-permissions)
+ [Syntaxe de la commande COPY](#r_COPY-syntax)
+ [Paramètres requis](#r_COPY-syntax-required-parameters)
+ [Paramètres facultatifs](#r_COPY-syntax-overview-optional-parameters)
+ [Notes d’utilisation et ressources supplémentaires pour la commande COPY](#r_COPY-using-the-copy-command)
+ [Exemples de commandes COPY](#r_COPY-using-the-copy-command-examples)
+ [COPY JOB](r_COPY-JOB.md)
+ [COPIER avec TEMPLATE](r_COPY-WITH-TEMPLATE.md)
+ [Description des paramètres de la commande COPY](r_COPY-parameters.md)
+ [Notes d’utilisation](r_COPY_usage_notes.md)
+ [Exemples de commandes COPY](r_COPY_command_examples.md)
## Autorisations requises
Pour utiliser la commande COPY, vous devez avoir le privilège [INSERT](r_GRANT.md#grant-insert) pour la table Amazon Redshift.
## Syntaxe de la commande COPY
```
COPY table-name
[ column-list ]
FROM data_source
authorization
[ [ FORMAT ] [ AS ] data_format ]
[ parameter [ argument ] [, ... ] ]
```
Vous pouvez effectuer une opération COPY avec aussi peu que trois paramètres : un nom de table, une source de données et l’autorisation d’accéder aux données.
Amazon Redshift étend la fonctionnalité de la commande COPY pour vous permettre de charger les données dans plusieurs formats de données à partir de plusieurs sources de données, de contrôler l’accès pour charger les données, de gérer les transformations des données et de gérer l’opération de chargement.
Les sections suivantes présentent les paramètres de la commande COPY requis et regroupent les paramètres facultatifs par fonction. Elles décrivent également chaque paramètre et expliquent comment différentes options fonctionnent ensemble. Vous pouvez accéder directement à une description du paramètre à l’aide de la liste alphabétique des paramètres.
## Paramètres requis
La commande COPY nécessite trois éléments :
+ [Table Name](#r_COPY-syntax-overview-table-name)
+ [Data Source](#r_COPY-syntax-overview-data-source)
+ [Authorization](#r_COPY-syntax-overview-credentials)
La commande COPY la plus simple utilise le format suivant.
```
COPY table-name
FROM data-source
authorization;
```
L’exemple suivant crée une table nommée CATDEMO et puis charge la table avec des exemples de données à partir d’un fichier de données dans Amazon S3 nommé `category_pipe.txt`.
```
create table catdemo(catid smallint, catgroup varchar(10), catname varchar(10), catdesc varchar(50));
```
Dans l’exemple suivant, la source de données de la commande COPY est un fichier de données nommé `category_pipe.txt` dans le dossier `tickit` d’un compartiment Amazon S3 nommé `redshift-downloads`. La commande COPY est autorisée à accéder au compartiment Amazon S3 via un rôle Gestion des identités et des accès AWS (IAM). Si votre cluster comporte un rôle IAM existant avec la permission d’accès à Amazon S3 attaché, vous pouvez remplacer le nom Amazon Resource Name (ARN) de votre rôle dans la commande COPY suivante et l’exécuter.
```
copy catdemo
from 's3://redshift-downloads/tickit/category_pipe.txt'
iam_role 'arn:aws:iam:::role/'
region 'us-east-1';
```
Pour obtenir des instructions complètes sur l'utilisation des commandes COPY pour charger des échantillons de données, y compris des instructions pour charger des données provenant d'autres AWS régions, consultez la section [Charger des échantillons de données depuis Amazon S3](https://docs.aws.amazon.com/redshift/latest/gsg/rs-gsg-create-sample-db.html) dans le guide de démarrage Amazon Redshift.
*table-name*
Nom de la table cible de la commande COPY. La table doit déjà exister dans la base de données. La table peut être temporaire ou permanente. La commande COPY ajoute les nouvelles données d’entrée à toutes les lignes existantes de la table.
FROM *data-source*
Emplacement des données source à charger dans la table cible. Un fichier manifeste peut être spécifié avec des sources de données.
Le référentiel de données le plus couramment utilisé est un compartiment Amazon S3. Vous pouvez également charger des fichiers de données situés dans un cluster Amazon EMR, une instance Amazon EC2 ou un hôte distant auquel votre cluster peut accéder à l’aide d’une connexion SSH, ou vous pouvez charger directement depuis une table DynamoDB.
+ [Commande COPY depuis Amazon S3](copy-parameters-data-source-s3.md)
+ [Commande COPY depuis Amazon EMR](copy-parameters-data-source-emr.md)
+ [Exécution de la commande COPY à partir de l’hôte distant (SSH)](copy-parameters-data-source-ssh.md)
+ [Commande COPY depuis Amazon DynamoDB](copy-parameters-data-source-dynamodb.md)
Autorisation
Clause qui indique la méthode utilisée par votre cluster pour l'authentification et l'autorisation d'accéder à d'autres AWS ressources. La commande COPY nécessite une autorisation pour accéder aux données d'une autre AWS ressource, notamment Amazon S3, Amazon EMR, Amazon DynamoDB et Amazon EC2. Vous pouvez fournir cette autorisation en faisant référence à un rôle IAM qui est attaché à votre cluster ou en fournissant l’ID de clé d’accès et la clé d’accès secrète pour un utilisateur IAM.
+ [Paramètres d’autorisation](copy-parameters-authorization.md)
+ [Contrôle d’accès basé sur les rôles](copy-usage_notes-access-permissions.md#copy-usage_notes-access-role-based)
+ [Contrôle d’accès basé sur les clés](copy-usage_notes-access-permissions.md#copy-usage_notes-access-key-based)
## Paramètres facultatifs
Le cas échéant, vous pouvez spécifier comment la commande COPY mappe les données de champ aux colonnes dans la table cible, définir les attributs de données source pour activer la commande COPY afin de lire et d’analyser correctement les données source et gérer les opérations que la commande COPY effectue pendant le processus de chargement.
+ [Options de mappage de colonnes](copy-parameters-column-mapping.md)
+ [Paramètres du format de données](#r_COPY-syntax-overview-data-format)
+ [Paramètres de conversion de données](#r_COPY-syntax-overview-data-conversion)
+ [Opérations de chargement de données](#r_COPY-syntax-overview-data-load)
### Mappage de colonnes
Par défaut, la commande COPY insère des valeurs de champ dans les colonnes de la table cible dans le même ordre que les champs se présentent dans les fichiers de données. Si l'ordre des colonnes par défaut ne fonctionne pas, vous pouvez spécifier une liste de colonnes ou utiliser des JSONPath expressions pour mapper les champs de données source aux colonnes cibles.
+ [Column List](copy-parameters-column-mapping.md#copy-column-list)
+ [JSONPaths File](copy-parameters-column-mapping.md#copy-column-mapping-jsonpaths)
### Paramètres du format de données
Vous pouvez charger les données à partir de fichiers texte au format JSON, dans des fichiers de valeurs séparées par des virgules, par des caractères, à largeur fixe (CSV), ou à partir de fichiers Avro.
Par défaut, la commande COPY attend que les données source se trouvent dans des fichiers texte UTF-8 séparés par des caractères. Le délimiteur par défaut est une barre verticale ( \$1 ). Si les données source sont dans un autre format, utilisez les paramètres suivants pour spécifier le format des données.
+ [FORMAT](copy-parameters-data-format.md#copy-format)
+ [CSV](copy-parameters-data-format.md#copy-csv)
+ [DELIMITER](copy-parameters-data-format.md#copy-delimiter)
+ [FIXEDWIDTH](copy-parameters-data-format.md#copy-fixedwidth)
+ [SHAPEFILE](copy-parameters-data-format.md#copy-shapefile)
+ [AVRO](copy-parameters-data-format.md#copy-avro)
+ [JSON format for COPY](copy-parameters-data-format.md#copy-json)
+ [ENCRYPTED](copy-parameters-data-source-s3.md#copy-encrypted)
+ [BZIP2](copy-parameters-file-compression.md#copy-bzip2)
+ [GZIP](copy-parameters-file-compression.md#copy-gzip)
+ [LZOP](copy-parameters-file-compression.md#copy-lzop)
+ [PARQUET](copy-parameters-data-format.md#copy-parquet)
+ [ORC](copy-parameters-data-format.md#copy-orc)
+ [ZSTD](copy-parameters-file-compression.md#copy-zstd)
### Paramètres de conversion de données
Lorsqu’elle charge la table, la commande COPY tente implicitement de convertir les chaînes dans les données source vers le type de données de la colonne cible. Si vous devez spécifier une conversion qui est différente du comportement par défaut, ou si la conversion par défaut entraîne des erreurs, vous pouvez gérer les conversions de données en spécifiant les paramètres suivants.
+ [ACCEPTANYDATE](copy-parameters-data-conversion.md#copy-acceptanydate)
+ [ACCEPTINVCHARS](copy-parameters-data-conversion.md#copy-acceptinvchars)
+ [BLANKSASNULL](copy-parameters-data-conversion.md#copy-blanksasnull)
+ [DATEFORMAT](copy-parameters-data-conversion.md#copy-dateformat)
+ [EMPTYASNULL](copy-parameters-data-conversion.md#copy-emptyasnull)
+ [ENCODING](copy-parameters-data-conversion.md#copy-encoding)
+ [ESCAPE](copy-parameters-data-conversion.md#copy-escape)
+ [EXPLICIT_IDS](copy-parameters-data-conversion.md#copy-explicit-ids)
+ [FILLRECORD](copy-parameters-data-conversion.md#copy-fillrecord)
+ [IGNOREBLANKLINES](copy-parameters-data-conversion.md#copy-ignoreblanklines)
+ [IGNOREHEADER](copy-parameters-data-conversion.md#copy-ignoreheader)
+ [NULL AS](copy-parameters-data-conversion.md#copy-null-as)
+ [REMOVEQUOTES](copy-parameters-data-conversion.md#copy-removequotes)
+ [ROUNDEC](copy-parameters-data-conversion.md#copy-roundec)
+ [TIMEFORMAT](copy-parameters-data-conversion.md#copy-timeformat)
+ [TRIMBLANKS](copy-parameters-data-conversion.md#copy-trimblanks)
+ [TRUNCATECOLUMNS](copy-parameters-data-conversion.md#copy-truncatecolumns)
### Opérations de chargement de données
Gérez le comportement par défaut de l’opération de chargement pour le dépannage ou pour réduire les temps de chargement en spécifiant les paramètres suivants.
+ [COMPROWS](copy-parameters-data-load.md#copy-comprows)
+ [COMPUPDATE](copy-parameters-data-load.md#copy-compupdate)
+ [IGNOREALLERRORS](copy-parameters-data-load.md#copy-ignoreallerrors)
+ [MAXERROR](copy-parameters-data-load.md#copy-maxerror)
+ [NOLOAD](copy-parameters-data-load.md#copy-noload)
+ [STATUPDATE](copy-parameters-data-load.md#copy-statupdate)
## Notes d’utilisation et ressources supplémentaires pour la commande COPY
Pour plus d’informations sur la façon d’utiliser la commande COPY, consultez les rubriques suivantes :
+ [Notes d’utilisation](r_COPY_usage_notes.md)
+ [Didacticiel : chargement des données à partir d’Amazon S3](tutorial-loading-data.md)
+ [Bonnes pratiques de chargement des données sur Amazon Redshift](c_loading-data-best-practices.md)
+ [Chargement de tables à l’aide de la commande COPY](t_Loading_tables_with_the_COPY_command.md)
+ [Chargement des données à partir d’Amazon S3](t_Loading-data-from-S3.md)
+ [Chargement de données à partir d’Amazon EMR](loading-data-from-emr.md)
+ [Chargement des données à partir des hôtes distants](loading-data-from-remote-hosts.md)
+ [Chargement de données à partir d’une table Amazon DynamoDB](t_Loading-data-from-dynamodb.md)
+ [Résolution des problèmes de chargement de données](t_Troubleshooting_load_errors.md)
## Exemples de commandes COPY
Pour d’autres exemples montrant comment utiliser COPY à partir de différentes sources, dans des formats disparates et avec différentes options de copie, consultez [Exemples de commandes COPY](r_COPY_command_examples.md).
# COPY JOB
Pour plus d’informations sur l’utilisation de cette commande, consultez [Créer une intégration d’événements S3 pour copier automatiquement des fichiers à partir de compartiments Amazon S3](loading-data-copy-job.md).
Gère les commandes COPY qui chargent les données dans une table. La commande COPY JOB est une extension de la commande COPY et automatise le chargement des données à partir des compartiments Amazon S3. Lorsque vous créez une tâche COPY, Amazon Redshift détecte quand de nouveaux fichiers Amazon S3 sont créés dans un chemin spécifié, puis les charge automatiquement sans votre intervention. Les mêmes paramètres que ceux utilisés dans la commande COPY d’origine sont utilisés lors du chargement des données. Amazon Redshift assure le suivi des fichiers chargés (en fonction du nom des fichiers) afin de vérifier qu’ils ne sont chargés qu’une seule fois.
**Note**
Pour plus d’informations sur la commande COPY, notamment sur l’utilisation, les paramètres et les autorisations, consultez [COPY](r_COPY.md).
## Autorisation obligatoire
Pour utiliser la commande COPY JOB, vous devez disposer de l’une des autorisations suivantes en plus de toutes les autorisations requises pour utiliser COPY :
+ Superuser
+ Tous les éléments suivants :
+ L’autorisation étendue CREATE, ALTER ou DROP appropriée pour utiliser COPY JOBS dans la base de données vers laquelle vous souhaitez copier.
+ Autorisation USAGE pour le schéma vers lequel vous souhaitez utiliser COPY, ou autorisation étendue USAGE pour les schémas de la base de données vers laquelle vous souhaitez utiliser COPY.
+ Autorisation INSERT pour la table vers laquelle vous souhaitez utiliser COPY, ou autorisation étendue INSERT pour les tables du schéma ou de la base de données vers lesquels vous souhaitez utiliser COPY.
Le rôle IAM spécifié avec la commande COPY doit être autorisé à accéder aux données à charger. Pour plus d’informations, consultez [Autorisations IAM pour les commandes COPY, UNLOAD et CREATE LIBRARY](copy-usage_notes-access-permissions.md#copy-usage_notes-iam-permissions).
## Syntaxe
Créez une tâche de copie. Les paramètres de la commande COPY sont enregistrés avec la tâche de copie.
Vous ne pouvez pas exécuter COPY JOB CREATE dans le cadre d’un bloc de transactions.
```
COPY copy-command JOB CREATE job-name
[AUTO ON | OFF]
```
Modifiez la configuration d’une tâche de copie.
```
COPY JOB ALTER job-name
[AUTO ON | OFF]
```
Exécutez une tâche de copie. Les paramètres de la commande COPY stockés sont utilisés.
```
COPY JOB RUN job-name
```
Répertoriez toutes les tâches de copie.
```
COPY JOB LIST
```
Afficher les détails d’une tâche de copie.
```
COPY JOB SHOW job-name
```
Supprimez une tâche de copie.
Vous ne pouvez pas exécuter COPY JOB DROP dans le cadre d’un bloc de transactions.
```
COPY JOB DROP job-name
```
## Parameters
*copy-command*
Une commande COPY qui charge les données d’Amazon S3 vers Amazon Redshift. La clause contient des paramètres COPY qui définissent le compartiment Amazon S3, la table cible, le rôle IAM et d’autres paramètres utilisés lors du chargement des données. Tous les paramètres de commande COPY pour un chargement de données Amazon S3 sont pris en charge, à l’exception des suivants :
+ La tâche COPY JOB n’ingère pas les fichiers préexistants dans le dossier pointé par la commande COPY. Seuls les fichiers créés après l’horodatage de création de COPY JOB sont ingérés.
+ Vous ne pouvez pas spécifier de commande COPY avec les options MAXERROR ou IGNOREALLERRORS.
+ Vous ne pouvez pas spécifier un fichier manifeste. COPY JOB nécessite un emplacement Amazon S3 désigné pour surveiller les fichiers nouvellement créés.
+ Vous ne pouvez pas spécifier de commande COPY avec des types d’autorisation tels que des clés d’accès et des clés secrètes. Seules les commandes COPY qui utilisent le paramètre `IAM_ROLE` pour l’autorisation sont prises en charge. Pour plus d’informations, consultez [Paramètres d’autorisation](copy-parameters-authorization.md).
+ COPY JOB ne prend pas en charge le rôle IAM par défaut associé au cluster. Vous devez spécifier le `IAM_ROLE` dans la commande COPY.
Pour plus d’informations, consultez [Commande COPY depuis Amazon S3](copy-parameters-data-source-s3.md).
*job-name*
Nom de la tâche utilisé pour référencer la tâche COPY. Le *nom de la tâche* ne peut pas contenir de tiret (‐).
[AUTO ON \$1 OFF]
Clause indiquant si les données Amazon S3 sont automatiquement chargées dans les tables Amazon Redshift.
+ Sur `ON`, Amazon Redshift surveille le chemin Amazon S3 source pour les fichiers nouvellement créés et, s’il en trouve, une commande COPY est exécutée avec les paramètres COPY dans la définition de la tâche. Il s’agit de l’option par défaut.
+ Sur `OFF`, Amazon Redshift n’exécute pas automatiquement COPY JOB.
## Notes d’utilisation
Les options de la commande COPY ne sont validées qu’au moment de l’exécution. Par exemple, un `IAM_ROLE` ou une source de données Amazon S3 non valide entraîne des erreurs d’exécution lorsque COPY JOB démarre.
Si le cluster est suspendu, COPY JOBS ne sont pas exécutées.
Pour interroger les fichiers de commandes COPY chargés et les erreurs de chargement, consultez [STL\$1LOAD\$1COMMITS](r_STL_LOAD_COMMITS.md), [STL\$1LOAD\$1ERRORS](r_STL_LOAD_ERRORS.md) et [STL\$1LOADERROR\$1DETAIL](r_STL_LOADERROR_DETAIL.md). Pour de plus amples informations, veuillez consulter [Vérification que les données ont été chargées correctement](verifying-that-data-loaded-correctly.md).
Les tâches de copie ne sont pas prises en charge sur les bases de données Zero-ETL car elles fonctionnent en mode lecture seule.
## Exemples
L’exemple suivant montre comment créer COPY JOB pour charger les données d’un compartiment Amazon S3.
```
COPY public.target_table
FROM 's3://amzn-s3-demo-bucket/staging-folder'
IAM_ROLE 'arn:aws:iam::123456789012:role/MyLoadRoleName'
JOB CREATE my_copy_job_name
AUTO ON;
```
# COPIER avec TEMPLATE
Vous pouvez utiliser les modèles Redshift avec les commandes COPY pour simplifier la syntaxe des commandes et garantir la cohérence des opérations de chargement de données. Au lieu de spécifier les mêmes paramètres de mise en forme à plusieurs reprises, vous les définissez une fois dans un modèle et vous référencez le modèle dans vos commandes COPY. Lorsque vous utilisez un modèle, la commande COPY combine les paramètres du modèle avec tous les paramètres spécifiés directement dans la commande. Si le même paramètre apparaît à la fois dans le modèle et dans la commande, le paramètre de commande est prioritaire. Pour de plus amples informations, veuillez consulter [CRÉER UN MODÈLE](r_CREATE_TEMPLATE.md).
Les modèles pour la commande COPY peuvent être créés avec :
+ [Paramètres du format de données](copy-parameters-data-format.md)
+ [Paramètres de compression de fichier](copy-parameters-file-compression.md)
+ [Paramètres de conversion de données](copy-parameters-data-conversion.md)
+ [Opérations de chargement de données](copy-parameters-data-load.md)
Pour une liste complète des paramètres pris en charge, voir [COPY](r_COPY.md) commande.
## Autorisation obligatoire
Pour utiliser un modèle dans une commande COPY, vous devez disposer des éléments suivants :
+ Toutes les autorisations requises pour exécuter la commande COPY (voir[Autorisations requises](r_COPY.md#r_COPY-permissions))
+ L'une des autorisations de modèle suivantes :
+ Privilèges de superutilisateur
+ Privilège USAGE sur le modèle et privilège USAGE sur le schéma contenant le modèle
## Syntaxe
```
COPY target_table FROM 's3://...'
authorization
[ option, ...]
USING TEMPLATE [database_name.][schema_name.]template_name;
```
## Parameters
*database\$1name*
(Facultatif) Nom de la base de données dans laquelle le modèle existe. Si elle n'est pas spécifiée, la base de données actuelle est utilisée.
*nom\$1schéma*
(Facultatif) Nom du schéma dans lequel le modèle existe. S'il n'est pas spécifié, le modèle est recherché dans le chemin de recherche actuel.
*nom\$1modèle*
Nom du modèle à utiliser dans COPY.
## Notes d’utilisation
+ Les paramètres spécifiques à la commande (source, destination, autorisation) doivent toujours être spécifiés dans la commande COPY.
+ Les modèles ne peuvent pas contenir de spécifications de fichier manifeste pour les commandes COPY.
## Exemples
Les exemples suivants montrent comment créer un modèle et l'utiliser dans les commandes COPY :
```
CREATE TEMPLATE public.test_template FOR COPY AS
CSV DELIMITER '|' IGNOREHEADER 1 MAXERROR 100;
COPY public.target_table
FROM 's3://amzn-s3-demo-bucket/staging-folder'
IAM_ROLE 'arn:aws:iam::123456789012:role/MyLoadRoleName'
USING TEMPLATE public.test_template;
```
Lorsqu'un paramètre existe à la fois dans le modèle et dans la commande, le paramètre de commande est prioritaire. Dans cet exemple, si le modèle `public.test_template` contient `DELIMITER '|'` mais que la commande COPY le spécifie`DELIMITER ','`, le séparateur de virgule (`,`) de la commande sera utilisé à la place du séparateur de canaux (`|`) du modèle.
```
COPY public.target_table
FROM 's3://amzn-s3-demo-bucket/staging-folder'
IAM_ROLE 'arn:aws:iam::123456789012:role/MyLoadRoleName'
DELIMITER ','
USING TEMPLATE public.test_template;
```
# Description des paramètres de la commande COPY
COPY possède de nombreux paramètres qui peuvent être utilisés dans de nombreuses situations. Toutefois, tous les paramètres ne sont pas pris en charge dans chaque situation. Par exemple, pour le chargement à partir de fichiers ORC ou PARQUET, le nombre de paramètres pris en charge est limité. Pour plus d’informations, consultez [COPY depuis les formats de données en colonnes](copy-usage_notes-copy-from-columnar.md).
**Topics**
+ [Sources de données](copy-parameters-data-source.md)
+ [Paramètres d’autorisation](copy-parameters-authorization.md)
+ [Options de mappage de colonnes](copy-parameters-column-mapping.md)
+ [Paramètres du format de données](copy-parameters-data-format.md)
+ [Paramètres de compression de fichier](copy-parameters-file-compression.md)
+ [Paramètres de conversion de données](copy-parameters-data-conversion.md)
+ [Opérations de chargement de données](copy-parameters-data-load.md)
+ [Liste alphabétique des paramètres](r_COPY-alphabetical-parm-list.md)
# Sources de données
Vous pouvez charger des données à partir de fichiers texte dans un compartiment Amazon S3, dans un cluster Amazon EMR, ou sur un hôte distant auquel votre cluster peut accéder à l’aide d’une connexion SSH. Vous pouvez également charger les données directement à partir d’une table DynamoDB.
La taille maximale d’une seule ligne d’entrée à partir de n’importe quelle source est de 4 Mo.
Pour exporter les données d’une table dans un ensemble de fichiers dans une instance Amazon S3, utilisez la commande [UNLOAD](r_UNLOAD.md).
**Topics**
+ [Commande COPY depuis Amazon S3](copy-parameters-data-source-s3.md)
+ [Commande COPY depuis Amazon EMR](copy-parameters-data-source-emr.md)
+ [Exécution de la commande COPY à partir de l’hôte distant (SSH)](copy-parameters-data-source-ssh.md)
+ [Commande COPY depuis Amazon DynamoDB](copy-parameters-data-source-dynamodb.md)
# Commande COPY depuis Amazon S3
Pour charger des données à partir de fichiers situés dans un ou plusieurs compartiments S3, utilisez la clause FROM pour indiquer comment la commande COPY localise les fichiers dans Amazon S3. Vous pouvez fournir le chemin d’objet aux fichiers de données dans le cadre de la clause FROM, ou vous pouvez fournir l’emplacement d’un fichier manifeste qui contient une liste de chemins d’objets Amazon S3. L’exécution de la commande COPY à partir d’Amazon S3 utilise une connexion HTTPS. Assurez-vous que les plages d’adresses IP S3 sont ajoutées à votre liste des autorisations. Pour plus d’informations sur les plages d’adresses IP S3 requises, consultez [Isolement de réseau](https://docs.aws.amazon.com//redshift/latest/mgmt/security-network-isolation.html#network-isolation).
**Important**
Si les compartiments Amazon S3 qui contiennent les fichiers de données ne résident pas dans la même AWS région que votre cluster, vous devez utiliser le [REGION](#copy-region) paramètre pour spécifier la région dans laquelle se trouvent les données.
**Topics**
+ [Syntaxe](#copy-parameters-data-source-s3-syntax)
+ [Exemples](#copy-parameters-data-source-s3-examples)
+ [Paramètres facultatifs](#copy-parameters-data-source-s3-optional-parms)
+ [Paramètres non pris en charge](#copy-parameters-data-source-s3-unsupported-parms)
## Syntaxe
```
FROM { 's3://objectpath' | 's3://manifest_file' }
authorization
| MANIFEST
| ENCRYPTED
| REGION [AS] 'aws-region'
| optional-parameters
```
## Exemples
L’exemple suivant utilise un chemin d’objet pour charger les données à partir d’Amazon S3.
```
copy customer
from 's3://amzn-s3-demo-bucket/customer'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole';
```
L’exemple suivant utilise un fichier manifeste pour charger les données à partir d’Amazon S3.
```
copy customer
from 's3://amzn-s3-demo-bucket/cust.manifest'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
manifest;
```
### Parameters
FROM
Source des données à charger. Pour plus d’informations sur l’encodage du fichier Amazon S3, consultez [Paramètres de conversion de données](copy-parameters-data-conversion.md).
’s3://*copy\$1from\$1s3\$1objectpath*’
Spécifie le chemin d’accès aux objets Amazon S3 contenant les données (par exemple `'s3://amzn-s3-demo-bucket/custdata.txt'`). Le paramètre *s3://copy\$1from\$1s3\$1objectpath* peut faire référence à un seul fichier ou à un ensemble d’objets ou de dossiers ayant le même préfixe de clé. Par exemple, le nom `custdata.txt` est un préfixe de clé qui fait référence à un certain nombre de fichiers physiques : `custdata.txt`, `custdata.txt.1`, `custdata.txt.2`, `custdata.txt.bak` et ainsi de suite. Le préfixe de clé peut également faire référence à un certain nombre de dossiers. Par exemple, `'s3://amzn-s3-demo-bucket/custfolder'` fait référence aux dossiers `custfolder`, `custfolder_1`, `custfolder_2` et ainsi de suite. Si un préfixe de clé fait référence à plusieurs dossiers, tous les fichiers dans les dossiers sont chargés. Si un préfixe de clé correspond à un fichier et à un dossier, par exemple `custfolder.log`, COPY tente de charger le fichier également. Si un préfixe de clé risque d’entraîner le chargement de fichiers indésirables par COPY, utilisez un fichier manifeste. Pour plus d’informations, consultez [copy_from_s3_manifest_file](#copy-manifest-file), ci-après.
Si le compartiment S3 qui contient les fichiers de données ne réside pas dans la même AWS région que votre cluster, vous devez utiliser le [REGION](#copy-region) paramètre pour spécifier la région dans laquelle se trouvent les données.
Pour de plus amples informations, veuillez consulter [Chargement des données à partir d’Amazon S3](t_Loading-data-from-S3.md).
’s3://*copy\$1from\$1s3\$1manifest\$1file*’
Spécifie la clé de l’objet Amazon S3 d’un fichier manifeste qui répertorie les fichiers de données à charger. L’argument *’s3://*copy\$1from\$1s3\$1manifest\$1file’** doit explicitement faire référence à un seul fichier, par exemple, `'s3://amzn-s3-demo-bucket/manifest.txt'`. Il ne peut pas faire référence à un préfixe de clé.
Le manifeste est un fichier texte au format JSON qui répertorie l’URL de chaque fichier qui doit être chargé à partir d’Amazon S3. L’URL inclut le nom du compartiment et le chemin d’objet complet du fichier. Les fichiers spécifiés dans le manifeste peuvent se trouver dans différents compartiments, mais tous les compartiments doivent se trouver dans la même AWS région que le cluster Amazon Redshift. Si un fichier est répertorié deux fois, le fichier est chargé deux fois. L’exemple suivant illustre le format JSON pour un manifeste qui charge trois fichiers.
```
{
"entries": [
{"url":"s3://amzn-s3-demo-bucket1/custdata.1","mandatory":true},
{"url":"s3://amzn-s3-demo-bucket1/custdata.2","mandatory":true},
{"url":"s3://amzn-s3-demo-bucket2/custdata.1","mandatory":false}
]
}
```
Les guillemets doubles sont nécessaires et doivent être des guillemets simples (0x22), ni culbutés, ni courbes. Chaque entrée dans le manifeste peut éventuellement inclure un indicateur `mandatory`. Si `mandatory` est défini sur `true`, la commande COPY s’arrête si elle ne trouve pas le fichier pour cette entrée ; dans le cas contraire, la commande COPY se poursuit. La valeur par défaut de `mandatory` est `false`.
Lors du chargement des fichiers de données au format ORC or Parquet, le champ `meta` est obligatoire, comme illustré dans l’exemple suivant.
```
{
"entries":[
{
"url":"s3://amzn-s3-demo-bucket1/orc/2013-10-04-custdata",
"mandatory":true,
"meta":{
"content_length":99
}
},
{
"url":"s3://amzn-s3-demo-bucket2/orc/2013-10-05-custdata",
"mandatory":true,
"meta":{
"content_length":99
}
}
]
}
```
Le fichier manifeste ne doit pas être chiffré ou compressé, même si les options ENCRYPTED, GZIP, LZOP ou ZSTD sont spécifiées. BZIP2 La commande COPY renvoie une erreur si le fichier manifeste spécifié est introuvable ou si le fichier manifeste n’est pas correctement formé.
Si un fichier manifeste est utilisé, le paramètre MANIFEST doit être spécifié avec la commande COPY. Si le paramètre MANIFEST n’est pas spécifié, la commande COPY présume que le fichier spécifié avec FROM est un fichier de données.
Pour plus d'informations, consultez [Chargement des données à partir d’Amazon S3](t_Loading-data-from-S3.md).
*authorization*
La commande COPY a besoin de l'autorisation pour accéder aux données dans une autre ressource AWS , y compris Amazon S3, Amazon EMR, Amazon DynamoDB et Amazon EC2. Vous pouvez fournir cette autorisation en référençant un rôle Gestion des identités et des accès AWS (IAM) attaché à votre cluster (contrôle d'accès basé sur les rôles) ou en fournissant les informations d'identification d'accès d'un utilisateur (contrôle d'accès basé sur des clés). Pour plus de sécurité et de flexibilité, nous recommandons d’utiliser contrôle d’accès basé sur les rôles IAM. Pour plus d'informations, consultez [Paramètres d’autorisation](copy-parameters-authorization.md).
MANIFEST
Spécifie qu’un manifeste est utilisé pour identifier les fichiers de données à charger à partir d’Amazon S3. Si le paramètre MANIFEST est utilisé, la commande COPY charge des données depuis les fichiers répertoriés dans le manifeste référencé par *’s3://copy\$1from\$1s3\$1manifest\$1file’*. Si le fichier manifeste n’est pas trouvé ou est dans un format incorrect, la commande COPY échoue. Pour plus d'informations, consultez [Utilisation d’un manifeste pour spécifier les fichiers de données](loading-data-files-using-manifest.md).
ENCRYPTED
Une clause qui spécifie que les fichiers d’entrée sur Amazon S3 sont chiffrés à l’aide du chiffrement côté client avec des clés gérées par le client. Pour plus d'informations, consultez [Chargement de fichiers de données chiffrés à partir d’Amazon S3](c_loading-encrypted-files.md). N’indiquez pas ENCRYPTED si les fichiers d’entrée sont chiffrés à l’aide du chiffrement côté serveur Amazon S3 (SSE-KMS ou SSE-S3). La commande COPY lit automatiquement les fichiers chiffrés côté serveur.
Si vous spécifiez le paramètre ENCRYPTED, vous devez également spécifier le paramètre [MASTER_SYMMETRIC_KEY](#copy-master-symmetric-key) ou inclure la valeur **master\$1symmetric\$1key** dans la chaîne [Utilisation du paramètre CREDENTIALS](copy-parameters-authorization.md#copy-credentials).
Si les fichiers chiffrés sont au format compressé, ajoutez le paramètre GZIP, LZOP ou BZIP2 ZSTD.
Les fichiers manifestes et JSONPaths les fichiers ne doivent pas être chiffrés, même si l'option ENCRYPTED est spécifiée.
MASTER\$1SYMMETRIC\$1KEY ’*root\$1key*’
La clé symétrique racine qui a été utilisée pour chiffrer les fichiers de données sur Amazon S3. Si la clé MASTER\$1SYMMETRIC\$1KEY est spécifiée, le paramètre [ENCRYPTED](#copy-encrypted) doit également être spécifié. La clé MASTER\$1SYMMETRIC\$1KEY ne peut pas être utilisée avec le paramètre CREDENTIALS. Pour de plus amples informations, veuillez consulter [Chargement de fichiers de données chiffrés à partir d’Amazon S3](c_loading-encrypted-files.md).
Si les fichiers chiffrés sont au format compressé, ajoutez le paramètre GZIP, LZOP ou BZIP2 ZSTD.
REGION [AS] ’*aws-region*’
Spécifie la AWS région dans laquelle se trouvent les données sources. REGION est nécessaire pour exécuter la commande COPY depuis un compartiment Amazon S3 ou une table DynamoDB lorsque la ressource AWS qui contient les données ne se trouve pas dans la même région que le cluster Amazon Redshift.
La valeur pour *aws\$1region* doit correspondre à une région répertoriée dans le tableau [Régions et points de terminaison Amazon Redshift](https://docs.aws.amazon.com/general/latest/gr/rande.html#redshift_region).
Si le paramètre REGION est spécifié, toutes les ressources, y compris un fichier manifeste ou plusieurs compartiments Amazon S3, doivent se trouver dans la région spécifiée.
Le transfert de données entre les régions engage des frais supplémentaires pour le compartiment Amazon S3 ou la table DynamoDB qui contient les données. Pour plus d'informations sur la tarification, consultez les sections **Transfert de données sortantes d'Amazon S3 vers une autre AWS région** sur la page de [tarification d'Amazon S3](https://aws.amazon.com/s3/pricing/) et **Transfert de données sortantes** sur la page de tarification d'[Amazon DynamoDB](https://aws.amazon.com/dynamodb/pricing/).
Par défaut, la commande COPY part du principe que les données se trouvent dans la même région que le cluster Amazon Redshift.
## Paramètres facultatifs
Vous pouvez éventuellement spécifier les paramètres suivants avec la commande COPY à partir d’Amazon S3 :
+ [Options de mappage de colonnes](copy-parameters-column-mapping.md)
+ [Paramètres du format de données](copy-parameters-data-format.md#copy-data-format-parameters)
+ [Paramètres de conversion de données](copy-parameters-data-conversion.md)
+ [Opérations de chargement de données](copy-parameters-data-load.md)
## Paramètres non pris en charge
Vous ne pouvez pas utiliser les paramètres suivants avec la commande COPY à partir d’Amazon S3 :
+ SSH
+ READRATIO
# Commande COPY depuis Amazon EMR
Vous pouvez utiliser la commande COPY pour charger des données en parallèle à partir d’un cluster Amazon EMR configuré pour écrire des fichiers texte dans le système de fichiers distribué Hadoop (HDFS) du cluster sous la forme de fichiers à largeur fixe, de fichiers séparés par des caractères, de fichiers CSV, de fichiers au format JSON ou de fichiers Avro.
**Topics**
+ [Syntaxe](#copy-parameters-data-source-emr-syntax)
+ [Exemple](#copy-parameters-data-source-emr-example)
+ [Parameters](#copy-parameters-data-source-emr-parameters)
+ [Paramètres pris en charge](#copy-parameters-data-source-emr-optional-parms)
+ [Paramètres non pris en charge](#copy-parameters-data-source-emr-unsupported-parms)
## Syntaxe
```
FROM 'emr://emr_cluster_id/hdfs_filepath'
authorization
[ optional_parameters ]
```
## Exemple
L’exemple suivant charge des données depuis un cluster Amazon EMR.
```
copy sales
from 'emr://j-SAMPLE2B500FC/myoutput/part-*'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole';
```
## Parameters
FROM
Source des données à charger.
’emr://*emr\$1cluster\$1id*/*hdfs\$1file\$1path*’
Identifiant unique du cluster Amazon EMR et chemin d’accès au fichier HDFS faisant référence aux fichiers de données pour la commande COPY. Les noms de fichiers de données HDFS ne doivent pas comporter les caractères génériques suivants : l’astérisque (\$1) et le point d’interrogation (?).
Le cluster Amazon EMR doit continuer de s’exécuter jusqu’à la fin de l’opération COPY. Si l’un des fichiers de données HDFS est modifié ou supprimé avant la fin de l’opération COPY, vous pouvez avoir des résultats inattendus ou l’opération COPY peut échouer.
Vous pouvez utiliser les caractères génériques astérisque (\$1) et point d’interrogation (?) dans le cadre de l’argument *hdfs\$1file\$1path* pour spécifier le chargement de plusieurs fichiers. Par exemple, `'emr://j-SAMPLE2B500FC/myoutput/part*'` identifie les fichiers `part-0000`, `part-0001`, et ainsi de suite. Si le chemin d’accès ne contient pas de caractères génériques, il est traité comme un littéral de chaîne. Si vous spécifiez uniquement un nom de dossier, COPY tente de charger tous les fichiers dans le dossier.
Si vous utilisez des caractères génériques ou uniquement le nom du dossier, vérifiez qu’aucun fichier indésirable ne sera chargé. Par exemple, certains processus peuvent écrire un fichier journal sur le dossier de sortie.
Pour plus d'informations, consultez [Chargement de données à partir d’Amazon EMR](loading-data-from-emr.md).
*authorization*
La commande COPY a besoin de l'autorisation pour accéder aux données dans une autre ressource AWS , y compris Amazon S3, Amazon EMR, Amazon DynamoDB et Amazon EC2. Vous pouvez fournir cette autorisation en référençant un rôle Gestion des identités et des accès AWS (IAM) attaché à votre cluster (contrôle d'accès basé sur les rôles) ou en fournissant les informations d'identification d'accès d'un utilisateur (contrôle d'accès basé sur des clés). Pour plus de sécurité et de flexibilité, nous recommandons d’utiliser contrôle d’accès basé sur les rôles IAM. Pour plus d'informations, consultez [Paramètres d’autorisation](copy-parameters-authorization.md).
## Paramètres pris en charge
Vous pouvez éventuellement spécifier les paramètres suivants avec la commande COPY à partir d’Amazon EMR :
+ [Options de mappage de colonnes](copy-parameters-column-mapping.md)
+ [Paramètres du format de données](copy-parameters-data-format.md#copy-data-format-parameters)
+ [Paramètres de conversion de données](copy-parameters-data-conversion.md)
+ [Opérations de chargement de données](copy-parameters-data-load.md)
## Paramètres non pris en charge
Vous ne pouvez pas utiliser les paramètres suivants avec la commande COPY à partir d’Amazon EMR :
+ ENCRYPTED
+ MANIFEST
+ REGION
+ READRATIO
+ SSH
# Exécution de la commande COPY à partir de l’hôte distant (SSH)
Vous pouvez utiliser la commande COPY pour charger les données en parallèle à partir d’un ou de plusieurs hôtes distants, comme les instances Amazon Elastic Compute Cloud (Amazon EC2) ou d’autres ordinateurs. La commande COPY se connecte aux hôtes distants à l’aide de SSH (Secure Shell) et exécute les commandes sur les hôtes distants pour générer la sortie de texte. L’hôte distant peut être une instance Linux EC2 ou un autre ordinateur Unix ou Linux configuré pour accepter les connexions SSH. Amazon Redshift peut se connecter à plusieurs hôtes et ouvrir plusieurs connexions SSH à chaque hôte. Amazon Redshift envoie une commande unique lors de chaque connexion pour générer la sortie de texte sur la sortie standard de l’hôte, qu’Amazon Redshift lit alors comme un fichier texte.
Utilisez la clause FROM pour spécifier la clé d’objet Amazon S3 pour le fichier manifeste qui fournit les informations que la commande COPY utilise pour ouvrir des connexions SSH et exécuter les commandes à distance.
**Topics**
+ [Syntaxe](#copy-parameters-data-source-ssh-syntax)
+ [Exemples](#copy-parameters-data-source-ssh-examples)
+ [Parameters](#copy-parameters-data-source-ssh-parameters)
+ [Paramètres facultatifs](#copy-parameters-data-source-ssh-optional-parms)
+ [Paramètres non pris en charge](#copy-parameters-data-source-ssh-unsupported-parms)
**Important**
Si le compartiment S3 contenant le fichier manifeste ne réside pas dans la même région AWS que votre cluster, vous devez utiliser le paramètre REGION pour spécifier la région dans laquelle le compartiment se trouve.
## Syntaxe
```
FROM 's3://'ssh_manifest_file' }
authorization
SSH
| optional-parameters
```
## Exemples
L’exemple suivant utilise un fichier manifeste pour charger les données à partir d’un hôte distant à l’aide de SSH.
```
copy sales
from 's3://amzn-s3-demo-bucket/ssh_manifest'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
ssh;
```
## Parameters
FROM
Source des données à charger.
’s3://*copy\$1from\$1ssh\$1manifest\$1file*’
La commande COPY peut se connecter à plusieurs hôtes à l’aide de SSH et créer plusieurs connexions SSH à chaque hôte. COPY exécute une commande via chaque connexion hôte, puis charge la sortie à partir des commandes en parallèle de la table. L’argument *s3://copy\$1from\$1ssh\$1manifest\$1file* spécifie la clé d’objet Amazon S3 du fichier manifeste qui fournit les informations que la commande COPY utilise pour ouvrir les connexions SSH et exécuter les commandes à distance.
L’argument *s3://copy\$1from\$1ssh\$1manifest\$1file* doit explicitement faire référence à un seul fichier ; il ne peut pas être un préfixe de clé. Voici un exemple:
```
's3://amzn-s3-demo-bucket/ssh_manifest.txt'
```
Le fichier manifeste est un fichier texte au format JSON qu’Amazon Redshift utilise pour se connecter à l’hôte. Le fichier manifeste spécifie les points de terminaison hôte SSH et les commandes qui seront exécutées sur les hôtes pour renvoyer les données à Amazon Redshift. Le cas échéant, vous pouvez inclure la clé publique de l’hôte, le nom d’utilisateur de connexion et un indicateur obligatoire pour chaque entrée. L’exemple suivant montre un fichier manifeste qui crée deux connexions SSH :
```
{
"entries": [
{"endpoint":"",
"command": "",
"mandatory":true,
"publickey": "",
"username": ""},
{"endpoint":"",
"command": "",
"mandatory":true,
"publickey": "",
"username": ""}
]
}
```
Le fichier manifeste contient une construction `"entries"` pour chaque connexion SSH. Vous pouvez avoir plusieurs connexions à un seul hôte ou plusieurs connexions à plusieurs hôtes. Les guillemets doubles sont obligatoires comme illustré, aussi bien pour les noms de champ que pour les valeurs. Les guillemets doivent être des guillemets simples (0x22), ni culbutés, ni courbes. La seule valeur qui n’a pas besoin de guillemets doubles est la valeur booléenne `true` ou `false` pour le champ `"mandatory"`.
La liste suivante décrit les champs dans le fichier manifeste.
point de terminaison
L’adresse URL ou l’adresse IP de l’hôte, par exemple, `"ec2-111-222-333.compute-1.amazonaws.com"` ou `"198.51.100.0"`.
command
La commande doit être exécutée par l’hôte pour générer la sortie de texte ou la sortie binaire au format gzip, lzop, bzip2 ou zstd. La commande peut être n’importe quelle commande que l’utilisateur *« host\$1user\$1name »* est autorisé à exécuter. La commande peut être aussi simple que l’impression d’un fichier, ou elle bien peut interroger une base de données ou lancer un script. Les sorties (fichier texte, fichier binaire gzip, fichier binaire lzop ou fichier binaire bzip2) doivent être sous une forme que la commande COPY Amazon Redshift peut intégrer. Pour plus d'informations, consultez [Préparation de vos données d’entrée](t_preparing-input-data.md).
publickey
(Facultatif) La clé publique de l’hôte. Si la clé est fournie, Amazon Redshift l’utilise pour identifier l’hôte. Si la clé publique n’est pas fournie, Amazon Redshift n’essaie pas d’identifier l’hôte. Par exemple, si la clé publique l’hôte distant est `ssh-rsa AbcCbaxxx…Example root@amazon.com`, tapez le texte suivant dans le champ de clé publique : `"AbcCbaxxx…Example"`
mandatory
(Facultatif) Clause qui indique si la commande COPY doit échouer en cas d’échec de la tentative de connexion. La valeur par défaut est `false`. Si Amazon Redshift n’établit pas au moins une connexion, la commande COPY échoue.
nom d’utilisateur
(Facultatif) Nom d’utilisateur qui sera utilisé pour vous connecter au système hôte et exécuter la commande à distance. Le nom de connexion d’utilisateur doit être le même que la connexion qui a été utilisée pour ajouter la clé publique du cluster Amazon Redshift au fichier de clés autorisé de l’hôte. Le nom d’utilisateur par défaut est `redshift`.
Pour plus d’informations sur la création d’un fichier manifeste, consultez [Processus de chargement de données](loading-data-from-remote-hosts.md#load-from-host-process).
Pour exécuter la commande COPY d’un hôte distant, le paramètre SSH doit être spécifié avec la commande COPY. Si le paramètre SSH n’est pas spécifié, la commande COPY suppose que le fichier spécifié avec FROM est un fichier de données et échoue.
Si vous utilisez la compression automatique, la commande COPY effectue deux opérations de lecture des données, ce qui signifie qu’elle va exécuter la commande à distance à deux reprises. La première opération de lecture vise à fournir un échantillon de données pour l’analyse de la compression, et la deuxième opération de lecture charge réellement les données. Si l’exécution de la commande à distance à deux reprises est susceptible d’entraîner un problème, vous devez désactiver la compression automatique. Pour désactiver la compression automatique, exécutez la commande COPY avec le paramètre COMPUPDATE défini sur OFF. Pour plus d'informations, consultez [Chargement des tables avec compression automatique](c_Loading_tables_auto_compress.md).
Pour connaître les procédures détaillées de l’utilisation de la commande COPY dans SSH, consultez [Chargement des données à partir des hôtes distants](loading-data-from-remote-hosts.md).
*authorization*
La commande COPY a besoin de l'autorisation pour accéder aux données dans une autre ressource AWS , y compris Amazon S3, Amazon EMR, Amazon DynamoDB et Amazon EC2. Vous pouvez fournir cette autorisation en référençant un rôle Gestion des identités et des accès AWS (IAM) attaché à votre cluster (contrôle d'accès basé sur les rôles) ou en fournissant les informations d'identification d'accès d'un utilisateur (contrôle d'accès basé sur des clés). Pour plus de sécurité et de flexibilité, nous recommandons d’utiliser contrôle d’accès basé sur les rôles IAM. Pour plus d'informations, consultez [Paramètres d’autorisation](copy-parameters-authorization.md).
SSH
Clause qui spécifie que les données doivent être chargées à partir d’un hôte distant à l’aide du protocole SSH. Si vous spécifiez SSH, vous devez également fournir un fichier manifeste à l’aide de l’argument [s3://copy_from_ssh_manifest_file](#copy-ssh-manifest).
Si vous utilisez SSH pour effectuer une copie à partir d’un hôte à l’aide d’une adresse IP privée dans un VPC distant, le routage VPC amélioré doit être activé pour le VPC. Pour plus d’informations sur le routage VPC amélioré, consultez [Routage VPC amélioré Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/enhanced-vpc-routing.html).
## Paramètres facultatifs
Vous pouvez éventuellement spécifier les paramètres suivants avec la commande COPY à partir de SSH :
+ [Options de mappage de colonnes](copy-parameters-column-mapping.md)
+ [Paramètres du format de données](copy-parameters-data-format.md#copy-data-format-parameters)
+ [Paramètres de conversion de données](copy-parameters-data-conversion.md)
+ [Opérations de chargement de données](copy-parameters-data-load.md)
## Paramètres non pris en charge
Vous ne pouvez pas utiliser les paramètres suivants avec la commande COPY à partir de SSH :
+ ENCRYPTED
+ MANIFEST
+ READRATIO
# Commande COPY depuis Amazon DynamoDB
Pour charger les données à partir d’une table DynamoDB existante, utilisez la clause FROM pour spécifier le nom de la table DynamoDB.
**Topics**
+ [Syntaxe](#copy-parameters-data-source-dynamodb-syntax)
+ [Exemples](#copy-parameters-data-source-dynamodb-examples)
+ [Paramètres facultatifs](#copy-parameters-data-source-dynamodb-optional-parms)
+ [Paramètres non pris en charge](#copy-parameters-data-source-dynamodb-unsupported-parms)
**Important**
Si la table DynamoDB ne réside pas dans la même région que votre cluster Amazon Redshift, vous devez utiliser le paramètre REGION pour spécifier la région dans laquelle les données se trouvent.
## Syntaxe
```
FROM 'dynamodb://table-name'
authorization
READRATIO ratio
| REGION [AS] 'aws_region'
| optional-parameters
```
## Exemples
L’exemple suivant charge des données à partir d’une table DynamoDB.
```
copy favoritemovies from 'dynamodb://ProductCatalog'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
readratio 50;
```
### Parameters
FROM
Source des données à charger.
’dynamodb://*table-name*’
Nom de la table DynamoDB qui contient les données, par exemple, `'dynamodb://ProductCatalog'`. Pour plus d’informations sur la manière dont les attributs DynamoDB sont mappés aux colonnes Amazon Redshift, consultez [Chargement de données à partir d’une table Amazon DynamoDB](t_Loading-data-from-dynamodb.md).
Le nom d'une table DynamoDB est propre à AWS un compte, qui est identifié par AWS les informations d'identification d'accès.
*authorization*
La commande COPY a besoin de l’autorisation pour accéder aux données dans une autre ressource AWS , y compris Amazon S3, Amazon EMR, Amazon DynamoDB et Amazon EC2. Vous pouvez fournir cette autorisation en référençant un rôle Gestion des identités et des accès AWS (IAM) attaché à votre cluster (contrôle d'accès basé sur les rôles) ou en fournissant les informations d'identification d'accès d'un utilisateur (contrôle d'accès basé sur des clés). Pour plus de sécurité et de flexibilité, nous recommandons d’utiliser contrôle d’accès basé sur les rôles IAM. Pour plus d'informations, consultez [Paramètres d’autorisation](copy-parameters-authorization.md).
READRATIO [AS] *ratio*
Pourcentage du débit alloué à la table DynamoDB à utiliser pour le chargement des données. READRATIO est nécessaire pour exécuter la commande COPY à partir de DynamoDB. Il ne peut pas être utilisé pour exécuter la commande COPY à partir d’Amazon S3. Nous vous recommandons vivement de définir le ratio avec une valeur inférieure au débit moyen alloué non utilisé. Les valeurs valides sont des nombres entiers compris entre 1 et 200.
La définition de READRATIO sur 100 ou plus active Amazon Redshift pour tirer parti de l’intégralité du débit alloué de la table DynamoDB, ce qui dégrade considérablement les performances des opérations de lecture simultanées par rapport à la même table pendant la séance COPY. Le trafic d’écriture n’est pas affecté. Les valeurs supérieures à 100 sont autorisées pour résoudre les scénarios rares où Amazon Redshift ne respecte pas le débit alloué de la table. Si vous chargez les données de DynamoDB vers Amazon Redshift en permanence, pensez à organiser vos tables DynamoDB sous forme de série chronologique pour séparer le trafic en direct de l’opération COPY.
## Paramètres facultatifs
Vous pouvez éventuellement spécifier les paramètres suivants avec la commande COPY à partir d’Amazon DynamoDB :
+ [Options de mappage de colonnes](copy-parameters-column-mapping.md)
+ Les paramètres de conversion de données suivants sont pris en charge :
+ [ACCEPTANYDATE](copy-parameters-data-conversion.md#copy-acceptanydate)
+ [BLANKSASNULL](copy-parameters-data-conversion.md#copy-blanksasnull)
+ [DATEFORMAT](copy-parameters-data-conversion.md#copy-dateformat)
+ [EMPTYASNULL](copy-parameters-data-conversion.md#copy-emptyasnull)
+ [ROUNDEC](copy-parameters-data-conversion.md#copy-roundec)
+ [TIMEFORMAT](copy-parameters-data-conversion.md#copy-timeformat)
+ [TRIMBLANKS](copy-parameters-data-conversion.md#copy-trimblanks)
+ [TRUNCATECOLUMNS](copy-parameters-data-conversion.md#copy-truncatecolumns)
+ [Opérations de chargement de données](copy-parameters-data-load.md)
## Paramètres non pris en charge
Vous ne pouvez pas utiliser les paramètres suivants avec la commande COPY à partir de DynamoDB :
+ Paramètres du format de toutes les données
+ ESCAPE
+ FILLRECORD
+ IGNOREBLANKLINES
+ IGNOREHEADER
+ NULL
+ REMOVEQUOTES
+ ACCEPTINVCHARS
+ MANIFEST
+ ENCRYPTED
# Paramètres d’autorisation
La commande COPY nécessite une autorisation pour accéder aux données d'une autre AWS ressource, notamment Amazon S3, Amazon EMR, Amazon DynamoDB et Amazon EC2. Vous fournissez cette autorisation en référençant un [rôle Gestion des identités et des accès AWS (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) qui est attaché à votre cluster (*contrôle d’accès basé sur le rôle*). Vous pouvez chiffrer vos données de chargement sur Amazon S3.
Les rubriques suivantes fournissent plus de détails et des exemples d’options d’authentification:
+ [Autorisations IAM pour les commandes COPY, UNLOAD et CREATE LIBRARY](copy-usage_notes-access-permissions.md#copy-usage_notes-iam-permissions)
+ [Contrôle d’accès basé sur les rôles](copy-usage_notes-access-permissions.md#copy-usage_notes-access-role-based)
+ [Contrôle d’accès basé sur les clés](copy-usage_notes-access-permissions.md#copy-usage_notes-access-key-based)
Utilisez l’un des paramètres suivants pour autoriser la commande COPY :
+ [Utilisation du paramètre IAM\$1ROLE](#copy-iam-role) paramètre
+ Paramètres dans l’[Utilisation des paramètres ACCESS\$1KEY\$1ID et SECRET\$1ACCESS\$1KEY](#copy-access-key-id)
+ [Utilisation du paramètre CREDENTIALS](#copy-credentials)Clause
## Utilisation du paramètre IAM\$1ROLE
### IAM\$1ROLE
Utilisez le mot clé par défaut pour qu’Amazon Redshift utilise le rôle IAM défini par défaut et associé au cluster lorsque la commande COPY s’exécute.
Utilisez l’Amazon Resource Name (ARN) d’un rôle IAM que votre cluster utilise pour l’authentification et l’autorisation. Si vous spécifiez IAM\$1ROLE, vous ne pouvez pas utiliser ACCESS\$1KEY\$1ID et SECRET\$1ACCESS\$1KEY, SESSION\$1TOKEN ni CREDENTIALS.
L’exemple suivant montre la syntaxe du paramètre IAM\$1ROLE.
```
IAM_ROLE { default | 'arn:aws:iam:::role/' }
```
Pour plus d’informations, consultez [Contrôle d’accès basé sur les rôles](copy-usage_notes-access-permissions.md#copy-usage_notes-access-role-based).
## Utilisation des paramètres ACCESS\$1KEY\$1ID et SECRET\$1ACCESS\$1KEY
### Utilisation de ACCESS\$1KEY\$1ID et SECRET\$1ACCESS\$1KEY
Cette méthode d’autorisation n’est pas recommandée.
**Note**
Plutôt que de fournir des informations d’identification d’accès sous forme de texte brut, nous vous recommandons vivement d’utiliser l’authentification basée sur les rôles en spécifiant le paramètre IAM\$1ROLE. Pour plus d’informations, consultez [Contrôle d’accès basé sur les rôles](copy-usage_notes-access-permissions.md#copy-usage_notes-access-role-based).
### SESSION\$1TOKEN
Le jeton de séance à utiliser avec les informations d’identification d’accès temporaires. Lorsque SESSION\$1TOKEN est spécifié, vous devez également utiliser ACCESS\$1KEY\$1ID et SECRET\$1ACCESS\$1KEY afin de fournir des informations d’identification de clé d’accès temporaire. Si vous spécifiez SESSION\$1TOKEN, vous ne pouvez utiliser ni IAM\$1ROLE, ni CREDENTIALS. Pour plus d’informations, consultez [informations d’identification de sécurité temporaires](copy-usage_notes-access-permissions.md#r_copy-temporary-security-credentials) dans le Guide de l’utilisateur IAM.
**Note**
Plutôt que de créer des informations d’identification de sécurité temporaires, nous vous recommandons vivement d’utiliser l’authentification basée sur les rôles. Lorsque vous autorisez l’accès à l’aide d’un rôle IAM, Amazon Redshift crée automatiquement des informations d’identification utilisateur temporaires à chaque séance. Pour plus d'informations, consultez [Contrôle d’accès basé sur les rôles](copy-usage_notes-access-permissions.md#copy-usage_notes-access-role-based).
L’exemple suivant illustre la syntaxe du paramètre SESSION\$1TOKEN avec les paramètres ACCESS\$1KEY\$1ID et SECRET\$1ACCESS\$1KEY.
```
ACCESS_KEY_ID ''
SECRET_ACCESS_KEY ''
SESSION_TOKEN '';
```
Si vous spécifiez SESSION\$1TOKEN, vous ne pouvez utiliser ni IAM\$1ROLE, ni CREDENTIALS.
## Utilisation du paramètre CREDENTIALS
### CREDENTIALS
Clause qui indique la méthode que votre cluster utilisera pour accéder à d'autres AWS ressources contenant des fichiers de données ou des fichiers manifestes. Vous ne pouvez pas utiliser le paramètre CREDENTIALS avec IAM\$1ROLE ou ACCESS\$1KEY\$1ID et SECRET\$1ACCESS\$1KEY.
L’exemple suivant montre la syntaxe du paramètre CREDENTIALS.
```
[WITH] CREDENTIALS [AS] 'credentials-args'
```
**Note**
Pour une meilleure flexibilité, nous vous recommandons d’utiliser le paramètre [IAM\$1ROLE](#copy-iam-role-iam) plutôt que le paramètre CREDENTIALS.
Le cas échéant, si le paramètre [ENCRYPTED](copy-parameters-data-source-s3.md#copy-encrypted) est utilisé, la chaîne *credentials-args* fournit également la clé de chiffrement.
La chaîne *credentials-args* est sensible à la casse et ne doit pas contenir d’espaces.
Les mots-clés WITH et AS sont facultatifs, et ils sont ignorés.
Vous pouvez spécifier [role-based access control](copy-usage_notes-access-permissions.md#copy-usage_notes-access-role-based.phrase) ou [key-based access control](copy-usage_notes-access-permissions.md#copy-usage_notes-access-key-based.phrase). Dans les deux cas, le rôle IAM ou l’utilisateur doit avoir les autorisations nécessaires pour accéder aux ressources AWS spécifiées. Pour de plus amples informations, veuillez consulter [Autorisations IAM pour les commandes COPY, UNLOAD et CREATE LIBRARY](copy-usage_notes-access-permissions.md#copy-usage_notes-iam-permissions).
**Note**
Pour protéger vos AWS informations d'identification et protéger les données sensibles, nous vous recommandons vivement d'utiliser un contrôle d'accès basé sur les rôles.
Pour spécifier un contrôle d’accès basé sur les rôles, fournissez la chaîne *credentials-args* au format suivant :
```
'aws_iam_role=arn:aws:iam:::role/'
```
Pour utiliser les informations d’identification de jeton temporaires, vous devez fournir l’ID de clé d’accès temporaire, la clé d’accès secrète temporaire et le jeton temporaire. La chaîne *credentials-args* doit être au format suivant.
```
CREDENTIALS
'aws_access_key_id=;aws_secret_access_key=;token='
```
Une commande COPY utilisant le contrôle d’accès basé sur les rôles avec des informations d’identification temporaires ressemblerait à l’exemple suivant :
```
COPY customer FROM 's3://amzn-s3-demo-bucket/mydata'
CREDENTIALS
'aws_access_key_id=;aws_secret_access_key=;token='
```
Pour de plus amples informations, veuillez consulter [informations d’identification de sécurité temporaires](copy-usage_notes-access-permissions.md#r_copy-temporary-security-credentials).
Si le [ENCRYPTED](copy-parameters-data-source-s3.md#copy-encrypted) paramètre est utilisé, la chaîne *credentials-args* est au format suivant, où ** est la valeur de la clé racine utilisée pour chiffrer les fichiers.
```
CREDENTIALS
';master_symmetric_key='
```
Une commande COPY utilisant le contrôle d’accès basé sur les rôles avec une clé de chiffrement ressemblerait à l’exemple suivant :
```
COPY customer FROM 's3://amzn-s3-demo-bucket/mydata'
CREDENTIALS
'aws_iam_role=arn:aws:iam:::role/;master_symmetric_key='
```
# Options de mappage de colonnes
Par défaut, la commande COPY insère des valeurs dans les colonnes de la table cible dans le même ordre que les champs se trouvent dans les fichiers de données. Si l'ordre des colonnes par défaut ne fonctionne pas, vous pouvez spécifier une liste de colonnes ou utiliser des JSONPath expressions pour mapper les champs de données source aux colonnes cibles.
+ [Column List](#copy-column-list)
+ [JSONPaths File](#copy-column-mapping-jsonpaths)
## Liste de colonnes
Vous pouvez spécifier une liste des noms de colonnes séparés par des virgules pour charger les champs de données source dans des colonnes cible spécifiques. Les colonnes peuvent être dans n’importe quel ordre dans l’instruction COPY, mais lors du chargement de fichiers plats, tels que dans un compartiment Amazon S3, leur ordre doit correspondre à celui des données sources.
Lors du chargement d’une table Amazon DynamoDB, l’ordre n’importe pas La commande COPY met en correspondance les noms d’attribut des éléments extraits de la table DynamoDB et les noms de colonne de la table Amazon Redshift. Pour plus d'informations, consultez [Chargement de données à partir d’une table Amazon DynamoDB](t_Loading-data-from-dynamodb.md)
Le format d’une liste de colonnes est le suivant.
```
COPY tablename (column1 [,column2, ...])
```
Si une colonne dans la table cible est absente de la liste de colonnes, la commande COPY charge l’expression [DEFAULT](r_CREATE_TABLE_NEW.md#create-table-default) de la colonne cible.
Si la colonne cible n’a pas de valeur par défaut, la commande COPY tente de charger NULL.
Si la commande COPY tente d’affecter NULL à une colonne qui est définie comme NOT NULL, elle échoue.
Si une colonne [IDENTITY](r_CREATE_TABLE_NEW.md#identity-clause) est incluse dans la liste de colonnes, [EXPLICIT_IDS](copy-parameters-data-conversion.md#copy-explicit-ids) doit également être spécifié ; si une colonne IDENTITY n’est pas spécifiée, EXPLICIT\$1IDS ne peut pas être spécifié. Si aucune liste de la colonne n’est spécifiée, la commande se comporte comme si une liste de colonnes complète, dans l’ordre, a été spécifiée, avec les colonnes IDENTITY omises si EXPLICIT\$1IDS n’a pas non plus été spécifié.
Si une colonne est définie avec GENERATED BY DEFAULT AS IDENTITY, elle peut être copiée. Les valeurs sont générées ou mises à jour avec des valeurs que vous fournissez. L’option EXPLICIT\$1IDS n’est pas obligatoire. COPY ne met pas à jour le filigrane élevé d’identité. Pour de plus amples informations, veuillez consulter [GENERATED BY DEFAULT AS IDENTITY](r_CREATE_TABLE_NEW.md#identity-generated-bydefault-clause).
## JSONPaths fichier
Lors du chargement des fichiers de données au format JSON ou Avro, la commande COPY mappe automatiquement les éléments de données aux données source JSON ou Avro dans les colonnes de la table cible. Pour ce faire, elle met en correspondance les noms de champs du schéma Avro avec les noms de colonnes de la liste de tables ou de colonnes cible.
Dans certains cas, vos noms de colonnes et de champs ne correspondent pas, ou vous devez mapper à des niveaux plus profonds de la hiérarchie de données. Dans ces cas, vous pouvez utiliser un JSONPaths fichier pour mapper explicitement des éléments de données JSON ou Avro à des colonnes.
Pour de plus amples informations, veuillez consulter [JSONPaths fichier](copy-parameters-data-format.md#copy-json-jsonpaths).
# Paramètres du format de données
Par défaut, la commande COPY attend que les données source soient dans un format texte UTF-8 séparé par des caractères. Le délimiteur par défaut est une barre verticale ( \$1 ). Si les données source sont dans un autre format, utilisez les paramètres suivants pour spécifier le format des données:
+ [FORMAT](#copy-format)
+ [CSV](#copy-csv)
+ [DELIMITER](#copy-delimiter)
+ [FIXEDWIDTH](#copy-fixedwidth)
+ [SHAPEFILE](#copy-shapefile)
+ [AVRO](#copy-avro)
+ [JSON format for COPY](#copy-json)
+ [PARQUET](#copy-parquet)
+ [ORC](#copy-orc)
En plus des formats de données standard, COPY prend en charge les formats de données en colonnes suivants pour la commande COPY depuis Amazon S3 :
+ [ORC](#copy-orc)
+ [PARQUET](#copy-parquet)
La commande COPY à partir du format en colonne est pris en charge avec certaines restrictions. Pour plus d'informations, consultez [COPY depuis les formats de données en colonnes](copy-usage_notes-copy-from-columnar.md). Paramètres du format de données
FORMAT [AS]
(Facultatif) Identifie les mots-clés de format des données. Les arguments FORMAT sont décrits ci-après.
CSV [ QUOTE [AS] *’quote\$1character’* ]
Permet l’utilisation du format CSV dans les données d’entrée. Pour insérer automatiquement des délimiteurs, des caractères de saut de ligne et des retours à la ligne, entourez le champ dans le caractère spécifié par le paramètre QUOTE. Le guillemet par défaut correspond aux guillemets doubles ( " ). Lorsque le guillemet simple est utilisé dans un champ, précédez le caractère d’un guillemet simple supplémentaire. Par exemple, si les guillemets sont doubles, pour insérer la chaîne `A "quoted" word` le fichier d’entrée doit inclure la chaîne `"A ""quoted"" word"`. Lorsque le paramètre CSV est utilisé, le délimiteur par défaut est une virgule ( , ). Vous pouvez spécifier un autre délimiteur en utilisant le paramètre DELIMITER.
Lorsqu’un champ est placé entre guillemets, l’espace blanc entre les délimiteurs et les guillemets est ignoré. Si le délimiteur est un caractère d’espace vide, comme un onglet, le délimiteur n’est pas considéré comme un espace vide.
CSV ne peut pas être utilisé avec FIXEDWIDTH, REMOVEQUOTES ou ESCAPE.
QUOTE [AS] *’quote\$1character’*
Facultatif. Spécifie le caractère à utiliser comme guillemet lorsque vous utilisez le paramètre CSV. La valeur par défaut est les guillemets doubles ( " ). Si vous utilisez le paramètre QUOTE pour définir un autre guillemet que des guillemets doubles, vous n’avez pas besoin d’insérer les guillemets doubles dans le champ. Le paramètre QUOTE peut être utilisé uniquement avec le paramètre CSV. Le mot-clé AS est facultatif.
DELIMITER [AS] [’*delimiter\$1char*’]
Spécifie les caractères qui sont utilisés pour séparer les champs dans le fichier d’entrée, tels qu’une barre verticale ( `|` ), une virgule ( `,` ), une tabulation ( `\t` ) ou plusieurs caractères tels que `|~|`. Les caractères non imprimables sont pris en charge. Les caractères peuvent également être représentés en octal sous forme d’unités de code UTF-8. Pour l’octal, utilisez le format « \$1ddd », où « d » est un chiffre octal (de 0 à 7). Le délimiteur par défaut est une barre verticale ( `|` ), à moins que le paramètre CSV soit utilisé, auquel cas le délimiteur par défaut est une virgule ( `,` ). Le mot-clé AS est facultatif. DELIMITER ne peut pas être utilisé avec FIXEDWIDTH.
FIXEDWIDTH ’*fixedwidth\$1spec*’
Charge les données d’un fichier où la largeur de chaque colonne est une longueur fixe, plutôt que des colonnes séparées par un délimiteur. *fixedwidth\$1spec* est une chaîne qui spécifie une étiquette de colonne définie par l’utilisateur et la largeur de la colonne. L’étiquette de colonne peut être une chaîne de texte ou un nombre entier, en fonction de ce que l’utilisateur choisit. L’étiquette de colonne n’a aucun lien avec le nom de la colonne. L'ordre des label/width paires doit correspondre exactement à l'ordre des colonnes du tableau. FIXEDWIDTH ne peut pas être utilisé avec CSV ou DELIMITER. Dans Amazon Redshift la longueur des colonnes CHAR et VARCHAR est exprimée en octets, aussi n’oubliez pas que la largeur de colonne que vous spécifiez correspond à la longueur binaire de caractères sur plusieurs octets lors de la préparation du fichier à charger. Pour plus d'informations, consultez [Types caractères](r_Character_types.md).
Le format de *fixedwidth\$1spec* apparaît comme suit :
```
'colLabel1:colWidth1,colLabel:colWidth2, ...'
```
SHAPEFILE [ SIMPLIFY [AUTO] [*’tolerance’*] ]
Permet l’utilisation du format CSV dans les données d’entrée. Par défaut, la première colonne du shapefile est une colonne `GEOMETRY` ou `IDENTITY`. Toutes les colonnes suivantes suivent l’ordre spécifié dans le shapefile.
Vous ne pouvez pas utiliser SHAPEFILE avec FIXEDWIDTH, REMOVEQUOTES ou ESCAPE.
Pour utiliser des objets `GEOGRAPHY` avec `COPY FROM SHAPEFILE`, intégrez-les d’abord dans une colonne `GEOMETRY`, puis convertissez-les en objets `GEOGRAPHY`.
SIMPLIFY [*tolerance*]
(Facultatif) Simplifie toutes les géométries pendant le processus d'ingestion à l'aide de l' Ramer-Douglas-Peuckeralgorithme et de la tolérance donnée.
SIMPLIFY AUTO [*tolerance*]
(Facultatif) Simplifie uniquement les géométries supérieures à la taille de géométrie maximale. Cette simplification utilise l' Ramer-Douglas-Peuckeralgorithme et la tolérance calculée automatiquement si celle-ci ne dépasse pas la tolérance spécifiée. Cet algorithme calcule la taille pour stocker les objets dans la tolérance spécifiée. La valeur *tolerance* est facultative.
Pour voir des exemples de chargement de shapefiles, consultez [Chargement d’un shapefile dans Amazon Redshift](r_COPY_command_examples.md#copy-example-spatial-copy-shapefile).
AVRO [AS] ’*avro\$1option*’
Spécifie que les données source sont au format Avro.
Le format Avro est pris en charge pour la commande COPY dans les services et protocoles suivants :
+ Amazon S3
+ Amazon EMR
+ Hôtes distants (SSH)
Avro n’est pas pris en charge pour la commande COPY dans DynamoDB.
Avro est un protocole de sérialisation de données. Un fichier source Avro inclut un schéma qui définit la structure des données. Le type de schéma Avro doit être `record`. La commande COPY accepte la création de fichiers Avro à l’aide du codec non compressé par défaut, ainsi que les codecs de compression `deflate` et `snappy`. Pour plus d’informations sur Avro, accédez à [Apache Avro](https://avro.apache.org/).
Les valeurs valides pour *avro\$1option* sont les suivantes :
+ `'auto'`
+ `'auto ignorecase'`
+ `'s3://jsonpaths_file'`
La valeur par défaut est `'auto'`.
COPY mappe automatiquement les éléments de données des données source Avro aux colonnes de la table cible en mettant en correspondance les noms de champs du schéma Avro avec les noms de colonnes dans la table cible. La mise en correspondance est sensible à la casse pour `'auto'` et n’est pas sensible à la casse pour `'auto ignorecase'`.
Les noms de colonnes des tables Amazon Redshift sont toujours en lettres minuscules, aussi lorsque vous utilisez l’option `'auto'`, les noms de champs correspondants doivent être en minuscules. Si les noms de champs ne sont pas tous en minuscules, vous pouvez utiliser l’option `'auto ignorecase'`. Avec l’argument `'auto'` par défaut, la commande COPY ne reconnaît que le premier niveau de champs (ou *champs externes*) dans la structure.
Pour mapper explicitement les noms de colonnes aux noms de champs Avro, vous pouvez utiliser [JSONPaths fichier](#copy-json-jsonpaths).
Par défaut, la commande COPY tente de mettre en correspondance toutes les colonnes de la table cible avec les noms de champs Avro. Pour charger un sous-ensemble de colonnes, vous pouvez éventuellement spécifier une liste de colonnes. Si une colonne dans la table cible est absente de la liste de colonnes, la commande COPY charge l’expression [DEFAULT](r_CREATE_TABLE_NEW.md#create-table-default) de la colonne cible. Si la colonne cible n’a pas de valeur par défaut, la commande COPY tente de charger NULL. Si une colonne est incluse dans la liste de colonnes et que la commande COPY ne trouve pas de champ correspondant dans les données Avro, la commande COPY tente de charger NULL dans la colonne.
Si la commande COPY tente d’affecter NULL à une colonne qui est définie comme NOT NULL, elle échoue.
**Schéma Avro**
Un fichier de données source Avro inclut un schéma qui définit la structure des données. La commande COPY lit le schéma qui fait partie du fichier de données source Avro pour mapper des éléments de données aux colonnes de la table cible. L’exemple suivant illustre un schéma Avro.
```
{
"name": "person",
"type": "record",
"fields": [
{"name": "id", "type": "int"},
{"name": "guid", "type": "string"},
{"name": "name", "type": "string"},
{"name": "address", "type": "string"}]
}
```
Le schéma Avro est défini à l’aide du format JSON. L’objet de niveau supérieur JSON contient trois paires nom-valeur avec les noms ou *clés*, `"name"`, `"type"` et `"fields"`.
La clé `"fields"` s’apparie à un tableau d’objets qui définissent le nom et le type de données de chaque champ dans la structure de données. Par défaut, la commande COPY met automatiquement en correspondance les noms de champs avec les noms de colonnes. Les noms de colonnes sont toujours en minuscules, les noms de champs correspondants doivent donc toujours être en minuscules, sauf si vous spécifiez l’option `‘auto ignorecase’`. Tous les noms de domaines qui ne correspondent pas à un nom de colonne sont ignorés. L’ordre n’a pas d’importance. Dans l’exemple précédent, la commande COPY mappe aux noms de colonnes `id`, `guid`, `name`, et `address`.
Avec l’argument `'auto'` par défaut, la commande COPY met en correspondance uniquement les objets de premier niveau des colonnes. Pour effectuer un mappage vers des niveaux plus profonds du schéma, ou si les noms de champs et de colonnes ne correspondent pas, utilisez un JSONPaths fichier pour définir le mappage. Pour de plus amples informations, veuillez consulter [JSONPaths fichier](#copy-json-jsonpaths).
Si la valeur associée à une clé est un type de données complexe Avro comme octets, tableau, enregistrement, carte ou lien, la commande COPY charge la valeur sous forme de chaîne. Ici, la chaîne est la représentation JSON des données. La commande COPY charge les types de données d’énumération Avro sous forme de chaînes dans lesquelles le contenu est le nom du type. Pour obtenir un exemple, consultez [Exécution de la commande COPY à partir du format JSON](copy-usage_notes-copy-from-json.md).
La taille maximale de l’en-tête du fichier Avro, qui inclut les métadonnées de fichiers et de schéma, est de 1 Mo.
La taille maximale d’un seul bloc de données Avro est de 4 Mo. Ce qui est différent de la taille de ligne maximale. Si la taille maximale d’un seul bloc de données Avro est dépassée, même si la taille de la ligne qui en résulte est inférieure à la limite de taille de ligne de 4 Mo, la commande COPY échoue.
Lors du calcul de la taille des lignes, Amazon Redshift compte deux fois les barres verticales (\$1) en interne. Si les données entrées contiennent un très grand nombre de barres verticales, la taille des lignes peut dépasser 4 Mo même si la taille du bloc de données est inférieure à 4 Mo.
JSON [AS] ’*json\$1option*’
Les données source sont au format JSON.
Le format JSON est pris en charge pour la commande COPY dans ces services et protocoles :
+ Amazon S3
+ Commande COPY depuis Amazon EMR
+ Exécution de la commande COPY depuis SSH
JSON n’est pas pris en charge pour exécuter la commande COPY dans DynamoDB.
Les valeurs valides pour *json\$1option* sont les suivantes :
+ `'auto'`
+ `'auto ignorecase'`
+ `'s3://jsonpaths_file'`
+ `'noshred'`
La valeur par défaut est `'auto'`. Amazon Redshift ne déchiquète pas les attributs des structures JSON en plusieurs colonnes lors du chargement d’un document JSON.
Par défaut, la commande COPY tente de mettre en correspondance toutes les colonnes de la table cible avec les clés de noms de champs JSON. Pour charger un sous-ensemble de colonnes, vous pouvez éventuellement spécifier une liste de colonnes. Si les clés de nom de domaine JSON ne sont pas toutes en minuscules, vous pouvez utiliser l’option `'auto ignorecase'` ou [JSONPaths fichier](#copy-json-jsonpaths) pour mapper explicitement les noms de colonnes aux clés de nom de domaine JSON.
Si une colonne dans la table cible est absente de la liste de colonnes, la commande COPY charge l’expression [DEFAULT](r_CREATE_TABLE_NEW.md#create-table-default) de la colonne cible. Si la colonne cible n’a pas de valeur par défaut, la commande COPY tente de charger NULL. Si une colonne est incluse dans la liste de colonnes et que la commande COPY ne trouve pas de champ correspondant dans les données JSON, la commande COPY tente de charger NULL dans la colonne.
Si la commande COPY tente d’affecter NULL à une colonne qui est définie comme NOT NULL, elle échoue.
La commande COPY mappe les éléments de données dans les données source JSON aux colonnes de la table cible. Pour cela, elle fait correspondre les *clés d’objet* (ou les noms) dans les paires nom-valeur source aux noms des colonnes de la table cible.
Reportez-vous aux informations suivantes sur chaque valeur *json\$1option* :
’auto’
Avec cette option, la mise en correspondance est sensible à la casse. Les noms de colonnes des tables Amazon Redshift sont toujours en lettres minuscules, aussi lorsque vous utilisez l’option `'auto'`, les noms de champs JSON correspondants doivent être en minuscules.
’auto ignorecase’
Avec cette option, la mise en correspondance n’est pas sensible à la casse. Les noms de colonnes des tables Amazon Redshift étant toujours en minuscules, lorsque vous utilisez la commande `'auto ignorecase'`, les noms de champs JSON correspondants peuvent être en minuscules, en majuscules ou en casse mixte.
’s3://*jsonpaths\$1file*’
Avec cette option, COPY utilise le JSONPaths fichier nommé pour mapper les éléments de données des données sources JSON aux colonnes de la table cible. L’argument *`s3://jsonpaths_file`* doit être une clé d’objet Amazon S3 faisant explicitement référence à un seul fichier. Par exemple : `'s3://amzn-s3-demo-bucket/jsonpaths.txt`’. L’argument ne peut pas être un préfixe de clé. Pour plus d'informations sur l'utilisation d'un JSONPaths fichier, consultez[JSONPaths fichier](#copy-json-jsonpaths).
Dans certains cas, le fichier spécifié par `jsonpaths_file` a le même préfixe que le chemin spécifié par `copy_from_s3_objectpath` pour les fichiers de données. Dans ce cas, COPY lit le JSONPaths fichier sous forme de fichier de données et renvoie des erreurs. Supposons, par exemple, que vos fichiers de données utilisent le chemin de l'objet `s3://amzn-s3-demo-bucket/my_data.json` et que votre JSONPaths fichier le soit`s3://amzn-s3-demo-bucket/my_data.jsonpaths`. Dans ce cas, la commande COPY tente de charger `my_data.jsonpaths` en tant que fichier de données.
’noshred’
Avec cette option, Amazon Redshift ne déchiquète pas les attributs des structures JSON en plusieurs colonnes lors du chargement d’un document JSON.
## Fichier de données JSON
Le fichier de données JSON contient un ensemble d’objets ou tableaux. La commande COPY charge chaque objet ou tableau JSON dans une seule ligne de la table cible. Chaque objet ou tableau correspondant à une ligne doit être une structure autonome, de niveau racine, autrement dit, il ne doit être membre d’une autre structure JSON.
Un *objet* JSON commence et finit par des accolades ( \$1 \$1 ) et contient une collection non ordonnée de paires nom-valeur. Chaque paire de nom et de valeur est séparée par deux points, et les paires sont séparées par des virgules. Par défaut, la *clé d’objet*, ou le nom, dans les paires nom-valeur, doit correspondre au nom de la colonne correspondante dans la table. Les noms de colonnes des tables Amazon Redshift étant toujours en minuscules, les clés des noms de champs JSON correspondants doivent également être en minuscules. Si vos noms de colonnes et clés JSON ne correspondent pas, utilisez un [JSONPaths fichier](#copy-json-jsonpaths) pour mapper explicitement les colonnes aux clés.
L’ordre d’un objet JSON n’est pas important. Tous les noms qui ne correspondent pas à un nom de colonne sont ignorés. L’exemple suivant illustre la structure d’un objet JSON simple.
```
{
"column1": "value1",
"column2": value2,
"notacolumn" : "ignore this value"
}
```
Un *tableau* JSON commence et finit par des crochets ( [ ] ) et contient une collection ordonnée de valeurs séparées par des virgules. Si vos fichiers de données utilisent des tableaux, vous devez spécifier un JSONPaths fichier pour faire correspondre les valeurs aux colonnes. L’exemple suivant illustre la structure d’un tableau JSON simple.
```
["value1", value2]
```
Le JSON doit être dans un format correct. Par exemple, les objets ou les tableaux ne peuvent pas être séparés par des virgules ou tout autre caractère à l’exception des espaces vides. Les chaînes doivent être placées entre guillemets doubles. Les guillemets doivent être des guillemets simples (0x22), ni culbutés, ni courbes.
La taille maximale d’un seul objet ou tableau JSON, y compris les accolades ou les crochets, est de 4 Mo. Ce qui est différent de la taille de ligne maximale. Si la taille maximale d’un seul objet ou tableau JSON est dépassée, même si la taille de la ligne qui en résulte est inférieure à la limite de taille de ligne de 4 Mo, la commande COPY échoue.
Lors du calcul de la taille des lignes, Amazon Redshift compte deux fois les barres verticales (\$1) en interne. Si les données entrées contiennent un très grand nombre de barres verticales, la taille des lignes peut dépasser 4 Mo même si la taille de l’objet est inférieure à 4 Mo.
La commande COPY charge `\n` comme un caractère de saut de ligne et charge `\t` comme un caractère de tabulation. Pour charger une barre oblique inverse, précédez-la d’une barre oblique inverse ( `\\` ).
La commande COPY recherche la source JSON spécifiée pour un objet ou tableau JSON bien formé et valide. Si la commande COPY rencontre des caractères qui ne sont pas des espaces vides avant de localiser une structure JSON utilisable, ou entre des objets ou tableaux JSON valides, elle renvoie une erreur pour chaque instance. Ces erreurs sont prises en compte dans le nombre d’erreurs MAXERROR. Lorsque le nombre d’erreurs est égal ou supérieur à MAXERROR, la commande COPY échoue.
Pour chaque erreur, Amazon Redshift enregistre une ligne dans la table système STL\$1LOAD\$1ERRORS. La colonne LINE\$1NUMBER enregistre la dernière ligne de l’objet JSON qui a provoqué l’erreur.
Si IGNOREHEADER est spécifié, la commande COPY ignore le nombre de lignes dans les données JSON spécifiées. Les caractères de saut de ligne dans les données JSON comptent toujours pour les calculs IGNOREHEADER.
La commande COPY charge des chaînes vides dans les champs vides par défaut. Si EMPTYASNULL est spécifié, la commande COPY charge des chaînes vides dans les champs CHAR et VARCHAR comme NULL. Les chaînes vides d’autres types de données, tels que INT, sont toujours chargées avec NULL.
Les options suivantes ne sont pas prises en charge avec JSON :
+ CSV
+ DELIMITER
+ ESCAPE
+ FILLRECORD
+ FIXEDWIDTH
+ IGNOREBLANKLINES
+ NULL AS
+ READRATIO
+ REMOVEQUOTES
Pour plus d'informations, consultez [Exécution de la commande COPY à partir du format JSON](copy-usage_notes-copy-from-json.md). Pour plus d’informations sur les structures de données JSON, accédez à [www.json.org](https://www.json.org/).
## JSONPaths fichier
Si vous chargez depuis des données source au format JSON ou Avro, la commande COPY mappe par défaut les éléments de données de premier niveau dans les données source aux colonnes de la table cible. Pour ce faire, elle met en correspondance chaque nom (ou clé d’objet) dans une paire nom-valeur avec le nom d’une colonne de la table cible.
Si les noms de vos colonnes et vos clés d'objet ne correspondent pas, ou pour les mapper à des niveaux plus profonds de la hiérarchie des données, vous pouvez utiliser un JSONPaths fichier pour mapper explicitement des éléments de données JSON ou Avro à des colonnes. Le JSONPaths fichier mappe les éléments de données JSON aux colonnes en faisant correspondre l'ordre des colonnes dans la table ou la liste de colonnes cible.
Le JSONPaths fichier ne doit contenir qu'un seul objet JSON (pas un tableau). L’objet JSON est une paire nom-valeur. La *clé d’objet*, qui est le nom de la paire nom-valeur, doit être `"jsonpaths"`. *La *valeur* de la paire nom-valeur est un tableau d'JSONPath expressions.* Chaque JSONPath expression fait référence à un seul élément de la hiérarchie de données JSON ou du schéma Avro, de la même manière qu'une XPath expression fait référence aux éléments d'un document XML. Pour de plus amples informations, veuillez consulter [JSONPath expressions](#copy-json-jsonpath-expressions).
Pour utiliser un JSONPaths fichier, ajoutez le mot clé JSON ou AVRO à la commande COPY. Spécifiez le nom du compartiment S3 et le chemin de l'objet du JSONPaths fichier en utilisant le format suivant.
```
COPY tablename
FROM 'data_source'
CREDENTIALS 'credentials-args'
FORMAT AS { AVRO | JSON } 's3://jsonpaths_file';
```
La valeur `s3://jsonpaths_file` doit être une clé d’objet Amazon S3 faisant explicitement référence à un seul fichier, tel que `'s3://amzn-s3-demo-bucket/jsonpaths.txt'`. Elle ne pas être un préfixe de clé.
Dans certains cas, si vous chargez à partir d’Amazon S3, le fichier spécifié par `jsonpaths_file` a le même préfixe que le chemin spécifié par `copy_from_s3_objectpath` pour les fichiers de données. Dans ce cas, COPY lit le JSONPaths fichier sous forme de fichier de données et renvoie des erreurs. Supposons, par exemple, que vos fichiers de données utilisent le chemin de l'objet `s3://amzn-s3-demo-bucket/my_data.json` et que votre JSONPaths fichier le soit`s3://amzn-s3-demo-bucket/my_data.jsonpaths`. Dans ce cas, la commande COPY tente de charger `my_data.jsonpaths` en tant que fichier de données.
Si le nom de clé est une chaîne autre que `"jsonpaths"`, la commande COPY ne renvoie pas d’erreur, mais elle ignore *jsonpaths\$1file* et utilise l’argument `'auto'` à la place.
Si l’une des actions suivantes se produit, la commande COPY échoue :
+ Le JSON est incorrect.
+ Il existe plusieurs objets JSON.
+ Tous les caractères sauf les espaces vides existent en dehors de l’objet.
+ Un élément de tableau est une chaîne vide ou n’est pas une chaîne.
MAXERROR ne s'applique pas au JSONPaths fichier.
Le JSONPaths fichier ne doit pas être chiffré, même si l'[ENCRYPTED](copy-parameters-data-source-s3.md#copy-encrypted)option est spécifiée.
Pour de plus amples informations, veuillez consulter [Exécution de la commande COPY à partir du format JSON](copy-usage_notes-copy-from-json.md).
## JSONPath expressions
Le JSONPaths fichier utilise des JSONPath expressions pour mapper les champs de données aux colonnes cibles. Chaque JSONPath expression correspond à une colonne de la table cible Amazon Redshift. L'ordre des éléments du JSONPath tableau doit correspondre à l'ordre des colonnes de la table cible ou de la liste des colonnes, si une liste de colonnes est utilisée.
Les guillemets doubles sont obligatoires comme illustré, aussi bien pour les noms de champ que pour les valeurs. Les guillemets doivent être des guillemets simples (0x22), ni culbutés, ni courbes.
Si aucun élément d'objet référencé par une JSONPath expression n'est trouvé dans les données JSON, COPY tente de charger une valeur NULL. Si l’objet référencé est incorrect, la commande COPY renvoie une erreur de chargement.
Si aucun élément de tableau référencé par une JSONPath expression n'est trouvé dans les données JSON ou Avro, COPY échoue avec l'erreur suivante : `Invalid JSONPath format: Not an array or index out of range.` Supprimez tous les éléments du tableau JSONPaths qui n'existent pas dans les données sources et vérifiez que les tableaux des données sources sont bien formés.
Les JSONPath expressions peuvent utiliser la notation entre crochets ou la notation par points, mais vous ne pouvez pas mélanger les notations. L'exemple suivant montre des JSONPath expressions utilisant la notation entre crochets.
```
{
"jsonpaths": [
"$['venuename']",
"$['venuecity']",
"$['venuestate']",
"$['venueseats']"
]
}
```
L'exemple suivant montre des JSONPath expressions utilisant la notation par points.
```
{
"jsonpaths": [
"$.venuename",
"$.venuecity",
"$.venuestate",
"$.venueseats"
]
}
```
Dans le contexte de la syntaxe COPY d'Amazon Redshift, une JSONPath expression doit spécifier le chemin explicite vers un élément de nom unique dans une structure de données hiérarchique JSON ou Avro. Amazon Redshift ne prend en charge aucun JSONPath élément, tel que les caractères génériques ou les expressions de filtre, susceptibles de donner lieu à un chemin ambigu ou à plusieurs éléments de nom.
Pour de plus amples informations, veuillez consulter [Exécution de la commande COPY à partir du format JSON](copy-usage_notes-copy-from-json.md).
## Utilisation JSONPaths avec Avro Data
L’exemple suivant illustre un schéma Avro à plusieurs niveaux.
```
{
"name": "person",
"type": "record",
"fields": [
{"name": "id", "type": "int"},
{"name": "guid", "type": "string"},
{"name": "isActive", "type": "boolean"},
{"name": "age", "type": "int"},
{"name": "name", "type": "string"},
{"name": "address", "type": "string"},
{"name": "latitude", "type": "double"},
{"name": "longitude", "type": "double"},
{
"name": "tags",
"type": {
"type" : "array",
"name" : "inner_tags",
"items" : "string"
}
},
{
"name": "friends",
"type": {
"type" : "array",
"name" : "inner_friends",
"items" : {
"name" : "friends_record",
"type" : "record",
"fields" : [
{"name" : "id", "type" : "int"},
{"name" : "name", "type" : "string"}
]
}
}
},
{"name": "randomArrayItem", "type": "string"}
]
}
```
L'exemple suivant montre un JSONPaths fichier qui utilise des AvroPath expressions pour faire référence au schéma précédent.
```
{
"jsonpaths": [
"$.id",
"$.guid",
"$.address",
"$.friends[0].id"
]
}
```
L' JSONPaths exemple inclut les éléments suivants :
jsonpaths
Nom de l'objet JSON qui contient les AvroPath expressions.
[ … ]
Les crochets entourent le tableau JSON qui contient les éléments de chemin d’accès.
\$1
Le symbole du dollar fait référence à l’élément racine du schéma Avro, qui est le tableau `"fields"`.
"\$1.id",
La cible de l' AvroPath expression. Dans ce cas, la cible est l’élément dans le tableau `"fields"` avec le nom `"id"`. Les expressions sont séparées par des virgules.
"\$1.friends[0].id"
Les crochets indiquent un index de tableau. JSONPath les expressions utilisent une indexation basée sur zéro. Cette expression fait donc référence au premier élément du `"friends"` tableau portant le nom. `"id"`
La syntaxe du schéma Avro nécessite l’utilisation de *champs internes* pour définir la structure d’enregistrement et les types de données du tableau. Les champs internes sont ignorés par les AvroPath expressions. Par exemple, le champ `"friends"` définit un tableau nommé `"inner_friends"`, qui définit à son tour un enregistrement nommé `"friends_record"`. L' AvroPath expression faisant référence au champ `"id"` peut ignorer les champs supplémentaires pour référencer directement le champ cible. Les AvroPath expressions suivantes font référence aux deux champs appartenant au `"friends"` tableau.
```
"$.friends[0].id"
"$.friends[0].name"
```
## Paramètres du format des données en colonnes
En plus des formats de données standard, COPY prend en charge les formats de données en colonnes suivants pour la commande COPY depuis Amazon S3. La commande COPY à partir du format en colonne est pris en charge avec certaines restrictions. Pour plus d'informations, consultez [COPY depuis les formats de données en colonnes](copy-usage_notes-copy-from-columnar.md).
ORC
Charge les données à partir d’un fichier qui utilise le format de fichier ORC (Optimized Row Columnar).
PARQUET
Charge les données à partir d’un fichier qui utilise le format de fichier Parquet.
# Paramètres de compression de fichier
Vous pouvez charger à partir de fichiers de données compressés en spécifiant les paramètres suivants. Paramètres de compression de fichier
BZIP2
Valeur qui indique que le ou les fichiers d’entrée sont au format compressé bzip2 (fichiers .bz2). L’opération COPY lit chaque fichier compressé et décompresse les données qu’elle charge.
GZIP
Valeur qui indique que le ou les fichiers d’entrée sont au format compressé gzip (fichiers .gz). L’opération COPY lit chaque fichier compressé et décompresse les données qu’elle charge.
LZOP
Valeur qui indique que le ou les fichiers d’entrée sont au format compressé lzop (fichiers .lzo). L’opération COPY lit chaque fichier compressé et décompresse les données qu’elle charge.
L’opération COPY ne prend pas en charge les fichiers qui sont compressés à l’aide de l’option lzop *--filter*.
ZSTD
Valeur qui indique que le ou les fichiers d’entrée sont au format compressé Zstandard (fichiers .zst). L’opération COPY lit chaque fichier compressé et décompresse les données qu’elle charge.
ZSTD est pris en charge uniquement avec la commande COPY depuis Amazon S3.
# Paramètres de conversion de données
Lorsqu’elle charge la table, la commande COPY tente implicitement de convertir les chaînes dans les données source vers le type de données de la colonne cible. Si vous devez spécifier une conversion qui est différente du comportement par défaut, ou si la conversion par défaut entraîne des erreurs, vous pouvez gérer les conversions de données en spécifiant les paramètres suivants. Pour plus d’informations sur la syntaxe de ces paramètres, consultez [Syntaxe de la commande COPY](https://docs.aws.amazon.com/redshift/latest/dg/r_COPY.html#r_COPY-syntax).
+ [ACCEPTANYDATE](#copy-acceptanydate)
+ [ACCEPTINVCHARS](#copy-acceptinvchars)
+ [BLANKSASNULL](#copy-blanksasnull)
+ [DATEFORMAT](#copy-dateformat)
+ [EMPTYASNULL](#copy-emptyasnull)
+ [ENCODING](#copy-encoding)
+ [ESCAPE](#copy-escape)
+ [EXPLICIT_IDS](#copy-explicit-ids)
+ [FILLRECORD](#copy-fillrecord)
+ [IGNOREBLANKLINES](#copy-ignoreblanklines)
+ [IGNOREHEADER](#copy-ignoreheader)
+ [NULL AS](#copy-null-as)
+ [REMOVEQUOTES](#copy-removequotes)
+ [ROUNDEC](#copy-roundec)
+ [TIMEFORMAT](#copy-timeformat)
+ [TRIMBLANKS](#copy-trimblanks)
+ [TRUNCATECOLUMNS](#copy-truncatecolumns) Paramètres de conversion de données
ACCEPTANYDATE
Autorise n’importe quel format de date, y compris les formats non valides comme `00/00/00 00:00:00`, à charger sans générer d’erreur. Ce paramètre s’applique uniquement aux colonnes TIMESTAMP et DATE. Utilisez toujours ACCEPTANYDATE avec le paramètre DATEFORMAT. Si le format de date pour les données ne correspond pas à la spécification DATEFORMAT, Amazon Redshift insère une valeur NULL dans ce champ.
ACCEPTINVCHARS [AS] [’*replacement\$1char*’]
Autorise le chargement de données dans les colonnes VARCHAR, même si les données contiennent des caractères UTF-8 non valides. Lorsque ACCEPTINVCHARS est spécifié, la commande COPY remplace chaque caractère UTF-8 non valide par une chaîne de la même longueur comprenant le caractère spécifié par *replacement\$1char*. Par exemple, si le caractère de remplacement est ’`^`’, un caractère non valide de trois octets sera remplacé par ’`^^^`’.
Le caractère de remplacement peut être n’importe quel caractère ASCII sauf NULL. La valeur par défaut est un point d’interrogation ( ? ). Pour plus d’informations sur les caractères UTF-8 non valides, consultez [Erreurs de chargement de caractères multioctets](multi-byte-character-load-errors.md).
La commande COPY renvoie le nombre de lignes qui contenaient des caractères UTF-8 non valides, et ajoute une entrée à la table système [STL\$1REPLACEMENTS](r_STL_REPLACEMENTS.md) pour chaque ligne concernée, à concurrence de 100 lignes au maximum pour chaque tranche de nœud. Les caractères UTF-8 non valides supplémentaires sont également remplacés, mais ces événements de remplacement ne sont pas enregistrés.
Si ACCEPTINVCHARS n’est pas spécifié, la commande COPY renvoie une erreur chaque fois qu’elle rencontre un caractère UTF-8 non valide.
ACCEPTINVCHARS est valide uniquement pour les colonnes VARCHAR.
BLANKSASNULL
Charge les champs vides, qui comprennent des espaces vides uniquement, comme NULL. Cette option s’applique uniquement aux colonnes CHAR et VARCHAR. Les champs vides pour d’autres types de données, tels que INT, sont toujours chargés avec NULL. Par exemple, une chaîne qui contient trois espaces à la suite (et aucun autre caractère) est chargée comme une valeur NULL. Le comportement par défaut, sans cette option, consiste à charger les espaces tels quels.
DATEFORMAT [AS] \$1’*dateformat\$1string*’ \$1 ’auto’ \$1
Si aucun DATEFORMAT n’est spécifié, le format par défaut est `'YYYY-MM-DD'`. Par exemple, un autre format valide est `'MM-DD-YYYY'`.
Si la commande COPY ne reconnaît pas le format de vos valeurs de date ou d’heure, ou si vos valeurs de date ou d’heure utilisent des formats différents, utilisez l’argument `'auto'` avec le paramètre DATEFORMAT ou TIMEFORMAT. L’argument `'auto'` reconnaît plusieurs formats qui ne sont pas pris en charge lors de l’utilisation d’une chaîne DATEFORMAT et TIMEFORMAT. Le mot-clé `'auto'` est sensible à la casse. Pour plus d'informations, consultez [Utilisation de la reconnaissance automatique avec DATEFORMAT et TIMEFORMAT](automatic-recognition.md).
Le format de date peut inclure des informations de temps (heure, minutes, secondes), mais ces informations sont ignorées. Le mot-clé AS est facultatif. Pour plus d'informations, consultez [Chaînes DATEFORMAT et TIMEFORMATExemple](r_DATEFORMAT_and_TIMEFORMAT_strings.md).
EMPTYASNULL
Indique que Amazon Redshift doit charger les champs CHAR et VARCHAR vides comme des valeurs NULL. Les champs vides pour d’autres types de données, tels que INT, sont toujours chargés avec NULL. Les champs vides surviennent lorsque les données contiennent deux délimiteurs de suite sans caractère entre les délimiteurs. EMPTYASNULL et NULL AS ’’ (chaîne vide) entraînent le même comportement.
ENCODING [AS] *file\$1encoding*
Spécifie le type d’encodage des données de chargement. La commande COPY convertit les données de l’encodage spécifié dans UTF-8 pendant le chargement.
Les valeurs valides pour *file\$1encoding* sont les suivantes :
+ `UTF8`
+ `UTF16`
+ `UTF16LE`
+ `UTF16BE`
+ `ISO88591`
La valeur par défaut est `UTF8`.
Les noms de fichier source doivent utiliser l’encodage UTF-8.
Les fichiers suivants doivent utiliser l’encodage UTF-8, même si un autre encodage a été spécifié pour les données de chargement :
+ Fichiers manifestes
+ JSONPaths fichiers
Les chaînes d’arguments fournies avec les paramètres suivants doivent utiliser UTF-8 :
+ FIXEDWIDTH ’*fixedwidth\$1spec*’
+ ACCEPTINVCHARS ’*replacement\$1char*’
+ DATEFORMAT ’*dateformat\$1string*’
+ TIMEFORMAT ’*timeformat\$1string*’
+ NULL AS ’*null\$1string*’
Les fichiers de données de largeur fixe doivent utiliser l’encodage UTF-8. Les largeurs des champs dépendent du nombre de caractères, et non du nombre d’octets.
Toutes les données de chargement doivent utiliser l’encodage spécifié. Si la commande COPY rencontre un autre encodage, elle ignore le fichier et renvoie une erreur.
Si vous spécifiez `UTF16`, vos données doivent comporter une marque d’ordre d’octet. Si vous savez que vos données UTF-16 sont de poids faible (Little endian) ou de poids fort (Big endian), vous pouvez utiliser `UTF16LE` ou `UTF16BE`, indépendamment de la présence d’une marque d’ordre d’octet.
Pour utiliser l’encodage ISO-8859-1, spécifiez `ISO88591`. Pour plus d’informations, consultez [ISO/IEC 8859-1](https://en.wikipedia.org/wiki/ISO/IEC_8859-1) sur *Wikipédia*.
ESCAPE
Lorsque ce paramètre est spécifié, la barre oblique inverse (`\`) dans les données d’entrée est considérée comme un caractère d’échappement. Le caractère qui se trouve immédiatement après la barre oblique inverse est chargé dans la table comme faisant partie de la valeur de la colonne actuelle, même s’il s’agit d’un caractère qui a normalement une fonction particulière. Par exemple, vous pouvez utiliser ce paramètre pour insérer le caractère délimiteur, un guillemet anglais, un caractère de saut de ligne intégré, ou le caractère d’échappement lui-même lorsque l’un de ces caractères fait légitimement partie d’une valeur de la colonne.
Si vous spécifiez le paramètre ESCAPE en liaison avec le paramètre REMOVEQUOTES, vous pouvez insérer et conserver des guillemets doubles (`'` ou `"`) qui peuvent être supprimés dans le cas contraire. La chaîne vide par défaut, `\N`, fonctionne telle quelle, mais elle peut également être insérée dans les données d’entrée en tant que `\\N`. Tant que vous ne spécifiez pas d’autre chaîne nulle avec le paramètre NULL AS, `\N` et `\\N` entraînent les mêmes résultats.
Le caractère de contrôle `0x00` (NUL) ne peut pas être inséré et doit être supprimé des données d’entrée ou converti. Ce caractère est considéré comme une marque de fin d’enregistrement, ce qui entraîne la troncation du reste de l’enregistrement.
Vous ne pouvez pas utiliser le paramètre ESCAPE pour les charges FIXEDWIDTH, et vous ne pouvez pas spécifier le caractère d’échappement lui-même ; il s’agit toujours de la barre oblique inverse. En outre, vous devez vous assurer que les données d’entrée contiennent le caractère d’échappement aux endroits appropriés.
Voici des exemples de données d’entrée et des données chargées résultant de celles-ci lorsque le paramètre ESCAPE est spécifié. Le résultat de la ligne 4 part du principe que le paramètre REMOVEQUOTES est également spécifié. Les données d’entrée se composent de deux champs séparés par une barre verticale :
```
1|The quick brown fox\[newline]
jumped over the lazy dog.
2| A\\B\\C
3| A \| B \| C
4| 'A Midsummer Night\'s Dream'
```
Les données chargées dans la colonne 2 ressemblent à ceci :
```
The quick brown fox
jumped over the lazy dog.
A\B\C
A|B|C
A Midsummer Night's Dream
```
L’application du caractère d’échappement aux données d’entrée pour une charge est de la responsabilité de l’utilisateur, sauf lorsque vous rechargez les données qui ont été précédemment déchargées avec le paramètre ESCAPE. Dans ce cas, les données contiennent déjà les caractères d’échappement nécessaires.
Le paramètre ESCAPE n’interprète pas la notation de séquence d’échappement octale, hexadécimale, Unicode, ou autre. Par exemple, si vos données source contiennent la valeur de saut de ligne octale (`\012`) et que vous essayez de charger ces données avec le paramètre ESCAPE, Amazon Redshift charge la valeur `012` dans la table et ne l’interprète pas comme un saut de ligne qui est en cours d’échappement.
Pour insérer des caractère de saut ligne dans les données qui proviennent de plateformes Microsoft Windows, vous devrez peut-être utiliser deux caractères d’échappement : un pour le retour chariot et un autre pour le saut de ligne. Sinon, vous pouvez supprimer les retours chariot avant de charger le fichier (par exemple, en utilisant l’utilitaire dos2unix).
EXPLICIT\$1IDS
Utilisez EXPLICIT\$1IDS avec des tables ayant des colonnes IDENTITY si vous souhaitez remplacer les valeurs générées automatiquement par des valeurs explicites dans les fichiers de données source pour les tables. Si la commande inclut une liste de colonnes, cette liste doit inclure les colonnes IDENTITY pour utiliser ce paramètre. Le format de données pour les valeurs EXPLICIT\$1IDS doit correspondre au format IDENTITY spécifié par la définition CREATE TABLE.
Lorsque vous exécutez une commande COPY sur une table avec l’option EXPLICIT\$1IDS, Amazon Redshift ne vérifie plus l’unicité des colonnes IDENTITY dans la table.
Si une colonne est définie avec GENERATED BY DEFAULT AS IDENTITY, elle peut être copiée. Les valeurs sont générées ou mises à jour avec des valeurs que vous fournissez. L’option EXPLICIT\$1IDS n’est pas obligatoire. COPY ne met pas à jour le filigrane élevé d’identité.
Pour un exemple de commande COPY utilisant EXPLICIT\$1IDS, consultez [Charger la table VENUE avec des valeurs EXPLICIT pour une colonne IDENTITY](r_COPY_command_examples.md#r_COPY_command_examples-load-venue-with-explicit-values-for-an-identity-column).
FILLRECORD
Autorise le chargement des fichiers de données lorsqu’il manque des colonnes contiguës à la fin de certains des enregistrements. Les colonnes manquantes sont chargées en tant que NULLs. Pour les formats texte et CSV, si la colonne manquante est une colonne VARCHAR, des chaînes de longueur nulle sont chargées à la place de. NULLs Pour charger des colonnes NULLs dans VARCHAR à partir de texte et de CSV, spécifiez le mot clé EMPTYASNULL. La substitution NULL ne fonctionne que si la définition de colonne le permet NULLs.
Par exemple, si la définition de table contient quatre colonnes CHAR qui autorisent la valeur Null, et qu’un enregistrement contient les valeurs `apple, orange, banana, mango`, la commande COPY peut charger et remplir un enregistrement qui contient uniquement les valeurs `apple, orange`. Les valeurs CHAR manquantes seraient chargées en tant que valeurs NULL.
IGNOREBLANKLINES
Ignore les lignes vides qui contiennent uniquement un saut de ligne dans un fichier de données et n’essaie pas de les charger.
IGNOREHEADER [ AS ] *number\$1rows*
Traite les *number\$1rows* spécifiées comme un en-tête de fichier et ne les charge pas. Utilisez IGNOREHEADER pour ignorer les en-têtes de fichier dans tous les fichiers d’une charge parallèle.
NULL AS ’*null\$1string*’
Charge les champs qui mettent en correspondance les *null\$1string* comme NULL, où *null\$1string* peut être une chaîne. Si vos données incluent une marque de fin null, également appelée NUL (UTF-8 0000) ou zéro binaire (0x000), la commande COPY la traite comme tout autre caractère. Par exemple, un enregistrement contenant ’1’ \$1\$1 NUL \$1\$1 ’2’ est copié sous la forme d’une chaîne d’une longueur de 3 octets. Si un champ contient uniquement NUL, vous pouvez utiliser NULL AS pour remplacer la marque de fin null par NULL en spécifiant `'\0'` ou `'\000'`, par exemple, `NULL AS '\0'` ou `NULL AS '\000'`. Si un champ qui contient une chaîne qui se termine par NUL et NULL AS est spécifié, la chaîne est insérée avec NUL à la fin. N’utilisez pas ’\$1n’ (saut de ligne) pour la valeur *null\$1string*. Amazon Redshift réserve ’\$1n’ pour l’utiliser en tant que délimiteur de ligne. La valeur par défaut *null\$1string* est `'\N`’.
Si vous essayez de charger les valeurs null dans une colonne définie comme NOT NULL, la commande COPY échoue.
REMOVEQUOTES
Supprime les guillemets des chaînes dans les données entrantes. Tous les caractères compris entre les guillemets, y compris les délimiteurs, sont conservés. Si une chaîne commence par un guillemet anglais ou des guillemets doubles, sans caractère de fin correspondant, la commande COPY échoue à charger cette ligne et renvoie une erreur. Le tableau suivant présente quelques exemples simples de chaînes contenant des guillemets et les valeurs chargées en conséquence.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/copy-parameters-data-conversion.html)
ROUNDEC
Arrondit les valeurs numériques lorsque l’échelle de la valeur d’entrée est supérieure à l’échelle de la colonne. Par défaut, la commande COPY tronque les valeurs lorsque cela est nécessaire pour s’adapter à l’échelle de la colonne. Par exemple, si une valeur de `20.259` est chargée dans une colonne DECIMAL(8,2), la commande COPY tronque la valeur de `20.25` par défaut. Si ROUNDEC est spécifié, la commande COPY arrondit la valeur de `20.26`. La commande INSERT arrondit toujours les valeurs autant que possible afin de les adapter à l’échelle de la colonne. Une commande COPY avec le paramètre ROUNDEC se comporte donc de la même manière qu’une commande INSERT.
TIMEFORMAT [AS] \$1’*timeformat\$1string*’ \$1 ’auto’ \$1 ’epochsecs’ \$1 ’epochmillisecs’ \$1
Spécifie le format de l’heure. Si aucun TIMEFORMAT n’est spécifié, le format par défaut est `YYYY-MM-DD HH:MI:SS` pour les colonnes TIMESTAMP ou `YYYY-MM-DD HH:MI:SSOF` pour les colonnes TIMESTAMPTZ, `OF` correspondant au décalage par rapport à l’heure UTC (Coordinated Universal Time). Vous ne pouvez pas inclure de spécificateur de fuseau horaire dans *timeformat\$1string*. Pour charger les données TIMESTAMPTZ dont le format est différent du format par défaut, spécifiez « auto ». Pour plus d’informations, consultez [Utilisation de la reconnaissance automatique avec DATEFORMAT et TIMEFORMAT](automatic-recognition.md). Pour plus d’informations sur *timeformat\$1string*, consultez [Chaînes DATEFORMAT et TIMEFORMATExemple](r_DATEFORMAT_and_TIMEFORMAT_strings.md).
L’argument `'auto'` reconnaît plusieurs formats qui ne sont pas pris en charge lors de l’utilisation d’une chaîne DATEFORMAT et TIMEFORMAT. Si la commande COPY ne reconnaît pas le format de vos valeurs de date ou d’heure, ou si vos valeurs de date et d’heure utilisent des formats différents les uns des autres, utilisez l’argument `'auto'` avec le paramètre DATEFORMAT ou TIMEFORMAT. Pour plus d'informations, consultez [Utilisation de la reconnaissance automatique avec DATEFORMAT et TIMEFORMAT](automatic-recognition.md).
Si vos données source sont représentées sous la forme de l’heure d’époque, qui est le nombre de secondes ou de millisecondes depuis le 1er janvier 1970, 00:00:00 UTC, précisez `'epochsecs'` ou `'epochmillisecs'`.
Les mots-clés `'auto'`, `'epochsecs'`, et `'epochmillisecs'` sont sensibles à la casse.
Le mot-clé AS est facultatif.
TRIMBLANKS
Supprime les caractères d’espace vide de fin d’une chaîne VARCHAR. Ce paramètre s’applique uniquement aux colonnes avec un type de données VARCHAR.
TRUNCATECOLUMNS
Tronque les données des colonnes avec le nombre de caractères donné afin qu’il corresponde à la spécification de la colonne. S’applique uniquement aux colonnes avec un type de données VARCHAR ou CHAR et des lignes de 4 Mo ou moins.
# Opérations de chargement de données
Gérez le comportement par défaut de l’opération de chargement pour le dépannage ou pour réduire les temps de chargement en spécifiant les paramètres suivants.
+ [COMPROWS](#copy-comprows)
+ [COMPUPDATE](#copy-compupdate)
+ [IGNOREALLERRORS](#copy-ignoreallerrors)
+ [MAXERROR](#copy-maxerror)
+ [NOLOAD](#copy-noload)
+ [STATUPDATE](#copy-statupdate) Parameters
COMPROWS *numrows*
Permet de spécifier le nombre de lignes à utiliser comme taille d’échantillon pour l’analyse de la compression. L’analyse est exécutée sur les lignes de chaque tranche de données. Par exemple, si vous spécifiez `COMPROWS 1000000` (1 000 000) et que le système contient quatre sections totales, pas plus de 250 000 lignes par section sont lues et analysées.
Si le paramètre COMPROWS n’est pas spécifié, la taille de l’échantillon par défaut est de 100 000 par tranche. Les valeurs du paramètre COMPROWS inférieures à la valeur par défaut de 100 000 lignes par tranche sont automatiquement mises à niveau vers la valeur par défaut. Toutefois, la compression automatique n’aura pas lieu si la quantité de données en cours de chargement n’est pas suffisante pour produire un échantillon représentatif.
Si le nombre défini pour le paramètre COMPROWS dépasse le nombre de lignes dans le fichier d’entrée, la commande COPY produit et exécute toujours l’analyse de la compression sur toutes les lignes disponibles. La plage acceptée pour cet argument est un nombre compris entre 1000 et 2147483647 (2 147 483 647).
COMPUPDATE [ PRESET \$1 \$1 ON \$1 TRUE \$1 \$1 \$1 OFF \$1 FALSE \$1 ]
Permet de contrôler si les encodages de compression sont appliqués automatiquement pendant une exécution de la commande COPY.
Lorsque COMPUPDATE utilise PRESET, la commande COPY choisit l’encodage de compression pour chaque colonne si la table de la cible est vide, même si les colonnes ont déjà des encodages autres que RAW. Les encodages de colonne actuellement spécifiés peuvent être remplacés. L’encodage de chaque colonne est basé sur le type de données de la colonne. Aucune donnée échantillonnée. Amazon Redshift attribue automatiquement l’encodage de compression comme suit :
+ Les colonnes qui sont définies comme des clés de tri se voient attribuer une compression RAW.
+ Les colonnes qui sont définies comme des types de données BOOLEAN, REAL ou DOUBLE PRECISION se voient attribuer une compression RAW.
+ Les colonnes définies comme SMALLINT, INTEGER, BIGINT, DECIMAL, DATE, TIMESTAMP ou TIMESTAMPTZ sont compressées. AZ64
+ Les colonnes définies comme CHAR ou VARCHAR sont affectées à la compression LZO.
Lorsque COMPUPDATE est omis, la commande COPY choisit l’encodage de compression pour chaque colonne uniquement si la table de la cible est vide et si vous n’avez pas spécifié d’encodage (autre que BRUT) pour les colonnes. L’encodage pour chaque colonne est déterminé par Amazon Redshift. Aucune donnée échantillonnée.
Lorsque le paramètre COMPUPDATE est défini sur ON (ou TRUE) ou que le paramètre COMPUPDATE est spécifié sans une option, la commande COPY applique la compression automatique si la table est vide, même si les colonnes de la table contiennent déjà des encodages autres que RAW. Les encodages de colonne actuellement spécifiés peuvent être remplacés. L’encodage de chaque colonne est basé sur une analyse des exemples de données. Pour plus d'informations, consultez [Chargement des tables avec compression automatique](c_Loading_tables_auto_compress.md).
Lorsque le paramètre COMPUPDATE est défini sur OFF (ou FALSE), la compression automatique est désactivée. Les encodages de colonne ne sont pas modifiés.
Pour plus de détails sur la table système utilisée pour analyser la compression, consultez [STL\$1ANALYZE\$1COMPRESSION](r_STL_ANALYZE_COMPRESSION.md).
IGNOREALLERRORS
Vous pouvez spécifier cette option pour ignorer toutes les erreurs qui se produisent pendant l’opération de chargement.
Vous ne pouvez pas spécifier l’option IGNOREALLERRORS si vous spécifiez l’option MAXERROR. Vous ne pouvez pas spécifier l’option IGNOREALLERRORS pour les formats de données en colonnes tels que ORC et Parquet.
MAXERROR [AS] *error\$1count*
Si la charge renvoie le nombre d’erreurs *error\$1count* ou un nombre supérieur, la charge échoue. Si la charge renvoie moins d’erreurs, elle continue et renvoie un message INFO qui indique le nombre de lignes qui n’a pas pu être chargé. Utilisez ce paramètre pour permettre aux charges de continuer lorsque certaines lignes échouent à se charger dans la table en raison d’erreurs de mise en forme ou d’autres incohérences dans les données.
Définissez cette valeur sur `0` ou `1` si vous voulez que la charge échoue dès que la première erreur se produit. Le mot-clé AS est facultatif. La valeur par défaut MAXERROR est `0` et la limite est `100000`.
Le nombre d’erreurs réel signalé peut être supérieur à la valeur du paramètre MAXERROR spécifié en raison de la nature parallèle d’Amazon Redshift. Si un nœud dans le cluster Amazon Redshift détecte que la valeur du paramètre MAXERROR a été dépassée, chaque nœud indique toutes les erreurs qu’il a rencontrées.
NOLOAD
Permet de vérifier la validité du fichier de données sans réellement charger les données. Utilisez le paramètre NOLOAD pour vous assurer que votre fichier de données se charge sans erreur avant d’exécuter la charge de données réelle. L’exécution de COPY avec le paramètre NOLOAD est beaucoup plus rapide que le chargement des données, car il analyse uniquement les fichiers.
STATUPDATE [ \$1 ON \$1 TRUE \$1 \$1 \$1 OFF \$1 FALSE \$1 ]
Permet de définir le calcul automatique et l’actualisation des statistiques de l’optimiseur à la fin d’une commande COPY réussie. Par défaut, si le paramètre STATUPDATE n’est pas utilisé, les statistiques sont mises à jour automatiquement si la table est initialement vide.
Chaque fois qu’une intégration de données dans une table non vide modifie considérablement la taille de la table, nous recommandons la mise à jour des statistiques en exécutant une commande [ANALYSE](r_ANALYZE.md) ou en utilisant l’argument STATUPDATE ON.
Avec le paramètre STATUPDATE ON (ou TRUE), les statistiques sont mises à jour automatiquement, que la table soit initialement vide ou non. Si le paramètre STATUPDATE est utilisé, l’utilisateur actuel doit être soit propriétaire de la table soit un super-utilisateur. Si le paramètre STATUPDATE n’est pas spécifié, seule l’autorisation INSERT est obligatoire.
Avec le paramètre STATUPDATE OFF (ou FALSE), les statistiques ne sont jamais mises à jour.
Pour plus d’informations, consultez [Analyse des tables](t_Analyzing_tables.md).
# Liste alphabétique des paramètres
La liste suivante fournit des liens vers chaque description du paramètre de commande COPY, par ordre alphabétique.
+ [ACCEPTANYDATE](copy-parameters-data-conversion.md#copy-acceptanydate)
+ [ACCEPTINVCHARS](copy-parameters-data-conversion.md#copy-acceptinvchars)
+ [Utilisation de ACCESS\$1KEY\$1ID et SECRET\$1ACCESS\$1KEY](copy-parameters-authorization.md#copy-access-key-id-access)
+ [AVRO](copy-parameters-data-format.md#copy-avro)
+ [BLANKSASNULL](copy-parameters-data-conversion.md#copy-blanksasnull)
+ [BZIP2](copy-parameters-file-compression.md#copy-bzip2)
+ [COMPROWS](copy-parameters-data-load.md#copy-comprows)
+ [COMPUPDATE](copy-parameters-data-load.md#copy-compupdate)
+ [CREDENTIALS](copy-parameters-authorization.md#copy-credentials-cred)
+ [CSV](copy-parameters-data-format.md#copy-csv)
+ [DATEFORMAT](copy-parameters-data-conversion.md#copy-dateformat)
+ [DELIMITER](copy-parameters-data-format.md#copy-delimiter)
+ [EMPTYASNULL](copy-parameters-data-conversion.md#copy-emptyasnull)
+ [ENCODING](copy-parameters-data-conversion.md#copy-encoding)
+ [ENCRYPTED](copy-parameters-data-source-s3.md#copy-encrypted)
+ [ESCAPE](copy-parameters-data-conversion.md#copy-escape)
+ [EXPLICIT_IDS](copy-parameters-data-conversion.md#copy-explicit-ids)
+ [FILLRECORD](copy-parameters-data-conversion.md#copy-fillrecord)
+ [FIXEDWIDTH](copy-parameters-data-format.md#copy-fixedwidth)
+ [FORMAT](copy-parameters-data-format.md#copy-format)
+ [FROM](copy-parameters-data-source-s3.md#copy-parameters-from)
+ [GZIP](copy-parameters-file-compression.md#copy-gzip)
+ [IAM\$1ROLE](copy-parameters-authorization.md#copy-iam-role-iam)
+ [IGNOREALLERRORS](copy-parameters-data-load.md#copy-ignoreallerrors)
+ [IGNOREBLANKLINES](copy-parameters-data-conversion.md#copy-ignoreblanklines)
+ [IGNOREHEADER](copy-parameters-data-conversion.md#copy-ignoreheader)
+ [JSON format for COPY](copy-parameters-data-format.md#copy-json)
+ [LZOP](copy-parameters-file-compression.md#copy-lzop)
+ [MANIFEST](copy-parameters-data-source-s3.md#copy-manifest)
+ [MASTER_SYMMETRIC_KEY](copy-parameters-data-source-s3.md#copy-master-symmetric-key)
+ [MAXERROR](copy-parameters-data-load.md#copy-maxerror)
+ [NOLOAD](copy-parameters-data-load.md#copy-noload)
+ [NULL AS](copy-parameters-data-conversion.md#copy-null-as)
+ [READRATIO](copy-parameters-data-source-dynamodb.md#copy-readratio)
+ [REGION](copy-parameters-data-source-s3.md#copy-region)
+ [REMOVEQUOTES](copy-parameters-data-conversion.md#copy-removequotes)
+ [ROUNDEC](copy-parameters-data-conversion.md#copy-roundec)
+ [SESSION\$1TOKEN](copy-parameters-authorization.md#copy-token)
+ [SHAPEFILE](copy-parameters-data-format.md#copy-shapefile)
+ [SSH](copy-parameters-data-source-ssh.md#copy-ssh)
+ [STATUPDATE](copy-parameters-data-load.md#copy-statupdate)
+ [TIMEFORMAT](copy-parameters-data-conversion.md#copy-timeformat)
+ [TRIMBLANKS](copy-parameters-data-conversion.md#copy-trimblanks)
+ [TRUNCATECOLUMNS](copy-parameters-data-conversion.md#copy-truncatecolumns)
+ [ZSTD](copy-parameters-file-compression.md#copy-zstd)
# Notes d’utilisation
**Topics**
+ [Autorisations d'accès à d'autres AWS ressources](copy-usage_notes-access-permissions.md)
+ [Utilisation de COPY avec des alias de point d’accès Amazon S3](copy-usage_notes-s3-access-point-alias.md)
+ [Chargement de données multioctets à partir d’Amazon S3](copy-usage_notes-multi-byte.md)
+ [Chargement d’une colonne avec le type de données GEOMETRY ou GEOGRAPHY](copy-usage_notes-spatial-data.md)
+ [Chargement du type de données HLLSKETCH](copy-usage_notes-hll.md)
+ [Chargement d’une colonne avec le type de données VARBYTE](copy-usage-varbyte.md)
+ [Erreurs survenant lors de la lecture de plusieurs fichiers](copy-usage_notes-multiple-files.md)
+ [Exécution de la commande COPY à partir du format JSON](copy-usage_notes-copy-from-json.md)
+ [COPY depuis les formats de données en colonnes](copy-usage_notes-copy-from-columnar.md)
+ [Chaînes DATEFORMAT et TIMEFORMAT](r_DATEFORMAT_and_TIMEFORMAT_strings.md)
+ [Utilisation de la reconnaissance automatique avec DATEFORMAT et TIMEFORMAT](automatic-recognition.md)
# Autorisations d'accès à d'autres AWS ressources
Pour déplacer des données entre votre cluster et une autre AWS ressource, telle qu'Amazon S3, Amazon DynamoDB, Amazon EMR ou Amazon EC2, votre cluster doit être autorisé à accéder à la ressource et à effectuer les actions nécessaires. Par exemple, pour charger des données depuis Amazon S3, la commande COPY doit disposer de l’accès LIST au compartiment et de l’accès GET pour les objets du compartiment. Pour plus d’informations sur les autorisations minimales, consultez [Autorisations IAM pour les commandes COPY, UNLOAD et CREATE LIBRARY](#copy-usage_notes-iam-permissions).
Pour obtenir l’autorisation d’accéder à la ressource, votre cluster doit être authentifié. Vous pouvez choisir l’une des méthodes d’authentification suivantes :
+ [Contrôle d’accès basé sur les rôles](#copy-usage_notes-access-role-based)— Pour le contrôle d'accès basé sur les rôles, vous spécifiez un rôle Gestion des identités et des accès AWS (IAM) que votre cluster utilise pour l'authentification et l'autorisation. Pour protéger vos AWS informations d'identification et vos données sensibles, nous vous recommandons vivement d'utiliser l'authentification basée sur les rôles.
+ [Contrôle d’accès basé sur les clés](#copy-usage_notes-access-key-based)— Pour le contrôle d'accès par clé, vous fournissez les informations d' AWS accès (ID de clé d'accès et clé d'accès secrète) d'un utilisateur sous forme de texte brut.
## Contrôle d’accès basé sur les rôles
Avec un contrôle d’accès basé sur les rôles, votre cluster assume temporairement un rôle IAM en votre nom. Puis, selon les autorisations accordées au rôle, votre cluster peut accéder aux ressources AWS requises.
La création d’un *rôle* IAM est similaire à l’octroi d’autorisations à un utilisateur, car il s’agit d’une identité AWS avec des politiques d’autorisation qui déterminent ce que l’identité peut et ne peut pas faire dans AWS. En revanche, plutôt que d’être associé de manière unique à un utilisateur, un rôle peut être assumé par toute entité le nécessitant. En outre, aucune information d’identification (mot de passe ou clés d’accès) n’est associée à celui-ci. Au lieu de cela, si un rôle est associé à un cluster, les clés d’accès sont créées de manière dynamique et fournies au cluster.
Nous vous recommandons d'utiliser le contrôle d'accès basé sur les rôles, car il permet un contrôle plus sûr et plus précis de l'accès aux AWS ressources et aux données utilisateur sensibles, en plus de protéger vos informations d'identification. AWS
L’authentification basée sur les rôles offre les avantages suivants :
+ Vous pouvez utiliser les outils IAM AWS standard pour définir un rôle IAM et l'associer à plusieurs clusters. Lorsque vous modifiez la stratégie d’accès d’un rôle, les modifications sont automatiquement appliquées à tous les clusters qui utilisent ce rôle.
+ Vous pouvez définir des politiques IAM détaillées qui accordent des autorisations à des clusters et à des utilisateurs de base de données spécifiques pour accéder à des AWS ressources et à des actions spécifiques.
+ Votre cluster obtient les informations d’identification de séance temporaires au moment de l’exécution et les actualise en fonction des besoins jusqu’à la fin de l’opération. Si vous utilisez les informations d’identification temporaires basées sur la clé, l’opération échoue si celles-ci expirent avant la fin.
+ Votre ID de clé d’accès et ID de clé d’accès secrète ne sont pas stockés ou transmis dans votre code SQL.
Pour utiliser le contrôle d’accès basé sur les rôles, vous devez d’abord créer un rôle IAM à l’aide du type de rôle de service Amazon Redshift, puis attacher le rôle à votre cluster. Le rôle doit avoir, au minimum, les autorisations répertoriées dans [Autorisations IAM pour les commandes COPY, UNLOAD et CREATE LIBRARY](#copy-usage_notes-iam-permissions). Pour savoir comment créer un rôle IAM et l'associer à votre cluster, consultez la section [Autoriser Amazon Redshift à accéder à AWS d'autres services en votre nom dans le guide](https://docs.aws.amazon.com/redshift/latest/mgmt/authorizing-redshift-service.html) de gestion Amazon *Redshift*.
Vous pouvez ajouter un rôle à un cluster ou afficher les rôles associés à un cluster à l’aide de la console de gestion, de la CLI ou de l’API Amazon Redshift. Pour plus d’informations, consultez [Associer un rôle IAM à un cluster](https://docs.aws.amazon.com/redshift/latest/mgmt/copy-unload-iam-role.html) dans le *Guide de gestion Amazon Redshift*.
Lorsque vous créez un rôle IAM, IAM renvoie un Amazon Resource Name (ARN) pour le rôle. Pour spécifier un rôle IAM, indiquez l’ARN de rôle avec le paramètre [Utilisation du paramètre IAM\$1ROLE](copy-parameters-authorization.md#copy-iam-role) ou le paramètre [Utilisation du paramètre CREDENTIALS](copy-parameters-authorization.md#copy-credentials).
Par exemple, supposons que le rôle suivant est attaché au cluster.
```
"IamRoleArn": "arn:aws:iam::0123456789012:role/MyRedshiftRole"
```
L’exemple suivant de commande COPY utilise le paramètre IAM\$1ROLE avec l’ARN dans l’exemple précédent pour l’authentification et l’accès à Amazon S3.
```
copy customer from 's3://amzn-s3-demo-bucket/mydata'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole';
```
L’exemple suivant de commande COPY utilise le paramètre CREDENTIALS pour spécifier le rôle IAM.
```
copy customer from 's3://amzn-s3-demo-bucket/mydata'
credentials
'aws_iam_role=arn:aws:iam::0123456789012:role/MyRedshiftRole';
```
En outre, un super-utilisateur peut accorder le privilège ASSUMEROLE à des utilisateurs et groupes de base de données afin de fournir l’accès à un rôle pour les opérations COPY. Pour plus d'informations, consultez [GRANT](r_GRANT.md).
## Contrôle d’accès basé sur les clés
Avec le contrôle d'accès basé sur les clés, vous fournissez l'ID de clé d'accès et la clé d'accès secrète à un utilisateur IAM autorisé à accéder aux AWS ressources contenant les données. Vous pouvez utiliser les paramètres [Utilisation des paramètres ACCESS\$1KEY\$1ID et SECRET\$1ACCESS\$1KEY](copy-parameters-authorization.md#copy-access-key-id) ensemble ou le paramètre [Utilisation du paramètre CREDENTIALS](copy-parameters-authorization.md#copy-credentials).
**Note**
Nous vous recommandons vivement d’utiliser un rôle IAM pour l’authentification au lieu de fournir une clé d’accès secrète et un ID de clé d’accès en texte brut. Si vous optez pour le contrôle d'accès par clé, n'utilisez jamais les informations d'identification de votre AWS compte (root). Créez toujours un utilisateur IAM et fournissez l’ID de clé d’accès et la clé d’accès secrète de cet utilisateur. Pour connaître les étapes à suivre pour créer un utilisateur IAM, consultez [Création d’un utilisateur IAM dans votre compte AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_create.html).
Pour vous authentifier à l'aide de ACCESS\$1KEY\$1ID et SECRET\$1ACCESS\$1KEY, remplacez et par l'ID de clé d'accès ** et la clé ** d'accès secrète complète d'un utilisateur autorisé, comme indiqué ci-dessous.
```
ACCESS_KEY_ID ''
SECRET_ACCESS_KEY '';
```
Pour vous authentifier à l'aide du paramètre CREDENTIALS, remplacez ** et ** par l'ID de clé d'accès d'un utilisateur autorisé et la clé d'accès secrète complète, comme indiqué ci-dessous.
```
CREDENTIALS
'aws_access_key_id=;aws_secret_access_key=';
```
L’utilisateur IAM doit avoir, au minimum, les autorisations répertoriées dans [Autorisations IAM pour les commandes COPY, UNLOAD et CREATE LIBRARY](#copy-usage_notes-iam-permissions).
### informations d’identification de sécurité temporaires
Si vous utilisez un contrôle d’accès basé sur la clé, vous pouvez limiter davantage l’accès dont disposent les utilisateurs à vos données en utilisant des informations d’identification de sécurité temporaires. L’authentification basée sur les rôles utilise automatiquement des informations d’identification temporaires.
**Note**
Nous vous recommandons vivement d’utiliser [role-based access control](#copy-usage_notes-access-role-based.phrase) plutôt que de créer des identifiants temporaires et de fournir un ID de clé d’accès et une clé d’accès secrète sous forme de texte brut. Le contrôle d’accès basé sur les rôles utilise automatiquement des informations d’identification temporaires.
Les informations d’identification de sécurité temporaires offrent une sécurité améliorée parce qu’elles sont de courte durée et ne peuvent pas être réutilisées après leur expiration. L’ID de clé d’accès et la clé d’accès secrète générés avec le jeton ne peuvent pas être utilisés sans le jeton et un utilisateur qui dispose de ces informations d’identification de sécurité temporaires peut accéder à vos ressources uniquement jusqu’à ce que les informations d’identification expirent.
Pour accorder aux utilisateurs un accès temporaire à vos ressources, vous devez appeler les opérations d'API AWS Security Token Service (AWS STS). Les opérations AWS STS d'API renvoient des informations d'identification de sécurité temporaires composées d'un jeton de sécurité, d'un identifiant de clé d'accès et d'une clé d'accès secrète. Vous pouvez délivrer des informations d’identification de sécurité temporaires aux utilisateurs qui doivent accéder temporairement à vos ressources. Ces utilisateurs peuvent être des utilisateurs IAM existants, ou bien ils peuvent être des utilisateurs non-AWS . Pour plus d’informations sur les informations d’identification de sécurité temporaires, consultez [Informations d’identification de sécurité temporaires](https://docs.aws.amazon.com/STS/latest/UsingSTS/Welcome.html) dans le Guide de l’utilisateur IAM.
Vous pouvez utiliser les paramètres [Utilisation des paramètres ACCESS\$1KEY\$1ID et SECRET\$1ACCESS\$1KEY](copy-parameters-authorization.md#copy-access-key-id) ensemble avec le paramètre [SESSION\$1TOKEN](copy-parameters-authorization.md#copy-token) ou le paramètre [Utilisation du paramètre CREDENTIALS](copy-parameters-authorization.md#copy-credentials). Vous devez également fournir l’ID de clé d’accès et la clé d’accès secrète qui ont été fournis avec le jeton.
Pour vous authentifier à l'aide de ACCESS\$1KEY\$1ID, SECRET\$1ACCESS\$1KEY et SESSION\$1TOKEN, remplacez et comme indiqué ci-dessous. ** ** **
```
ACCESS_KEY_ID ''
SECRET_ACCESS_KEY ''
SESSION_TOKEN '';
```
Pour vous authentifier à l’aide de CREDENTIALS, ajoutez `session_token=` dans la chaîne d’informations d’identification, comme indiqué ci-après.
```
CREDENTIALS
'aws_access_key_id=;aws_secret_access_key=;session_token=';
```
Une commande COPY avec des informations d’identification de sécurité temporaires est indiquée dans l’exemple suivant.
```
copy table-name
from 's3://objectpath'
access_key_id ''
secret_access_key ''
session_token '';
```
L’exemple suivant charge la table LISTING à l’aide des informations d’identification temporaires et de chiffrement de fichier.
```
copy listing
from 's3://amzn-s3-demo-bucket/data/listings_pipe.txt'
access_key_id ''
secret_access_key ''
session_token ''
master_symmetric_key ''
encrypted;
```
L’exemple suivant charge la table LISTING à l’aide du paramètre CREDENTIALS avec des informations d’identification temporaires et de chiffrement de fichier.
```
copy listing
from 's3://amzn-s3-demo-bucket/data/listings_pipe.txt'
credentials
'aws_access_key_id=;aws_secret_access_key=;session_token=;master_symmetric_key='
encrypted;
```
**Important**
Les informations d’identification de sécurité temporaires doivent être valides pour toute la durée de l’opération COPY ou UNLOAD. Si les informations d’identification de sécurité temporaires arrivent à expiration au cours de l’opération, la commande échoue et la transaction est annulée. Par exemple, si les informations d’identification de sécurité temporaires expirent au bout de 15 minutes et que l’opération COPY dure une heure, cette dernière échouera avant d’être terminée. Si vous utilisez l’accès basé sur les rôles, les informations d’identification de sécurité temporaires sont automatiquement actualisées jusqu’à la fin de l’opération.
## Autorisations IAM pour les commandes COPY, UNLOAD et CREATE LIBRARY
Le rôle IAM ou l’utilisateur référencé par le paramètre CREDENTIALS doit disposer, au minimum, des autorisations suivantes :
+ Pour exécuter la commande COPY depuis Amazon S3, l’autorisation d’exécuter LIST sur le compartiment Amazon S3 et d’exécuter GET sur les objets Amazon S3 en cours de chargement, ainsi que le fichier manifeste, le cas échéant.
+ Pour COPIER depuis Amazon S3, Amazon EMR et des hôtes distants (SSH) avec des données au format JSON, autorisation de LISTER et d'OBTENIR le fichier sur JSONPaths Amazon S3, le cas échéant.
+ Pour exécuter la commande COPY depuis DynamoDB, l’autorisation d’exécuter SCAN et DESCRIBE sur la table DynamoDB qui est en cours de chargement.
+ Pour exécuter la commande COPY depuis un cluster Amazon EMR, l’autorisation pour l’action `ListInstances` sur le cluster Amazon EMR.
+ Pour exécuter la commande UNLOAD sur Amazon S3, les autorisations d’exécuter GET, LIST et PUT pour le compartiment Amazon S3 vers lequel les fichiers de données sont en cours de déchargement.
+ Pour exécuter la commande CREATE LIBRARY depuis Amazon S3, l’autorisation d’exécuter LIST sur le compartiment Amazon S3 et d’exécuter GET sur les objets Amazon S3 qui sont importés
**Note**
Si vous recevez le message d’erreur `S3ServiceException: Access Denied`, lorsque vous exécutez une commande COPY, UNLOAD ou CREATE LIBRARY, votre cluster ne dispose pas des autorisations d’accès appropriées pour Amazon S3.
Vous pouvez gérer les autorisations IAM en attachant une politique IAM à un rôle IAM attaché à votre cluster, à votre utilisateur ou au groupe auquel appartient votre utilisateur. Par exemple, la politique gérée par `AmazonS3ReadOnlyAccess` accorde les autorisations LIST et GET aux ressources Amazon S3. Pour plus d’informations sur les politiques IAM, consultez [Gestion des politiques IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage.html) dans le *Guide de l’utilisateur IAM*.
# Utilisation de COPY avec des alias de point d’accès Amazon S3
COPY prend en charge les alias de point d’accès Amazon S3. Pour plus d’informations, consultez [Utilisation d’un alias de type compartiment pour votre point d’accès](https://docs.aws.amazon.com/AmazonS3/latest/userguide/access-points-alias.html) dans le *Guide de l’utilisateur Amazon Simple Storage Service*.
# Chargement de données multioctets à partir d’Amazon S3
Si vos données incluent des caractères non-ASCII codés sur plusieurs octets (par exemple, les caractères chinois ou cyrilliques), vous devez charger les données dans des colonnes VARCHAR. Le type de données VARCHAR prend en charge les caractères UTF-8 codés sur quatre octets, mais le type de données CHAR n’accepte que les caractères ASCII codés sur un octet. Vous ne pouvez pas charger de caractères codés sur cinq octets ou plus dans des tables Amazon Redshift. Pour plus d'informations, consultez [Caractères multioctets](c_Supported_data_types.md#c_Supported_data_types-multi-byte-characters).
# Chargement d’une colonne avec le type de données GEOMETRY ou GEOGRAPHY
Vous ne pouvez exécuter la commande COPY vers des colonnes `GEOMETRY` ou `GEOGRAPHY` qu’à partir de données d’un fichier texte séparé par des caractères, tel qu’un fichier CSV. Les données doivent être sous la forme hexadécimale du format well-known binary (WKB ou EWKB) ou du format well-known text (WKT ou EWKT) et correspondre à la taille maximale d’une ligne d’entrée unique à la commande COPY. Pour plus d'informations, consultez [COPY](r_COPY.md).
Pour plus d’informations sur la façon de charger à partir d’un fichier de formes, consultez [Chargement d’un shapefile dans Amazon Redshift](spatial-copy-shapefile.md).
Pour plus d’informations sur le type de données `GEOMETRY` ou `GEOGRAPHY`, consultez [Interrogation des données spatiales dans Amazon Redshift](geospatial-overview.md).
# Chargement du type de données HLLSKETCH
Vous pouvez copier les esquisses HLL uniquement dans un format fragmenté ou dense pris en charge par Amazon Redshift. Pour utiliser la commande COPY sur HyperLogLog des esquisses, utilisez le format Base64 pour les HyperLogLog esquisses denses et le format JSON pour les esquisses clairsemées. HyperLogLog Pour de plus amples informations, veuillez consulter [HyperLogLog fonctions](hyperloglog-functions.md).
L’exemple suivant importe les données d’un fichier CSV dans une table à l’aide des commandes CREATE TABLE et COPY. Tout d’abord, l’exemple crée la table `t1` à l’aide de la commande CREATE TABLE.
```
CREATE TABLE t1 (sketch hllsketch, a bigint);
```
Ensuite, il utilise la commande COPY pour importer des données d’un fichier CSV dans la table `t1`.
```
COPY t1 FROM s3://amzn-s3-demo-bucket/unload/' IAM_ROLE 'arn:aws:iam::0123456789012:role/MyRedshiftRole' NULL AS 'null' CSV;
```
# Chargement d’une colonne avec le type de données VARBYTE
Vous pouvez charger des données à partir d’un fichier au format CSV, Parquet et ORC. Pour CSV, les données sont chargées à partir d’un fichier en représentation hexadécimale des données VARBYTE. Vous ne pouvez pas charger les données VARBYTE avec l’option `FIXEDWIDTH`. L’option `ADDQUOTES` ou `REMOVEQUOTES` de COPY n’est pas prise en charge. Une colonne VARBYTE ne peut pas être utilisée comme colonne de partition.
# Erreurs survenant lors de la lecture de plusieurs fichiers
La commande COPY est atomique et transactionnelle. En d’autres termes, même lorsque la commande COPY lit des données de plusieurs fichiers, l’ensemble du processus est considéré comme une seule opération. Si la commande COPY rencontre une erreur de lecture d’un fichier, elle refait automatiquement des tentatives jusqu’à ce que le processus expire (voir [statement\$1timeout](r_statement_timeout.md)) ou si les données ne peuvent pas être téléchargées depuis Amazon S3 pendant une période prolongée (entre 15 et 30 minutes), en s’assurant que chaque fichier est chargé une seule fois. En cas d’échec de la commande COPY, l’ensemble de la transaction est annulé et toutes les modifications sont annulées. Pour plus d’informations sur la gestion des erreurs de chargement, consultez [Résolution des problèmes de chargement de données](t_Troubleshooting_load_errors.md).
Une fois qu’une commande COPY est lancée avec succès, elle n’échoue pas si la séance s’arrête, par exemple lorsque le client se déconnecte. Toutefois, si la commande COPY se trouve dans bloc de transaction BEGIN … END qui ne se termine pas, car la séance s’arrête, toute la transaction, y compris la commande COPY, est annulée. Pour plus d’informations sur les transactions, consultez [BEGIN](r_BEGIN.md).
# Exécution de la commande COPY à partir du format JSON
La structure des données JSON se compose d’un ensemble d’objets ou de tableaux. Un *objet* JSON commence et finit par des accolades, et contient une collection non ordonnée de paires nom-valeur. Chaque paire de nom et de valeur est séparée par deux points, et les paires sont séparées par des virgules. Le nom est une chaîne entre guillemets doubles. Les guillemets doivent être des guillemets simples (0x22), ni culbutés, ni courbes.
Un *tableau* JSON commence et finit par des crochets, et contient une collection ordonnée de valeurs séparées par des virgules. Une valeur peut être une chaîne comprise entre des guillemets doubles, un nombre, une valeur booléenne true ou false, null, un objet JSON ou tableau.
Les tableaux et objets JSON peuvent être imbriqués, ce qui permet d’obtenir une structure de données hiérarchique. L’exemple suivant illustre une structure de données JSON avec deux objets valides.
```
{
"id": 1006410,
"title": "Amazon Redshift Database Developer Guide"
}
{
"id": 100540,
"name": "Amazon Simple Storage Service User Guide"
}
```
L’exemple suivant illustre les mêmes données sous forme de deux tableaux JSON.
```
[
1006410,
"Amazon Redshift Database Developer Guide"
]
[
100540,
"Amazon Simple Storage Service User Guide"
]
```
## Options COPY pour JSON
Vous pouvez spécifier les options suivantes lorsque vous utilisez la commande COPY avec des données au format JSON :
+ `'auto' ` – La commande COPY charge automatiquement les champs à partir du fichier JSON.
+ `'auto ignorecase'` – La commande COPY charge automatiquement les champs à partir du fichier JSON tout en ignorant la casse des noms de champs.
+ `s3://jsonpaths_file`— COPY utilise un JSONPaths fichier pour analyser les données source JSON. Un *JSONPaths fichier* est un fichier texte qui contient un seul objet JSON dont le nom est `"jsonpaths"` associé à un tableau d' JSONPath expressions. Si le nom est une chaîne autre que`"jsonpaths"`, COPY utilise l'`'auto'`argument au lieu du JSONPaths fichier.
Pour des exemples montrant comment charger des données à l'aide de `'auto'``'auto ignorecase'`, ou d'un JSONPaths fichier, et à l'aide d'objets ou de tableaux JSON, consultez[Copier à partir d’exemples JSON](r_COPY_command_examples.md#r_COPY_command_examples-copy-from-json).
## JSONPath option
Dans la syntaxe COPY d'Amazon Redshift, une JSONPath expression indique le chemin explicite vers un élément de nom unique dans une structure de données hiérarchique JSON, en utilisant soit la notation entre crochets, soit la notation par points. Amazon Redshift ne prend en charge aucun JSONPath élément, tel que les caractères génériques ou les expressions de filtre, susceptibles de donner lieu à un chemin ambigu ou à plusieurs éléments de nom. Par conséquent, Amazon Redshift ne peut pas analyser des structures de données complexes, à plusieurs niveaux.
Voici un exemple de JSONPaths fichier contenant des JSONPath expressions utilisant la notation entre crochets. Le symbole du dollar (\$1) représente la structure de niveau racine.
```
{
"jsonpaths": [
"$['id']",
"$['store']['book']['title']",
"$['location'][0]"
]
}
```
Dans l’exemple précédent, `$['location'][0]` fait référence au premier élément d’un tableau. JSON utilise l’indexation de tableau de base zéro. Les index du tableau doivent être des nombres entiers positifs (supérieurs ou égaux à zéro).
L'exemple suivant montre le JSONPaths fichier précédent en utilisant la notation par points.
```
{
"jsonpaths": [
"$.id",
"$.store.book.title",
"$.location[0]"
]
}
```
Vous ne pouvez pas combiner la notation d’accolades et la notation de points dans le tableau `jsonpaths`. Les accolades peuvent être utilisées dans la notation d’accolades et la notation de points pour faire référence à un élément du tableau.
Lorsque vous utilisez la notation par points, les JSONPath expressions ne peuvent pas contenir les caractères suivants :
+ Guillemet anglais (’)
+ Point ( . )
+ Crochets ([ ]), sauf pour faire référence à un élément de tableau
Si la valeur de la paire nom-valeur référencée par une JSONPath expression est un objet ou un tableau, l'objet ou le tableau entier est chargé sous forme de chaîne, y compris les accolades. Par exemple, supposons que vos données JSON contiennent l’objet suivant.
```
{
"id": 0,
"guid": "84512477-fa49-456b-b407-581d0d851c3c",
"isActive": true,
"tags": [
"nisi",
"culpa",
"ad",
"amet",
"voluptate",
"reprehenderit",
"veniam"
],
"friends": [
{
"id": 0,
"name": "Martha Rivera"
},
{
"id": 1,
"name": "Renaldo"
}
]
}
```
L' JSONPath expression renvoie `$['tags']` ensuite la valeur suivante.
```
"["nisi","culpa","ad","amet","voluptate","reprehenderit","veniam"]"
```
L' JSONPath expression renvoie `$['friends'][1]` ensuite la valeur suivante.
```
"{"id": 1,"name": "Renaldo"}"
```
Chaque JSONPath expression du `jsonpaths` tableau correspond à une colonne de la table cible Amazon Redshift. L’ordre des éléments du tableau `jsonpaths` doit correspondre à celui des colonnes de la table cible ou de la liste de colonnes, si une liste de colonnes est utilisée.
Pour des exemples montrant comment charger des données à l'aide de l'`'auto'`argument ou d'un JSONPaths fichier, et à l'aide d'objets ou de tableaux JSON, consultez[Copier à partir d’exemples JSON](r_COPY_command_examples.md#r_COPY_command_examples-copy-from-json).
Pour plus d’informations sur la copie de plusieurs fichiers JSON, consultez [Utilisation d’un manifeste pour spécifier les fichiers de données](loading-data-files-using-manifest.md).
## Caractères d’échappement dans JSON
La commande COPY charge `\n` comme un caractère de saut de ligne et charge `\t` comme un caractère de tabulation. Pour charger une barre oblique inverse, précédez-la d’une barre oblique inverse ( `\\` ).
Par exemple, supposons que le JSON suivant se trouve dans un fichier nommé `escape.json` dans le compartiment `s3://amzn-s3-demo-bucket/json/`.
```
{
"backslash": "This is a backslash: \\",
"newline": "This sentence\n is on two lines.",
"tab": "This sentence \t contains a tab."
}
```
Exécutez les commandes suivantes pour créer la table ESCAPES et charger le fichier JSON.
```
create table escapes (backslash varchar(25), newline varchar(35), tab varchar(35));
copy escapes from 's3://amzn-s3-demo-bucket/json/escape.json'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
format as json 'auto';
```
Interrogez la table ESCAPES pour afficher les résultats.
```
select * from escapes;
backslash | newline | tab
------------------------+-------------------+----------------------------------
This is a backslash: \ | This sentence | This sentence contains a tab.
: is on two lines.
(1 row)
```
## Perte de précision numérique
Vous pouvez perdre de la précision lors du chargement de nombres à partir de fichiers de données en format JSON dans une colonne qui est définie comme un type de données numérique. Certaines valeurs en virgule flottantes ne seront pas représentées de manière exacte sur les systèmes informatiques. De ce fait, des données que vous copiez depuis un fichier JSON sont susceptibles de ne pas être arrondies comme vous vous y attendez. Pour éviter une perte de précision, nous recommandons l’utilisation d’une des autres solutions suivantes :
+ Représenter le nombre sous la forme d’une chaîne en plaçant la valeur entre guillemets doubles.
+ Utiliser [ROUNDEC](copy-parameters-data-conversion.md#copy-roundec) pour arrondir le nombre au lieu de le tronquer.
+ Plutôt que des fichiers JSON ou Avro, utiliser des fichiers CSV, délimités par un caractère, ou des fichiers texte à largeur fixe.
# COPY depuis les formats de données en colonnes
COPY peut charger les données depuis Amazon S3 dans les formats en colonnes suivants :
+ ORC
+ Parquet
Pour des exemples d’utilisation de la commande COPY à partir de formats de données en colonnes, consultez [Exemples de commandes COPY](r_COPY_command_examples.md).
La commande COPY prend en charge les données mises en forme en colonnes avec les considérations suivantes :
+ Le compartiment Amazon S3 doit se trouver dans la même AWS région que la base de données Amazon Redshift.
+ Pour accéder à vos données Amazon S3 via un point de terminaison de VPC, configurez l’accès à l’aide de politiques IAM et de rôles IAM, comme décrit dans [Utilisation d’Amazon Redshift Spectrum avec le routage VPC amélioré](https://docs.aws.amazon.com/redshift/latest/mgmt/spectrum-enhanced-vpc.html) dans le *Guide de gestion Amazon Redshift*.
+ La commande COPY n’applique pas automatiquement l’encodage de compression.
+ Seuls les paramètres COPY suivants sont pris en charge :
+ [ACCEPTINVCHARS](copy-parameters-data-conversion.md#copy-acceptinvchars) lors de la copie à partir d’un fichier ORC ou Parquet.
+ [FILLRECORD](copy-parameters-data-conversion.md#copy-fillrecord)
+ [FROM](copy-parameters-data-source-s3.md#copy-parameters-from)
+ [IAM\$1ROLE](copy-parameters-authorization.md#copy-iam-role)
+ [CREDENTIALS](copy-parameters-authorization.md#copy-credentials)
+ [STATUPDATE ](copy-parameters-data-load.md#copy-statupdate)
+ [MANIFEST](copy-parameters-data-source-s3.md#copy-manifest)
+ [EXPLICIT\$1IDS](copy-parameters-data-conversion.md#copy-explicit-ids)
+ Si la commande COPY rencontre une erreur lors du chargement, la commande échoue. ACCEPTANYDATE et MAXERROR ne sont pas pris en charge pour les types de données en colonnes.
+ Les messages d’erreur sont envoyés au client SQL. Certaines erreurs sont consignées dans STL\$1LOAD\$1ERRORS et STL\$1ERROR.
+ La commande COPY insère les valeurs dans les colonnes de la table cible dans le même ordre que celui où les colonnes se trouvent dans les fichiers de données en colonnes. Le nombre de colonnes de la table cible et le nombre de colonnes du fichier de données doivent correspondre.
+ Si le fichier que vous spécifiez pour l’opération COPY inclut l’une des extensions ci-après, nous décompressons les données sans avoir besoin d’ajouter des paramètres :
+ `.gz`
+ `.snappy`
+ `.bz2`
+ La commande COPY à partir des formats de fichiers Parquet et ORC utilise Redshift Spectrum et l’accès au compartiment. Pour utiliser COPY pour ces formats, assurez-vous qu'aucune politique IAM ne bloque l'utilisation d'Amazon S3 URLs présigné. Les fichiers présignés URLs générés par Amazon Redshift sont valides pendant 1 heure afin qu'Amazon Redshift ait suffisamment de temps pour charger tous les fichiers depuis le compartiment Amazon S3. Une URL présignée unique est générée pour chaque fichier scanné par COPY à partir de formats de données en colonnes. Pour les stratégies de compartiment qui incluent une action `s3:signatureAge`, veillez à définir la valeur sur au moins 3 600 000 millisecondes. Pour plus d’informations, consultez [Utilisation d’Amazon Redshift Spectrum avec le routage VPC amélioré](https://docs.aws.amazon.com/redshift/latest/mgmt/spectrum-enhanced-vpc.html).
+ Le paramètre REGION n’est pas pris en charge avec COPY à partir de formats de données en colonnes. Même si votre compartiment Amazon S3 et votre base de données se trouvent dans le même emplacement Région AWS, vous pouvez rencontrer une erreur, telle que l'argument REGION n'est pas pris en charge pour le COPY basé sur PARQUET.
+ COPY à partir de formats colonnaires prend désormais en charge la mise à l’échelle de la simultanéité. Pour activer la mise à l’échelle de la simultanéité, consultez [Configuration des files d’attente de mise à l’échelle de la simultanéité](https://docs.aws.amazon.com/redshift/latest/dg/concurrency-scaling.html#concurrency-scaling-queues).
# Chaînes DATEFORMAT et TIMEFORMAT
La commande COPY utilise les options DATEFORMAT et TIMEFORMAT pour analyser les valeurs de date et d’heure de vos données sources. DATEFORMAT et TIMEFORMAT sont des chaînes formatées qui doivent correspondre au format des valeurs de date et d’heure de vos données source. Par exemple, une commande COPY chargeant des données source avec la valeur de date `Jan-01-1999` doit inclure la chaîne DATEFORMAT suivante :
```
COPY ...
DATEFORMAT AS 'MON-DD-YYYY'
```
Pour plus d’informations sur la gestion des conversions de données COPY, consultez [Paramètres de conversion de données](https://docs.aws.amazon.com/redshift/latest/dg/copy-parameters-data-conversion.html).
Les chaînes DATEFORMAT et TIMEFORMAT peuvent contenir des séparateurs date/heure (tels que « `-` », « `/` » ou « `:` »), ainsi que les formats datepart et timepart présentés dans la table suivante.
**Note**
Si vous ne pouvez pas faire correspondre le format de vos valeurs de date ou d’heure avec les dateparts et timeparts suivants, ou si vos valeurs de date et d’heure utilisent des formats différents les uns des autres, utilisez l’argument `'auto'` avec le paramètre DATEFORMAT ou TIMEFORMAT. L’argument `'auto'` reconnaît plusieurs formats qui ne sont pas pris en charge lors de l’utilisation d’une chaîne DATEFORMAT ou TIMEFORMAT. Pour plus d’informations, consultez [Utilisation de la reconnaissance automatique avec DATEFORMAT et TIMEFORMAT](automatic-recognition.md).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/r_DATEFORMAT_and_TIMEFORMAT_strings.html)
Le format de date par défaut est YYYY-MM-DD. Le format d'horodatage sans fuseau horaire (TIMESTAMP) par défaut est HH:MI:SS. YYYY-MM-DD L'horodatage par défaut avec fuseau horaire (TIMESTAMPTZ) est YYYY-MM-DD HH:MI:SSOF, où OF est le décalage par rapport à UTC (par exemple, - 8:00. Vous ne pouvez pas inclure de spécificateur de fuseau horaire (TZ, tz ou OF) dans le timeformat\$1string. Le champ des secondes (SS) prend également en charge les fractions de secondes jusqu'à un niveau de détail de la microseconde. Pour charger les données TIMESTAMPTZ qui sont dans un format différent du format par défaut, spécifiez « auto ».
Vous trouverez ci-dessous des exemples de dates ou d’heures que vous pouvez trouver dans vos données sources, ainsi que les chaînes DATEFORMAT ou TIMEFORMAT correspondantes.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/r_DATEFORMAT_and_TIMEFORMAT_strings.html)
## Exemple
Pour obtenir un exemple d’utilisation de TIMEFORMAT, consultez [Charger un horodatage ou une datation](r_COPY_command_examples.md#r_COPY_command_examples-load-a-time-datestamp).
# Utilisation de la reconnaissance automatique avec DATEFORMAT et TIMEFORMAT
Si vous spécifiez `'auto'` comme argument pour le paramètre DATEFORMAT ou TIMEFORMAT, Amazon Redshift détecte et convertit automatiquement le format de date ou d’heure de vos données sources. Vous en trouverez un exemple ci-dessous.
```
copy favoritemovies from 'dynamodb://ProductCatalog'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
dateformat 'auto';
```
Lorsqu’elle est utilisée avec l’argument `'auto'` pour DATEFORMAT et TIMEFORMAT, la commande COPY reconnaît et convertit les formats de date et d’heure répertoriés dans la table de [Chaînes DATEFORMAT et TIMEFORMATExemple](r_DATEFORMAT_and_TIMEFORMAT_strings.md). En outre, l’argument `'auto'` reconnaît les formats suivants qui ne sont pas pris en charge lors de l’utilisation d’une chaîne DATEFORMAT et TIMEFORMAT.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/automatic-recognition.html)
La reconnaissance automatique ne prend pas en charge epochsecs et epochmillisecs.
Pour vérifier si une valeur de date ou d’horodatage est automatiquement convertie, utilisez une fonction CAST pour tenter de convertir la chaîne en une valeur de date ou d’horodatage. Par exemple, les commandes suivantes testent la valeur d’horodatage `'J2345678 04:05:06.789'` :
```
create table formattest (test char(21));
insert into formattest values('J2345678 04:05:06.789');
select test, cast(test as timestamp) as timestamp, cast(test as date) as date from formattest;
test | timestamp | date
----------------------+---------------------+------------
J2345678 04:05:06.789 1710-02-23 04:05:06 1710-02-23
```
Si les données source d’une colonne DATE comprennent des informations sur l’heure, le composant est tronqué. Si les données source d’une colonne TIMESTAMP omettent des informations sur l’heure, 00:00:00 est utilisé comme composant d’heure.
# Exemples de commandes COPY
**Note**
Ces exemples contiennent des sauts de ligne pour faciliter la lecture. N’incluez pas de sauts de ligne, ni d’espaces dans votre chaîne *credentials-args*.
**Topics**
+ [Charger FAVORITEMOVIES depuis une table DynamoDB](#r_COPY_command_examples-load-favoritemovies-from-an-amazon-dynamodb-table)
+ [Charger la table LISTING depuis un compartiment Amazon S3](#r_COPY_command_examples-load-listing-from-an-amazon-s3-bucket)
+ [Charger la table LISTING depuis un cluster Amazon EMR](#copy-command-examples-emr)
+ [Example: COPY from Amazon S3 using a manifest](#copy-command-examples-manifest)
+ [Charger la table LISTING à partir d’un fichier séparés par une barre verticale (délimiteur par défaut)](#r_COPY_command_examples-load-listing-from-a-pipe-delimited-file-default-delimiter)
+ [Charger LISTING en utilisant des données en colonnes en format Parquet](#r_COPY_command_examples-load-listing-from-parquet)
+ [Chargement du LISTING à l’aide de données en colonnes au format ORC](#r_COPY_command_examples-load-listing-from-orc)
+ [Charger la table EVENT avec des options](#r_COPY_command_examples-load-event-with-options)
+ [Charger la table VENUE à partir d’un fichier de données de largeur fixe](#r_COPY_command_examples-load-venue-from-a-fixed-width-data-file)
+ [Charger la table CATEGORY à partir d’un fichier CSV](#load-from-csv)
+ [Charger la table VENUE avec des valeurs EXPLICIT pour une colonne IDENTITY](#r_COPY_command_examples-load-venue-with-explicit-values-for-an-identity-column)
+ [Charger la table TIME à partir d’un fichier GZIP séparé par une barre verticale](#r_COPY_command_examples-load-time-from-a-pipe-delimited-gzip-file)
+ [Charger un horodatage ou une datation](#r_COPY_command_examples-load-a-time-datestamp)
+ [Charger les données d’un fichier avec des valeurs par défaut](#r_COPY_command_examples-load-data-from-a-file-with-default-values)
+ [Exécuter la commande COPY des données avec l’option ESCAPE](#r_COPY_command_examples-copy-data-with-the-escape-option)
+ [Copier à partir d’exemples JSON](#r_COPY_command_examples-copy-from-json)
+ [Copier depuis des exemples Avro](#r_COPY_command_examples-copy-from-avro)
+ [Préparation de fichiers pour la commande COPY avec l’option ESCAPE](#r_COPY_preparing_data)
+ [Chargement d’un shapefile dans Amazon Redshift](#copy-example-spatial-copy-shapefile)
+ [Commande COPY avec l’option NOLOAD](#r_COPY_command_examples-load-noload-option)
+ [Commande COPY avec un délimiteur multioctet et l’option ENCODING](#r_COPY_command_examples-load-encoding-multibyte-delimiter-option)
## Charger FAVORITEMOVIES depuis une table DynamoDB
*Ils AWS SDKs incluent un exemple simple de création d'une table DynamoDB appelée Movies.* (Pour cet exemple, consultez [Mise en route avec DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GettingStarted.html).) L’exemple suivant charge la table Amazon Redshift MOVIES avec les données provenant de la table DynamoDB. La table Amazon Redshift doit déjà exister dans la base de données.
```
copy favoritemovies from 'dynamodb://Movies'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
readratio 50;
```
## Charger la table LISTING depuis un compartiment Amazon S3
L’exemple suivant charge la table LISTING depuis un compartiment Amazon S3. La commande COPY charge tous les fichiers dans le dossier `/data/listing/`.
```
copy listing
from 's3://amzn-s3-demo-bucket/data/listing/'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole';
```
## Charger la table LISTING depuis un cluster Amazon EMR
L’exemple suivant charge la table SALES avec les données délimités par des tabulations des fichiers compressés lzop dans un cluster Amazon EMR. La commande COPY charge tous les fichiers du dossier `myoutput/` qui commencent par `part-`.
```
copy sales
from 'emr://j-SAMPLE2B500FC/myoutput/part-*'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
delimiter '\t' lzop;
```
L’exemple suivant charge la table SALES avec des données au format JSON dans un cluster Amazon EMR. La commande COPY charge tous les fichiers du dossier `myoutput/json/`.
```
copy sales
from 'emr://j-SAMPLE2B500FC/myoutput/json/'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
JSON 's3://amzn-s3-demo-bucket/jsonpaths.txt';
```
## Utilisation d’un manifeste pour spécifier les fichiers de données
Vous pouvez utiliser un manifeste pour vous assurer que votre commande COPY charge tous les fichiers requis et uniquement les fichiers requis, à partir d’Amazon S3. Vous pouvez également utiliser un manifeste lorsque vous avez besoin de charger plusieurs fichiers de différents compartiments ou des fichiers qui ne partagent pas le même préfixe.
Par exemple, supposons que vous devez charger les trois fichiers suivants : `custdata1.txt`, `custdata2.txt` et `custdata3.txt`. Vous pouvez utiliser la commande suivante pour charger tous les fichiers qui commencent par `amzn-s3-demo-bucket` dans `custdata` en spécifiant un préfixe :
```
copy category
from 's3://amzn-s3-demo-bucket/custdata'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole';
```
S’il n’existe que deux des fichiers en raison d’une erreur, la commande COPY charge uniquement ces deux fichiers et se termine correctement, ce qui entraîne une charge de données incomplète. Si le compartiment contient également un fichier indésirable qui utilise le même préfixe, par exemple, un fichier nommé `custdata.backup`, la commande COPY charge ce fichier également, ce qui entraîne le chargement de données indésirables.
Pour vous assurer que tous les fichiers nécessaires sont chargés et pour empêcher que des fichiers indésirables soient chargés, vous pouvez utiliser un fichier manifeste. Le manifeste est un fichier texte au format JSON qui répertorie les fichiers à traiter par la commande COPY. Par exemple, le manifeste suivant charge les trois fichiers dans l’exemple précédent.
```
{
"entries":[
{
"url":"s3://amzn-s3-demo-bucket/custdata.1",
"mandatory":true
},
{
"url":"s3://amzn-s3-demo-bucket/custdata.2",
"mandatory":true
},
{
"url":"s3://amzn-s3-demo-bucket/custdata.3",
"mandatory":true
}
]
}
```
L’indicateur `mandatory` facultatif indique si la commande COPY doit s’arrêter si le fichier n’existe pas. La valeur par défaut est `false`. Quels que soient les paramètres obligatoires, la commande COPY s’arrête si aucun fichier n’est trouvé. Dans cet exemple, la commande COPY renvoie une erreur si l’un des fichiers est introuvable. Les fichiers indésirables qui peuvent avoir été collectés si vous avez spécifié uniquement un préfixe de clé, comme `custdata.backup`, sont ignorés, car ils ne sont pas sur le manifeste.
Lors du chargement des fichiers de données au format ORC or Parquet, le champ `meta` est obligatoire, comme illustré dans l’exemple suivant.
```
{
"entries":[
{
"url":"s3://amzn-s3-demo-bucket1/orc/2013-10-04-custdata",
"mandatory":true,
"meta":{
"content_length":99
}
},
{
"url":"s3://amzn-s3-demo-bucket2/orc/2013-10-05-custdata",
"mandatory":true,
"meta":{
"content_length":99
}
}
]
}
```
L’exemple suivant utilise un manifeste nommé `cust.manifest`.
```
copy customer
from 's3://amzn-s3-demo-bucket/cust.manifest'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
format as orc
manifest;
```
Vous pouvez utiliser un manifeste pour charger les fichiers de différents compartiments ou les fichiers qui ne partagent pas le même préfixe. L’exemple suivant illustre le format JSON permettant de charger des données avec des fichiers dont les noms commencent par un horodatage.
```
{
"entries": [
{"url":"s3://amzn-s3-demo-bucket/2013-10-04-custdata.txt","mandatory":true},
{"url":"s3://amzn-s3-demo-bucket/2013-10-05-custdata.txt","mandatory":true},
{"url":"s3://amzn-s3-demo-bucket/2013-10-06-custdata.txt","mandatory":true},
{"url":"s3://amzn-s3-demo-bucket/2013-10-07-custdata.txt","mandatory":true}
]
}
```
Le manifeste peut répertorier les fichiers qui se trouvent dans différents compartiments, à condition que les compartiments se trouvent dans la même AWS région que le cluster.
```
{
"entries": [
{"url":"s3://amzn-s3-demo-bucket1/custdata1.txt","mandatory":false},
{"url":"s3://amzn-s3-demo-bucket2/custdata1.txt","mandatory":false},
{"url":"s3://amzn-s3-demo-bucket2/custdata2.txt","mandatory":false}
]
}
```
## Charger la table LISTING à partir d’un fichier séparés par une barre verticale (délimiteur par défaut)
L’exemple suivant est un cas très simple dans lequel aucune option n’est spécifiée et le fichier d’entrée contient le délimiteur par défaut, une barre verticale (’\$1’).
```
copy listing
from 's3://amzn-s3-demo-bucket/data/listings_pipe.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole';
```
## Charger LISTING en utilisant des données en colonnes en format Parquet
L’exemple suivant charge des données depuis un dossier sur Amazon S3 nommé parquet.
```
copy listing
from 's3://amzn-s3-demo-bucket/data/listings/parquet/'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
format as parquet;
```
## Chargement du LISTING à l’aide de données en colonnes au format ORC
L’exemple suivant charge des données depuis un dossier sur Amazon S3 nommé `orc`.
```
copy listing
from 's3://amzn-s3-demo-bucket/data/listings/orc/'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
format as orc;
```
## Charger la table EVENT avec des options
L’exemple suivant charge des données séparées par une barre verticale dans la table EVENT et applique les règles suivantes :
+ Si des paires de guillemets anglais sont utilisées pour entourer des chaînes de caractères, elles sont supprimées.
+ Les chaînes vides et les chaînes qui contiennent des espaces vides sont chargées en tant que valeurs NULL.
+ La charge échoue si plus de 5 erreurs sont renvoyées.
+ Les valeurs d’horodatage doivent être conformes au format spécifié ; par exemple, un horodatage valide est `2008-09-26 05:43:12`.
```
copy event
from 's3://amzn-s3-demo-bucket/data/allevents_pipe.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
removequotes
emptyasnull
blanksasnull
maxerror 5
delimiter '|'
timeformat 'YYYY-MM-DD HH:MI:SS';
```
## Charger la table VENUE à partir d’un fichier de données de largeur fixe
```
copy venue
from 's3://amzn-s3-demo-bucket/data/venue_fw.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
fixedwidth 'venueid:3,venuename:25,venuecity:12,venuestate:2,venueseats:6';
```
L’exemple précédent suppose un fichier de données au format identique à celui des exemples de données affichés. Dans le prochain exemple, les espaces se comportent comme des espaces réservés afin que toutes les colonnes soient de la même largeur, tel qu’indiqué dans la spécification :
```
1 Toyota Park Bridgeview IL0
2 Columbus Crew Stadium Columbus OH0
3 RFK Stadium Washington DC0
4 CommunityAmerica BallparkKansas City KS0
5 Gillette Stadium Foxborough MA68756
```
## Charger la table CATEGORY à partir d’un fichier CSV
Supposons que vous voulez charger la table CATEGORY avec les valeurs indiquées dans le tableau suivant.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/r_COPY_command_examples.html)
L’exemple suivant montre le contenu d’un fichier texte avec les champs de valeurs séparés par des virgules.
```
12,Shows,Musicals,Musical theatre
13,Shows,Plays,All "non-musical" theatre
14,Shows,Opera,All opera, light, and "rock" opera
15,Concerts,Classical,All symphony, concerto, and choir concerts
```
Si vous chargez le fichier à l’aide du paramètre DELIMITER pour spécifier des entrées séparées par des virgules, la commande COPY échoue parce que certains champs d’entrée contiennent des virgules. Vous pouvez éviter ce problème en utilisant le paramètre CSV et en entourant les champs qui contiennent des virgules de guillemets. Si le guillemet s’affiche au sein d’une chaîne entre guillemets, vous devez doubler le guillemet. Le guillemet par défaut est double. Vous devez donc ajouter à tous les guillemets doubles des guillemets doubles supplémentaires. Votre nouveau fichier d’entrée ressemble à quelque chose comme ça.
```
12,Shows,Musicals,Musical theatre
13,Shows,Plays,"All ""non-musical"" theatre"
14,Shows,Opera,"All opera, light, and ""rock"" opera"
15,Concerts,Classical,"All symphony, concerto, and choir concerts"
```
En supposant que le nom du fichier est `category_csv.txt`, vous pouvez charger le fichier en utilisant la commande COPY suivante :
```
copy category
from 's3://amzn-s3-demo-bucket/data/category_csv.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
csv;
```
Sinon, pour éviter d’avoir à doubler les guillemets doubles de votre entrée, vous pouvez spécifier un guillemet différent à l’aide du paramètre QUOTE AS. Par exemple, la version suivante de `category_csv.txt` utilise ’`%`’ comme caractère de citation :
```
12,Shows,Musicals,Musical theatre
13,Shows,Plays,%All "non-musical" theatre%
14,Shows,Opera,%All opera, light, and "rock" opera%
15,Concerts,Classical,%All symphony, concerto, and choir concerts%
```
La commande COPY suivante utilise QUOTE AS pour charger `category_csv.txt` :
```
copy category
from 's3://amzn-s3-demo-bucket/data/category_csv.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
csv quote as '%';
```
## Charger la table VENUE avec des valeurs EXPLICIT pour une colonne IDENTITY
L’exemple suivant suppose que lorsque la table VENUE a été créée, au moins une colonne (telle que la colonne `venueid`) a été désignée comme colonne IDENTITY. Cette commande se substitue au comportement IDENTITY par défaut pour la génération automatique de valeurs pour une colonne IDENTITY et charge à la place des valeurs explicites depuis le fichier venue.txt. Amazon Redshift ne vérifie pas si des valeurs IDENTITY dupliquées sont chargées dans la table lors de l’utilisation de l’option EXLICIT\$1IDS.
```
copy venue
from 's3://amzn-s3-demo-bucket/data/venue.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
explicit_ids;
```
## Charger la table TIME à partir d’un fichier GZIP séparé par une barre verticale
L’exemple suivant charge la table TIME à partir d’un fichier GZIP séparé par une barre verticale :
```
copy time
from 's3://amzn-s3-demo-bucket/data/timerows.gz'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
gzip
delimiter '|';
```
## Charger un horodatage ou une datation
L’exemple suivant charge les données avec un horodatage formaté.
**Note**
Le TIMEFORMAT de `HH:MI:SS` peut également prendre en charge des fractions de secondes au-delà de `SS` jusqu’aux microsecondes. Le fichier `time.txt` utilisé dans cet exemple contient une seule ligne, `2009-01-12 14:15:57.119568`.
```
copy timestamp1
from 's3://amzn-s3-demo-bucket/data/time.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
timeformat 'YYYY-MM-DD HH:MI:SS';
```
Le résultat de cette copie est le suivant :
```
select * from timestamp1;
c1
----------------------------
2009-01-12 14:15:57.119568
(1 row)
```
## Charger les données d’un fichier avec des valeurs par défaut
L’exemple suivant utilise une variation de la table VENUE dans la base de données TICKIT. Prenons une table VENUE\$1NEW définie avec l’instruction suivante :
```
create table venue_new(
venueid smallint not null,
venuename varchar(100) not null,
venuecity varchar(30),
venuestate char(2),
venueseats integer not null default '1000');
```
Imaginons un fichier de données venue\$1noseats.txt qui ne contient aucune valeur pour la colonne VENUESEATS, comme illustré dans l’exemple suivant :
```
1|Toyota Park|Bridgeview|IL|
2|Columbus Crew Stadium|Columbus|OH|
3|RFK Stadium|Washington|DC|
4|CommunityAmerica Ballpark|Kansas City|KS|
5|Gillette Stadium|Foxborough|MA|
6|New York Giants Stadium|East Rutherford|NJ|
7|BMO Field|Toronto|ON|
8|The Home Depot Center|Carson|CA|
9|Dick's Sporting Goods Park|Commerce City|CO|
10|Pizza Hut Park|Frisco|TX|
```
L’instruction COPY suivante charge correctement la table depuis le fichier et applique la valeur DEFAULT (’1000’) à la colonne omise :
```
copy venue_new(venueid, venuename, venuecity, venuestate)
from 's3://amzn-s3-demo-bucket/data/venue_noseats.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
delimiter '|';
```
Maintenant, affichez la table chargée :
```
select * from venue_new order by venueid;
venueid | venuename | venuecity | venuestate | venueseats
---------+----------------------------+-----------------+------------+------------
1 | Toyota Park | Bridgeview | IL | 1000
2 | Columbus Crew Stadium | Columbus | OH | 1000
3 | RFK Stadium | Washington | DC | 1000
4 | CommunityAmerica Ballpark | Kansas City | KS | 1000
5 | Gillette Stadium | Foxborough | MA | 1000
6 | New York Giants Stadium | East Rutherford | NJ | 1000
7 | BMO Field | Toronto | ON | 1000
8 | The Home Depot Center | Carson | CA | 1000
9 | Dick's Sporting Goods Park | Commerce City | CO | 1000
10 | Pizza Hut Park | Frisco | TX | 1000
(10 rows)
```
Pour l’exemple suivant, en plus de supposer qu’aucune donnée VENUESEATS n’est incluse dans le fichier, supposons également qu’aucune donnée VENUENAME n’est incluse :
```
1||Bridgeview|IL|
2||Columbus|OH|
3||Washington|DC|
4||Kansas City|KS|
5||Foxborough|MA|
6||East Rutherford|NJ|
7||Toronto|ON|
8||Carson|CA|
9||Commerce City|CO|
10||Frisco|TX|
```
A l’aide de la même définition de table, l’instructions COPY suivante échoue, car aucune valeur DEFAULT n’a été spécifié pour VENUENAME et VENUENAME est une colonne NOT NULL :
```
copy venue(venueid, venuecity, venuestate)
from 's3://amzn-s3-demo-bucket/data/venue_pipe.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
delimiter '|';
```
Maintenant, prenons une variation de la table VENUE qui utilise une colonne IDENTITY :
```
create table venue_identity(
venueid int identity(1,1),
venuename varchar(100) not null,
venuecity varchar(30),
venuestate char(2),
venueseats integer not null default '1000');
```
Comme dans l’exemple précédent, supposons que la colonne VENUESEATS n’a aucune valeur correspondante dans le fichier source. L’instruction COPY suivante charge la table avec succès, y compris les valeurs de données IDENTITY prédéfinies au lieu de générer ces valeurs :
```
copy venue(venueid, venuename, venuecity, venuestate)
from 's3://amzn-s3-demo-bucket/data/venue_pipe.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
delimiter '|' explicit_ids;
```
Cette instruction échoue, car elle n’inclut pas la colonne IDENTITY (VENUEID est manquante dans la liste de colonnes) mais inclut un paramètre EXPLICIT\$1IDS :
```
copy venue(venuename, venuecity, venuestate)
from 's3://amzn-s3-demo-bucket/data/venue_pipe.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
delimiter '|' explicit_ids;
```
Cette instruction échoue, car elle n’inclut pas un paramètre EXPLICIT\$1IDS :
```
copy venue(venueid, venuename, venuecity, venuestate)
from 's3://amzn-s3-demo-bucket/data/venue_pipe.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
delimiter '|';
```
## Exécuter la commande COPY des données avec l’option ESCAPE
L’exemple suivant présente le chargement des caractères qui correspondent au délimiteur (dans ce cas, la barre verticale). Dans le fichier d’entrée, assurez-vous qu’une barre oblique inverse (\$1) est ajoutée à toutes les barres verticales (\$1) que vous voulez charger. Puis chargez le fichier avec le paramètre ESCAPE.
```
$ more redshiftinfo.txt
1|public\|event\|dwuser
2|public\|sales\|dwuser
create table redshiftinfo(infoid int,tableinfo varchar(50));
copy redshiftinfo from 's3://amzn-s3-demo-bucket/data/redshiftinfo.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
delimiter '|' escape;
select * from redshiftinfo order by 1;
infoid | tableinfo
-------+--------------------
1 | public|event|dwuser
2 | public|sales|dwuser
(2 rows)
```
Sans le paramètre ESCAPE, cette commande COPY échoue avec une erreur `Extra column(s) found`.
**Important**
Si vous chargez vos données à l’aide d’une commande COPY avec le paramètre ESCAPE, vous devez également spécifier le paramètre ESCAPE avec votre commande UNLOAD pour générer le fichier de sortie réciproque. De même, si vous exécuter la commande UNLOAD à l’aide du paramètre ESCAPE, vous devez utiliser la commande ESCAPE lorsque vous exécutez la commande COPY sur les mêmes données.
## Copier à partir d’exemples JSON
Dans les exemples suivants, vous chargez la table CATEGORY avec les données suivantes.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/r_COPY_command_examples.html)
**Topics**
+ [Charger des données JSON à l’aide de l’option ’auto’](#copy-from-json-examples-using-auto)
+ [Charger des données JSON à l’aide de l’option ’auto ignorecase’](#copy-from-json-examples-using-auto-ignorecase)
+ [Charger à partir de données JSON à l'aide d'un JSONPaths fichier](#copy-from-json-examples-using-jsonpaths)
+ [Chargement à partir de tableaux JSON à l'aide d'un JSONPaths fichier](#copy-from-json-examples-using-jsonpaths-arrays)
### Charger des données JSON à l’aide de l’option ’auto’
Pour charger des données JSON à l’aide de l’option `'auto'`, les données JSON doivent consister en un ensemble d’objets. Les noms de clés doivent correspondre aux noms de colonnes, mais dans ce cas, l’ordre n’a pas d’importance. Ce qui suit montre le contenu d’un fichier nommé `category_object_auto.json`.
```
{
"catdesc": "Major League Baseball",
"catid": 1,
"catgroup": "Sports",
"catname": "MLB"
}
{
"catgroup": "Sports",
"catid": 2,
"catname": "NHL",
"catdesc": "National Hockey League"
}
{
"catid": 3,
"catname": "NFL",
"catgroup": "Sports",
"catdesc": "National Football League"
}
{
"bogus": "Bogus Sports LLC",
"catid": 4,
"catgroup": "Sports",
"catname": "NBA",
"catdesc": "National Basketball Association"
}
{
"catid": 5,
"catgroup": "Shows",
"catname": "Musicals",
"catdesc": "All symphony, concerto, and choir concerts"
}
```
Pour charger depuis le fichier de données JSON dans l’exemple précédent, exécutez la commande COPY suivante.
```
copy category
from 's3://amzn-s3-demo-bucket/category_object_auto.json'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
json 'auto';
```
### Charger des données JSON à l’aide de l’option ’auto ignorecase’
Pour charger des données JSON à l’aide de l’option `'auto ignorecase'`, les données JSON doivent consister en un ensemble d’objets. Le cas des noms de clés n’a pas besoin de correspondre aux noms de colonnes et l’ordre n’a pas d’importance. Ce qui suit montre le contenu d’un fichier nommé `category_object_auto-ignorecase.json`.
```
{
"CatDesc": "Major League Baseball",
"CatID": 1,
"CatGroup": "Sports",
"CatName": "MLB"
}
{
"CatGroup": "Sports",
"CatID": 2,
"CatName": "NHL",
"CatDesc": "National Hockey League"
}
{
"CatID": 3,
"CatName": "NFL",
"CatGroup": "Sports",
"CatDesc": "National Football League"
}
{
"bogus": "Bogus Sports LLC",
"CatID": 4,
"CatGroup": "Sports",
"CatName": "NBA",
"CatDesc": "National Basketball Association"
}
{
"CatID": 5,
"CatGroup": "Shows",
"CatName": "Musicals",
"CatDesc": "All symphony, concerto, and choir concerts"
}
```
Pour charger depuis le fichier de données JSON dans l’exemple précédent, exécutez la commande COPY suivante.
```
copy category
from 's3://amzn-s3-demo-bucket/category_object_auto ignorecase.json'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
json 'auto ignorecase';
```
### Charger à partir de données JSON à l'aide d'un JSONPaths fichier
Si les objets de données JSON ne correspondent pas directement aux noms de colonnes, vous pouvez utiliser un JSONPaths fichier pour mapper les éléments JSON aux colonnes. L'ordre n'a pas d'importance dans les données source JSON, mais l'ordre des expressions de JSONPaths fichier doit correspondre à l'ordre des colonnes. Supposons que vous ayez le fichier de données suivant, nommé `category_object_paths.json`.
```
{
"one": 1,
"two": "Sports",
"three": "MLB",
"four": "Major League Baseball"
}
{
"three": "NHL",
"four": "National Hockey League",
"one": 2,
"two": "Sports"
}
{
"two": "Sports",
"three": "NFL",
"one": 3,
"four": "National Football League"
}
{
"one": 4,
"two": "Sports",
"three": "NBA",
"four": "National Basketball Association"
}
{
"one": 6,
"two": "Shows",
"three": "Musicals",
"four": "All symphony, concerto, and choir concerts"
}
```
Le JSONPaths fichier suivant, nommé`category_jsonpath.json`, met en correspondance les données source avec les colonnes du tableau.
```
{
"jsonpaths": [
"$['one']",
"$['two']",
"$['three']",
"$['four']"
]
}
```
Pour charger depuis le fichier de données JSON dans l’exemple précédent, exécutez la commande COPY suivante.
```
copy category
from 's3://amzn-s3-demo-bucket/category_object_paths.json'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
json 's3://amzn-s3-demo-bucket/category_jsonpath.json';
```
### Chargement à partir de tableaux JSON à l'aide d'un JSONPaths fichier
Pour charger à partir de JSON des données constituées d'un ensemble de tableaux, vous devez utiliser un JSONPaths fichier pour mapper les éléments du tableau aux colonnes. Supposons que vous ayez le fichier de données suivant, nommé `category_array_data.json`.
```
[1,"Sports","MLB","Major League Baseball"]
[2,"Sports","NHL","National Hockey League"]
[3,"Sports","NFL","National Football League"]
[4,"Sports","NBA","National Basketball Association"]
[5,"Concerts","Classical","All symphony, concerto, and choir concerts"]
```
Le JSONPaths fichier suivant, nommé`category_array_jsonpath.json`, met en correspondance les données source avec les colonnes du tableau.
```
{
"jsonpaths": [
"$[0]",
"$[1]",
"$[2]",
"$[3]"
]
}
```
Pour charger depuis le fichier de données JSON dans l’exemple précédent, exécutez la commande COPY suivante.
```
copy category
from 's3://amzn-s3-demo-bucket/category_array_data.json'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
json 's3://amzn-s3-demo-bucket/category_array_jsonpath.json';
```
## Copier depuis des exemples Avro
Dans les exemples suivants, vous chargez la table CATEGORY avec les données suivantes.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/r_COPY_command_examples.html)
**Topics**
+ [Charger à partir des données Avro à l’aide de l’option ’auto’](#copy-from-avro-examples-using-auto)
+ [Charger à partir des données Avro à l’aide de l’option ’auto ignorecase’](#copy-from-avro-examples-using-auto-ignorecase)
+ [Charger des données depuis Avro à l'aide d'un fichier JSONPaths](#copy-from-avro-examples-using-avropaths)
### Charger à partir des données Avro à l’aide de l’option ’auto’
Pour charger à partir des données Avro à l’aide de l’argument `'auto'`, les noms de champs du schéma Avro doivent correspondre aux noms de colonnes. Lorsque vous utilisez l’argument `'auto'`, l’ordre n’est pas important. Ce qui suit montre le schéma d’un fichier nommé `category_auto.avro`.
```
{
"name": "category",
"type": "record",
"fields": [
{"name": "catid", "type": "int"},
{"name": "catdesc", "type": "string"},
{"name": "catname", "type": "string"},
{"name": "catgroup", "type": "string"},
}
```
Les données contenues dans un fichier Avro sont au format binaire, elles ne sont donc pas explicites. L’exemple suivant illustre une représentation JSON des données dans le fichier `category_auto.avro`.
```
{
"catid": 1,
"catdesc": "Major League Baseball",
"catname": "MLB",
"catgroup": "Sports"
}
{
"catid": 2,
"catdesc": "National Hockey League",
"catname": "NHL",
"catgroup": "Sports"
}
{
"catid": 3,
"catdesc": "National Basketball Association",
"catname": "NBA",
"catgroup": "Sports"
}
{
"catid": 4,
"catdesc": "All symphony, concerto, and choir concerts",
"catname": "Classical",
"catgroup": "Concerts"
}
```
Pour charger depuis le fichier de données Avro dans l’exemple précédent, exécutez la commande COPY suivante.
```
copy category
from 's3://amzn-s3-demo-bucket/category_auto.avro'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
format as avro 'auto';
```
### Charger à partir des données Avro à l’aide de l’option ’auto ignorecase’
Pour charger à partir des données Avro à l’aide de l’argument `'auto ignorecase'`, la casse des noms de champs du schéma Avro ne doit pas forcément correspondre à celle des noms de colonnes. Lorsque vous utilisez l’argument `'auto ignorecase'`, l’ordre n’est pas important. Ce qui suit montre le schéma d’un fichier nommé `category_auto-ignorecase.avro`.
```
{
"name": "category",
"type": "record",
"fields": [
{"name": "CatID", "type": "int"},
{"name": "CatDesc", "type": "string"},
{"name": "CatName", "type": "string"},
{"name": "CatGroup", "type": "string"},
}
```
Les données contenues dans un fichier Avro sont au format binaire, elles ne sont donc pas explicites. L’exemple suivant illustre une représentation JSON des données dans le fichier `category_auto-ignorecase.avro`.
```
{
"CatID": 1,
"CatDesc": "Major League Baseball",
"CatName": "MLB",
"CatGroup": "Sports"
}
{
"CatID": 2,
"CatDesc": "National Hockey League",
"CatName": "NHL",
"CatGroup": "Sports"
}
{
"CatID": 3,
"CatDesc": "National Basketball Association",
"CatName": "NBA",
"CatGroup": "Sports"
}
{
"CatID": 4,
"CatDesc": "All symphony, concerto, and choir concerts",
"CatName": "Classical",
"CatGroup": "Concerts"
}
```
Pour charger depuis le fichier de données Avro dans l’exemple précédent, exécutez la commande COPY suivante.
```
copy category
from 's3://amzn-s3-demo-bucket/category_auto-ignorecase.avro'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
format as avro 'auto ignorecase';
```
### Charger des données depuis Avro à l'aide d'un fichier JSONPaths
Si les noms de champs du schéma Avro ne correspondent pas directement aux noms de colonnes, vous pouvez utiliser un JSONPaths fichier pour mapper les éléments du schéma aux colonnes. L'ordre des expressions du JSONPaths fichier doit correspondre à l'ordre des colonnes.
Supposons que vous ayez un fichier de données nommé `category_paths.avro` qui contient les mêmes données que dans l’exemple précédent, mais avec le schéma suivant.
```
{
"name": "category",
"type": "record",
"fields": [
{"name": "id", "type": "int"},
{"name": "desc", "type": "string"},
{"name": "name", "type": "string"},
{"name": "group", "type": "string"},
{"name": "region", "type": "string"}
]
}
```
Le JSONPaths fichier suivant, nommé`category_path.avropath`, met en correspondance les données source avec les colonnes du tableau.
```
{
"jsonpaths": [
"$['id']",
"$['group']",
"$['name']",
"$['desc']"
]
}
```
Pour charger depuis le fichier de données Avro dans l’exemple précédent, exécutez la commande COPY suivante.
```
copy category
from 's3://amzn-s3-demo-bucket/category_object_paths.avro'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
format avro 's3://amzn-s3-demo-bucket/category_path.avropath ';
```
## Préparation de fichiers pour la commande COPY avec l’option ESCAPE
L’exemple suivant décrit comment préparer les données pour insérer des caractères de saut de ligne avant d’importer les données dans une table Amazon Redshift à l’aide de la commande COPY avec le paramètre ESCAPE. Si vous ne préparez pas les données afin de délimiter les caractères de saut ligne, Amazon Redshift renvoie des erreurs de charge lorsque vous exécutez la commande COPY, car le caractère de saut de ligne est généralement utilisé comme séparateur d’enregistrements.
Par exemple, prenons un fichier ou une colonne dans une table externe que vous voulez copier dans une table Amazon Redshift. Si le fichier ou la colonne contient des données de contenu au format XML ou similaires, vous devez vous assurer que tous les caractères de saut de ligne (\$1n) qui font partie du contenu sont insérés avec la barre oblique inverse (\$1).
Si un fichier ou une table contient des caractères de saut de ligne imbriqués, cela offre un modèle relativement facile à mettre en correspondance. Chaque caractère de saut de ligne imbriqué suit presque toujours un caractère `>` avec, potentiellement, des caractères d’espace (`' '` ou une tabulation) entre les deux, comme vous pouvez le voir dans l’exemple suivant d’un fichier texte intitulé `nlTest1.txt`.
```
$ cat nlTest1.txt
|1000
|2000
```
Avec l’exemple suivant, vous pouvez exécuter un utilitaire de traitement de texte permettant de prétraiter le fichier source et d’insérer des caractères d’échappement si nécessaire. (Le caractère `|` est destiné à être utilisé comme délimiteur pour séparer les données de la colonne lorsqu’elles sont copiées dans une table Amazon Redshift.)
```
$ sed -e ':a;N;$!ba;s/>[[:space:]]*\n/>\\\n/g' nlTest1.txt > nlTest2.txt
```
De même, vous pouvez utiliser Perl pour effectuer une opération similaire :
```
cat nlTest1.txt | perl -p -e 's/>\s*\n/>\\\n/g' > nlTest2.txt
```
Pour faciliter le chargement des données à partir du fichier `nlTest2.txt` dans Amazon Redshift, nous avons créé une table à deux colonnes dans Amazon Redshift. La première colonne c1, est une colonne de caractères dont le contenu est au format XML issu du fichier `nlTest2.txt`. La deuxième colonne c2 contient des valeurs de nombres entiers chargés à partir du même fichier.
Après avoir exécuté la commande `sed`, vous pouvez charger correctement des données à partir du fichier `nlTest2.txt` dans une table Amazon Redshift à l’aide du paramètre ESCAPE.
**Note**
Lorsque vous incluez le paramètre ESCAPE avec la commande COPY, il insère un certain nombre de caractères spéciaux, parmi lesquels la barre oblique (ainsi que le saut de ligne).
```
copy t2 from 's3://amzn-s3-demo-bucket/data/nlTest2.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
escape
delimiter as '|';
select * from t2 order by 2;
c1 | c2
-------------+------
| 1000
| 2000
(2 rows)
```
Vous pouvez préparer les fichiers de données exportés à partir de bases de données externes d’une manière similaire. Par exemple, avec une base de données Oracle, vous pouvez utiliser la fonction REPLACE sur chaque colonne concernée dans une table que vous voulez copier dans Amazon Redshift.
```
SELECT c1, REPLACE(c2, \n',\\n' ) as c2 from my_table_with_xml
```
En outre, de nombreux outils d’exportation et d’extraction, de transformation, de chargement (ETL) de la base de données qui traitent régulièrement de grandes quantités de données offrent des options permettant de spécifier des caractères d’échappement et délimiteurs.
## Chargement d’un shapefile dans Amazon Redshift
Les exemples suivants montrent comment charger un shapefile Esri à l’aide de la commande COPY. Pour plus d’informations sur le chargement des fichiers de forme, consultez [Chargement d’un shapefile dans Amazon Redshift](spatial-copy-shapefile.md).
### Chargement d’un shapefile
Les étapes suivantes montrent comment ingérer des OpenStreetMap données depuis Amazon S3 à l'aide de la commande COPY. Cet exemple suppose que l'archive du shapefile de Norvège [provenant du site de téléchargement de](https://download.geofabrik.de/europe.html) Geofabrik a été chargée dans un compartiment Amazon S3 privé de votre région. AWS Les fichiers `.shp`, `.shx` et `.dbf` doivent partager le même préfixe et le même nom de fichier Amazon S3.
#### Intégration des données sans simplification
Les commandes suivantes créent des tables et intègrent des données qui peuvent s’adapter à la taille géométrique maximale sans aucune simplification. Ouvrez `gis_osm_natural_free_1.shp` dans votre logiciel SIG préféré et inspectez les colonnes de cette couche. Par défaut, les colonnes IDENTITY ou GEOMETRY sont les premières. Lorsque la première colonne est une colonne GEOMETRY, vous pouvez créer la table comme indiqué ci-dessous.
```
CREATE TABLE norway_natural (
wkb_geometry GEOMETRY,
osm_id BIGINT,
code INT,
fclass VARCHAR,
name VARCHAR);
```
Sinon, lorsque la première colonne est une colonne IDENTITY, vous pouvez créer la table comme indiqué ci-dessous.
```
CREATE TABLE norway_natural_with_id (
fid INT IDENTITY(1,1),
wkb_geometry GEOMETRY,
osm_id BIGINT,
code INT,
fclass VARCHAR,
name VARCHAR);
```
Maintenant, vous pouvez intégrer les données en utilisant la commande COPY.
```
COPY norway_natural FROM 's3://bucket_name/shapefiles/norway/gis_osm_natural_free_1.shp'
FORMAT SHAPEFILE
CREDENTIALS 'aws_iam_role=arn:aws:iam::123456789012:role/MyRoleName';
INFO: Load into table 'norway_natural' completed, 83891 record(s) loaded successfully
```
Vous pouvez également intégrer les données comme indiqué ci-dessous.
```
COPY norway_natural_with_id FROM 's3://bucket_name/shapefiles/norway/gis_osm_natural_free_1.shp'
FORMAT SHAPEFILE
CREDENTIALS 'aws_iam_role=arn:aws:iam::123456789012:role/MyRoleName';
INFO: Load into table 'norway_natural_with_id' completed, 83891 record(s) loaded successfully.
```
#### Intégration des données avec simplification
Les commandes suivantes créent une table et tentent d’intégrer des données qui ne rentrent pas dans la taille géométrique maximale sans aucune simplification. Inspectez le shapefile `gis_osm_water_a_free_1.shp` et créez la table appropriée comme indiqué ci-dessous.
```
CREATE TABLE norway_water (
wkb_geometry GEOMETRY,
osm_id BIGINT,
code INT,
fclass VARCHAR,
name VARCHAR);
```
Lorsque la commande COPY s’exécute, une erreur est renvoyée.
```
COPY norway_water FROM 's3://bucket_name/shapefiles/norway/gis_osm_water_a_free_1.shp'
FORMAT SHAPEFILE
CREDENTIALS 'aws_iam_role=arn:aws:iam::123456789012:role/MyRoleName';
ERROR: Load into table 'norway_water' failed. Check 'stl_load_errors' system table for details.
```
L’interrogation de `STL_LOAD_ERRORS` indique que la géométrie est trop volumineuse.
```
SELECT line_number, btrim(colname), btrim(err_reason) FROM stl_load_errors WHERE query = pg_last_copy_id();
line_number | btrim | btrim
-------------+--------------+-----------------------------------------------------------------------
1184705 | wkb_geometry | Geometry size: 1513736 is larger than maximum supported size: 1048447
```
Pour résoudre ce problème, le paramètre `SIMPLIFY AUTO` est ajouté à la commande COPY afin de simplifier les géométries.
```
COPY norway_water FROM 's3://bucket_name/shapefiles/norway/gis_osm_water_a_free_1.shp'
FORMAT SHAPEFILE
SIMPLIFY AUTO
CREDENTIALS 'aws_iam_role=arn:aws:iam::123456789012:role/MyRoleName';
INFO: Load into table 'norway_water' completed, 1989196 record(s) loaded successfully.
```
Pour afficher les lignes et les géométries simplifiées, interrogez `SVL_SPATIAL_SIMPLIFY`.
```
SELECT * FROM svl_spatial_simplify WHERE query = pg_last_copy_id();
query | line_number | maximum_tolerance | initial_size | simplified | final_size | final_tolerance
-------+-------------+-------------------+--------------+------------+------------+----------------------
20 | 1184704 | -1 | 1513736 | t | 1008808 | 1.276386653895e-05
20 | 1664115 | -1 | 1233456 | t | 1023584 | 6.11707814796635e-06
```
Lorsque la commande SIMPLIY AUTO *max\$1tolerance* est utilisée avec une tolérance inférieure à celle calculée automatiquement, une erreur d’ingestion est généralement renvoyée. Dans ce cas, utilisez la commande MAXERROR pour ignorer les erreurs.
```
COPY norway_water FROM 's3://bucket_name/shapefiles/norway/gis_osm_water_a_free_1.shp'
FORMAT SHAPEFILE
SIMPLIFY AUTO 1.1E-05
MAXERROR 2
CREDENTIALS 'aws_iam_role=arn:aws:iam::123456789012:role/MyRoleName';
INFO: Load into table 'norway_water' completed, 1989195 record(s) loaded successfully.
INFO: Load into table 'norway_water' completed, 1 record(s) could not be loaded. Check 'stl_load_errors' system table for details.
```
Interrogez à nouveau `SVL_SPATIAL_SIMPLIFY` pour identifier l’enregistrement que la commande COPY n’a pas réussi à charger.
```
SELECT * FROM svl_spatial_simplify WHERE query = pg_last_copy_id();
query | line_number | maximum_tolerance | initial_size | simplified | final_size | final_tolerance
-------+-------------+-------------------+--------------+------------+------------+-----------------
29 | 1184704 | 1.1e-05 | 1513736 | f | 0 | 0
29 | 1664115 | 1.1e-05 | 1233456 | t | 794432 | 1.1e-05
```
Dans cet exemple, le premier enregistrement n’a pas réussi à s’ajuster, c’est pourquoi la colonne `simplified` affiche false. Le deuxième enregistrement a été chargé dans la tolérance donnée. Toutefois, la taille finale est supérieure à l’utilisation de la tolérance calculée automatiquement sans spécifier la tolérance maximale.
### Chargement à partir d’un shapefile compressé
La commande COPY Amazon Redshift prend en charge l’ingestion de données à partir d’un shapefile compressé. Tous les composants de shapefiles doivent avoir le même préfixe Amazon S3 et le même suffixe de compression. Par exemple, supposons que vous souhaitiez charger les données de l’exemple précédent. Dans ce cas, les fichiers `gis_osm_water_a_free_1.shp.gz`, `gis_osm_water_a_free_1.dbf.gz` et `gis_osm_water_a_free_1.shx.gz` doivent partager le même répertoire Amazon S3. La commande COPY nécessite l’option GZIP, et la clause FROM doit spécifier le fichier compressé correct, comme indiqué ci-dessous.
```
COPY norway_natural FROM 's3://bucket_name/shapefiles/norway/compressed/gis_osm_natural_free_1.shp.gz'
FORMAT SHAPEFILE
GZIP
CREDENTIALS 'aws_iam_role=arn:aws:iam::123456789012:role/MyRoleName';
INFO: Load into table 'norway_natural' completed, 83891 record(s) loaded successfully.
```
### Chargement des données dans une table avec un ordre de colonnes différent
Si vous avez une table qui n’a pas `GEOMETRY` comme première colonne, vous pouvez utiliser le mappage de colonnes pour mapper des colonnes à la table cible. Par exemple, créez une table en spécifiant `osm_id` comme première colonne.
```
CREATE TABLE norway_natural_order (
osm_id BIGINT,
wkb_geometry GEOMETRY,
code INT,
fclass VARCHAR,
name VARCHAR);
```
Intégrez ensuite un shapefile à l’aide du mappage de colonnes.
```
COPY norway_natural_order(wkb_geometry, osm_id, code, fclass, name)
FROM 's3://bucket_name/shapefiles/norway/gis_osm_natural_free_1.shp'
FORMAT SHAPEFILE
CREDENTIALS 'aws_iam_role=arn:aws:iam::123456789012:role/MyRoleName';
INFO: Load into table 'norway_natural_order' completed, 83891 record(s) loaded successfully.
```
### Chargement de données dans une table avec une colonne de géographies
Si vous disposez d’une table avec une colonne `GEOGRAPHY`, vous devez d’abord l’intégrer à une colonne `GEOMETRY`, puis convertir les objets en objets `GEOGRAPHY`. Par exemple, après avoir copié votre shapefile dans une colonne `GEOMETRY`, modifiez le tableau pour ajouter une colonne du type de données `GEOGRAPHY`.
```
ALTER TABLE norway_natural ADD COLUMN wkb_geography GEOGRAPHY;
```
Convertissez ensuite les géométries en géographies.
```
UPDATE norway_natural SET wkb_geography = wkb_geometry::geography;
```
Vous pouvez éventuellement supprimer la colonne `GEOMETRY`.
```
ALTER TABLE norway_natural DROP COLUMN wkb_geometry;
```
## Commande COPY avec l’option NOLOAD
Pour valider des fichiers de données avant de charger réellement les données, utilisez l’option NOLOAD avec la commande COPY. Amazon Redshift analyse le fichier d’entrée et affiche les erreurs éventuelles. L’exemple suivant utilise l’option NOLOAD et aucune ligne n’est réellement chargée dans la table.
```
COPY public.zipcode1
FROM 's3://amzn-s3-demo-bucket/mydata/zipcode.csv'
DELIMITER ';'
IGNOREHEADER 1 REGION 'us-east-1'
NOLOAD
CREDENTIALS 'aws_iam_role=arn:aws:iam::123456789012:role/myRedshiftRole';
Warnings:
Load into table 'zipcode1' completed, 0 record(s) loaded successfully.
```
## Commande COPY avec un délimiteur multioctet et l’option ENCODING
L'exemple suivant se charge LATIN1 à partir d'un fichier Amazon S3 contenant des données multioctets. La commande COPY spécifie le délimiteur sous forme octale `\302\246\303\254` pour séparer les champs du fichier d’entrée encodé au format ISO-8859-1. Pour spécifier le même délimiteur en UTF-8, spécifiez `DELIMITER '¦ì'`.
```
COPY latin1
FROM 's3://amzn-s3-demo-bucket/multibyte/myfile'
IAM_ROLE 'arn:aws:iam::123456789012:role/myRedshiftRole'
DELIMITER '\302\246\303\254'
ENCODING ISO88591
```
# CREATE DATABASE
Crée une nouvelle base de données.
Pour créer une base de données, vous devez être super-utilisateur ou disposer du privilège CREATEDB. Pour créer une base de données associée à une intégration zéro ETL, vous devez être super-utilisateur ou disposer des privilèges CREATEDB et CREATEUSER.
Vous ne pouvez pas exécuter CREATE DATABASE au sein d’un bloc de transaction (BEGIN ... END). Pour plus d’informations sur les transactions, consultez [Niveaux d’isolement dans Amazon Redshift](c_serial_isolation.md).
## Syntaxe
```
CREATE DATABASE database_name
[ { [
FROM INTEGRATION ''[ DATABASE '' ]
[ SET ]
[ ACCEPTINVCHARS [=] { TRUE | FALSE }]
[ QUERY_ALL_STATES [=] { TRUE | FALSE }]
[ REFRESH_INTERVAL ]
[ TRUNCATECOLUMNS [=] { TRUE | FALSE } ]
[ HISTORY_MODE [=] {TRUE | FALSE} ]
]
[ WITH ]
[ OWNER [=] db_owner ]
[ CONNECTION LIMIT { limit | UNLIMITED } ]
[ COLLATE { CASE_SENSITIVE | CS | CASE_INSENSITIVE | CI } ]
[ ISOLATION LEVEL { SNAPSHOT | SERIALIZABLE } ]
}
| { FROM { { ARN '' } { WITH DATA CATALOG SCHEMA '' | WITH NO DATA CATALOG SCHEMA } } }
| { IAM_ROLE {default | 'SESSION' | 'arn:aws:iam:::role/' } }
| { [ WITH PERMISSIONS ] FROM DATASHARE datashare_name OF [ ACCOUNT account_id ] NAMESPACE namespace_guid }
]
```
## Parameters
*database\$1name*
Nom de la nouvelle base de données. Pour plus d’informations sur les noms valides, consultez [Noms et identificateurs](r_names.md).
FROM INTEGRATION ’’ [ DATABASE ’’ ]
Spécifie s’il faut créer la base de données à l’aide d’un identifiant d’intégration zéro ETL. Vous pouvez récupérer l’`integration_id` depuis la vue système SVV\$1INTEGRATION. Pour les intégrations zéro ETL Aurora PostgreSQL, vous devez également spécifier le nom `source_database`, qui peut également être récupéré à partir de SVV\$1INTEGRATION.
Pour obtenir un exemple, consultez [Crée des bases de données pour recevoir les résultats des intégrations zéro ETL](#r_CREATE_DATABASE-integration). Pour plus d’informations sur la création de bases de données avec des intégrations zéro ETL, consultez [Création de bases de données de destination dans Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.creating-db.html) dans le *Guide de gestion Amazon Redshift*.
SET
Mot-clé facultatif.
ACCEPTINVCHARS [=] \$1 TRUE \$1 FALSE \$1
La clause ACCEPTINVCHARS indique si les tables d’intégration zéro ETL continuent à être ingérées lorsque des caractères non valides sont détectés pour le type de données VARCHAR. Lorsque des caractères non valides sont détectés, ils sont remplacés par un caractère `?` par défaut.
QUERY\$1ALL\$1STATES [=] \$1 TRUE \$1 FALSE \$1
La clause QUERY\$1ALL\$1STATES indique si les tables d’intégration zéro ETL peuvent être interrogées dans tous les états (`Synced`, `Failed`, `ResyncRequired` et `ResyncInitiated`). Par défaut, une table d’intégration zéro ETL ne peut être interrogée que dans son état `Synced`.
REFRESH\$1INTERVAL
La clause REFRESH\$1INTERVAL définit l’intervalle de temps approximatif, en secondes, pour actualiser les données de la source zéro ETL vers la base de données cible. La valeur peut être définie entre 0 et 432 000 secondes (5 jours) pour les intégrations zéro ETL dont le type de source est Aurora MySQL, Aurora PostgreSQL ou RDS for MySQL. Pour les intégrations zéro ETL Amazon DynamoDB, la valeur peut être définie entre 900 et 432 000 secondes (15 minutes et 5 jours). L’`interval` par défaut est zéro (0) secondes pour les intégrations zéro ETL dont le type de source est Aurora MySQL, Aurora PostgreSQL ou RDS for MySQL. Pour les intégrations Amazon DynamoDB zéro ETL, l’`interval` par défaut est de 900 secondes (15 minutes).
TRUNCATECOLUMNS [=] \$1 TRUE \$1 FALSE \$1
La clause TRUNCATECOLUMNS indique si les tables d’intégration zéro ETL continuent à être ingérées lorsque les valeurs des attributs de colonne VARCHAR ou SUPER dépassent les limites. Avec `TRUE`, les valeurs sont tronquées pour tenir dans la colonne et les valeurs des attributs JSON débordants sont tronquées pour tenir dans la colonne SUPER.
HISTORY\$1MODE [=] \$1TRUE \$1 FALSE\$1
Clause spécifiant si Amazon Redshift définira le mode historique pour toutes les nouvelles tables de la base de données spécifiée. Cette option s’applique uniquement aux bases de données créées pour une intégration zéro ETL.
La clause HISTORY\$1MODE peut être définie sur `TRUE` ou `FALSE`. La valeur par défaut est `FALSE`. Pour plus d’informations sur HISTORY\$1MODE, consultez [Mode historique](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-history-mode.html) dans le *Guide de gestion Amazon Redshift*.
WITH
Mot-clé facultatif.
OWNER [=] db\$1owner
Spécifie le nom d’utilisateur du propriétaire de base de données.
CONNECTION LIMIT \$1 *limite* \$1 UNLIMITED \$1
Le nombre maximum de connexions à la base de données que les utilisateurs sont autorisés à ouvrir simultanément. La limite se s’applique pas aux super-utilisateurs. Utilisez le mot-clé UNLIMITED pour autoriser le nombre maximum de connexions simultanées. Une limite sur le nombre de connexions pour chaque utilisateur peut également s’appliquer. Pour plus d'informations, consultez [CREATE USER](r_CREATE_USER.md). La valeur par défaut est UNLIMITED. Pour afficher les connexions en cours, interrogez la vue système [STV\$1SESSIONS](r_STV_SESSIONS.md).
Si les deux limites de connexion (utilisateurs et base de données) s’appliquent, un emplacement de connexion inutilisé situé entre les deux limites doit également être disponible lorsqu’un utilisateur tente de se connecter.
COLLATE \$1 CASE\$1SENSITIVE \$1 CS \$1 CASE\$1INSENSITIVE \$1 CI \$1
Clause spécifiant si la recherche de chaînes ou la comparaison est sensible à la casse ou non. Elle est sensible à la casse par défaut.
COLLATE n’est pas pris en charge lorsque vous créez une base de données à partir d’une unité de partage des données.
CASE\$1SENSITIVE et CS sont interchangeables et donnent les mêmes résultats. De même, CASE\$1INSENSITIVE et CI sont interchangeables et donnent les mêmes résultats.
ISOLATION LEVEL \$1 SNAPSHOT \$1 SERIALIZABLE \$1
Clause qui spécifie le niveau d’isolation utilisé lorsque les requêtes sont exécutées sur une base de données. Pour de plus amples informations sur les niveaux d’isolation, consultez [Niveaux d’isolement dans Amazon Redshift](c_serial_isolation.md).
+ Isolation SNAPSHOT : offre un niveau d’isolation avec protection contre les conflits de mise à jour et de suppression Il s’agit de la valeur par défaut pour une base de données créée dans un cluster alloué ou un espace de noms sans serveur.
+ Isolation SERIALIZABLE : offre une mise en série complète pour les transactions simultanées.
FROM ARN ’’
L'ARN AWS Glue de base de données à utiliser pour créer la base de données.
\$1 WITH DATA CATALOG SCHEMA ’’ \$1 WITH NO DATA CATALOG SCHEMA \$1
Ce paramètre ne s’applique que si votre commande CREATE DATABASE utilise également le paramètre FROM ARN.
Indique si la base de données doit être créée à l’aide d’un schéma pour pouvoir accéder à des objets dans le AWS Glue Data Catalog.
IAM\$1ROLE \$1par défaut \$1 'SESSION' \$1 'arn:aws:iam : :role/ '\$1 ** **
Ce paramètre ne s’applique que si votre commande CREATE DATABASE utilise également le paramètre FROM ARN.
Si vous spécifiez un rôle IAM qui est associé au cluster pendant l’exécution de la commande CREATE DATABASE, Amazon Redshift utilise les informations d’identification du rôle lorsque vous exécutez des requêtes sur la base de données.
Si le mot clé `default` est spécifié, le rôle IAM défini par défaut et qui est associé au cluster est alors utilisé.
Utilisez `'SESSION'` si vous vous connectez à votre cluster Amazon Redshift à l’aide d’une identité fédérée et que vous accédez aux tables à partir du schéma externe créé à l’aide de cette commande. Pour voir un exemple d’utilisation d’une identité fédéré, consultez [Utilisation d’une identité fédérée pour gérer l’accès d’Amazon Redshift aux ressources locales et aux tables externes Amazon Redshift Spectrum](https://docs.aws.amazon.com/redshift/latest/mgmt/authorization-fas-spectrum.html), qui explique comment configurer l’identité fédérée.
Utilisez l’Amazon Resource Name (ARN) d’un rôle IAM que votre cluster utilise pour l’authentification et l’autorisation. Au minimum, le rôle IAM doit être autorisé à exécuter une opération LIST sur le compartiment Amazon S3 devant être accessible et une opération GET sur les objets Amazon S3 contenus dans le compartiment. Pour en savoir plus sur l'utilisation de IAM\$1ROLE lors de la création d'une base de données à des AWS Glue Data Catalog fins de partage de données, consultez la section Utilisation de partages de données gérés [par Lake Formation en tant](https://docs.aws.amazon.com/redshift/latest/dg/lake-formation-getting-started-consumer.html) que consommateur.
Le code suivant montre la syntaxe de la chaîne de paramètre IAM\$1ROLE pour un seul ARN.
```
IAM_ROLE 'arn:aws:iam:::role/'
```
Vous pouvez créer des chaînes de rôles pour permettre à votre cluster d’endosser un autre rôle IAM, y compris un rôle appartenant à un autre compte. Les chaînes ainsi créées peuvent inclure jusqu’à 10 rôles. Pour plus d'informations, consultez [Créer des rôles IAM dans Amazon Redshift Spectrum](c-spectrum-iam-policies.md#c-spectrum-chaining-roles).
Attachez à ce rôle IAM une politique d’autorisations IAM similaire à la suivante.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AccessSecret",
"Effect": "Allow",
"Action": [
"secretsmanager:GetResourcePolicy",
"secretsmanager:GetSecretValue",
"secretsmanager:DescribeSecret",
"secretsmanager:ListSecretVersionIds"
],
"Resource": "arn:aws:secretsmanager:us-west-2:123456789012:secret:my-rds-secret-VNenFy"
},
{
"Sid": "VisualEditor1",
"Effect": "Allow",
"Action": [
"secretsmanager:GetRandomPassword",
"secretsmanager:ListSecrets"
],
"Resource": "*"
}
]
}
```
Pour connaître les étapes à suivre afin de créer un rôle IAM à utiliser avec une requête fédérée, consultez [Création d’un secret et d’un rôle IAM pour utiliser des requêtes fédérées](federated-create-secret-iam-role.md).
N’incluez pas d’espaces dans la liste des rôles chaînés.
L’exemple suivant montre la syntaxe d’une chaîne de trois rôles.
```
IAM_ROLE 'arn:aws:iam:::role/,arn:aws:iam:::role/,arn:aws:iam:::role/'
```
## Syntaxe pour l’utilisation de CREATE DATABASE avec une unité de partage des données
La syntaxe suivante décrit la commande CREATE DATABASE utilisée pour créer des bases de données à partir d'un partage de données afin de partager des données au sein d'un même AWS compte.
```
CREATE DATABASE database_name
[ [ WITH PERMISSIONS ] FROM DATASHARE datashare_name OF [ ACCOUNT account_id ] NAMESPACE namespace_guid
```
La syntaxe suivante décrit la commande CREATE DATABASE utilisée pour créer des bases de données à partir d'un partage de données afin de partager des données entre comptes. AWS
```
CREATE DATABASE database_name
[ [ WITH PERMISSIONS ] FROM DATASHARE datashare_name OF ACCOUNT account_id NAMESPACE namespace_guid
```
### Paramètres pour l’utilisation de CREATE DATABASE avec une unité de partage des données
FROM DATASHARE
Mot-clé indiquant où se situe l’unité de partage des données externe.
*datashare\$1name*
Nom de la base de données sur laquelle la base de données consommateur est créée.
WITH PERMISSIONS
Spécifie que la base de données créée à partir de l’unité de partage des données nécessite des autorisations de niveau objet pour accéder à des objets de base de données individuels. Sans cette clause, les utilisateurs ou les rôles disposant de l’autorisation USAGE sur la base de données auront automatiquement accès à tous les objets de celle-ci.
NAMESPACE *namespace\$1guid*
Valeur spécifiant l’espace de noms du producteur compte auquel l’unité de partage des données appartient.
ACCOUNT *account\$1id*
Valeur spécifiant le compte du producteur auquel l’unité de partage des données appartient.
## Notes d’utilisation de la commande CREATE DATABASE pour le partage de données
En tant que superutilisateur de base de données, lorsque vous utilisez CREATE DATABASE pour créer des bases de données à partir de partages de données au sein du AWS compte, spécifiez l'option NAMESPACE. L’option ACCOUNT est facultative. Lorsque vous utilisez CREATE DATABASE pour créer des bases de données provenant d’unités de partage des données sur des comptes AWS , spécifiez les options ACCOUNT et NAMESPACE du producteur.
Vous ne pouvez créer qu’une seule base de données grand public pour une unité de partage des données sur un cluster consommateur. Vous ne pouvez pas créer plusieurs bases de données grand public faisant référence à la même unité de partage des données.
## CRÉER UNE BASE DE DONNÉES depuis AWS Glue Data Catalog
Pour créer une base de données à l'aide d'un ARN AWS Glue de base de données, spécifiez cet ARN dans votre commande CREATE DATABASE.
```
CREATE DATABASE sampledb FROM ARN WITH NO DATA CATALOG SCHEMA;
```
Vous pouvez aussi éventuellement fournir une valeur dans le paramètre IAM\$1ROLE. Pour en savoir plus sur le paramètre et les valeurs acceptées, consultez [Paramètres](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_DATABASE.html#r_CREATE_DATABASE-parameters).
Les exemples suivants montrent comment créer une base de données à partir d’un ARN en utilisant un rôle IAM.
```
CREATE DATABASE sampledb FROM ARN WITH NO DATA CATALOG SCHEMA IAM_ROLE
```
```
CREATE DATABASE sampledb FROM ARN WITH NO DATA CATALOG SCHEMA IAM_ROLE default;
```
Vous pouvez également créer une base de données en utilisant un DATA CATALOG SCHEMA.
```
CREATE DATABASE sampledb FROM ARN WITH DATA CATALOG SCHEMA IAM_ROLE default;
```
## Crée des bases de données pour recevoir les résultats des intégrations zéro ETL
Pour créer une base de données utilisant une identité d’intégration zéro ETL, spécifiez l’`integration_id` dans votre commande CREATE DATABASE.
```
CREATE DATABASE destination_db_name FROM INTEGRATION 'integration_id';
```
Par exemple, récupérez d’abord les identifiants d’intégration dans SVV\$1INTEGRATION ;
```
SELECT integration_id FROM SVV_INTEGRATION;
```
Utilisez ensuite l’un des identifiants d’intégration récupérés pour créer la base de données qui reçoit les intégrations zéro ETL.
```
CREATE DATABASE sampledb FROM INTEGRATION 'a1b2c3d4-5678-90ab-cdef-EXAMPLE11111';
```
Lorsque la base de données source des intégrations zéro ETL est requise, spécifiez par exemple.
```
CREATE DATABASE sampledb FROM INTEGRATION 'a1b2c3d4-5678-90ab-cdef-EXAMPLE11111' DATABASE sourcedb;
```
Vous pouvez également définir un intervalle d’actualisation pour la base de données. Par exemple, pour définir l’intervalle d’actualisation à 7 200 secondes pour les données provenant d’une source d’intégration zéro ETL :
```
CREATE DATABASE myacct_mysql FROM INTEGRATION 'a1b2c3d4-5678-90ab-cdef-EXAMPLE11111' SET REFRESH_INTERVAL 7200;
```
Interrogez la vue du catalogue SVV\$1INTEGRATION pour obtenir des informations sur une intégration zéro ETL, telles que integration\$1id, target\$1database, source, refresh\$1interval, etc.
```
SELECT * FROM svv_integration;
```
L’exemple suivant crée une base de données à partir d’une intégration avec le mode historique activé.
```
CREATE DATABASE sample_integration_db FROM INTEGRATION 'a1b2c3d4-5678-90ab-cdef-EXAMPLE11111' SET HISTORY_MODE = true;
```
## Limites de CREATE DATABASE
Amazon Redshift applique ces limites pour les bases de données :
+ Maximum de 60 bases de données définies par l’utilisateur par cluster.
+ Maximum de 127 octets pour un nom de base de données.
+ Un nom de base de données ne peut pas être un mot réservé.
## Classement de base de données
Le classement est un ensemble de règles qui définit la façon dont le moteur de base de données compare et trie les données de type caractère dans SQL. Le classement insensible à la casse est le classement le plus utilisé. Amazon Redshift utilise un classement insensible à la casse pour faciliter la migration à partir d’autres systèmes d’entrepôts des données. Grâce à la prise en charge native du classement insensible à la casse, Amazon Redshift continue d’utiliser des méthodes de réglage ou d’optimisation importantes, telles que les clés de distribution, les clés de tri ou l’analyse à plage restreinte.
La clause COLLATE spécifie le classement par défaut de toutes les colonnes CHAR et VARCHAR de la base de données. Si CASE\$1INSENSITIVE est spécifié, toutes les colonnes CHAR ou VARCHAR utilisent un classement insensible à la casse. Pour obtenir des informations sur le classement, consultez [Séquences de classement](c_collation_sequences.md).
Les données insérées ou intégrées dans des colonnes insensibles à la casse conserveront leur casse d’origine. Cependant, toutes les opérations de chaîne basées sur la comparaison, y compris le tri et le regroupement, sont insensibles à la casse. Les opérations de correspondance de modèles telles que les prédicats LIKE, similaire à et les fonctions d’expression régulière sont également insensibles à la casse.
Les opérations SQL suivantes prennent en charge la sémantique de classement applicable :
+ Opérateurs de comparaison : =, <>, <, <=, >, >=.
+ Opérateur LIKE
+ Clauses ORDER BY
+ Clauses GROUP BY
+ Fonctions d’agrégation qui utilisent la comparaison de chaînes, telles que MIN, MAX et LISTAGG
+ Fonctions de fenêtrage, telles que les clauses PARTITION BY et ORDER BY
+ Fonctions scalaires greatest() et least (), STRPOS(), REGEXP\$1COUNT (), REGEXP\$1REPLACE(), REGEXP\$1INSTR(), REGEXP\$1SUBSTR()
+ Clause Distinct
+ UNION, INTERSECT et EXCEPT
+ IN LIST
Pour les requêtes externes, y compris les requêtes fédérées Amazon Redshift Spectrum et Aurora PostgreSQL, le classement de la colonne VARCHAR ou CHAR est le même que le classement actuel au niveau de la base de données.
L’exemple suivant interroge une table Amazon Redshift Spectrum :
```
SELECT ci_varchar FROM spectrum.test_collation
WHERE ci_varchar = 'AMAZON';
ci_varchar
----------
amazon
Amazon
AMAZON
AmaZon
(4 rows)
```
Pour obtenir des informations sur la création de tables à l'aide du classement de bases de données, consultez [CREATE TABLE](r_CREATE_TABLE_NEW.md).
Pour obtenir des informations sur la fonction COLLATE, consultez [Fonction COLLATE](r_COLLATE.md).
### Limites de classement de bases de données
Les limitations suivantes concernent l’utilisation du classement de base de données dans Amazon Redshift :
+ Toutes les tables ou vues système, y compris les tables catalogue PG et les tables système Amazon Redshift, sont sensibles à la casse.
+ Lorsque la base de données consommateur et la base de données producteur ont des classements différents au niveau de la base de données, Amazon Redshift ne prend pas en charge les requêtes inter-bases de données et inter-clusters.
+ Amazon Redshift ne prend pas en charge le classement insensible à la casse dans les requêtes au nœud principal uniquement.
L’exemple suivant montre une requête insensible à la casse non prise en charge et l’erreur envoyée par qu’Amazon Redshift :
```
SELECT collate(usename, 'case_insensitive') FROM pg_user;
ERROR: Case insensitive collation is not supported in leader node only query.
```
+ Amazon Redshift ne prend pas en charge l’interaction entre les colonnes sensibles à la casse et non sensibles à la casse, telles que les opérations de comparaison, de fonction, de jointure ou d’ensembles.
Les exemples suivants montrent des erreurs lorsque des colonnes sensibles à la casse et insensibles à la casse interagissent :
```
CREATE TABLE test
(ci_col varchar(10) COLLATE case_insensitive,
cs_col varchar(10) COLLATE case_sensitive,
cint int,
cbigint bigint);
```
```
SELECT ci_col = cs_col FROM test;
ERROR: Query with different collations is not supported yet.
```
```
SELECT concat(ci_col, cs_col) FROM test;
ERROR: Query with different collations is not supported yet.
```
```
SELECT ci_col FROM test UNION SELECT cs_col FROM test;
ERROR: Query with different collations is not supported yet.
```
```
SELECT * FROM test a, test b WHERE a.ci_col = b.cs_col;
ERROR: Query with different collations is not supported yet.
```
```
Select Coalesce(ci_col, cs_col) from test;
ERROR: Query with different collations is not supported yet.
```
```
Select case when cint > 0 then ci_col else cs_col end from test;
ERROR: Query with different collations is not supported yet.
```
Pour que ces requêtes fonctionnent, utilisez la fonction COLLATE afin de convertir le classement d’une colonne et la faire correspondre à l’autre. Pour plus d'informations, consultez [Fonction COLLATE](r_COLLATE.md).
## Exemples
**Création d’une base de données**
L’exemple suivant crée une base de données nommée TICKIT et attribue la propriété à l’utilisateur DWUSER.
```
create database tickit
with owner dwuser;
```
Interrogez la table de catalogue PG\$1DATABASE\$1INFO afin d’afficher les détails relatifs aux bases de données.
```
select datname, datdba, datconnlimit
from pg_database_info
where datdba > 1;
datname | datdba | datconnlimit
-------------+--------+-------------
admin | 100 | UNLIMITED
reports | 100 | 100
tickit | 100 | 100
```
L’exemple suivant crée une base de données nommée **sampledb** avec niveau d’isolation SNAPSHOT.
```
CREATE DATABASE sampledb ISOLATION LEVEL SNAPSHOT;
```
L’exemple suivant crée la base de données sales\$1db à partir de l’unité de partage des données salesshare.
```
CREATE DATABASE sales_db FROM DATASHARE salesshare OF NAMESPACE '13b8833d-17c6-4f16-8fe4-1a018f5ed00d';
```
### Exemple de classement de bases de données
**Création d’une base de données sensible à la casse**
L’exemple suivant crée la base de données `sampledb`, crée la table `T1` et insère des données dans la table `T1`.
```
create database sampledb collate case_insensitive;
```
Connectez-vous à la nouvelle base de données que vous venez de créer à l’aide de votre client SQL. Lorsque vous utilisez l’éditeur de requêtes Amazon Redshift, choisissez `sampledb` dans **Éditeur**. Lorsque vous utilisez RSQL, utilisez une commande similaire à celle-ci.
```
\connect sampledb;
```
```
CREATE TABLE T1 (
col1 Varchar(20) distkey sortkey
);
```
```
INSERT INTO T1 VALUES ('bob'), ('john'), ('Mary'), ('JOHN'), ('Bob');
```
Ensuite, la requête trouve des résultats avec `John`.
```
SELECT * FROM T1 WHERE col1 = 'John';
col1
------
john
JOHN
(2 row)
```
**Classement par sensibilité à la casse**
L’exemple suivant montre le classement par sensibilité à la casse avec la table T1. Le classement de *Bob* et *bob* ou *John* et *john* est non déterministe, car ils sont égaux dans la colonne insensible à la casse.
```
SELECT * FROM T1 ORDER BY 1;
col1
------
bob
Bob
JOHN
john
Mary
(5 rows)
```
De même, l’exemple suivant montre un classement par sensibilité à la casse avec la clause GROUP BY. *Bob* et *bob* sont égaux et appartiennent au même groupe. Lequel des deux apparaît dans le résultat est non déterministe.
```
SELECT col1, count(*) FROM T1 GROUP BY 1;
col1 | count
-----+------
Mary | 1
bob | 2
JOHN | 2
(3 rows)
```
**Interrogation avec une fonction de fenêtrage sur des colonnes insensibles à la casse**
L’exemple suivant interroge une fonction de fenêtrage sur une colonne insensible à la casse.
```
SELECT col1, rank() over (ORDER BY col1) FROM T1;
col1 | rank
-----+------
bob | 1
Bob | 1
john | 3
JOHN | 3
Mary | 5
(5 rows)
```
**Interrogation avec le mot-clé DISTINCT**
L’exemple suivant interroge la table `T1` avec le mot-clé DISTINCT.
```
SELECT DISTINCT col1 FROM T1;
col1
------
bob
Mary
john
(3 rows)
```
**Interrogation avec la clause UNION**
L’exemple suivant illustre les résultats de la clause UNION des tables `T1` et `T2`.
```
CREATE TABLE T2 AS SELECT * FROM T1;
```
```
SELECT col1 FROM T1 UNION SELECT col1 FROM T2;
col1
------
john
bob
Mary
(3 rows)
```
# CREATE DATASHARE
Crée une nouvelle unité de partage des données dans la base de données actuelle. Le propriétaire de cette unité de partage des données est l’auteur de la commande CREATE TABLE.
Amazon Redshift associe chaque unité de partage des données à une seule base de données Amazon Redshift. Vous pouvez uniquement ajouter des objets de la base de données associée à une unité de partage des données. Vous pouvez créer plusieurs unités de partage des données sur la même base de données Amazon Redshift.
Pour obtenir des informations sur les unités de partage des données, consultez [Partage de données dans Amazon Redshift](datashare-overview.md).
Pour afficher des informations sur les unités de partage des données, utilisez [SHOW DATASHARES](r_SHOW_DATASHARES.md).
## Privilèges requis
Les privilèges suivants sont requis pour CREATE DATASHARE :
+ Superuser
+ Utilisateurs disposant du privilège CREATE DATASHARE
+ Propriétaire de la base de données
## Syntaxe
```
CREATE DATASHARE datashare_name
[[SET] PUBLICACCESSIBLE [=] TRUE | FALSE ];
```
## Parameters
*datashare\$1name*
Nom du datashare. Le nom de l’unité de partage des données doit être unique dans l’espace de noms du cluster.
[[SET] PUBLICACCESSIBLE]
Clause spécifiant si l’unité de partage des données peut être partagée avec des clusters qui sont accessibles publiquement.
La valeur par défaut de `SET PUBLICACCESSIBLE` est `FALSE`.
## Notes d’utilisation
Par défaut, le propriétaire de l’unité de partage des données possède le partage, mais pas les objets dans le partage.
Seuls les super-utilisateurs et le propriétaire de la base de données peuvent utiliser CREATE DATASHARE et déléguer des privilèges ALTER à d’autres utilisateurs ou groupes.
## Exemples
L’exemple suivant crée l’unité de partage des données `salesshare`.
```
CREATE DATASHARE salesshare;
```
L’exemple suivant crée l’unité de partage des données `demoshare` que gère AWS Data Exchange .
```
CREATE DATASHARE demoshare SET PUBLICACCESSIBLE TRUE, MANAGEDBY ADX;
```
# CREATE EXTERNAL FUNCTION
Crée une fonction scalaire définie par l'utilisateur (UDF) basée sur Amazon AWS Lambda Redshift. Pour plus d’informations sur les fonctions Lambda définies par l’utilisateur, consultez [Lambda scalaire UDFs](udf-creating-a-lambda-sql-udf.md).
## Privilèges requis
Les privilèges suivants sont requis pour CREATE EXTERNAL FUNCTION :
+ Superuser
+ Utilisateurs possédant le privilège CREATE [ OR REPLACE ] EXTERNAL FUNCTION
## Syntaxe
```
CREATE [ OR REPLACE ] EXTERNAL FUNCTION external_fn_name ( [data_type] [, ...] )
RETURNS data_type
{ VOLATILE | STABLE }
LAMBDA 'lambda_fn_name'
IAM_ROLE { default | ‘arn:aws:iam:::role/’
RETRY_TIMEOUT milliseconds
MAX_BATCH_ROWS count
MAX_BATCH_SIZE size [ KB | MB ];
```
## Parameters
OR REPLACE
Clause qui spécifie que si une fonction ayant le même nom et les mêmes types de données pour les arguments en entrée, ou *signature*, existe déjà, la fonction existante est remplacée. Vous pouvez uniquement remplacer une fonction par une nouvelle fonction qui définit un ensemble identique de types de données. Vous devez être un super-utilisateur pour remplacer une fonction.
Si vous définissez une fonction avec le même nom qu’une fonction existante, mais avec une signature différente, vous créez une nouvelle fonction. En d’autres termes, le nom de la fonction est surchargé. Pour plus d'informations, consultez [Surcharge des noms de fonctions](udf-naming-udfs.md#udf-naming-overloading-function-names).
*external\$1fn\$1name*
Nom de la fonction externe. Si vous spécifiez un nom de schéma (tel que myschema.myfunction), la fonction est créée à l’aide du schéma spécifié. Sinon, la fonction est créée dans le schéma en cours. Pour plus d’informations sur les noms valides, consultez [Noms et identificateurs](r_names.md).
Nous vous recommandons de nommer toutes les fonctions UDF en utilisant le préfixe `f_`. Amazon Redshift réserve le préfixe `f_` pour les noms de fonctions UDF. En utilisant le préfixe `f_`, vous vous assurez que le nom de votre fonction UDF n’entrera pas en conflit avec le nom d’une fonction SQL intégrée pour Amazon Redshift, que ce soit maintenant ou à l’avenir. Pour plus d'informations, consultez [Prévention des conflits de dénomination des fonctions UDF](udf-naming-udfs.md).
*data\$1type*
Type de données des arguments en entrée. Pour plus d’informations, consultez [Python scalaire UDFs](udf-creating-a-scalar-udf.md) et [Lambda scalaire UDFs](udf-creating-a-lambda-sql-udf.md).
RETURNS *type\$1données*
Type de données de la valeur renvoyée par la fonction. Le type de données RETURNS peut être n’importe quel type de données Amazon Redshift standard. Pour plus d’informations, consultez [Python scalaire UDFs](udf-creating-a-scalar-udf.md) et [Lambda scalaire UDFs](udf-creating-a-lambda-sql-udf.md).
VOLATILE \$1 STABLE
Informe l’optimiseur de requête à propos de l’instabilité de la fonction.
Pour obtenir la meilleure optimisation possible, qualifiez votre fonction avec la catégorie d’instabilité la plus stricte qui s’y applique. En matière de rigueur, en commençant par la moins stricte, les catégories d’instabilité sont les suivantes :
+ VOLATILE
+ STABLE
VOLATILE
Soit les mêmes arguments, la fonction peut renvoyer des résultats différents sur des appels successifs, y compris pour les lignes d’une même instruction. L’optimiseur de requête ne peut pas émettre d’hypothèses concernant le comportement d’une fonction volatile. Une requête qui utilise une fonction volatile doit réévaluer la fonction pour chaque entrée.
STABLE
À partir des mêmes arguments, la fonction renvoie invariablement les mêmes résultats lors des appels successifs traités au sein d’une même instruction. La fonction peut renvoyer des résultats différents lorsqu’elle est appelée dans différents instructions. Cette catégorie vise ici à permettre à l’optimiseur de réduire le nombre de fois que la fonction est appelée au sein d’une même instruction.
Notez que si la rigueur choisie n’est pas valide pour la fonction, l’optimiseur risque d’ignorer certains appels basés sur cette rigueur. Cela peut produire un jeu de résultats incorrect.
La clause IMMUTABLE n'est actuellement pas prise en charge pour Lambda UDFs.
LAMBDA *’lambda\$1fn\$1name’*
Nom de la fonction qu’Amazon Redshift appelle.
Pour connaître les étapes de création d'une AWS Lambda fonction, voir [Créer une fonction Lambda avec la console dans le](https://docs.aws.amazon.com/lambda/latest/dg/getting-started-create-function.html) Guide du *AWS Lambda développeur*.
Pour obtenir des informations sur les autorisations requises pour la fonction Lambda, consultez [Autorisations AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-permissions.html) dans le *Guide du développeur AWS Lambda *.
IAM\$1ROLE \$1par défaut \$1 'arn:aws:iam : :role/ '****
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 CREATE EXTERNAL FUNCTION s’exécute.
Utilisez l’Amazon Resource Name (ARN) d’un rôle IAM que votre cluster utilise pour l’authentification et l’autorisation. La commande CREATE EXTERNAL FUNCTION est autorisée à invoquer les fonctions Lambda via ce rôle IAM. Si votre cluster dispose d’un rôle IAM existant avec les autorisations pour invoquer les fonctions Lambda attachées, vous pouvez remplacer l’ARN de votre rôle. Pour plus d'informations, consultez [Configuration du paramètre d'autorisation pour Lambda UDFs](udf-creating-a-lambda-sql-udf.md#udf-lambda-authorization).
L’exemple suivant montre la syntaxe du paramètre IAM\$1ROLE.
```
IAM_ROLE 'arn:aws:iam::aws-account-id:role/role-name'
```
RETRY\$1TIMEOUT *millisecondes*
Durée totale en millisecondes utilisée par Amazon Redshift pour les retards dans les interruptions de nouvelles tentatives.
Au lieu de lancer de nouvelles tentatives immédiatement pour toute requête ayant échoué, Amazon Redshift effectue des interruptions et attend un certain temps entre les nouvelles tentatives. Amazon Redshift lance ensuite la nouvelle demande pour exécuter à nouveau la requête ayant échoué jusqu’à ce que la somme de tous les retards soit égale ou supérieure à la valeur RETRY\$1TIMEOUT que vous avez spécifiée. La valeur par défaut est de 20 000 millisecondes.
Lorsqu’une fonction Lambda est appelée, Amazon Redshift lance une nouvelle tentative pour les requêtes qui reçoivent des erreurs telles que `TooManyRequestsException`, `EC2ThrottledException` et `ServiceException`.
Vous pouvez définir le paramètre RETRY\$1TIMEOUT sur 0 millisecondes pour empêcher toute nouvelle tentative pour une UDF Lambda.
*Nombre de* MAX\$1BATCH\$1ROWS
Nombre maximum de lignes qu’Amazon Redshift envoie dans une seule demande par lot pour une seule invocation Lambda.
La valeur minimale pour ce paramètre est 1. La valeur maximale est INT\$1MAX ou 2 147 483 647.
Ce paramètre est facultatif. La valeur maximale est INT\$1MAX ou 2 147 483 647.
*Taille* MAX\$1BATCH\$1SIZE [ KB \$1 MB ]
Taille maximum de la charge utile de données qu’Amazon Redshift envoie dans une seule demande par lot pour une seule invocation Lambda.
La valeur minimale pour ce paramètre est 1 Ko. La valeur maximale est 5 Mo.
La valeur par défaut de ce paramètre est 5 Mo.
Ko et Mo sont facultatifs. Si vous ne définissez pas l’unité de mesure, Amazon Redshift utilise Ko par défaut.
## Notes d’utilisation
Tenez compte des points suivants lorsque vous créez Lambda UDFs :
+ L’ordre des appels de fonctions Lambda au niveau des arguments d’entrée n’est ni fixe ni garanti. Il peut varier selon les instances de requêtes en cours d’exécution, en fonction de la configuration du cluster.
+ Il n’est pas garanti que les fonctions soient appliquées une seule fois à chaque argument d’entrée. L'interaction entre Amazon Redshift et Amazon Redshift AWS Lambda peut entraîner des appels répétitifs avec les mêmes entrées.
## Exemples
Vous trouverez ci-dessous des exemples d'utilisation de fonctions scalaires Lambda définies par l'utilisateur (). UDFs
### Exemple de fonction scalaire UDF Lambda utilisant une fonction Node.js Lambda
L’exemple suivant crée une fonction externe appelée `exfunc_sum` qui prend deux entiers comme arguments d’entrée. Cette fonction renvoie la somme sous la forme d’une sortie de nombre entier. Le nom de la fonction Lambda à appeler est `lambda_sum`. Le langage utilisé pour cette fonction Lambda est Node.js 12.x. Veillez à spécifier le rôle IAM. L’exemple utilise `'arn:aws:iam::123456789012:user/johndoe'` en tant que rôle IAM.
```
CREATE EXTERNAL FUNCTION exfunc_sum(INT,INT)
RETURNS INT
VOLATILE
LAMBDA 'lambda_sum'
IAM_ROLE 'arn:aws:iam::123456789012:role/Redshift-Exfunc-Test';
```
La fonction Lambda prend la charge utile de la requête et effectue une itération sur chaque ligne. Toutes les valeurs d’une seule ligne sont ajoutées pour calculer la somme de cette ligne, qui est enregistrée dans la table de réponses. Le nombre de lignes dans la table de résultats est similaire au nombre de lignes reçues dans la charge utile de la requête.
La charge utile de la réponse JSON doit avoir les données de résultat dans le champ « results » pour être reconnue par la fonction externe. Le champ arguments de la requête envoyée à la fonction Lambda contient la charge utile de données. Il peut y avoir plusieurs lignes dans la charge utile de données en cas de requête par lots. La fonction Lambda suivante effectue une itération sur toutes les lignes de la charge utile de données de la requête. Elle effectue également une itération individuelle sur toutes les valeurs d’une seule ligne.
```
exports.handler = async (event) => {
// The 'arguments' field in the request sent to the Lambda function contains the data payload.
var t1 = event['arguments'];
// 'len(t1)' represents the number of rows in the request payload.
// The number of results in the response payload should be the same as the number of rows received.
const resp = new Array(t1.length);
// Iterating over all the rows in the request payload.
for (const [i, x] of t1.entries())
{
var sum = 0;
// Iterating over all the values in a single row.
for (const y of x) {
sum = sum + y;
}
resp[i] = sum;
}
// The 'results' field should contain the results of the lambda call.
const response = {
results: resp
};
return JSON.stringify(response);
};
```
L’exemple suivant appelle la fonction externe avec des valeurs littérales.
```
select exfunc_sum(1,2);
exfunc_sum
------------
3
(1 row)
```
L’exemple suivant crée une table appelée t\$1sum avec deux colonnes, c1 et c2, du type de données entier et insère deux lignes de données. Ensuite, la fonction externe est appelée en transmettant les noms de colonne de cette table. Les deux lignes de la table sont envoyées dans une requête par lots dans la charge utile de la requête sous la forme d’une seule invocation Lambda.
```
CREATE TABLE t_sum(c1 int, c2 int);
INSERT INTO t_sum VALUES (4,5), (6,7);
SELECT exfunc_sum(c1,c2) FROM t_sum;
exfunc_sum
---------------
9
13
(2 rows)
```
### Exemple de fonction scalaire UDF Lambda utilisant l’attribut RETRY\$1TIMEOUT
Dans la section suivante, vous trouverez un exemple d'utilisation de l'attribut RETRY\$1TIMEOUT dans Lambda. UDFs
AWS Lambda les fonctions ont des limites de simultanéité que vous pouvez définir pour chaque fonction. Pour plus d'informations sur les limites de simultanéité, consultez [la section Gestion de la simultanéité pour une fonction Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-concurrency.html) dans le *Guide du AWS Lambda développeur* et l'article [Gestion de la simultanéité des AWS Lambda fonctions sur le blog Compute](https://aws.amazon.com/blogs/compute/managing-aws-lambda-function-concurrency). AWS
Lorsque le nombre de requêtes traitées par une fonction UDF Lambda dépasse les limites de simultanéité, les nouvelles requêtes renvoient l’erreur `TooManyRequestsException`. La fonction UDF Lambda lance une nouvelle tentative pour cette erreur jusqu’à ce que la somme de tous les retards entre les requêtes envoyées à la fonction Lambda soit égale ou supérieure à la valeur RETRY\$1TIMEOUT que vous avez définie. La valeur RETRY\$1TIMEOUT par défaut est de 20 000 millisecondes.
L’exemple suivant utilise une fonction Lambda nommée `exfunc_sleep_3`. Cette fonction prend la charge utile de la requête, effectue une itération sur chaque ligne et convertit l’entrée en majuscules. Ensuite, elle passe en veille pendant 3 secondes puis renvoie le résultat. Le langage utilisé pour cette fonction Lambda est Python 3.8.
Le nombre de lignes dans la table de résultats est similaire au nombre de lignes reçues dans la charge utile de la requête. La charge utile de la réponse JSON doit avoir les données de résultat dans le champ `results` pour être reconnue par la fonction externe. Le champ `arguments` dans la requête envoyée à la fonction Lambda contient la charge utile de données. Dans le cas d’une requête par lots, plusieurs lignes peuvent apparaître dans la charge utile de données.
La limite de simultanéité pour cette fonction est spécifiquement définie sur 1 dans la simultanéité réservée pour démontrer l’utilisation de l’attribut RETRY\$1TIMEOUT. Lorsque l’attribut est défini sur 1, la fonction Lambda ne peut servir qu’une seule requête à la fois.
```
import json
import time
def lambda_handler(event, context):
t1 = event['arguments']
# 'len(t1)' represents the number of rows in the request payload.
# The number of results in the response payload should be the same as the number of rows received.
resp = [None]*len(t1)
# Iterating over all rows in the request payload.
for i, x in enumerate(t1):
# Iterating over all the values in a single row.
for j, y in enumerate(x):
resp[i] = y.upper()
time.sleep(3)
ret = dict()
ret['results'] = resp
ret_json = json.dumps(ret)
return ret_json
```
Voici deux exemples supplémentaires illustrant l’attribut RETRY\$1TIMEOUT. Ils invoquent chacun une seule fonction UDF Lambda. Lorsque la fonction UDF Lambda est appelée, chaque exemple exécute la même requête SQL pour appeler la fonction UDF Lambda à partir de deux séances de base de données simultanées. Lorsque la première requête qui appelle la fonction UDF Lambda est servie par la fonction UDF, la deuxième requête renvoie l’erreur `TooManyRequestsException`. Cela se produit parce que vous avez spécifiquement défini la simultanéité réservée dans la fonction UDF sur 1. Pour obtenir des informations sur la définition de la simultanéité réservée pour les fonctions Lambda, consultez [Configuration de la simultanéité réservée](https://docs.aws.amazon.com/lambda/latest/dg/configuration-concurrency.html#configuration-concurrency-reservedconfiguration-concurrency-reserved).
Le premier exemple ci-dessous définit l’attribut RETRY\$1TIMEOUT de la fonction UDF Lambda sur 0 milliseconde. Si la requête Lambda reçoit des exceptions de la fonction Lambda, Amazon Redshift n’effectue pas de nouvelle tentative. Ce résultat se produit car l’attribut RETRY\$1TIMEOUT est défini sur 0.
```
CREATE OR REPLACE EXTERNAL FUNCTION exfunc_upper(varchar)
RETURNS varchar
VOLATILE
LAMBDA 'exfunc_sleep_3'
IAM_ROLE 'arn:aws:iam::123456789012:role/Redshift-Exfunc-Test'
RETRY_TIMEOUT 0;
```
Lorsque la valeur RETRY\$1TIMEOUT est définie sur 0, vous pouvez exécuter les deux requêtes suivantes à partir de séances de base de données distinctes pour afficher des résultats différents.
La première requête SQL qui utilise la fonction UDF Lambda s’exécute avec succès.
```
select exfunc_upper('Varchar');
exfunc_upper
--------------
VARCHAR
(1 row)
```
La deuxième requête, qui est exécutée à partir d’une séance de base de données distincte en même temps, renvoie l’erreur `TooManyRequestsException`.
```
select exfunc_upper('Varchar');
ERROR: Rate Exceeded.; Exception: TooManyRequestsException; ShouldRetry: 1
DETAIL:
-----------------------------------------------
error: Rate Exceeded.; Exception: TooManyRequestsException; ShouldRetry: 1
code: 32103
context:query: 0
location: exfunc_client.cpp:102
process: padbmaster [pid=26384]
-----------------------------------------------
```
Le deuxième exemple ci-dessous définit l’attribut RETRY\$1TIMEOUT de la fonction UDF Lambda sur 3 000 millisecondes. Même si la deuxième requête est exécutée simultanément, la fonction UDF Lambda recommence jusqu’à ce que le total des délais atteigne 3 000 millisecondes. Ainsi, les deux requêtes s’exécutent avec succès.
```
CREATE OR REPLACE EXTERNAL FUNCTION exfunc_upper(varchar)
RETURNS varchar
VOLATILE
LAMBDA 'exfunc_sleep_3'
IAM_ROLE 'arn:aws:iam::123456789012:role/Redshift-Exfunc-Test'
RETRY_TIMEOUT 3000;
```
Lorsque RETRY\$1TIMEOUT est défini sur 3 000 millisecondes, vous pouvez exécuter les deux requêtes suivantes à partir de séances de base de données distinctes pour afficher les mêmes résultats.
La première requête SQL qui exécute la fonction UDF Lambda s’exécute avec succès.
```
select exfunc_upper('Varchar');
exfunc_upper
--------------
VARCHAR
(1 row)
```
La deuxième requête s’exécute simultanément, et la fonction UDF Lambda lance de nouvelles tentatives jusqu’à ce que le total des délais atteigne 3 000 millisecondes.
```
select exfunc_upper('Varchar');
exfunc_upper
--------------
VARCHAR
(1 row)
```
### Exemple de fonction scalaire UDF Lambda utilisant une fonction Python Lambda
L’exemple suivant crée une fonction externe appelée `exfunc_multiplication` qui multiplie les nombres et renvoie un nombre entier. Cet exemple intègre les champs success et `error_msg` dans la réponse Lambda. Le champ success est défini sur false lorsqu’il y a un dépassement d’entier dans le résultat de la multiplication et que la valeur du message `error_msg` est définie sur `Integer multiplication overflow`. La fonction `exfunc_multiplication` prend trois nombres entiers comme arguments d’entrée et renvoie la somme sous la forme d’une sortie de nombre entier.
Le nom de la fonction Lambda qui est appelée est `lambda_multiplication`. Le langage utilisé pour cette fonction Lambda est Python 3.8. Veillez à spécifier le rôle IAM.
```
CREATE EXTERNAL FUNCTION exfunc_multiplication(int, int, int)
RETURNS INT
VOLATILE
LAMBDA 'lambda_multiplication'
IAM_ROLE 'arn:aws:iam::123456789012:role/Redshift-Exfunc-Test';
```
La fonction Lambda prend la charge utile de la requête et effectue une itération sur chaque ligne. Toutes les valeurs d’une seule ligne sont multipliées pour calculer le résultat de cette ligne, qui est enregistré dans la liste de réponses. Cet exemple utilise une valeur success booléenne définie sur true par défaut. Si le résultat de multiplication d’une ligne a un dépassement d’entier, la valeur success est définie sur false. Ensuite, la boucle d’itération s’arrête.
Lorsque la charge utile de la réponse est créée, si la valeur success est false, la fonction Lambda suivante ajoute le champ `error_msg` dans la charge utile. Elle définit également le message d’erreur sur `Integer multiplication overflow`. Si la valeur success est true, les données de résultat sont ajoutées dans le champ results. Le nombre de lignes dans la table de résultats, le cas échéant, est similaire au nombre de lignes reçues dans la charge utile de la requête.
Le champ arguments de la requête envoyée à la fonction Lambda contient la charge utile de données. Il peut y avoir plusieurs lignes dans la charge utile de données en cas de demande par lots. La fonction Lambda suivante effectue une itération sur toutes les lignes de la charge utile de données de la requête et effectue une itération individuelle sur toutes les valeurs au sein d’une seule ligne.
```
import json
def lambda_handler(event, context):
t1 = event['arguments']
# 'len(t1)' represents the number of rows in the request payload.
# The number of results in the response payload should be the same as the number of rows received.
resp = [None]*len(t1)
# By default success is set to 'True'.
success = True
# Iterating over all rows in the request payload.
for i, x in enumerate(t1):
mul = 1
# Iterating over all the values in a single row.
for j, y in enumerate(x):
mul = mul*y
# Check integer overflow.
if (mul >= 9223372036854775807 or mul <= -9223372036854775808):
success = False
break
else:
resp[i] = mul
ret = dict()
ret['success'] = success
if not success:
ret['error_msg'] = "Integer multiplication overflow"
else:
ret['results'] = resp
ret_json = json.dumps(ret)
return ret_json
```
L’exemple suivant appelle la fonction externe avec des valeurs littérales.
```
SELECT exfunc_multiplication(8, 9, 2);
exfunc_multiplication
---------------------------
144
(1 row)
```
L’exemple suivant crée une table nommée t\$1multi avec trois colonnes, c1, c2 et c3, du type de données entier. La fonction externe est appelée en transmettant les noms de colonnes de cette table. Les données sont insérées de manière à provoquer un dépassement d’entier afin de montrer comment l’erreur est propagée.
```
CREATE TABLE t_multi (c1 int, c2 int, c3 int);
INSERT INTO t_multi VALUES (2147483647, 2147483647, 4);
SELECT exfunc_multiplication(c1, c2, c3) FROM t_multi;
DETAIL:
-----------------------------------------------
error: Integer multiplication overflow
code: 32004context:
context:
query: 38
location: exfunc_data.cpp:276
process: query2_16_38 [pid=30494]
-----------------------------------------------
```
# CREATE EXTERNAL MODEL
**Topics**
+ [Prérequis pour CREATE EXTERNAL MODEL](#r_create_external_model_prereqs)
+ [Privilèges requis](#r_simple_create_model-privileges)
+ [Contrôle des coûts](#r_create_model_cost)
+ [Syntaxe CREATE EXTERNAL MODEL](#r_create_external_model_syntax)
+ [Paramètres et réglages de CREATE EXTERNAL MODEL](#r_create_external_model_parameters_settings)
+ [Paramètres de la fonction d’inférence CREATE EXTERNAL MODEL](#r_create_external_model_if_parameters)
## Prérequis pour CREATE EXTERNAL MODEL
Avant d’utiliser l’instruction CREATE EXTERNAL MODEL, suivez les étapes requises détaillées dans [Configuration du cluster pour l’utilisation d’Amazon Redshift ML](getting-started-machine-learning.md#cluster-setup). Vous trouverez ci-dessous un résumé général des étapes requises.
+ Créez un cluster Amazon Redshift à l'aide de la console de AWS gestion ou de l'interface de ligne de AWS commande (AWS CLI).
+ Attachez la politique AWS Identity and Access Management (IAM) lors de la création du cluster.
+ Pour permettre à Amazon Redshift et Amazon Bedrock d’assumer le rôle afin d’interagir avec d’autres services, ajoutez la politique de confiance appropriée au rôle IAM.
+ Activez l'accès aux informations spécifiques LLMs que vous souhaitez utiliser depuis la console Amazon Bedrock.
+ (Facultatif) Si vous rencontrez des exceptions de limitation provenant d’Amazon Bedrock, par exemple `Too many requests, please wait before trying again`, même avec de petites quantités de données, vérifiez les quotas dans la section **Service Quotas** de votre compte Amazon Bedrock. Vérifiez que le quota appliqué au niveau du compte est au moins identique à la valeur de quota AWS par défaut pour les **InvokeModel**demandes relatives au modèle que vous utilisez.
Pour plus d’informations sur le rôle IAM, la politique d’approbation et d’autres prérequis, consultez [Configuration du cluster pour l’utilisation d’Amazon Redshift ML](getting-started-machine-learning.md#cluster-setup).
## Privilèges requis
Les privilèges suivants sont requis pour CREATE EXTERNAL MODEL :
+ Superuser
+ Utilisateurs disposant du privilège CREATE MODEL
+ Rôles avec le privilège GRANT CREATE MODEL
## Contrôle des coûts
Amazon Redshift ML utilise les ressources existantes du cluster pour créer des modèles de prédiction, de sorte que vous n’avez pas à payer de frais supplémentaires. Toutefois, les AWS frais d'utilisation d'Amazon Bedrock dépendent du modèle que vous sélectionnez. Pour obtenir plus d’informations, consultez [Costs for using Amazon Redshift ML](https://docs.aws.amazon.com/redshift/latest/dg/cost.html) (Coûts d’utilisation d’Amazon Redshift ML).
## Syntaxe CREATE EXTERNAL MODEL
Voici la syntaxe complète de l’instruction CREATE EXTERNAL MODEL.
```
CREATE EXTERNAL MODEL model_name
FUNCTION function_name
IAM_ROLE {default/'arn:aws:iam:::role/'}
MODEL_TYPE BEDROCK
SETTINGS (
MODEL_ID model_id
[, PROMPT 'prompt prefix']
[, SUFFIX 'prompt suffix']
[, REQUEST_TYPE {RAW|UNIFIED}]
[, RESPONSE_TYPE {VARCHAR|SUPER}]
);
```
La commande `CREATE EXTERNAL MODEL` crée une fonction d’inférence que vous utilisez pour générer du contenu.
Voici la syntaxe d’une fonction d’inférence que `CREATE EXTERNAL MODEL` crée à l’aide d’un `REQUEST_TYPE` de type `RAW` :
```
SELECT inference_function_name(request_super)
[FROM table];
```
Voici la syntaxe d’une fonction d’inférence que `CREATE EXTERNAL MODEL` crée à l’aide d’un `REQUEST_TYPE` de type `UNIFIED` :
```
SELECT inference_function_name(input_text, [, inference_config [, additional_model_request_fields]])
[FROM table];
```
Pour en savoir plus sur la façon d’utiliser la fonction d’interférence, consultez [Utilisation d’un modèle externe pour l’intégration d’Amazon Redshift ML à Amazon Bedrock](machine-learning-br.md#machine-learning-br-use).
## Paramètres et réglages de CREATE EXTERNAL MODEL
Cette section décrit les paramètres et les réglages de la commande `CREATE EXTERNAL MODEL`.
**Topics**
+ [Paramètres de CREATE EXTERNAL MODEL](#r_create_external_model_parameters)
+ [Réglages de CREATE EXTERNAL MODEL](#r_create_external_model_settings)
### Paramètres de CREATE EXTERNAL MODEL
model\$1name
Nom du modèle externe. Le nom du modèle d’un schéma doit être unique.
FUNCTION *function\$1name (data\$1type [,...] )*
Nom de la fonction d’inférence que `CREATE EXTERNAL MODEL` crée. Vous utilisez la fonction d’inférence pour envoyer des demandes à Amazon Bedrock et récupérer du texte généré par ML.
IAM\$1ROLE * \$1 default \$1 ’arn:aws:iam:::role/’ \$1*
Rôle IAM utilisé par Amazon Redshift pour accéder à Amazon Bedrock. Pour obtenir des informations sur le rôle IAM, consultez [Création ou mise à jour d’un rôle IAM pour l’intégration d’Amazon Redshift ML à Amazon Bedrock](machine-learning-br.md#machine-learning-br-iam).
MODEL\$1TYPE BEDROCK
Spécifie le type de modèle. La seule valeur valide est `BEDROCK`.
SETTINGS ( MODEL\$1ID model\$1id [,...] )
Spécifie les paramètres du modèle externe. Pour plus d’informations, consultez la section.
### Réglages de CREATE EXTERNAL MODEL
MODEL\$1ID model\$1id
L’identifiant du modèle externe, par exemple, `anthropic.claude-v2`. Pour plus d'informations sur le modèle Amazon Bedrock IDs, consultez le modèle [Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/model-ids.html). IDs
PROMPT ’prompt prefix’
Spécifie une invite statique qu’Amazon Redshift ajoute au début de chaque demande d’inférence. Compatible uniquement avec un `REQUEST_TYPE` de type `UNIFIED`.
SUFFIX ’prompt suffix’
Spécifie une invite statique qu’Amazon Redshift ajoute à la fin de chaque demande d’inférence. Compatible uniquement avec un `REQUEST_TYPE` de type `UNIFIED`.
REQUEST\$1TYPE \$1 RAW \$1 UNIFIED \$1
Spécifie le format de la demande envoyée à Amazon Bedrock. Les valeurs valides sont les suivantes :
+ **RAW** : la fonction d’inférence prend l’entrée comme une super valeur unique et renvoie toujours une super valeur. Le format de la super valeur est spécifique au modèle Amazon Bedrock sélectionné. Un super est un modèle de prédiction qui combine plusieurs algorithmes pour produire une seule prédiction améliorée.
+ **UNIFIED** : la fonction d’inférence utilise l’API unifiée. Tous les modèles disposent d’une interface unifiée et cohérente avec Amazon Bedrock. Cela fonctionne pour tous les modèles compatibles avec les messages. Cette valeur est celle par défaut.
Pour plus d’informations, consultez la [Documentation de l’API Converse](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html) dans la *Documentation de l’API Amazon Bedrock*.
RESPONSE\$1TYPE \$1 VARCHAR \$1 SUPER \$1
Spécifie le format de la réponse. Si `REQUEST_TYPE` est de type `RAW`, `RESPONSE_TYPE` est requis et la seule valeur valide est `SUPER`. Pour toutes les autres valeurs `REQUEST TYPE`, la valeur par défaut est `VARCHAR` et `RESPONSE_TYPE` est facultatif. Les valeurs valides sont les suivantes :
+ **VARCHAR** : Amazon Redshift renvoie uniquement le texte de réponse généré par le modèle.
+ **SUPER** : Amazon Redshift renvoie l’intégralité de la réponse JSON générée par le modèle sous forme de super. Cela inclut la réponse textuelle et des informations telles que le motif de l’arrêt et l’utilisation du jeton d’entrée et de sortie du modèle. Un super est un modèle de prédiction qui combine plusieurs algorithmes pour produire une seule prédiction améliorée.
## Paramètres de la fonction d’inférence CREATE EXTERNAL MODEL
Cette section décrit les paramètres valides pour la fonction d’inférence créée par la commande `CREATE EXTERNAL MODEL`.
### Paramètres de la fonction d’inférence CREATE EXTERNAL MODEL pour `REQUEST_TYPE` de type `RAW`
Une fonction d’inférence créée avec un `REQUEST_TYPE` de type `RAW` possède un super argument d’entrée et renvoie toujours un super type de données. La syntaxe du super d’entrée suit la syntaxe de la demande du modèle spécifique sélectionné à partir d’Amazon Bedrock.
### Paramètres de la fonction d’inférence CREATE EXTERNAL MODEL pour `REQUEST_TYPE` de type `UNIFIED`
input\$1text
Le texte qu’Amazon Redshift envoie à Amazon Bedrock.
inference\$1config
Une super valeur qui contient des paramètres facultatifs qu’Amazon Redshift envoie à Amazon Bedrock. Il peut s’agir des éléments suivants :
+ maxTokens
+ stopSequences
+ temperature
+ topP
Ces paramètres sont tous facultatifs et tous sensibles à la casse. Pour plus d'informations sur ces paramètres, consultez le [ InferenceConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InferenceConfiguration.html)manuel *Amazon Bedrock API Reference*.
# CREATE EXTERNAL SCHEMA
Crée un schéma externe dans la base de données actuelle. Vous pouvez utiliser ce schéma externe pour vous connecter à des bases de données Amazon RDS for PostgreSQL ou d’édition compatible avec Amazon Aurora PostgreSQL. Vous pouvez également créer un schéma externe qui fait référence à une base de données dans un catalogue de données externe tel qu' AWS Glue Athena ou à une base de données dans un métastore Apache Hive, tel qu'Amazon EMR.
Le propriétaire de ce schéma est l’auteur de la commande CREATE EXTERNAL SCHEMA. Pour transférer la propriété d’un schéma externe, utilisez [ALTER SCHEMA](r_ALTER_SCHEMA.md) pour modifier le propriétaire. Utilisez la commande [GRANT](r_GRANT.md) pour autoriser d’autres utilisateurs ou groupes d’utilisateurs à accéder au schéma.
Vous ne pouvez pas utiliser les commandes GRANT ou REVOKE pour des autorisations concernant une table externe. Vous pouvez en revanche accorder ou révoquer les autorisations pour le schéma externe.
**Note**
Si vous disposez actuellement de tables externes Redshift Spectrum dans le catalogue de données Amazon Athena, vous pouvez procéder à la migration de votre catalogue de données Athena vers un AWS Glue Data Catalog. Pour utiliser le catalogue de AWS Glue données avec Redshift Spectrum, vous devrez peut-être modifier vos politiques Gestion des identités et des accès AWS (IAM). Pour plus d'informations, consultez la section [Mise à niveau vers le catalogue de AWS Glue données](https://docs.aws.amazon.com/athena/latest/ug/glue-athena.html#glue-upgrade) dans le guide de l'*utilisateur d'Athena*.
Pour afficher les détails relatifs aux schémas externes, interrogez la vue système [SVV\$1EXTERNAL\$1SCHEMAS](r_SVV_EXTERNAL_SCHEMAS.md).
## Syntaxe
La syntaxe suivante décrit la commande CREATE EXTERNAL SCHEMA utilisée pour référencer des données à l’aide d’un catalogue de données externe. Pour plus d'informations, consultez [Amazon Redshift Spectrum](c-using-spectrum.md).
```
CREATE EXTERNAL SCHEMA [IF NOT EXISTS] local_schema_name
FROM [ [ DATA CATALOG ] | HIVE METASTORE | POSTGRES | MYSQL | KINESIS | MSK | REDSHIFT | KAFKA ]
[ DATABASE 'database_name' ]
[ SCHEMA 'schema_name' ]
[ REGION 'aws-region' ]
[ IAM_ROLE [ default | 'SESSION' | 'arn:aws:iam:::role/' ] ]
[ AUTHENTICATION [ none | iam | mtls] ]
[ AUTHENTICATION_ARN 'acm-certificate-arn' | SECRET_ARN 'ssm-secret- arn' ]
[ URI ['hive_metastore_uri' [ PORT port_number ] | 'hostname' [ PORT port_number ] | 'Kafka bootstrap URL'] ]
[ CLUSTER_ARN 'arn:aws:kafka:::cluster/msk/' ]
[ CATALOG_ROLE [ 'SESSION' | 'catalog-role-arn-string' ] ]
[ CREATE EXTERNAL DATABASE IF NOT EXISTS ]
[ CATALOG_ID 'Amazon Web Services account ID containing Glue or Lake Formation database' ]
```
La syntaxe suivante décrit la commande CREATE EXTERNAL SCHEMA utilisée pour référencer des données à l’aide d’une requête fédérée vers RDS POSTGRES ou Aurora PostgreSQL. Vous pouvez également créer un schéma externe qui fait référence à des sources de streaming, telles que Kinesis Data Streams. Pour plus d’informations, consultez [Interrogation de données avec requête fédérée dans Amazon Redshift](federated-overview.md).
```
CREATE EXTERNAL SCHEMA [IF NOT EXISTS] local_schema_name
FROM POSTGRES
DATABASE 'federated_database_name' [SCHEMA 'schema_name']
URI 'hostname' [ PORT port_number ]
IAM_ROLE [ default | 'arn:aws:iam:::role/' ]
SECRET_ARN 'ssm-secret-arn'
```
La syntaxe suivante décrit la commande CREATE EXTERNAL SCHEMA utilisée pour référencer des données à l’aide d’une requête fédérée vers RDS MySQL ou Aurora MySQL. Pour plus d’informations, consultez [Interrogation de données avec requête fédérée dans Amazon Redshift](federated-overview.md).
```
CREATE EXTERNAL SCHEMA [IF NOT EXISTS] local_schema_name
FROM MYSQL
DATABASE 'federated_database_name'
URI 'hostname' [ PORT port_number ]
IAM_ROLE [ default | 'arn:aws:iam:::role/' ]
SECRET_ARN 'ssm-secret-arn'
```
La syntaxe suivante décrit la commande CREATE EXTERNAL SCHEMA utilisée pour référencer des données dans un flux Kinesis. Pour plus d’informations, consultez [Ingestion en streaming vers une vue matérialisée](materialized-view-streaming-ingestion.md).
```
CREATE EXTERNAL SCHEMA [IF NOT EXISTS] schema_name
FROM KINESIS
IAM_ROLE [ default | 'arn:aws:iam:::role/' ]
```
La syntaxe suivante décrit la commande CREATE EXTERNAL SCHEMA utilisée pour référencer le cluster Amazon Managed Streaming pour Apache Kafka ou Confluent Cloud et ses rubriques à partir desquelles s’effectue l’ingestion. Pour vous connecter, vous devez fournir l’URI de l’agent. Pour plus d’informations, consultez [Ingestion en streaming vers une vue matérialisée](materialized-view-streaming-ingestion.md).
```
CREATE EXTERNAL SCHEMA [IF NOT EXISTS] schema_name
FROM KAFKA
[ IAM_ROLE [ default | 'arn:aws:iam:::role/' ] ]
URI 'Kafka bootstrap URI'
AUTHENTICATION [ none | iam | mtls ]
[ AUTHENTICATION_ARN 'acm-certificate-arn' | SECRET_ARN 'ssm-secret- arn' ];
```
La syntaxe suivante décrit la commande CREATE EXTERNAL SCHEMA utilisée pour référencer des données à l’aide d’une requête entre bases de données.
```
CREATE EXTERNAL SCHEMA local_schema_name
FROM REDSHIFT
DATABASE 'redshift_database_name' SCHEMA 'redshift_schema_name'
```
## Parameters
IF NOT EXISTS
Clause indiquant que si le schéma spécifié existe déjà, la commande ne doit apporter aucune modification et renvoyer un message selon lequel le schéma existe, plutôt que de s’arrêter avec une erreur. Puisque cette clause est utile lors de l’écriture de scripts, le script n’échoue pas si CREATE EXTERNAL SCHEMA tente de créer un schéma qui existe déjà.
local\$1schema\$1name
Nom du nouveau schéma externe. Pour plus d’informations sur les noms valides, consultez [Noms et identificateurs](r_names.md).
FROM [ DATA CATALOG ] \$1 HIVE METASTORE \$1 POSTGRES \$1 MYSQL \$1 KINESIS \$1 MSK \$1 REDSHIFT
Mot-clé indiquant où se situe la base de données externe.
DATA CATALOG indique que la base de données externe est définie dans le catalogue de données Athena ou AWS Glue Data Catalog.
Si la base de données externe est définie dans un catalogue de données externe dans une autre région AWS , le paramètre REGION est requis. La valeur par défaut est DATA CATALOG.
HIVE METASTORE indique que la base de données externe est définie dans un metastore Apache Hive. L’URI est obligatoire si HIVE METASTORE est spécifié.
POSTGRES indique que la base de données externe est définie dans RDS PostgreSQL ou Aurora PostgreSQL.
MYSQL indique que la base de données externe est définie dans RDS MySQL ou Aurora MySQL.
KINESIS indique que la source de données est un flux de Kinesis Data Streams.
MSK indique que la source de données est un cluster Amazon MSK alloué ou sans serveur.
KAFKA indique que la source de données est un cluster Kafka. Vous pouvez utiliser ce mot clé pour Amazon MSK et Confluent Cloud.
FROM REDSHIFT
Mot-clé indiquant que la base de données se trouve dans Amazon Redshift.
DATABASE ’*nom\$1base\$1de\$1données\$1redshift*’ SCHEMA ’*nom\$1schéma\$1redshift*’
Nom de la base de données Amazon Redshift.
Le *nom\$1schéma\$1redshift* indique le schéma dans Amazon Redshift. La valeur par défaut de *nom\$1schéma\$1redshift* est `public`.
DATABASE ’*nom\$1base\$1de\$1données\$1fédérée*’
Mot-clé qui indique le nom de la base de données externe dans un moteur de base de données PostgreSQL ou MySQL.
[SCHEMA ’*schema\$1name*’]
Le *nom\$1schéma* indique le schéma dans un moteur de base de données PostgreSQL pris en charge. Le *nom\$1schéma* par défaut est `public`.
Vous ne pouvez pas spécifier de SCHEMA lorsque vous configurez une requête fédérée sur un moteur de base de données MySQL pris en charge.
REGION ’*aws-region*’
Si la base de données externe est définie dans un catalogue de données Athena ou dans la AWS Glue Data Catalog AWS région dans laquelle se trouve la base de données. Si la base de données est définie dans un catalogue de données externe, ce paramètre est obligatoire.
URI [ ’hive\$1metastore\$1uri’ [ PORT port\$1number ] \$1 ’hostname’ [ PORT port\$1number ] \$1 ’Kafka bootstrap URI’ ]
URI du nom\$1hôte et numéro\$1port d’un moteur de base de données PostgreSQL ou MySQL pris en charge. *nom\$1hôte* est le nœud principal du jeu de réplicas. Le point de terminaison doit être accessible (routable) à partir du cluster Amazon Redshift. Le numéro de port (port\$1number) par défaut pour PostgreSQL est 5432. Le numéro de port (port\$1number) par défaut pour MySQL est 3306.
Le moteur de base de données PostgreSQL ou MySQL pris en charge doit être dans le même VPC que votre cluster Amazon Redshift avec un groupe de sécurité reliant Amazon Redshift et RDS url-rsPostgreSQL ou Aurora PostgreSQL. En outre, vous pouvez utiliser le routage VPC amélioré pour configurer un cas d’utilisation inter-VPC. Pour plus d’informations, consultez [Points de terminaison d’un VPC géré par Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/managing-cluster-cross-vpc.html).
**Spécification d’un URI de métastore Hive**
Si la base de données se trouve dans un metastore Hive, spécifiez l’URI et éventuellement le numéro de port du metastore. Le numéro de port par défaut est 9083.
Un URI ne contient pas de spécification de protocole (« http:// »). Voici un exemple d’URI valide : `uri '172.10.10.10'`.
**Spécification d’un URI d’agent pour l’ingestion en streaming**
L’inclusion de l’URI de l’agent d’amorçage permet de se connecter à un cluster Amazon MSK ou Confluent Cloud et de recevoir des données en streaming. Pour plus d’informations et un exemple, consultez [Mise en route de l’ingestion en streaming à partir d’Amazon Managed Streaming pour Apache Kafka](https://docs.aws.amazon.com/redshift/latest/dg/materialized-view-streaming-ingestion-getting-started-MSK.html).
IAM\$1ROLE [par défaut \$1 'SESSION' \$1 'arn:aws:iam : :role/ '] ** **
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 CREATE EXTERNAL SCHEMA s’exécute.
Utilisez `'SESSION'` si vous vous connectez à votre cluster Amazon Redshift à l’aide d’une identité fédérée et que vous accédez aux tables à partir du schéma externe créé à l’aide de cette commande. Pour plus d’informations, consultez [Utilisation d’une identité fédérée pour gérer l’accès à Amazon Redshift aux ressources locales et aux tables externes Amazon Redshift Spectrum](https://docs.aws.amazon.com/redshift/latest/mgmt/authorization-fas-spectrum.html), qui explique comment configurer l’identité fédérée. Notez que cette configuration, qui utilise `'SESSION'` à la place de l’ARN, ne peut être utilisée que si le schéma est créé à l’aide de `DATA CATALOG`.
Utilisez l’Amazon Resource Name (ARN) d’un rôle IAM que votre cluster utilise pour l’authentification et l’autorisation. Au minimum, le rôle IAM doit être autorisé à exécuter une opération LIST sur le compartiment Amazon S3 devant être accessible et une opération GET sur les objets Amazon S3 contenus dans le compartiment.
Le code suivant montre la syntaxe de la chaîne de paramètre IAM\$1ROLE pour un seul ARN.
```
IAM_ROLE 'arn:aws:iam:::role/'
```
Vous pouvez créer des chaînes de rôles pour permettre à votre cluster d’endosser un autre rôle IAM, y compris un rôle appartenant à un autre compte. Les chaînes ainsi créées peuvent inclure jusqu’à 10 rôles. Pour voir un exemple de création de chaîne de rôles, consultez [Créer des rôles IAM dans Amazon Redshift Spectrum](c-spectrum-iam-policies.md#c-spectrum-chaining-roles).
Attachez à ce rôle IAM une politique d’autorisations IAM similaire à la suivante.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AccessSecret",
"Effect": "Allow",
"Action": [
"secretsmanager:GetResourcePolicy",
"secretsmanager:GetSecretValue",
"secretsmanager:DescribeSecret",
"secretsmanager:ListSecretVersionIds"
],
"Resource": "arn:aws:secretsmanager:us-west-2:123456789012:secret:my-rds-secret-VNenFy"
},
{
"Sid": "VisualEditor1",
"Effect": "Allow",
"Action": [
"secretsmanager:GetRandomPassword",
"secretsmanager:ListSecrets"
],
"Resource": "*"
}
]
}
```
Pour connaître les étapes à suivre afin de créer un rôle IAM à utiliser avec une requête fédérée, consultez [Création d’un secret et d’un rôle IAM pour utiliser des requêtes fédérées](federated-create-secret-iam-role.md).
N’incluez pas d’espaces dans la liste des rôles chaînés.
L’exemple suivant montre la syntaxe d’une chaîne de trois rôles.
```
IAM_ROLE 'arn:aws:iam:::role/,arn:aws:iam:::role/,arn:aws:iam:::role/'
```
SECRET\$1ARN « » *ssm-secret-arn*
Le nom de ressource Amazon (ARN) d'un secret de moteur de base de données PostgreSQL ou MySQL pris en charge créé à l'aide de. AWS Secrets Manager Pour plus d’informations sur la création et la récupération d’un ARN pour un secret, consultez [Gérer les secrets avec AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/manage_create-basic-secret.html) dans le *Guide de l’utilisateur AWS Secrets Manager * et [Récupération de l’Amazon Resource Name (ARN) du secret dans Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-secrets-manager-integration-retrieving-secret.html).
CATALOG\$1ROLE ['SESSION' \$1] *catalog-role-arn-string*
`'SESSION'`À utiliser pour vous connecter à votre cluster Amazon Redshift à l’aide d’une identité fédérée à des fins d’authentification et d’autorisation du catalogue de données. Pour plus d’informations sur la réalisation des étapes relatives à l’identité fédérée, consultez [Utilisation d’une identité fédérée pour gérer l’accès d’Amazon Redshift aux ressources locales et aux tables externes Amazon Redshift Spectrum](https://docs.aws.amazon.com/redshift/latest/mgmt/authorization-fas-spectrum.html). Notez que le`'SESSION'` rôle ne peut être utilisé que si le schéma est créé dans DATA CATALOG.
Nom Amazon Resource Name (ARN) d’un rôle IAM que votre cluster utilise pour l’authentification et l’autorisation.
Si CATALOG\$1ROLE n’est pas spécifié, Amazon Redshift utilise la valeur IAM\$1ROLE spécifiée. Le rôle du catalogue doit être autorisé à accéder au catalogue de données dans AWS Glue ou Athena. Pour de plus amples informations, veuillez consulter [Politiques IAM pour Amazon Redshift Spectrum](c-spectrum-iam-policies.md).
Le code suivant montre la syntaxe de la chaîne de paramètre CATALOG\$1ROLE pour un seul ARN.
```
CATALOG_ROLE 'arn:aws:iam:::role/'
```
Vous pouvez créer des chaînes de rôles pour permettre à votre cluster d’endosser un autre rôle IAM, y compris un rôle appartenant à un autre compte. Les chaînes ainsi créées peuvent inclure jusqu’à 10 rôles. Pour plus d'informations, consultez [Créer des rôles IAM dans Amazon Redshift Spectrum](c-spectrum-iam-policies.md#c-spectrum-chaining-roles).
La liste des rôles de la chaîne ne doit pas inclure d’espaces.
L’exemple suivant montre la syntaxe d’une chaîne de trois rôles.
```
CATALOG_ROLE 'arn:aws:iam:::role/,arn:aws:iam:::role/,arn:aws:iam:::role/'
```
CREATE EXTERNAL DATABASE IF NOT EXISTS
Clause qui crée une base de données externe avec le nom spécifié par l’argument DATABASE, si la base de données externe spécifiée n’existe pas. La commande n’apporte aucune modification si la base de données externe spécifiée existe. Dans ce cas, la commande renvoie un message indiquant que la base de données externe existe, plutôt que de s’arrêter avec une erreur.
La clause CREATE EXTERNAL DATABASE IF NOT EXISTS ne peut pas être utilisée avec HIVE METASTORE.
Pour utiliser CREATE EXTERNAL DATABASE IF NOT EXISTS avec un catalogue de données activé pour AWS Lake Formation, vous devez disposer de l’autorisation `CREATE_DATABASE` sur le catalogue de données.
CATALOG\$1ID « ID de *compte Amazon Web Services contenant la base de données Glue ou Lake Formation* »
L’identifiant du compte sur lequel la base de données du catalogue de données est stockée.
`CATALOG_ID`peut être spécifiée uniquement si vous prévoyez de vous connecter à votre cluster Amazon Redshift ou à Amazon Redshift sans serveur à l’aide d’une identité fédérée pour l’authentification et l’autorisation du catalogue de données en définissant l’une des options suivantes :
+ `CATALOG_ROLE` sur `'SESSION'`
+ `IAM_ROLE`à`'SESSION'` et`'CATALOG_ROLE'` régler sur sa valeur par défaut
Pour plus d’informations sur la réalisation des étapes relatives à l’identité fédérée, consultez [Utilisation d’une identité fédérée pour gérer l’accès d’Amazon Redshift aux ressources locales et aux tables externes Amazon Redshift Spectrum](https://docs.aws.amazon.com/redshift/latest/mgmt/authorization-fas-spectrum.html).
AUTHENTICATION
Type d’authentification défini pour l’ingestion en streaming. L’ingestion en streaming assortie de types d’authentification fonctionne avec Amazon Managed Streaming for Apache Kafka. Les types `AUTHENTICATION` sont les suivants :
+ **none** : indique l’absence de toute authentification requise. Cela correspond à un accès non authentifié sur MSK ou en texte brut avec TLS sur Apache Kafka.
+ **iam** – Indique une authentification IAM. Lorsque vous choisissez cette option, vérifiez que le rôle IAM dispose des autorisations nécessaires à l’authentification IAM. Pour en savoir plus sur la définition du schéma externe, consultez [Mise en route de l’ingestion en streaming à partir de sources Apache Kafka](materialized-view-streaming-ingestion-getting-started-MSK.md).
+ **mtls** : indique que le protocole mTLS (Mutual Transport Layer Security) assure une communication sécurisée en facilitant l’authentification entre un client et un serveur. Dans ce cas, le client est Redshift et le serveur est Amazon MSK. Pour de plus amples informations sur la configuration de l’ingestion en streaming avec mTLS, consultez [Authentification avec mTLS pour l’ingestion en streaming Redshift à partir de sources Apache Kafka](materialized-view-streaming-ingestion-mtls.md).
AUTHENTICATION\$1ARN
L'ARN du AWS Certificate Manager certificat utilisé par Amazon Redshift pour l'authentification MTLS avec Amazon MSK. L’ARN est disponible dans la console ACM lorsque vous choisissez le certificat émis.
CLUSTER\$1ARN
Pour l’ingestion en streaming, CLUSTER\$1ARN est l’identifiant de cluster Amazon Managed Streaming pour Apache Kafka à partir duquel vous effectuez le streaming. Lorsque vous utilisez CLUSTER\$1ARN, une politique de rôle IAM incluant l’autorisation `kafka:GetBootstrapBrokers` est requise. Cette option est fournie à des fins de rétrocompatibilité. Actuellement, nous recommandons d’utiliser l’option d’URI de l’agent d’amorçage pour vous connecter aux clusters Amazon Managed Streaming pour Apache Kafka. Pour plus d’informations, consultez [Ingestion en streaming (version préliminaire)](https://docs.aws.amazon.com/redshift/latest/dg/materialized-view-streaming-ingestion.html).
## Notes d’utilisation
Pour connaître les restrictions relatives à l’utilisation du catalogue de données Athena, consultez [Athena Limits](https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html#amazon-athena-limits) dans Références générales AWS.
Pour connaître les limites d'utilisation du AWS Glue Data Catalog, voir [AWS Glue Limites](https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html#limits_glue) dans le Références générales AWS.
Ces restrictions ne s’appliquent pas à un metastore Hive.
Il y a un maximum de 9 900 schémas par base de données. Pour plus d’informations, consultez [Quotas et limites](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) dans le *Guide de gestion Amazon Redshift*.
Pour annuler l’enregistrement du schéma, utilisez la commande [DROP SCHEMA](r_DROP_SCHEMA.md).
Pour afficher les détails relatifs aux schémas externes, interrogez les vues système suivantes :
+ [SVV\$1EXTERNAL\$1SCHEMAS](r_SVV_EXTERNAL_SCHEMAS.md)
+ [SVV\$1EXTERNAL\$1TABLES](r_SVV_EXTERNAL_TABLES.md)
+ [SVV\$1EXTERNAL\$1COLUMNS](r_SVV_EXTERNAL_COLUMNS.md)
## Exemples
L’exemple suivant permet de créer un schéma externe en utilisant une base de données dans un catalogue de données nommé `sampledb` dans la région USA Ouest (Oregon). Utilisez cet exemple avec un catalogue de données Athena ou AWS Glue .
```
create external schema spectrum_schema
from data catalog
database 'sampledb'
region 'us-west-2'
iam_role 'arn:aws:iam::123456789012:role/MySpectrumRole';
```
L’exemple suivant permet de créer un schéma externe ainsi qu’une base de données externe nommée `spectrum_db`.
```
create external schema spectrum_schema
from data catalog
database 'spectrum_db'
iam_role 'arn:aws:iam::123456789012:role/MySpectrumRole'
create external database if not exists;
```
L’exemple suivant permet de créer un schéma externe en utilisant une base de données de metastore Hive nommée `hive_db`.
```
create external schema hive_schema
from hive metastore
database 'hive_db'
uri '172.10.10.10' port 99
iam_role 'arn:aws:iam::123456789012:role/MySpectrumRole';
```
L’exemple suivant établit une chaîne de rôles afin d’utiliser le rôle `myS3Role` pour accéder à Amazon S3 et `myAthenaRole` pour l’accès au catalogue de données. Pour plus d'informations, consultez [Créer des rôles IAM dans Amazon Redshift Spectrum](c-spectrum-iam-policies.md#c-spectrum-chaining-roles).
```
create external schema spectrum_schema
from data catalog
database 'spectrum_db'
iam_role 'arn:aws:iam::123456789012:role/myRedshiftRole,arn:aws:iam::123456789012:role/myS3Role'
catalog_role 'arn:aws:iam::123456789012:role/myAthenaRole'
create external database if not exists;
```
L’exemple suivant crée un schéma externe qui référence une base de données Aurora PostgreSQL.
```
CREATE EXTERNAL SCHEMA [IF NOT EXISTS] myRedshiftSchema
FROM POSTGRES
DATABASE 'my_aurora_db' SCHEMA 'my_aurora_schema'
URI 'endpoint to aurora hostname' PORT 5432
IAM_ROLE 'arn:aws:iam::123456789012:role/MyAuroraRole'
SECRET_ARN 'arn:aws:secretsmanager:us-east-2:123456789012:secret:development/MyTestDatabase-AbCdEf'
```
L’exemple suivant crée un schéma externe pour renvoyer à la base de données sales\$1db importée sur le cluster consommateur.
```
CREATE EXTERNAL SCHEMA sales_schema FROM REDSHIFT DATABASE 'sales_db' SCHEMA 'public';
```
L’exemple suivant crée un schéma externe qui référence une base de données Aurora MySQL.
```
CREATE EXTERNAL SCHEMA [IF NOT EXISTS] myRedshiftSchema
FROM MYSQL
DATABASE 'my_aurora_db'
URI 'endpoint to aurora hostname'
IAM_ROLE 'arn:aws:iam::123456789012:role/MyAuroraRole'
SECRET_ARN 'arn:aws:secretsmanager:us-east-2:123456789012:secret:development/MyTestDatabase-AbCdEf'
```
# CREATE EXTERNAL TABLE
Crée une table externe dans le schéma spécifié. Toutes les tables externes doivent être créées dans un schéma externe. Le chemin de recherche n’est pas pris en charge pour les schémas et tables externes. Pour de plus amples informations, veuillez consulter [CREATE EXTERNAL SCHEMA](r_CREATE_EXTERNAL_SCHEMA.md).
Outre les tables externes créées à l'aide de la commande CREATE EXTERNAL TABLE, Amazon Redshift peut faire référence à des tables externes définies dans un AWS Lake Formation catalogue AWS Glue ou un métastore Apache Hive. Utilisez la commande [CREATE EXTERNAL SCHEMA](r_CREATE_EXTERNAL_SCHEMA.md) pour enregistrer une base de données externe définie dans un catalogue de données externe, et faites en sorte que les tables externes puissent être utilisées dans Amazon Redshift. Si la table externe existe dans un AWS Lake Formation catalogue AWS Glue ou un métastore Hive, vous n'avez pas besoin de créer la table à l'aide de CREATE EXTERNAL TABLE. Pour afficher les tables externes, interrogez la vue système [SVV\$1EXTERNAL\$1TABLES](r_SVV_EXTERNAL_TABLES.md).
En exécutant la commande CREATE EXTERNAL TABLE AS, vous pouvez créer une table externe basée sur la définition de colonne d’une requête et écrire les résultats de cette requête dans Amazon S3. Les résultats sont au format Apache Parquet ou au format texte délimité. Si la table externe possède une ou plusieurs clés de partition, Amazon Redshift partitionne les nouveaux fichiers en fonction de ces clés de partition et enregistre automatiquement les nouvelles partitions dans le catalogue externe. Pour plus d’informations sur la commande CREATE EXTERNAL TABLE AS, consultez [Notes d’utilisation](r_CREATE_EXTERNAL_TABLE_usage.md).
Vous pouvez interroger une table externe en utilisant la même syntaxe SELECT que celle que vous utilisez avec d’autres tables Amazon Redshift. Vous pouvez également utiliser la syntaxe INSERT pour écrire de nouveaux fichiers à l’emplacement de la table externe sur Amazon S3. Pour plus d'informations, consultez [INSERT (table externe)](r_INSERT_external_table.md).
Pour créer une vue avec une table externe, incluez la clause WITH NO SCHEMA BINDING dans l’instruction [CREATE VIEW](r_CREATE_VIEW.md).
Vous ne pouvez pas exécuter CREATE EXTERNAL TABLE à l’intérieur d’une transaction (BEGIN ... END). Pour plus d’informations sur les transactions, consultez [Niveaux d’isolement dans Amazon Redshift](c_serial_isolation.md).
## Privilèges requis
Pour créer des tables externes, vous devez être le propriétaire du schéma externe ou un superutilisateur. Pour transférer la propriété d’un schéma externe, utilisez ALTER SCHEMA pour modifier le propriétaire. L’accès aux tables externes est contrôlé par l’accès au schéma externe. Vous ne pouvez pas accorder [GRANT](r_GRANT.md) ni révoquer [REVOKE](r_REVOKE.md) des autorisations pour une table externe. A la place, accordez ou révoquez USAGE sur le schéma externe.
Vous trouverez dans les [Notes d’utilisation](r_CREATE_EXTERNAL_TABLE_usage.md) des informations complémentaires sur les autorisations spécifiques des tables externes.
## Syntaxe
```
CREATE EXTERNAL TABLE
external_schema.table_name
(column_name data_type [, …] )
[ PARTITIONED BY (col_name data_type [, … ] )]
[ { ROW FORMAT DELIMITED row_format |
ROW FORMAT SERDE 'serde_name'
[ WITH SERDEPROPERTIES ( 'property_name' = 'property_value' [, ...] ) ] } ]
STORED AS file_format
LOCATION { 's3://bucket/folder/' | 's3://bucket/manifest_file' }
[ TABLE PROPERTIES ( 'property_name'='property_value' [, ...] ) ]
```
Voici la syntaxe de la commande CREATE EXTERNAL TABLE AS.
```
CREATE EXTERNAL TABLE
external_schema.table_name
[ PARTITIONED BY (col_name [, … ] ) ]
[ ROW FORMAT DELIMITED row_format ]
STORED AS file_format
LOCATION { 's3://bucket/folder/' }
[ TABLE PROPERTIES ( 'property_name'='property_value' [, ...] ) ]
AS
{ select_statement }
```
## Parameters
*schéma\$1externe.nom\$1table*
Nom de la table à créer, qualifié par un nom de schéma externe. Les tables externes doivent être créées dans un schéma externe. Pour plus d'informations, consultez [CREATE EXTERNAL SCHEMA](r_CREATE_EXTERNAL_SCHEMA.md).
La longueur maximale d’un nom de table est de 127 octets ; les noms plus longs sont tronqués à 127 octets. Vous pouvez utiliser des caractères multioctets UTF-8 jusqu’à un maximum de quatre octets. Amazon Redshift impose une limite de 9 900 tables par cluster, y compris les tables temporaires définies par l’utilisateur et les tables temporaires créées par Amazon Redshift lors du traitement des requêtes ou de la maintenance du système. Le cas échéant, le nom de la table peut être qualifié avec le nom de la base de données. Dans l’exemple suivant, le nom de base de données est `spectrum_db`, le nom du schéma externe est `spectrum_schema` et le nom de la table est `test`.
```
create external table spectrum_db.spectrum_schema.test (c1 int)
stored as parquet
location 's3://amzn-s3-demo-bucket/myfolder/';
```
Si la base de données ou le schéma spécifié n’existe pas, la table n’est pas créée et l’instruction renvoie une erreur. Vous ne pouvez pas créer de tables ni de vues dans les bases de données système `template0`, `template1`, `padb_harvest` ou `sys:internal`.
Le nom de la table doit être un nom unique pour le schéma spécifié.
Pour plus d’informations sur les noms valides, consultez [Noms et identificateurs](r_names.md).
( *nom\$1colonne* *type\$1données* )
Nom et type de données de chaque colonne en cours de création.
La longueur maximale d’un nom de colonne est de 127 octets ; les noms plus longs sont tronqués à 127 octets. Vous pouvez utiliser des caractères multioctets UTF-8 jusqu’à un maximum de quatre octets. Vous ne pouvez pas spécifier de noms de colonne `"$path"` ou `"$size"`. Pour plus d’informations sur les noms valides, consultez [Noms et identificateurs](r_names.md).
Par défaut, Amazon Redshift crée les tables externes avec les pseudo-colonnes `$path` et `$size`. Vous pouvez désactiver la création de pseudo-colonnes d’une séance en définissant le paramètre de configuration `spectrum_enable_pseudo_columns` avec la valeur `false`. Pour plus d'informations, consultez [Pseudocolonnes](r_CREATE_EXTERNAL_TABLE_usage.md#r_CREATE_EXTERNAL_TABLE_usage-pseudocolumns).
Si les pseudo-colonnes sont activées, le nombre maximal de colonnes que vous pouvez définir dans une seule table est 1 598. Si les pseudo-colonnes ne sont pas activées, le nombre maximal de colonnes que vous pouvez définir dans une seule table est 1 600.
Si vous créez une grande table, assurez-vous que la liste de colonnes ne dépasse pas les limites de largeur de ligne pour les résultats intermédiaires pendant le traitement des charges et des requêtes. Pour plus d'informations, consultez [Notes d’utilisation](r_CREATE_TABLE_NEW.md#r_CREATE_TABLE_usage).
Pour une commande CREATE EXTERNAL TABLE AS, aucune liste de colonnes n’est requise, car les colonnes sont dérivées de la requête.
*data\$1type*
Les encodages [Types de données](c_Supported_data_types.md) suivants sont pris en charge :
+ PETITE MENTHE () INT2
+ ENTIER (INT, INT4)
+ BIGINT () INT8
+ DECIMAL (NUMERIC)
+ RÉEL (FLOAT4)
+ DOUBLE PRÉCISION (FLOAT8)
+ BOOLEAN (BOOL)
+ CHAR (CHARACTER)
+ VARCHAR (CHARACTER VARYING)
+ VARBYTE (CHARACTER VARYING) : peut être utilisé avec des fichiers de données Parquet et ORC, et uniquement avec des tables non partitionnées.
+ DATE : peut être utilisé uniquement avec du texte ou des fichiers de données Parquet ou ORC, ou comme colonne de partition.
+ TIMESTAMP
Pour DATE, vous pouvez utiliser les formats décrits ci-dessous. Pour les valeurs de mois représentées à l’aide de chiffres, les formats suivants sont pris en charge :
+ `mm-dd-yyyy` Par exemple, `05-01-2017`. Il s’agit de l’option par défaut.
+ `yyyy-mm-dd`, où l’année est représentée par plus de deux chiffres. Par exemple, `2017-05-01`.
Pour les valeurs de mois représentées à l’aide de l’abréviation de trois lettres, les formats suivants sont pris en charge :
+ `mmm-dd-yyyy` Par exemple, `may-01-2017`. Il s’agit de l’option par défaut.
+ `dd-mmm-yyyy`, où l’année est représentée par plus de deux chiffres. Par exemple, `01-may-2017`.
+ `yyyy-mmm-dd`, où l’année est représentée par plus de deux chiffres. Par exemple, `2017-may-01`.
Pour les valeurs d’années qui sont constamment inférieures à 100, l’année est calculée de la manière suivante :
+ Si l’année est inférieure à 70, elle est calculée comme l’année plus 2000. Par exemple, la date 05-01-17 au format `mm-dd-yyyy` est convertie au format `05-01-2017`.
+ Si l’année est inférieure à 100 et supérieure à 69, l’année est calculée comme l’année plus 1900. Par exemple, la date 05-01-89 au format `mm-dd-yyyy` est convertie au format `05-01-1989`.
+ Pour les valeurs d’année représentées par deux chiffres, ajoutez les zéros de tête pour représenter l’année en quatre chiffres.
Les valeurs d’horodatage dans les fichiers texte doivent être au format `yyyy-mm-dd HH:mm:ss.SSSSSS`, comme illustré par la valeur d’horodatage suivante : `2017-05-01 11:30:59.000000`.
La longueur d’une colonne VARCHAR est définie en octets et non pas en caractères. Par exemple, une colonne VARCHAR(12) peut contenir 12 caractères codés sur un octet ou 6 caractères codés sur deux octets. Lorsque vous interrogez une table externe, les résultats sont tronqués pour s’adapter à la taille définie de la colonne sans renvoyer d’erreur. Pour plus d'informations, consultez [Stockage et plages](r_Character_types.md#r_Character_types-storage-and-ranges).
Pour de meilleures performances, nous vous recommandons de spécifier la plus petite taille de colonne adaptée à vos données. Pour rechercher la taille maximale en octets des valeurs d’une colonne, utilisez la fonction [OCTET\$1LENGTH](r_OCTET_LENGTH.md). L’exemple suivant renvoie la taille maximale des valeurs de la colonne EMAIL.
```
select max(octet_length(email)) from users;
max
---
62
```
PARTITIONED BY (*nom\$1col* *type\$1données* [, … ] )
Clause qui définit une table partitionnée avec une ou plusieurs colonnes de partition. Un répertoire de données distinct est utilisé pour chaque combinaison spécifiée, ce qui dans certains cas améliore la performance des requêtes. Les colonnes partitionnées n’existent pas au sein même des données de la table. Si la valeur de *nom\$1col* est identique à celle d’une colonne de table, une erreur est renvoyée.
Après avoir créé une table partitionnée, modifiez-la à l’aide d’une instruction [ALTER TABLE](r_ALTER_TABLE.md) ... ADD PARTITION pour enregistrer de nouvelles partitions dans le catalogue externe. Lorsque vous ajoutez une partition, vous définissez l’emplacement du sous-dossier sur Amazon S3 qui contient les données de partition.
Par exemple, si la table `spectrum.lineitem_part` est définie avec `PARTITIONED BY (l_shipdate date)`, exécutez la commande ALTER TABLE suivante pour ajouter une partition.
```
ALTER TABLE spectrum.lineitem_part ADD PARTITION (l_shipdate='1992-01-29')
LOCATION 's3://spectrum-public/lineitem_partition/l_shipdate=1992-01-29';
```
Si vous utilisez la commande CREATE EXTERNAL TABLE AS, vous n’avez pas besoin d’exécuter la commande ALTER TABLE...ADD PARTITION. Amazon Redshift enregistre automatiquement les nouvelles partitions dans le catalogue externe. Amazon Redshift écrit également automatiquement les données correspondantes dans les partitions d’Amazon S3 en fonction de la ou des clés de partition définies dans la table.
Pour afficher les partitions, interrogez la vue système [SVV\$1EXTERNAL\$1PARTITIONS](r_SVV_EXTERNAL_PARTITIONS.md).
Pour une commande CREATE EXTERNAL TABLE AS, vous n’avez pas besoin de spécifier le type de données de la colonne de partition car cette colonne est dérivée de la requête.
ROW FORMAT DELIMITED *format\$1ligne*
Clause qui spécifie le format des données sous-jacentes. Les valeurs possibles pour *format\$1ligne* sont les suivantes :
+ LINES TERMINATED BY ’*délimiteur*’
+ FIELDS TERMINATED BY ’*délimiteur*’
Spécifiez un caractère ASCII unique pour ’*délimiteur*’. Vous pouvez spécifier des caractères ASCII non imprimables en octal, au format `'\`*`ddd`*`'`, où *`d`* est un chiffre octal (de 0 à 7) jusqu’à « \$1177 ». L’exemple suivant spécifie le caractère BEL (bell) en octal.
```
ROW FORMAT DELIMITED FIELDS TERMINATED BY '\007'
```
Si ROW FORMAT est omis, le format par défaut est DELIMITED FIELDS TERMINATED BY ’\$1A’ (début d’en-tête)et LINES TERMINATED BY ’\$1n’ (nouvelle ligne).
ROW FORMAT SERDE ’*nom\$1sérialisation\$1désérialisation*’ [WITH SERDEPROPERTIES ( ’*nom\$1propriété*’ = ’*valeur\$1propriété*’ [, ...] ) ]
Clause qui spécifie le format SERDE des données sous-jacentes.
’*nom\$1sérialisation\$1désérialisation*’
Le nom de l' SerDe. Vous pouvez spécifier les formats suivants :
+ org.apache.hadoop.hive.serde2. RegexSerDe
+ com.amazonaws.glue.serde. GrokSerDe
+ org.apache.hadoop.hive.serde2.ouvrir CSVSerde
Ce paramètre prend en charge la SerDe propriété suivante pour Open CSVSerde :
```
'wholeFile' = 'true'
```
Définissez la propriété `wholeFile` sur `true` pour analyser correctement les caractères de nouvelle ligne (\$1n) dans les chaînes entre guillemets pour les requêtes OpenCSV.
+ org.openx.data.json. JsonSerDe
+ Le SERDE JSON prend également en charge les fichiers Ion.
+ Le JSON doit être dans un format correct.
+ Les horodatages dans Ion et JSON doivent utiliser ISO8601 le format.
+ Ce paramètre prend en charge les SerDe propriétés suivantes pour JsonSerDe :
```
'strip.outer.array'='true'
```
Ion/JSON Traite les fichiers contenant un très grand tableau entre crochets ([...]) comme s'il contenait plusieurs enregistrements JSON dans le tableau.
+ com.amazon.ionhiveserde. IonHiveSerDe
Le format Amazon ION fournit des formats texte et binaire, en plus des types de données. Pour une table externe qui fait référence à des données au format ION, vous mappez chaque colonne de la table externe à l’élément correspondant dans les données au format ION. Pour plus d’informations, consultez [Amazon Ion](https://amzn.github.io/ion-docs/). Vous devez également spécifier les formats d’entrée et de sortie.
WITH SERDEPROPERTIES ( ’*nom\$1propriété*’ = ’*valeur\$1propriété*’ [, ...] ) ]
À titre facultatif, spécifiez les noms et valeurs des propriétés, séparés par des virgules.
Si ROW FORMAT est omis, le format par défaut est DELIMITED FIELDS TERMINATED BY ’\$1A’ (début d’en-tête)et LINES TERMINATED BY ’\$1n’ (nouvelle ligne).
STORED AS *format\$1fichier*
Format des fichiers de données.
Les formats valides sont les suivants :
+ PARQUET
+ RCFILE (pour l'utilisation des données ColumnarSerDe uniquement, pas LazyBinaryColumnarSerDe)
+ SEQUENCEFILE
+ TEXTFILE (pour les fichiers texte, y compris les fichiers JSON).
+ ORC
+ AVRO
+ INPUTFORMAT ’*nom\$1classe\$1format\$1entrée*’ OUTPUTFORMAT ’*nom\$1classe\$1format\$1sortie*’
La commande CREATE EXTERNAL TABLE AS prend uniquement en charge deux formats de fichiers, TEXTFILE et PARQUET.
Pour INPUTFORMAT et OUTPUTFORMAT, indiquez un nom de classe comme dans l’exemple suivant.
```
'org.apache.hadoop.mapred.TextInputFormat'
```
LOCATION \$1 ’s3://*bucket/folder*/’ \$1 ’s3://*bucket/manifest\$1file*’\$1
Chemin menant au compartiment Amazon S3 ou au dossier qui contient les fichiers de données ou un fichier manifeste qui contient une liste de chemins d’objets Amazon S3. Les compartiments doivent se trouver dans la même AWS région que le cluster Amazon Redshift. Pour obtenir une liste des régions AWS prises en charge, consultez [Limitations propres à Amazon Redshift Spectrum](c-spectrum-considerations.md).
Si le chemin précise un compartiment ou un dossier, par exemple, `'s3://amzn-s3-demo-bucket/custdata/'`, Redshift Spectrum analyse les fichiers qui se trouvent dans le compartiment ou dossier spécifié et dans tous les sous-dossiers. Redshift Spectrum ignore les fichiers masqués ainsi que les fichiers dont le nom commence par un point ou un trait de soulignement.
Si le chemin indique un fichier manifeste, l’argument `'s3://bucket/manifest_file'` 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, ainsi que la taille du fichier, en octets. 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", "meta": { "content_length": 5956875 } },
{"url":"s3://amzn-s3-demo-bucket1/custdata.2", "meta": { "content_length": 5997091 } },
{"url":"s3://amzn-s3-demo-bucket2/custdata.1", "meta": { "content_length": 5978675 } }
]
}
```
Vous pouvez rendre obligatoire l’inclusion d’un fichier particulier. Pour ce faire, incluez une option `mandatory` au niveau du fichier dans le manifeste. Lorsque vous interrogez une table externe avec un fichier obligatoire manquant, l’instruction SELECT échoue. Assurez-vous que tous les fichiers inclus dans la définition de la table externe sont présents. S’ils ne sont pas tous présents, une erreur apparaît, indiquant le premier fichier obligatoire introuvable. L’exemple suivant montre le fichier JSON d’un manifeste dont l’ `mandatory` option est définie sur `true`.
```
{
"entries": [
{"url":"s3://amzn-s3-demo-bucket1/custdata.1", "mandatory":true, "meta": { "content_length": 5956875 } },
{"url":"s3://amzn-s3-demo-bucket1/custdata.2", "mandatory":false, "meta": { "content_length": 5997091 } },
{"url":"s3://amzn-s3-demo-bucket2/custdata.1", "meta": { "content_length": 5978675 } }
]
}
```
Pour référencer les fichiers créés à l’aide de la commande UNLOAD, vous devez utiliser le manifeste créé à l’aide de la commande [UNLOAD](r_UNLOAD.md) avec le paramètre MANIFEST. Le fichier manifeste est compatible avec un fichier manifeste pour [Commande COPY depuis Amazon S3](copy-parameters-data-source-s3.md), mais il n’utilise pas les mêmes clés. Les clés inutilisées sont ignorées.
TABLE PROPERTIES ( ’*nom\$1propriété*’=’*valeur\$1propriété*’ [, ...] )
Clause qui définit la définition de table pour des propriétés de table.
Les propriétés de table sont sensibles à la casse.
’compression\$1type’=’*valeur*’
Propriété qui définit le type de compression à utiliser si le nom de fichier ne contient aucune extension. Si vous définissez cette propriété et que le nom de fichier contient une extension, celle-ci est ignorée et la valeur définie par la propriété est utilisée. Les valeurs valides pour chaque type de compression sont les suivantes :
+ bzip2
+ gzip
+ none
+ snappy
’data\$1cleansing\$1enabled’=’true / false’
Cette propriété définit si la gestion des données est activée pour la table. Lorsque ’data\$1cleansing\$1enabled’ est définie sur « true », la gestion des données est activée pour la table. Lorsque ’data\$1cleansing\$1enabled’ est définie sur « false », la gestion des données est désactivée pour la table. Vous trouverez ci-dessous la liste des propriétés de gestion des données au niveau de la table contrôlées par cette propriété :
+ column\$1count\$1mismatch\$1handling
+ invalid\$1char\$1handling
+ numeric\$1overflow\$1handling
+ replacement\$1char
+ surplus\$1char\$1handling
Pour obtenir des exemples, consultez [Exemples de gestion des données](r_CREATE_EXTERNAL_TABLE_examples.md#r_CREATE_EXTERNAL_TABLE_examples-data-handling).
’invalid\$1char\$1handling’=’*value*’
Spécifie l’action à effectuer lorsque les résultats de la requête contiennent des valeurs de caractères UTF-8 non valides. Vous pouvez spécifier les actions suivantes :
DISABLED
N’effectue pas de gestion des caractères non valides.
FAIL
Annule les requêtes renvoyant des données contenant des valeurs UTF-8 non valides.
SET\$1TO\$1NULL
Remplace les valeurs UTF-8 non valides par null.
DROP\$1ROW
Remplace chaque valeur de la ligne par null.
REPLACE
Remplace le caractère non valide par le caractère de remplacement que vous spécifiez à l’aide de `replacement_char`.
’replacement\$1char’=’*character*’
Spécifie le caractère de remplacement à utiliser lorsque vous définissez `invalid_char_handling` sur `REPLACE`.
’numeric\$1overflow\$1handling’=’value’
Spécifie l’action à effectuer lorsque les données ORC contiennent un entier (par exemple, BIGINT ou int64) supérieur à la définition de colonne (par exemple, SMALLINT ou int16). Vous pouvez spécifier les actions suivantes :
DISABLED
La gestion des caractères non valide est désactivée.
FAIL
Annulez la requête lorsque les données contiennent des caractères non valides.
SET\$1TO\$1NULL
Définissez les caractères non valides sur null.
DROP\$1ROW
Définissez chaque valeur de la ligne sur null.
’surplus\$1bytes\$1handling’=’*value*’
Spécifie comment traiter les données chargées qui dépassent la longueur du type de données défini pour les colonnes contenant des données VARBYTE. Par défaut, Redshift Spectrum définit la valeur sur null pour les données qui dépassent la largeur de la colonne.
Vous pouvez spécifier les actions suivantes à effectuer lorsque la requête renvoie des données qui dépassent la longueur du type de données :
SET\$1TO\$1NULL
Remplace les données qui dépassent la largeur de colonne par null.
DISABLED
N’effectue pas de gestion des octets excédentaires.
FAIL
Annule les requêtes qui renvoient des données dépassant la largeur de colonne.
DROP\$1ROW
Supprime toutes les lignes qui contiennent des données qui dépassent la largeur de la colonne.
TRUNCATE
Supprime les caractères qui dépassent le nombre maximal de caractères défini pour la colonne.
’surplus\$1char\$1handling’=’*value*’
Spécifie comment gérer les données chargées qui dépassent la longueur du type de données défini pour les colonnes contenant des données VARCHAR, CHAR ou chaîne. Par défaut, Redshift Spectrum définit la valeur sur null pour les données qui dépassent la largeur de la colonne.
Vous pouvez spécifier les actions suivantes à effectuer lorsque la requête renvoie des données qui dépassent la largeur de la colonne :
SET\$1TO\$1NULL
Remplace les données qui dépassent la largeur de colonne par null.
DISABLED
N’effectue pas de gestion des caractères excédentaires.
FAIL
Annule les requêtes qui renvoient des données dépassant la largeur de colonne.
DROP\$1ROW
Remplace chaque valeur de la ligne par null.
TRUNCATE
Supprime les caractères qui dépassent le nombre maximal de caractères défini pour la colonne.
’column\$1count\$1mismatch\$1handling’=’value’
Indique si le fichier contient moins ou plus de valeurs pour une ligne que le nombre de colonnes spécifié dans la définition de la table externe. Cette propriété est disponible uniquement pour un format de fichier texte non compressé. Vous pouvez spécifier les actions suivantes :
DISABLED
La gestion des non-correspondances du nombre de colonnes est désactivée.
FAIL
Fait échouer la requête si la non-correspondance du nombre de colonnes est détectée.
SET\$1TO\$1NULL
Remplit les valeurs manquantes avec NULL et ignore les valeurs supplémentaires de chaque ligne.
DROP\$1ROW
Supprime de l’analyse toutes les lignes qui contiennent une erreur de non-correspondance du nombre de colonnes.
’numRows’=’*nombre\$1lignes*’
Propriété qui définit la valeur numRows de la définition de table. Afin de mettre à jour explicitement les statistiques d’une table externe, définissez la propriété numRows pour indiquer la taille de la table. Amazon Redshift n'analyse pas les tables externes pour générer les statistiques de table utilisées par l'optimiseur de requête afin de générer un plan de requête. Si des statistiques de table ne sont pas définies pour une table externe, Amazon Redshift génère un plan d’exécution de requête d’après l’hypothèse selon laquelle les tables externes sont les tables les plus volumineuses et les tables locales les tables les plus petites.
’skip.header.line.count’=’*nombre\$1lignes*’
Propriété qui définit le nombre de lignes à ignorer au début de chaque fichier source.
’serialization.null.format’=’ ’
Propriété qui spécifie que Spectrum doit renvoyer une valeur `NULL` lorsqu’il y a une correspondance exacte avec le texte fourni dans un champ.
’orc.schema.resolution’=’type\$1mappage’
Propriété qui définit le type de mappage de colonne sur le mappage pour des tables qui utilisent le format de données ORC. Cette propriété est ignorée pour tous les autres formats de données.
Les valeurs valides pour le type de mappage de colonne sont les suivantes :
+ name
+ position
Si la propriété *orc.schema.resolution* est omise, les colonnes sont mappées par nom par défaut. Si la propriété *orc.schema.resolution* est définie sur une autre valeur que *’name’* ou *’position’*, les colonnes sont mappées par position. Pour en savoir plus sur le mappage des colonnes, consultez [Mappage de colonnes de table externe à des colonnes ORC](c-spectrum-external-tables.md#c-spectrum-column-mapping-orc).
La commande COPY mappe aux fichiers de données ORC uniquement par position. La propriété de table *orc.schema.resolution* n’a aucun effet sur le comportement de la commande COPY.
’write.parallel’=’on / off’
Propriété qui définit si la commande CREATE EXTERNAL TABLE AS doit écrire les données en parallèle. Par défaut, CREATE EXTERNAL TABLE AS écrit les données en parallèle dans plusieurs fichiers, en fonction du nombre de tranches du cluster. Par défaut, l’option est activée. Lorsque ’write.parallel’ est désactivé, CREATE EXTERNAL TABLE AS écrit en série dans un ou plusieurs fichiers de données sur Amazon S3. Cette propriété de table s’applique également à toute instruction INSERT ultérieure dans la même table externe.
‘write.maxfilesize.mb’=‘size’
Propriété qui définit la taille maximale (en Mo) de chaque fichier écrit dans Amazon S3 par la commande CREATE EXTERNAL TABLE AS. La taille doit être un entier valide compris entre 5 et 6 200. La taille maximale par défaut du fichier est de 6 200 Mo. Cette propriété de table s’applique également à toute instruction INSERT ultérieure dans la même table externe.
‘write.kms.key.id’=‘*value*’
Vous pouvez spécifier une AWS Key Management Service clé pour activer le chiffrement côté serveur (SSE) pour les objets Amazon S3, dont *la valeur* est l'une des suivantes :
+ `auto`pour utiliser la AWS KMS clé par défaut stockée dans le compartiment Amazon S3.
+ *kms-key* que vous spécifiez pour chiffrer les données.
*select\$1statement*
Instruction qui insère une ou plusieurs lignes dans la table externe en définissant une requête. Toutes les lignes produites par la requête sont écrites dans Amazon S3 au format texte ou Parquet en fonction de la définition de la table.
## Exemples
Divers exemples sont disponibles à la page [Exemples](r_CREATE_EXTERNAL_TABLE_examples.md).
# Notes d’utilisation
Cette rubrique contient des notes d’utilisation pour [CREATE EXTERNAL TABLE](r_CREATE_EXTERNAL_TABLE.md). Vous ne pouvez pas afficher les détails des tables Amazon Redshift Spectrum en utilisant les mêmes ressources que pour les tables Amazon Redshift standard, telles que [PG\$1TABLE\$1DEF](r_PG_TABLE_DEF.md), [STV\$1TBL\$1PERM](r_STV_TBL_PERM.md), PG\$1CLASS ou information\$1schema. Si votre outil de Business Intelligence ou d’analyse ne reconnaît pas les tables externes Redshift Spectrum, configurez votre application de façon à interroger [SVV\$1EXTERNAL\$1TABLES](r_SVV_EXTERNAL_TABLES.md) et [SVV\$1EXTERNAL\$1COLUMNS](r_SVV_EXTERNAL_COLUMNS.md).
## CREATE EXTERNAL TABLE AS
Dans certains cas, vous pouvez exécuter la commande CREATE EXTERNAL TABLE AS sur un catalogue de AWS Glue données, un catalogue AWS Lake Formation externe ou un métastore Apache Hive. Dans ce cas, vous utilisez un rôle Gestion des identités et des accès AWS (IAM) pour créer le schéma externe. Ce rôle IAM doit disposer d’autorisations de lecture et d’écriture sur Amazon S3.
Si vous utilisez un catalogue Lake Formation, le rôle IAM doit être autorisé à créer une table dans le catalogue. Dans ce cas, il doit également disposer de l’autorisation d’emplacement du lac de données sur le chemin Amazon S3 cible. Ce rôle IAM devient le propriétaire de la nouvelle table AWS Lake Formation .
Pour vous assurer que les noms de fichiers sont uniques, Amazon Redshift utilise le format suivant pour le nom de chaque fichier téléchargé dans Amazon S3 par défaut.
`_