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.
# Connexion à partir d’outils et de codes clients
Amazon Redshift fournit Amazon Redshift Query Editor V2 pour se connecter à vos clusters et groupes de travail. Pour plus d’informations, consultez [Interrogation d’une base de données à l’aide de l’éditeur de requête v2Interrogation d’une base de données à l’aide de Amazon Redshift Query Editor V2](query-editor-v2.md).
Cette section propose quelques options pour la connexion d’outils tiers. En outre, elle explique comment vous connecter à votre cluster par programmation.
**Topics**
+ [Connexion avec Amazon Redshift RSQL](rsql-query-tool.md)
+ [Connexion à un cluster avec Amazon Redshift RSQL](rsql-query-tool-starting-tool-connection.md)
+ [Méta-commandes Amazon Redshift RSQL](rsql-query-tool-commands.md)
+ [Variables Amazon Redshift RSQL](rsql-query-tool-variables.md)
+ [Codes d’erreur Amazon Redshift RSQL](rsql-query-tool-error-codes.md)
+ [Variables d’environnement Amazon Redshift RSQL](rsql-query-tool-environment-variables.md)
# Connexion avec Amazon Redshift RSQL
Amazon Redshift RSQL est un client en ligne de commande permettant d’interagir avec les clusters et bases de données Amazon Redshift. Vous pouvez vous connecter à un cluster Amazon Redshift, décrire des objets de base de données, interroger des données et afficher les résultats des requêtes dans différents formats de sortie.
Amazon Redshift RSQL prend en charge les fonctionnalités de l’outil de ligne de commande PostgreSQL psql avec un ensemble supplémentaire de fonctionnalités spécifiques à Amazon Redshift. Cela inclut les éléments suivants :
+ Vous pouvez utiliser l'authentification unique à l'aide d'AD FS, d'Okta PingIdentity, d'Azure ADm ou d'autres fournisseurs d'identité SAML/JWT basés. Vous pouvez également utiliser des fournisseurs d’identité SAML basés sur un navigateur pour l’authentification multifactorielle (MFA).
+ Vous pouvez décrire les propriétés ou les attributs des objets Amazon Redshift tels que les clés de distribution des tables, les clés de tri des tables, les vues à liaison tardive (LBVs) et les vues matérialisées. Vous pouvez également décrire les propriétés ou les attributs des tables externes d'un AWS Glue catalogue ou d'Apache Hive Metastore, des bases de données externes dans Amazon RDS for PostgreSQL, Amazon Aurora PostgreSQL Compatible Edition, RDS for MySQL (version préliminaire) et Amazon Aurora MySQL Compatible Edition (version préliminaire), ainsi que des tables partagées à l'aide du partage de données Amazon Redshift.
+ Vous pouvez également utiliser des commandes de flux de contrôle améliorées telles que `IF` (`\ELSEIF`, `\ELSE,` `\ENDIF`), `\GOTO` et `\LABEL`.
Avec le mode de traitement par lots Amazon Redshift RSQL, qui exécute un script transmis en tant que paramètre d’entrée, vous pouvez exécuter des scripts comprenant à la fois SQL et une logique métier complexe. Si vous avez déjà des entrepôts des données sur site autogérés, vous pouvez utiliser Amazon Redshift RSQL pour remplacer les scripts d’extraction, de transfert, de chargement (ETL) et d’automatisation existants, tels que les scripts BTEQ Teradata. L’utilisation de RSQL permet d’éviter de réimplémenter manuellement des scripts dans un langage procédural.
Amazon Redshift RSQL est disponible pour les systèmes d’exploitation Linux, Windows et macOS X.
Pour signaler des problèmes relatifs à Amazon Redshift RSQL, écrivez à redshift-rsql-support @amazon .com.
**Topics**
+ [Premiers pas avec Amazon Redshift RSQL](rsql-query-tool-getting-started.md)
+ [Journal des modifications Amazon Redshift RSQL](rsql-query-tool-changelog.md)
# Premiers pas avec Amazon Redshift RSQL
Installez Amazon Redshift RSQL sur un ordinateur doté d’un système d’exploitation Linux, macOS ou Microsoft Windows.
## Téléchargement de RSQL
+
+
+
+
+
Consultez le journal des modifications et les téléchargements des versions antérieures à l’adresse [Journal des modifications Amazon Redshift RSQL](rsql-query-tool-changelog.md).
## Installation de RSQL pour Linux
Suivez les étapes ci-dessous pour installer RSQL pour Linux.
1. Installez le gestionnaire de pilotes à l’aide de la commande suivante :
```
sudo yum install unixODBC
```
1. Installez le pilote ODBC : [Téléchargement et installation du pilote ODBC Amazon RedshiftTéléchargement et installation du pilote ODBC](odbc20-install-linux.md).
1. Copiez le fichier ini dans votre répertoire de base :
```
cp /opt/amazon/redshiftodbcx64/odbc.ini ~/.odbc.ini
```
1. Définissez les variables d’environnement pour qu’elles pointent vers l’emplacement du fichier :
```
export ODBCINI=~/.odbc.ini
export ODBCSYSINI=/opt/amazon/redshiftodbcx64/
export AMAZONREDSHIFTODBCINI=/opt/amazon/redshiftodbcx64/amazon.redshiftodbc.ini
```
1. Vous pouvez désormais installer RSQL en exécutant la commande suivante.
```
sudo rpm -i AmazonRedshiftRsql-.rhel.x86_64.rpm
```
## Installation de RSQL pour Mac
Suivez les étapes ci-dessous pour installer RSQL pour Mac OSX.
1. Installez le gestionnaire de pilotes à l’aide de la commande suivante :
```
brew install unixodbc --build-from-source
```
1. Installez le pilote ODBC : [Téléchargement et installation du pilote ODBC Amazon RedshiftTéléchargement et installation du pilote ODBC](odbc-driver-mac-how-to-install.md).
1. Copiez le fichier ini dans votre répertoire de base :
```
cp /opt/amazon/redshift/Setup/odbc.ini ~/.odbc.ini
```
1. Définissez les variables d’environnement pour qu’elles pointent vers l’emplacement du fichier :
```
export ODBCINI=~/.odbc.ini
export ODBCSYSINI=/opt/amazon/redshift/Setup
export AMAZONREDSHIFTODBCINI=/opt/amazon/redshift/lib/amazon.redshiftodbc.ini
```
1. Définissez `DYLD_LIBRARY_PATH` à l’emplacement de votre libodbc.dylib s’il n’est pas dans `/usr/local/lib`.
```
export DYLD_LIBRARY_PATH=$DYLD_LIBRARY_PATH:/usr/local/lib
```
1. Double-cliquez sur le fichier pkg pour exécuter le programme d’installation.
1. Suivez les étapes décrites dans le programme d’installation pour terminer l’installation. Acceptez les termes du contrat de licence.
## Installation de RSQL pour Windows
Suivez les étapes ci-dessous pour installer RSQL pour Windows.
1. Installez le pilote ODBC : [Téléchargement et installation du pilote ODBC Amazon RedshiftTéléchargement et installation du pilote ODBC](odbc-driver-windows-how-to-install.md).
1. Double-cliquez sur le fichier de téléchargement de RSQL pour exécuter le programme d’installation, puis suivez les étapes pour terminer l’installation.
# Journal des modifications Amazon Redshift RSQL
*1.1.2 (11/12/2025)*
Correctifs de bogue
+ Correction d'un bogue qui provoquait des échecs avec les commandes \$1 goto et \$1 label.
+ Correction d'un bogue qui empêchait RSQL d'imprimer les valeurs des variables lorsque celles-ci étaient placées entre guillemets.
+ Correction d'un bogue qui provoquait des blocages de RSQL lorsque les résultats de la requête dépassaient la taille du paramètre ODBC DSN Fetch alors qu'il était activé. UseDeclareFetch
+ Correction d'un problème en raison duquel plusieurs pages de résultats étaient renvoyées en même temps même si le téléavertisseur était activé.
+ Correction d'un bogue qui provoquait des blocages de RSQL lorsque des requêtes échouaient dans des blocs de transactions.
*1.1.1 (20-11-2025)*
Correctifs de bogue
+ Correction d'un problème en raison duquel RSQL analysait incorrectement les requêtes lors de l'utilisation de l'indicateur -c. Ce correctif s'applique à toutes les plateformes.
+ Correction d'un bogue sur Mac qui empêchait les utilisateurs d'utiliser la commande \$1 s dans RSQL.
*1,10 (11/11/2025)*
Correctifs de bogue
+ Résolution d'un problème de fuite de mémoire qui provoquait des blocages inattendus dans RSQL.
+ Suppression de la dépendance OpenSSL de RSQL.
+ Correction de conflits de liens avec libpq/psql des installations situées dans le même environnement.
+ Compatibilité de plateforme améliorée pour Amazon Linux 2023, Windows et macOS.
+ Correction d'un problème à cause duquel la sortie était tronquée en cas de dépassement de la taille d'affichage actuelle.
*1.0.8 (2023-06-19)*
Correctifs de bogue
+ Correction d’un problème où la sortie était tronquée avec les commandes SHOW.
+ Ajout de la prise en charge de \$1de pour la description des flux Kinesis externes et des rubriques Kafka.
*1.0.7 (2023-03-22)*
Correctifs de bogue
+ Correction d’un problème où RSQL ne pouvait pas décrire les vues matérialisées.
+ Correction de l’erreur d’autorisation refusée sur stl\$1connection\$1log lors de l’utilisation d’Amazon Redshift sans serveur.
+ Correction d’un problème où RSQL pouvait traiter les étiquettes \$1GOTO de manière incorrecte.
+ Correction d’un problème d’impression des messages SSL en mode silencieux.
+ Correction d’un problème d’affichage de caractères aléatoires lors de la description de procédures stockées.
+ Le problème lié à l'impression de doublons de ERROR/INFO messages a été résolu.
Nouveau
+ RSQL obtient désormais les informations SSL directement à partir du pilote ODBC.
*1.0.6 (2023-02-21)*
Correctifs de bogue
+ Correction d’un problème où \$1d renvoie une erreur - syntaxe d’entrée invalide pour l’entier : "xid" - sur le correctif Redshift 1.0.46086 (P173).
Nouveau
+ Les fichiers d’installation ont été renommés pour refléter l’architecture prise en charge.
*1.0.5 (27/06/2022)*
Correctifs de bogue
+ Envoyer des messages d’erreur SQL à l’erreur standard (stderr).
+ Correction d’un problème avec les codes de sortie lors de l’utilisation de ON\$1ERROR\$1STOP. Les scripts s’arrêtent désormais après avoir rencontré une erreur et renvoient les bons codes de sortie.
+ Maxerror n’est plus sensible à la casse.
Nouveau
+ Ajout de la prise en charge du pilote ODBC 2.x.
*1.0.4 (2022-03-19)*
+ Prise en charge de la variable d’environnement RSPASSWORD. Définissez un mot de passe pour vous connecter à Amazon Redshift. Par exemple, `export RSPASSWORD=TestPassw0rd`.
*1.0.3 (2021-12-08)*
Correctifs de bogue
+ Correction d’une fenêtre contextuelle de boîte de dialogue lors de l’utilisation de `\c` ou de `\logon` pour basculer entre les bases de données sous Windows OS.
+ Correction d’un crash lors de la vérification des informations ssl.
## Versions antérieures d’Amazon Redshift RSQL
Choisissez l’un des liens pour télécharger la version d’Amazon Redshift RSQL dont vous avez besoin, en fonction de votre système d’exploitation.
**Linux 64 bits RPM**
+ [Version 1.1.1 de RSQL](https://s3.amazonaws.com/redshift-downloads/amazon-redshift-rsql/1.1.1/AmazonRedshiftRsql-1.1.1.rhel.x86_64.rpm)
+ [Version 1.1.0 de RSQL](https://s3.amazonaws.com/redshift-downloads/amazon-redshift-rsql/1.1.0/AmazonRedshiftRsql-1.1.0.rhel.x86_64.rpm)
+ [Version 1.0.8 de RSQL](https://s3.amazonaws.com/redshift-downloads/amazon-redshift-rsql/1.0.8/AmazonRedshiftRsql-1.0.8.x86_64.rpm)
+ [RSQL Version 1.0.7](https://s3.amazonaws.com/redshift-downloads/amazon-redshift-rsql/1.0.7/AmazonRedshiftRsql-1.0.7.x86_64.rpm)
+ [RSQL Version 1.0.6](https://s3.amazonaws.com/redshift-downloads/amazon-redshift-rsql/1.0.6/AmazonRedshiftRsql-1.0.6.x86_64.rpm)
+ [RSQL Version 1.0.5](https://s3.amazonaws.com/redshift-downloads/amazon-redshift-rsql/1.0.5/AmazonRedshiftRsql-1.0.5-1.x86_64.rpm)
+ [RSQL Version 1.0.4](https://s3.amazonaws.com/redshift-downloads/amazon-redshift-rsql/1.0.4/AmazonRedshiftRsql-1.0.4-1.x86_64.rpm)
+ [Fichier RSQL version 1.0.3](https://s3.amazonaws.com/redshift-downloads/amazon-redshift-rsql/1.0.3/AmazonRedshiftRsql-1.0.3-1.x86_64.rpm)
+ [Fichier RSQL version 1.0.1](https://s3.amazonaws.com/redshift-downloads/amazon-redshift-rsql/1.0.1/AmazonRedshiftRsql-1.0.1-1.x86_64.rpm)
**DMG/PKG 64 bits pour Mac OS**
+ [Version 1.1.1 de RSQL](https://s3.amazonaws.com/redshift-downloads/amazon-redshift-rsql/1.1.1/AmazonRedshiftRsql-1.1.1.universal.pkg)
+ [Version 1.1.0 de RSQL](https://s3.amazonaws.com/redshift-downloads/amazon-redshift-rsql/1.1.0/AmazonRedshiftRsql-1.1.0.universal.pkg)
+ [Version 1.0.8 de RSQL](https://s3.amazonaws.com/redshift-downloads/amazon-redshift-rsql/1.0.8/AmazonRedshiftRsql-1.0.8.x86_64.dmg)
+ [RSQL Version 1.0.7](https://s3.amazonaws.com/redshift-downloads/amazon-redshift-rsql/1.0.7/AmazonRedshiftRsql-1.0.7.x86_64.dmg)
+ [RSQL Version 1.0.6](https://s3.amazonaws.com/redshift-downloads/amazon-redshift-rsql/1.0.6/AmazonRedshiftRsql-1.0.6.x86_64.dmg)
+ [Fichier RSQL version 1.0.5](https://s3.amazonaws.com/redshift-downloads/amazon-redshift-rsql/1.0.5/AmazonRedshiftRsql-1.0.5.dmg)
+ [Fichier RSQL version 1.0.4](https://s3.amazonaws.com/redshift-downloads/amazon-redshift-rsql/1.0.4/AmazonRedshiftRsql-1.0.4.dmg)
+ [Fichier RSQL version 1.0.3](https://s3.amazonaws.com/redshift-downloads/amazon-redshift-rsql/1.0.3/AmazonRedshiftRsql-1.0.3.dmg)
+ [Fichier RSQL64 version 1.0.1](https://s3.amazonaws.com/redshift-downloads/amazon-redshift-rsql/1.0.1/AmazonRedshiftRsql-1.0.1.dmg). Dans la région Chine (Beijing), utilisez le lien suivant :
**MSI Windows 64 bits**
+ [Version 1.1.1 de RSQL](https://s3.amazonaws.com/redshift-downloads/amazon-redshift-rsql/1.1.1/AmazonRedshiftRsql-1.1.1.x86_64.msi)
+ [Version 1.1.0 de RSQL](https://s3.amazonaws.com/redshift-downloads/amazon-redshift-rsql/1.1.0/AmazonRedshiftRsql-1.1.0.x86_64.msi)
+ [Version 1.0.8 de RSQL](https://s3.amazonaws.com/redshift-downloads/amazon-redshift-rsql/1.0.8/AmazonRedshiftRsql-1.0.8.x86_64.msi)
+ [RSQL Version 1.0.7](https://s3.amazonaws.com/redshift-downloads/amazon-redshift-rsql/1.0.7/AmazonRedshiftRsql-1.0.7.x86_64.msi)
+ [RSQL Version 1.0.6](https://s3.amazonaws.com/redshift-downloads/amazon-redshift-rsql/1.0.6/AmazonRedshiftRsql-1.0.6.x86_64.msi)
+ [RSQL Version 1.0.5](https://s3.amazonaws.com/redshift-downloads/amazon-redshift-rsql/1.0.5/AmazonRedshiftRsql-1.0.5.msi)
+ [RSQL Version 1.0.4](https://s3.amazonaws.com/redshift-downloads/amazon-redshift-rsql/1.0.4/AmazonRedshiftRsql-1.0.4.msi)
+ [Fichier RSQL version 1.0.3](https://s3.amazonaws.com/redshift-downloads/amazon-redshift-rsql/1.0.3/AmazonRedshiftRsql-1.0.3.msi)
+ [RSQL version 1.0.1](https://s3.amazonaws.com/redshift-downloads/amazon-redshift-rsql/1.0.1/AmazonRedshiftRsql-1.0.1.msi).
# Connexion à un cluster avec Amazon Redshift RSQL
Avec Amazon Redshift, vous pouvez vous connecter à un cluster et interagir avec eux à l’aide de RSQL. Il s’agit d’un outil de ligne de commande qui fournit un moyen sécurisé d’interroger des données, de créer des objets de base de données et de gérer votre cluster Amazon Redshift. Les sections suivantes vous indiquent les étapes à suivre pour établir une connexion à votre cluster à l’aide de RSQL avec ou sans nom de source de données (DSN).
## Connexion sans DSN
1. Sur la console Amazon Redshift, choisissez le cluster auquel vous souhaitez vous connecter et notez le point de terminaison, la base de données et le port.
1. A l’invite de commande, spécifiez les informations de connexion à l’aide des paramètres de ligne de commande.
```
rsql -h -U -d -p
```
Ici, les éléments suivants s’appliquent :
+ **est le **point de terminaison** que vous avez enregistré à l'étape précédente.
+ **est le nom d'un utilisateur autorisé à se connecter au cluster.
+ **est le **nom de la base de données** que vous avez enregistré à l'étape précédente.
+ **est le **port** que vous avez enregistré à l'étape précédente. **est un paramètre facultatif.
Un exemple suit.
```
rsql -h testcluster.example.amazonaws.com -U user1 -d dev -p 5439
```
1. À l'invite de mot de passe, entrez le mot de passe de l'**utilisateur.
Une réponse de connexion réussie ressemble à ce qui suit.
```
% rsql -h testcluster.example.com -d dev -U user1 -p 5349
Password for user user1:
DSN-less Connected
DBMS Name: Amazon Redshift
Driver Name: Amazon Redshift ODBC Driver
Driver Version: 1.4.27.1000
Rsql Version: 1.0.1
Redshift Version: 1.0.29306
Type "help" for help.
(testcluster) user1@dev=#
```
La commande de connexion possède les mêmes paramètres sous Linux, Mac OS et Windows.
## Connexion avec un DSN
Vous pouvez connecter RSQL à Amazon Redshift à l’aide d’un DSN pour simplifier l’organisation des propriétés de connexion DSN. Cette rubrique contient des instructions pour l’installation du pilote ODBC et des descriptions des propriétés DSN.
### Utilisation d’une connexion DSN avec un mot de passe
L’exemple suivant montre une configuration de connexion DSN utilisant un mot de passe. La valeur par défaut `` pour Mac OS X est `/opt/amazon/redshift/lib/libamazonredshiftodbc.dylib` et pour Linux, il s’agit de `/opt/amazon/redshiftodbc/lib/64/libamazonredshiftodbc64.so`.
```
[testuser]
Driver=/opt/amazon/redshiftodbc/lib/64/libamazonredshiftodbc64.so
SSLMode=verify-ca
Min_TLS=1.2
boolsaschar=0
Host=
Port=
Database=
UID=
PWD=
sslmode=prefer
```
La sortie suivante résulte d’une connexion réussie.
```
% rsql -D testuser
DSN Connected
DBMS Name: Amazon Redshift
Driver Name: Amazon Redshift ODBC Driver
Driver Version: 1.4.27.1000
Rsql Version: 1.0.1
Redshift Version: 1.0.29306
Type "help" for help.
(testcluster) user1@dev=#
```
### Utilisation du DSN à authentification unique
Vous pouvez configurer un DSN pour l’authentification unique. L’exemple suivant montre une configuration de connexion DSN utilisant l’authentification unique Okta.
```
[testokta]
Driver=
SSLMode=verify-ca
Min_TLS=1.2
boolsaschar=0
Host=
clusterid=
region=
Database=
locale=en-US
iam=1
plugin_name=
uid=
pwd=
idp_host=
app_id=
app_name=
preferred_role=
```
Exemple de sortie d’une connexion réussie.
```
% rsql -D testokta
DSN Connected
DBMS Name: Amazon Redshift
Driver Name: Amazon Redshift ODBC Driver
Driver Version: 1.4.27.1000
Rsql Version: 1.0.1
Redshift Version: 1.0.29306
Type "help" for help.
(testcluster) user1@dev=#
```
L’exemple suivant montre une configuration de connexion DSN utilisant l’authentification unique Azure.
```
[testazure]
Driver=
SSLMode=verify-ca
Min_TLS=1.2
boolsaschar=0
Host=
Port=
clusterid=
region=
Database=
locale=en-us
iam=1
plugin_name=
uid=
pwd=
idp_tenant=
client_id=
client_secret=
```
### Utilisation d’une connexion DSN avec un profil IAM
Vous pouvez vous connecter à Amazon Redshift à l’aide de votre profil IAM configuré. Le profil IAM doit être autorisé à appeler `GetClusterCredentials`. L’exemple suivant illustre les propriétés DSN à utiliser. Les paramètres `ClusterID` et `Region` ne sont obligatoires que si l’`Host` n’est pas un point de terminaison fourni par Amazon comme `examplecluster.abc123xyz789.us-west-2.redshift.amazonaws.com`.
```
[testiam]
Driver=Default
Host=testcluster.example.com
Database=dev
DbUser=testuser
ClusterID=rsqltestcluster
Region=us-east-1
IAM=1
Profile=default
```
La valeur de la `Profile` clé est le profil nommé que vous avez choisi parmi les informations d'identification de votre AWS CLI. Cet exemple montre les informations d’identification du profil nommé `default`.
```
$ cat .aws/credentials
[default]
aws_access_key_id = ASIAIOSFODNN7EXAMPLE
aws_secret_access_key = wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
```
L’exemple de réponse de connexion est le suivant.
```
$ rsql -D testiam
DSN Connected
DBMS Name: Amazon Redshift
Driver Name: Amazon Redshift ODBC Driver
Driver Version: 1.4.27.1000
Rsql Version: 1.0.1
Redshift Version: 1.0.29306
Type "help" for help.
(testcluster) testuser@dev=>
```
### Utilisation d’une connexion DSN avec un profil d’instance
Vous pouvez vous connecter à Amazon Redshift à l’aide de votre profil d’instance Amazon EC2. Le profil d’instance doit être autorisé à appeler `GetClusterCredentials`. Voir l’exemple ci-dessous pour connaître les propriétés DSN à utiliser. Les paramètres `ClusterID` et `Region` ne sont obligatoires que si l’`Host` n’est pas un point de terminaison fourni par Amazon comme `examplecluster.abc123xyz789.us-west-2.redshift.amazonaws.com`.
```
[testinstanceprofile]
Driver=Default
Host=testcluster.example.com
Database=dev
DbUser=testuser
ClusterID=rsqltestcluster
Region=us-east-1
IAM=1
Instanceprofile=1
```
L’exemple de réponse de connexion est le suivant.
```
$ rsql -D testinstanceprofile
DSN Connected
DBMS Name: Amazon Redshift
Driver Name: Amazon Redshift ODBC Driver
Driver Version: 1.4.27.1000
Rsql Version: 1.0.1
Redshift Version: 1.0.29306
Type "help" for help.
(testcluster) testuser@dev=>
```
### Utilisation d’une connexion DSN avec la chaîne de fournisseurs d’informations d’identification par défaut
Pour vous connecter à l'aide de la chaîne de fournisseurs d'informations d'identification par défaut, spécifiez uniquement la propriété IAM, et Amazon Redshift RSQL tentera d'obtenir les informations d'identification dans l'ordre décrit dans la section [Utilisation des informations d'identification dans le AWS SDK](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/credentials.html) for Java. AWS Au moins un des fournisseurs de la chaîne doit disposer de l’autorisation `GetClusterCredentials`. Cela est utile pour se connecter à partir de conteneurs ECS, par exemple.
```
[iamcredentials]
Driver=Default
Host=testcluster.example.com
Database=dev
DbUser=testuser
ClusterID=rsqltestcluster
Region=us-east-1
IAM=1
```
# Méta-commandes Amazon Redshift RSQL
Les méta-commandes Amazon Redshift RSQL renvoient des enregistrements informatifs sur des bases de données ou des objets de base de données spécifiques. Les résultats peuvent inclure diverses colonnes et métadonnées. D’autres commandes effectuent des actions spécifiques. Ces commandes sont précédées d’une barre oblique inverse.
## \$1d[S\$1]
Répertorie les tables créées par les utilisateurs locaux, les vues régulières, les vues à liaison tardive et les vues matérialisées. `\dS ` répertorie également les tableaux et les vues, comme `\d`, mais les objets système sont inclus dans les enregistrements renvoyés. Le `+` a pour résultat la colonne de métadonnées supplémentaires `description` pour tous les objets répertoriés. Les exemples d’enregistrements suivants sont renvoyés à la suite de la commande.
```
List of relations
schema | name | type | owner
--------+-----------+-------+---------
public | category | table | awsuser
public | date | table | awsuser
public | event | table | awsuser
public | listing | table | awsuser
public | sales | table | awsuser
public | users | table | awsuser
public | venue | table | awsuser
(7 rows)
```
## \$1d[S\$1] NAME
Décrit une table, une vue ou un index. Inclut les noms et les types de colonnes. Il fournit également le style de distribution diststyle, la configuration de sauvegarde, la date de création (tables créées après octobre 2018) et les contraintes. Par exemple, `\dS+ sample` renvoie les propriétés d’objet. L’ajout de `S+` donne lieu à l’inclusion de colonnes supplémentaires dans les enregistrements renvoyés.
```
Table "public.sample"
Column | Type | Collation | Nullable | Default Value | Encoding | DistKey | SortKey
--------+-----------------------------+----------------+----------+---------------+-----------+---------+---------
col1 | smallint | | NO | | none | t | 1
col2 | character(100) | case_sensitive | YES | | none | f | 2
col3 | character varying(100) | case_sensitive | YES | | text32k | f | 3
col4 | timestamp without time zone | | YES | | runlength | f | 0
col5 | super | | YES | | zstd | f | 0
col6 | bigint | | YES | | az64 | f | 0
Diststyle: KEY
Backup: YES
Created: 2021-07-20 19:47:27.997045
Unique Constraints:
"sample_pkey" PRIMARY KEY (col1)
"sample_col2_key" UNIQUE (col2)
Foreign-key constraints:
"sample_col2_fkey" FOREIGN KEY (col2) REFERENCES lineitem(l_orderkey)
```
Le style de distribution, ou *Diststyle*, de la table peut être KEY, AUTO, EVEN ou ALL.
*Backup (Sauvegarde)* indique si la table est sauvegardée lors de la prise d’un instantané. Les valeurs valides sont `YES` ou `NO`.
*Created (Créé)* est l’horodatage de la date de création de la table. La date de création n’est pas disponible pour les tables Amazon Redshift créées avant novembre 2018. Les tables créées avant cette date s'affichent n/a (Non disponible).
*Unique Constraints (Contraintes uniques)* répertorie les contraintes uniques et les contraintes de clé principale sur la table.
*Foreign-key constraints (Contraintes de clé étrangère)* répertorie les contraintes de clé étrangère sur la table.
## \$1dC[\$1] [PATTERN]
Répertorie les distributions. Inclut le type de source, le type de cible et indique si la distribution est implicite.
Les données suivantes présentent un sous-ensemble de résultats provenant de `\dC+`.
```
List of casts
source type | target type | function | implicit? | description
-----------------------------+-----------------------------+---------------------+---------------+-------------
"char" | character | bpchar | in assignment |
"char" | character varying | text | in assignment |
"char" | integer | int4 | no |
"char" | text | text | yes |
"path" | point | point | no |
"path" | polygon | polygon | in assignment |
abstime | date | date | in assignment |
abstime | integer | (binary coercible) | no |
abstime | time without time zone | time | in assignment |
abstime | timestamp with time zone | timestamptz | yes |
abstime | timestamp without time zone | timestamp | yes |
bigint | bit | bit | no |
bigint | boolean | bool | yes |
bigint | character | bpchar | in assignment |
bigint | character varying | text | in assignment |
bigint | double precision | float8 | yes |
bigint | integer | int4 | in assignment |
bigint | numeric | numeric | yes |
bigint | oid | oid | yes |
bigint | real | float4 | yes |
bigint | regclass | oid | yes |
bigint | regoper | oid | yes |
bigint | regoperator | oid | yes |
bigint | regproc | oid | yes |
bigint | regprocedure | oid | yes |
bigint | regtype | oid | yes |
bigint | smallint | int2 | in assignment |
bigint | super | int8_partiql | in assignment |
```
## \$1dd[S] [PATTERN]
Affiche les descriptions d’objets non affichées ailleurs.
## \$1de
Répertorie les tables externes. Cela inclut les tables du AWS Glue Data Catalog Hive Metastore et les tables fédérées d'Amazon MySQL RDS/Aurora , Amazon PostgreSQL RDS/Aurora et Amazon Redshift.
## \$1de NAME
Décrit une table externe.
L'exemple suivant montre une table AWS Glue externe.
```
# \de spectrum.lineitem
Glue External table "spectrum.lineitem"
Column | External Type | Redshift Type | Position | Partition Key | Nullable
-----------------+---------------+---------------+----------+---------------+----------
l_orderkey | bigint | bigint | 1 | 0 |
l_partkey | bigint | bigint | 2 | 0 |
l_suppkey | int | int | 3 | 0 |
l_linenumber | int | int | 4 | 0 |
l_quantity | decimal(12,2) | decimal(12,2) | 5 | 0 |
l_extendedprice | decimal(12,2) | decimal(12,2) | 6 | 0 |
l_discount | decimal(12,2) | decimal(12,2) | 7 | 0 |
l_tax | decimal(12,2) | decimal(12,2) | 8 | 0 |
l_returnflag | char(1) | char(1) | 9 | 0 |
l_linestatus | char(1) | char(1) | 10 | 0 |
l_shipdate | date | date | 11 | 0 |
l_commitdate | date | date | 12 | 0 |
l_receiptdate | date | date | 13 | 0 |
l_shipinstruct | char(25) | char(25) | 14 | 0 |
l_shipmode | char(10) | char(10) | 15 | 0 |
l_comment | varchar(44) | varchar(44) | 16 | 0 |
Location: s3://redshiftbucket/kfhose2019/12/31
Input_format: org.apache.hadoop.mapred.TextInputFormat
Output_format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat
Serialization_lib: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe
Serde_parameters: {"field.delim":"|","serialization.format":"|"}
Parameters: {"EXTERNAL":"TRUE","numRows":"178196721475","transient_lastDdlTime":"1577771873"}
```
Une table Hive Metastore.
```
# \de emr.lineitem
Hive Metastore External Table "emr.lineitem"
Column | External Type | Redshift Type | Position | Partition Key | Nullable
-----------------+---------------+---------------+----------+---------------+----------
l_orderkey | bigint | bigint | 1 | 0 |
l_partkey | bigint | bigint | 2 | 0 |
l_suppkey | int | int | 3 | 0 |
l_linenumber | int | int | 4 | 0 |
l_quantity | decimal(12,2) | decimal(12,2) | 5 | 0 |
l_extendedprice | decimal(12,2) | decimal(12,2) | 6 | 0 |
l_discount | decimal(12,2) | decimal(12,2) | 7 | 0 |
l_tax | decimal(12,2) | decimal(12,2) | 8 | 0 |
l_returnflag | char(1) | char(1) | 9 | 0 |
l_linestatus | char(1) | char(1) | 10 | 0 |
l_commitdate | date | date | 11 | 0 |
l_receiptdate | date | date | 12 | 0 |
l_shipinstruct | char(25) | char(25) | 13 | 0 |
l_shipmode | char(10) | char(10) | 14 | 0 |
l_comment | varchar(44) | varchar(44) | 15 | 0 |
l_shipdate | date | date | 16 | 1 |
Location: s3://redshiftbucket/cetas
Input_format: org.apache.hadoop.hive.ql.io.parquet.MapredParquetInputFormat
Output_format: org.apache.hadoop.hive.ql.io.parquet.MapredParquetOutputFormat
Serialization_lib: org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe
Serde_parameters: {"serialization.format":"1"}
Parameters: {"EXTERNAL":"TRUE", "numRows":"4307207", "transient_lastDdlTime":"1626990007"}
```
Table externe PostgreSQL.
```
# \de pgrsql.alltypes
Postgres Federated Table "pgrsql.alltypes"
Column | External Type | Redshift Type | Position | Partition Key | Nullable
--------+-----------------------------+-----------------------------+----------+---------------+----------
col1 | bigint | bigint | 1 | 0 |
col2 | bigint | bigint | 2 | 0 |
col5 | boolean | boolean | 3 | 0 |
col6 | box | varchar(65535) | 4 | 0 |
col7 | bytea | varchar(65535) | 5 | 0 |
col8 | character(10) | character(10) | 6 | 0 |
col9 | character varying(10) | character varying(10) | 7 | 0 |
col10 | cidr | varchar(65535) | 8 | 0 |
col11 | circle | varchar(65535) | 9 | 0 |
col12 | date | date | 10 | 0 |
col13 | double precision | double precision | 11 | 0 |
col14 | inet | varchar(65535) | 12 | 0 |
col15 | integer | integer | 13 | 0 |
col16 | interval | varchar(65535) | 14 | 0 |
col17 | json | varchar(65535) | 15 | 0 |
col18 | jsonb | varchar(65535) | 16 | 0 |
col19 | line | varchar(65535) | 17 | 0 |
col20 | lseg | varchar(65535) | 18 | 0 |
col21 | macaddr | varchar(65535) | 19 | 0 |
col22 | macaddr8 | varchar(65535) | 20 | 0 |
col23 | money | varchar(65535) | 21 | 0 |
col24 | numeric | numeric(38,20) | 22 | 0 |
col25 | path | varchar(65535) | 23 | 0 |
col26 | pg_lsn | varchar(65535) | 24 | 0 |
col28 | point | varchar(65535) | 25 | 0 |
col29 | polygon | varchar(65535) | 26 | 0 |
col30 | real | real | 27 | 0 |
col31 | smallint | smallint | 28 | 0 |
col32 | smallint | smallint | 29 | 0 |
col33 | integer | integer | 30 | 0 |
col34 | text | varchar(65535) | 31 | 0 |
col35 | time without time zone | varchar(65535) | 32 | 0 |
col36 | time with time zone | varchar(65535) | 33 | 0 |
col37 | timestamp without time zone | timestamp without time zone | 34 | 0 |
col38 | timestamp with time zone | timestamp with time zone | 35 | 0 |
col39 | tsquery | varchar(65535) | 36 | 0 |
col40 | tsvector | varchar(65535) | 37 | 0 |
col41 | txid_snapshot | varchar(65535) | 38 | 0 |
col42 | uuid | varchar(65535) | 39 | 0 |
col43 | xml | varchar(65535) | 40 | 0 |
```
## \$1df[anptw][S\$1] [PATTERN]
Répertorie les fonctions de différents types. La commande `\df`, par exemple, renvoie une liste de fonctions. Les résultats incluent des propriétés telles que le nom, le type de données renvoyé, les privilèges d’accès et les métadonnées supplémentaires. Les types de fonctions peuvent inclure des déclencheurs, des procédures stockées, des fonctions de fenêtrage et d’autres types. Lorsque vous ajoutez `S+` à la commande, par exemple `\dfantS+`, des colonnes de métadonnées supplémentaires sont incluses, telles que `owner`, `security` et `access privileges`.
## \$1dL[S\$1] [PATTERN]
Répertorie les données sur les langages procéduraux associés à la base de données. Les informations incluent le nom, tel que plpgsql, et des métadonnées supplémentaires, qui indiquent s’il est approuvé, les privilèges d’accès et la description. L’exemple d’appel est, par exemple, `\dLS+`, qui répertorie les langues et leurs propriétés. Lorsque vous ajoutez `S+` à la commande, des colonnes de métadonnées supplémentaires sont incluses, telles que `call handler` et `access privileges`.
Exemple de résultats :
```
List of languages
name | trusted | internal language | call handler | validator | access privileges | description
-----------+---------+-------------------+-------------------------+------------------------------------------------------------+-------------------+--------------------------------
c | f | t | - | fmgr_c_validator(oid) | | Dynamically-loaded C functions
exfunc | f | f | exfunc_call_handler() | - | rdsdb=U/rdsdb |
internal | f | t | - | fmgr_internal_validator(oid) | | Built-in functions
mlfunc | f | f | mlfunc_call_handler() | - | rdsdb=U/rdsdb |
plpgsql | t | f | plpgsql_call_handler() | plpgsql_validator(oid) | |
plpythonu | f | f | plpython_call_handler() | plpython_compiler(cstring,cstring,cstring,cstring,cstring) | rdsdb=U/rdsdb |
sql | t | t | - | fmgr_sql_validator(oid) | =U/rdsdb | SQL-language functions
```
## \$1dm[S\$1] [PATTERN]
Répertorie les vues matérialisées. Par exemple, `\dmS+` répertorie les vues matérialisées et leurs propriétés. Lorsque vous ajoutez `S+` à la commande, des colonnes de métadonnées supplémentaires sont incluses.
## \$1dn[S\$1] [PATTERN]
Répertorie les schémas. Lorsque vous ajoutez `S+` à la commande, par exemple `\dnS+`, des colonnes de métadonnées supplémentaires sont incluses, telles que `description` et `access privileges`.
## \$1dp [PATTERN]
Répertorie les privilèges d’accès aux tables, aux vues et aux séquences.
## \$1dt[S\$1] [PATTERN]
Répertorie les tables. Lorsque vous ajoutez `S+` à la commande, par exemple `\dtS+`, des colonnes de métadonnées supplémentaires sont incluses, telles que `description` dans ce cas.
## \$1du
Répertorie les utilisateurs pour la base de données. Inclut leur nom et leurs rôles, tels que super-utilisateur, ainsi que leurs attributs.
## \$1dv[S\$1] [PATTERN]
Répertorie les vues. Inclut le schéma, le type et les données de propriétaire. Lorsque vous ajoutez `S+` à la commande, par exemple `\dvS+`, des colonnes de métadonnées supplémentaires sont incluses.
## \$1H
Active la sortie HTML. Cela est utile pour renvoyer rapidement des résultats formatés. Par exemple, `select * from sales; \H` renvoie les résultats de la table des ventes, au format HTML. Pour revenir aux résultats tabulaires, utilisez `\q` ou silencieux.
## \$1i
Exécute des commandes à partir d’un fichier. Par exemple, supposons que vous avez rsql\$1steps.sql dans votre répertoire de travail, les commandes suivantes exécutent les commandes dans le fichier :`\i rsql_steps.sql`.
## \$1l[\$1] [PATTERN]
Répertorie les bases de données. Inclut le propriétaire, l’encodage et des informations supplémentaires.
## \$1q
La commande de fermeture, ou `\q`, déconnecte les séances de base de données et ferme RSQL.
## \$1sv[\$1] VIEWNAME
Affiche la définition d’une vue.
## \$1timing
Affiche le délai d’exécution, pour une requête, par exemple.
## \$1z [PATTERN]
Le même résultat que \$1dp.
## \$1?
Affiche les informations d’aide. Le paramètre facultatif indique l’élément à expliquer.
## \$1EXIT
Déconnecte toutes les séances de base de données et ferme Amazon Redshift RSQL. En outre, vous pouvez spécifier un code de sortie facultatif. Par exemple, `\EXIT 15` va fermer le terminal RSQL Amazon Redshift et renvoyer le code de sortie 15.
L’exemple suivant montre le résultat d’une connexion et la fermeture de RSQL.
```
% rsql -D testuser
DSN Connected
DBMS Name: Amazon Redshift
Driver Name: Amazon Redshift ODBC Driver
Driver Version: 1.4.34.1000
Rsql Version: 1.0.1
Redshift Version: 1.0.29306
Type "help" for help.
(testcluster) user1@dev=# \exit 15
% echo $?
15
```
## \$1EXPORT
Spécifie le nom d’un fichier d’exportation utilisé par RSQL pour stocker les informations de base de données renvoyées par une instruction SQL SELECT ultérieure.
export\$101.sql
```
\export report file='E:\\accounts.out'
\rset rformat off
\rset width 1500
\rset heading "General Title"
\rset titledashes on
select * from td_dwh.accounts;
\export reset
```
Sortie de console
```
Rformat is off.
Target width is 1500.
Heading is set to: General Title
Titledashes is on.
(exported 40 rows)
```
## \$1LOGON
Se connecte à une base de données. Vous pouvez spécifier des paramètres de connexion à l’aide de la syntaxe positionnelle ou d’une chaîne de connexion.
La syntaxe de commande est la suivante : `\logon {[DBNAME|- USERNAME|- HOST|- PORT|- [PASSWORD]] | conninfo}`
Le `DBNAME` est le nom de base de données à laquelle se connecter. Le `USERNAME` est le nom d’utilisateur utilisé pour se connecter. L’`HOST` par défaut est `localhost`. L’`PORT` par défaut est `5439`.
Lorsqu’un nom d’hôte est spécifié dans une commande `\LOGON`, il devient le nom d’hôte par défaut pour d’autres commandes `\LOGON`. Pour modifier le nom d’hôte par défaut, spécifiez un nouveau `HOST` dans une autre commande `\LOGON`.
L’exemple de résultat de la commande `\LOGON` pour `user1` suit.
```
(testcluster) user1@redshiftdb=# \logon dev
DBMS Name: Amazon Redshift
Driver Name: Amazon Redshift ODBC Driver
Driver Version: 1.4.27.1000
Rsql Version: 1.0.1
You are now connected to database "dev" as user "user1".
(testcluster) user1@dev=#
```
Exemple de résultat pour *user2*.
```
(testcluster) user1@dev=# \logon dev user2 testcluster2.example.com
Password for user user2:
DBMS Name: Amazon Redshift
Driver Name: Amazon Redshift ODBC Driver
Driver Version: 1.4.27.1000
Rsql Version: 1.0.1
You are now connected to database "dev" as user "user2" on host "testcluster2.example.com" at port "5439".
(testcluster2) user2@dev=#
```
## \$1REMARK
Une extension de la commande `\echo`. `\REMARK` imprime la chaîne spécifiée dans le flux de sortie. `\REMARK ` étend `\echo`en ajoutant la possibilité de répartir le résultat sur des lignes distinctes.
L’exemple suivant montre le résultat de la commande.
```
(testcluster) user1@dev=# \remark 'hello//world'
hello
world
```
## \$1RSET
La commande `\rset` définit les paramètres de commande et les variables. `\rset` dispose à la fois d’un mode interactif et d’un mode de traitement par lots. Elle ne prend pas en charge les options en tant qu’options bash, comme *-x*, ou des arguments, par exemple *--*.
Elle définit des variables, telles que les suivantes :
+ ERRORLEVEL
+ HEADING et RTITLE
+ RFORMAT
+ MAXERROR
+ TITLEDASHES
+ WIDTH
L’exemple suivant spécifie un en-tête.
```
\rset heading "Winter Sales Report"
```
Pour obtenir plus d’exemples d’utilisation `\rset`, vous pouvez en trouver plusieurs dans les rubriques [Variables Amazon Redshift RSQL](rsql-query-tool-variables.md).
## \$1RUN
Exécute le script Amazon Redshift RSQL contenu dans le fichier spécifié. `\RUN` étend la commande `\i` en ajoutant une option permettant d’ignorer les lignes d’en-tête dans un fichier.
Si le nom du fichier contient une virgule, un point-virgule ou un espace, placez-le entre guillemets simples. De plus, si le texte suit le nom du fichier, placez-le entre guillemets. Sous UNIX, les noms de fichier sont sensibles à la casse. Sous Windows, les noms de fichiers ne sont pas sensibles à la casse.
L’exemple suivant montre le résultat de la commande.
```
(testcluster) user1@dev=# \! cat test.sql
select count(*) as lineitem_cnt from lineitem;
select count(*) as customer_cnt from customer;
select count(*) as orders_cnt from orders;
(testcluster) user1@dev=# \run file=test.sql
lineitem_cnt
--------------
4307207
(1 row)
customer_cnt
--------------
37796166
(1 row)
orders_cnt
------------
0
(1 row)
(testcluster) user1@dev=# \run file=test.sql skip=2
2 records skipped in RUN file.
orders_cnt
------------
0
(1 row)
```
## \$1OS
Un alias pour la commande `\!`. `\OS` exécute la commande du système d’exploitation transmise en tant que paramètre. Le contrôle revient à Amazon Redshift RSQL une fois la commande exécutée. Par exemple, vous pouvez exécuter la commande suivante pour imprimer la date et l’heure du système actuel et revenir au terminal RSQL : `\os date`.
```
(testcluster) user1@dev=# \os date
Tue Sep 7 20:47:54 UTC 2021
```
## \$1GOTO
Une nouvelle commande pour Amazon Redshift RSQL. `\GOTO` ignore toutes les commandes intervenantes et reprend le traitement à l’`\LABEL` spécifiée. L’`\LABEL` doit être une référence future. Vous ne pouvez pas accéder à une`\LABEL` qui précède le `\GOTO` d’un point de vue lexical.
Voici un exemple de résultat.
```
(testcluster) user1@dev=# \! cat test.sql
select count(*) as cnt from lineitem \gset
select :cnt as cnt;
\if :cnt > 100
\goto LABELB
\endif
\label LABELA
\remark 'this is label LABELA'
\label LABELB
\remark 'this is label LABELB'
(testcluster) user1@dev=# \i test.sql
cnt
---------
4307207
(1 row)
\label LABELA ignored
\label LABELB processed
this is label LABELB
```
## \$1LABEL
Une nouvelle commande pour Amazon Redshift RSQL. `\LABEL` établit un point d’entrée pour exécuter le programme, en tant que cible pour une commande `\GOTO`.
L’exemple suivant montre un exemple de résultat de la commande.
```
(testcluster) user1@dev=# \! cat test.sql
select count(*) from lineitem limit 5;
\goto LABELB
\remark "this step was skipped by goto label";
\label LABELA
\remark 'this is label LABELA'
\label LABELB
\remark 'this is label LABELB'
(testcluster) user1@dev=# \i testgoto.sql
count
4307193
(1 row)
\label LABELA ignored
\label LABELB processed
this is label LABELB
```
## \$1IF (\$1ELSEIF, \$1ELSE, \$1ENDIF)
Les commandes `\IF`et associées exécutent conditionnellement des parties du script d’entrée. Une extension de la commande PSQL `\if` (`\elif`, `\else`, `\endif`). `\IF` et `\ELSEIF` prennent en charge les expressions booléennes, dont les conditions `AND`, `OR` et `NOT`.
L’exemple suivant montre un exemple de résultat des commandes.
```
(testcluster) user1@dev=# \! cat test.sql
SELECT query FROM stv_inflight LIMIT 1 \gset
select :query as query;
\if :query > 1000000
\remark 'Query id is greater than 1000000'
\elseif :query = 1000000
\remark 'Query id is equal than 1000000'
\else
\remark 'Query id is less than 1000000'
\endif
(testcluster) user1@dev=# \i test.sql
query
--------
994803
(1 row)
Query id is less than 1000000
```
Utilisez `ERRORCODE` dans votre logique de branchement.
```
\if :'ERRORCODE' = '00000'
\remark 'The statement was executed without error'
\else
\remark :LAST_ERROR_MESSAGE
\endif
```
Utilisez`\GOTO` dans un bloc `\IF` pour contrôler la façon dont le code est exécuté.
# Variables Amazon Redshift RSQL
Certains mots-clés agissent comme des variables dans RSQL. Vous pouvez définir chacun une valeur spécifique ou réinitialiser la valeur. La plupart sont réglées avec `\rset`, qui dispose d’un mode interactif et d’un mode de traitement par lots. Les commandes peuvent être définies en minuscules ou en majuscules.
## ACTIVITYCOUNT
Indique le nombre de lignes affectées par la dernière demande envoyée. Pour une demande renvoyant des données, il s’agit du nombre de lignes renvoyées vers RSQL à partir de la base de données. La valeur est 0 ou un nombre entier positif. La valeur maximale est 18 446 744 073 709 551 615.
La variable spécialement traitée `ACTIVITYCOUNT` est semblable à la variable `ROW_COUNT`. Toutefois, `ROW_COUNT` ne signale pas le nombre de lignes affectées à l’application cliente à la fin de la commande pour `SELECT`, `COPY` ou `UNLOAD`. Mais `ACTIVITYCOUNT` le fait.
activitycount\$101.sql :
```
select viewname, schemaname
from pg_views
where schemaname = 'not_existing_schema';
\if :ACTIVITYCOUNT = 0
\remark 'views do not exist'
\endif
```
Sortie de la console :
```
viewname | schemaname
----------+------------
(0 rows)
views do not exist
```
## ERRORLEVEL
Attribue des niveaux de sévérité aux erreurs. Utilisez les niveaux de sévérité pour déterminer un plan d’action. Si la commande `ERRORLEVEL` n’a pas été utilisée, sa valeur par défaut est `ON`.
errorlevel\$101.sql :
```
\rset errorlevel 42P01 severity 0
select * from tbl;
select 1 as col;
\echo exit
\quit
```
Sortie de la console :
```
Errorlevel is on.
rsql: ERROR: relation "tbl" does not exist
(1 row)
col
1
exit
```
## HEADING et RTITLE
Permet aux utilisateurs de spécifier un en-tête qui s’affiche dans la partie supérieure d’un rapport. L’en-tête spécifiée par la commande `RSET RTITLE` inclut automatiquement la date système actuelle de l’ordinateur client.
Contenu rset\$1heading\$1rtitle\$102.rsql :
```
\remark Starting...
\rset rtitle "Marketing Department||Confidential//Third Quarter//Chicago"
\rset width 70
\rset rformat on
select * from rsql_test.tbl_currency order by id limit 2;
\exit
\remark Finishing...
```
Sortie de la console :
```
Starting...
Rtitle is set to: &DATE||Marketing Department||Confidential//Third Quarter//Chicago (Changes will take effect after RFORMAT is
switched ON)
Target width is 70.
Rformat is on.
09/11/20 Marketing Department Confidential
Third Quarter
Chicago
id | bankid | name | start_date
100 | 1 | USD | 2020-09-11 10:51:39.106905
110 | 1 | EUR | 2020-09-11 10:51:39.106905
(2 rows)
Press any key to continue . . .
```
## MAXERROR
Désigne un niveau de sévérité d’erreur maximal au-delà duquel RSQL met fin au traitement des tâches. Les codes de retour sont des valeurs entières que RSQL renvoie au système d’exploitation client après avoir terminé chaque tâche. La valeur du code de retour indique l’état d’achèvement de la tâche. Si un script contient une instruction qui produit un niveau de sévérité d’erreur supérieur à la valeur `maxerror` désignée, RSQL s’interrompt immédiatement. Par conséquent, pour que RSQL s’interrompt à un niveau de sévérité d’erreur de 8, utilisez `RSET MAXERROR 7`.
Contenu maxerror\$101.sql :
```
\rset maxerror 0
select 1 as col;
\quit
```
Sortie de la console :
```
Maxerror is default.
(1 row)
col
1
```
## RFORMAT
Permet aux utilisateurs de spécifier s’il faut appliquer des paramètres aux commandes de formatage.
Contenu rset\$1rformat.rsql :
```
\remark Starting...
\pset border 2
\pset format wrapped
\pset expanded on
\pset title 'Great Title'
select * from rsql_test.tbl_long where id = 500;
\rset rformat
select * from rsql_test.tbl_long where id = 500;
\rset rformat off
select * from rsql_test.tbl_long where id = 500;
\rset rformat on
select * from rsql_test.tbl_long where id = 500;
\exit
\remark Finishing...
```
Sortie de la console :
```
Starting...
Border style is 2. (Changes will take effect after RFORMAT is switched ON)
Output format is wrapped. (Changes will take effect after RFORMAT is switched ON)
Expanded display is on. (Changes will take effect after RFORMAT is switched ON)
Title is "Great Title". (Changes will take effect after RFORMAT is switched ON)
id | long_string
500 | In general, the higher the number the more borders and lines the tables will have, but details depend on the particular
format.
(1 row)
Rformat is on.
Great Title
+-[ RECORD 1 ]+----------------------------------------------------------------------------------------------------------------------
-----------+
| id | 500
|
| long_string | In general, the higher the number the more borders and lines the tables will have, but details depend on the
particular format. |
+-------------+----------------------------------------------------------------------------------------------------------------------
-----------+
Rformat is off.
id | long_string
500 | In general, the higher the number the more borders and lines the tables will have, but details depend on the particular format.
(1 row)
Rformat is on.
Great Title
+-[ RECORD 1 ]+----------------------------------------------------------------------------------------------------------------------
-----------+
| id | 500
|
| long_string | In general, the higher the number the more borders and lines the tables will have, but details depend on the
particular format. |
+-------------+----------------------------------------------------------------------------------------------------------------------
-----------+
Press any key to continue . . .
```
## ROW\$1COUNT
Obtient le nombre d’enregistrements affectés par la requête précédente. Il est généralement utilisé pour vérifier un résultat, comme dans le fragment de code suivant :
```
SET result = ROW_COUNT;
IF result = 0
...
```
## TITLEDASHES
Ce contrôle permet aux utilisateurs de spécifier si une ligne de caractères de tiret doit être imprimée au-dessus des données de colonne renvoyées pour les instructions SQL.
Exemple :
```
\rset titledashes on
select dept_no, emp_no, salary from rsql_test.EMPLOYEE
where dept_no = 100;
\rset titledashes off
select dept_no, emp_no, salary from rsql_test.EMPLOYEE
where dept_no = 100;
```
Sortie de la console :
```
dept_no emp_no salary
----------- ----------- --------------------
100 1000346 1300.00
100 1000245 5000.00
100 1000262 2450.00
dept_no emp_no salary
100 1000346 1300.00
100 1000245 5000.00
100 1000262 2450.00
```
## WIDTH
Définit le format de sortie sur encapsulé et spécifie la largeur cible de chaque ligne d’un rapport. Sans paramètre, il renvoie les paramètres actuels pour le format et la largeur cible.
Contenu rset\$1width\$101.rsql :
```
\echo Starting...
\rset width
\rset width 50
\rset width
\quit
\echo Finishing...
```
Sortie de la console :
```
Starting...
Target width is 75.
Target width is 50.
Target width is 50.
Press any key to continue . . .
```
Exemple avec paramètre :
```
\echo Starting...
\rset rformat on
\pset format wrapped
select * from rsql_test.tbl_long where id = 500;
\rset width 50
select * from rsql_test.tbl_long where id = 500;
\quit
\echo Finishing...
```
Sortie de la console :
```
Starting...
Rformat is on.
Output format is wrapped.
id | long_string
500 | In general, the higher the number the more borders and lines the ta.
|.bles will have, but details depend on the particular format.
(1 row)
Target width is 50.
id | long_string
500 | In general, the higher the number the more.
|. borders and lines the tables will have, b.
|.ut details depend on the particular format.
|..
(1 row)
Press any key to continue . . .
```
# Codes d’erreur Amazon Redshift RSQL
Messages de réussite, avertissements et exceptions :
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/mgmt/rsql-query-tool-error-codes.html)
Exceptions de données :
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/mgmt/rsql-query-tool-error-codes.html)
Violations des contraintes d’intégrité :
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/mgmt/rsql-query-tool-error-codes.html)
# Variables d’environnement Amazon Redshift RSQL
Amazon Redshift RSQL peut utiliser des variables d’environnement pour sélectionner des valeurs de paramètres par défaut.
## RSPASSWORD
**Important**
Nous ne recommandons pas d’utiliser cette variable d’environnement pour des raisons de sécurité, car certains systèmes d’exploitation permettent aux utilisateurs non administratifs de visualiser les variables d’environnement des processus.
Définit le mot de passe pour Amazon Redshift RSQL à utiliser lors de la connexion à Amazon Redshift. Cette variable d’environnement nécessite Amazon Redshift RSQL 1.0.4 et version ultérieure.
RSQL donne la priorité à RSPASSWORD si celui-ci est défini. Si RSPASSWORD n’est pas défini et que vous vous connectez à l’aide d’un DSN, RSQL récupère le mot de passe dans les paramètres du fichier DSN. Enfin, si RSPASSWORD n’est pas défini et que vous n’utilisez pas de DSN, RSQL fournit une invite de mot de passe après une tentative de connexion.
Voici un exemple de définition d’un RSPASSWORD :
```
export RSPASSWORD=TestPassw0rd
```