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.
# Appel à l’API de données
Vous pouvez appeler l'API Data ou le AWS CLI pour exécuter des instructions SQL sur votre cluster ou votre groupe de travail sans serveur. Les principales opérations pour exécuter des instructions SQL sont [https://docs.aws.amazon.com/redshift-data/latest/APIReference/API_ExecuteStatement.html](https://docs.aws.amazon.com/redshift-data/latest/APIReference/API_ExecuteStatement.html) et [https://docs.aws.amazon.com/redshift-data/latest/APIReference/API_BatchExecuteStatement.html](https://docs.aws.amazon.com/redshift-data/latest/APIReference/API_BatchExecuteStatement.html) dans la *Référence de l’API de données Amazon Redshift*. L'API Data prend en charge les langages de programmation pris en charge par le AWS SDK. Pour plus d’informations sur ces derniers, consultez [Outils pour créer sur AWS](https://aws.amazon.com/tools/).
Pour voir des exemples de code relatifs à l'appel de l'API de données, consultez [Getting Started with Redshift Data API](https://github.com/aws-samples/getting-started-with-amazon-redshift-data-api#getting-started-with-redshift-data-api) dans. *GitHub* Ce référentiel contient des exemples d'utilisation AWS Lambda pour accéder aux données Amazon Redshift depuis Amazon EC2 et Amazon AWS Glue Data Catalog Runtime. SageMaker Les langages de programmation incluent Python, Go, Java et Javascript.
Vous pouvez appeler l’API de données avec la AWS CLI.
Les exemples suivants utilisent le AWS CLI pour appeler l'API Data. Pour exécuter les exemples, modifiez les valeurs des paramètres de manière à les adapter à votre environnement. Dans de nombreux exemples, un `cluster-identifier` est fourni pour être exécutée sur un cluster. Lorsque vous exécutez une opération sur un groupe de travail sans serveur, vous fournissez un `workgroup-name` à la place. Ces exemples illustrent quelques-unes des opérations de l’API de données. Pour plus d’informations, consultez la *référence des commandes de l’AWS CLI *.
Les commandes des exemples suivants ont été scindées et formatées pour être plus lisibles. Tous les paramètres et réponses ne sont pas présentés dans tous les exemples. Pour la définition API de la syntaxe complète de la demande, des paramètres de demande, de la syntaxe de réponse et des éléments de réponse, consultez la [Référence de l’API de données Amazon Redshift](https://docs.aws.amazon.com/redshift-data/latest/APIReference/).
# Transmission d’instructions SQL à un entrepôt de données Amazon Redshift
Les exemples présentés dans cette page présentent différentes manières de transmettre une instruction SQL à votre entrepôt de données.
## Exécuter une instruction SQL
Pour exécuter une instruction SQL, utilisez la `aws redshift-data execute-statement` AWS CLI commande.
La AWS CLI commande suivante exécute une instruction SQL sur un cluster et renvoie un identifiant pour récupérer les résultats. Cet exemple utilise la méthode d’authentification AWS Secrets Manager .
```
aws redshift-data execute-statement
--secret-arn arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn
--cluster-identifier mycluster-test
--sql "select * from stl_query limit 1"
--database dev
```
Voici un exemple de réponse.
```
{
"ClusterIdentifier": "mycluster-test",
"CreatedAt": 1598323175.823,
"Database": "dev",
"Id": "c016234e-5c6c-4bc5-bb16-2c5b8ff61814",
"SecretArn": "arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn"
}
```
La AWS CLI commande suivante exécute une instruction SQL sur un cluster et renvoie un identifiant pour récupérer les résultats. Cet exemple utilise la méthode d’authentification par informations d’identification temporaires.
```
aws redshift-data execute-statement
--db-user myuser
--cluster-identifier mycluster-test
--database dev
--sql "select * from stl_query limit 1"
```
Voici un exemple de réponse.
```
{
"ClusterIdentifier": "mycluster-test",
"CreatedAt": 1598306924.632,
"Database": "dev",
"DbUser": "myuser",
"Id": "d9b6c0c9-0747-4bf4-b142-e8883122f766"
}
```
La AWS CLI commande suivante exécute une instruction SQL sur un groupe de travail sans serveur et renvoie un identifiant pour récupérer les résultats. Cet exemple utilise la méthode d’authentification par informations d’identification temporaires.
```
aws redshift-data execute-statement
--database dev
--workgroup-name myworkgroup
--sql "select 1;"
```
Voici un exemple de réponse.
```
{
"CreatedAt": "2022-02-11T06:25:28.748000+00:00",
"Database": "dev",
"DbUser": "IAMR:RoleName",
"Id": "89dd91f5-2d43-43d3-8461-f33aa093c41e",
"WorkgroupName": "myworkgroup"
}
```
La AWS CLI commande suivante exécute une instruction SQL sur un cluster et renvoie un identifiant pour récupérer les résultats. Cet exemple utilise la méthode d’authentification AWS Secrets Manager et un jeton d’idempotence.
```
aws redshift-data execute-statement
--secret-arn arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn
--cluster-identifier mycluster-test
--sql "select * from stl_query limit 1"
--database dev
--client-token b855dced-259b-444c-bc7b-d3e8e33f94g1
```
Voici un exemple de réponse.
```
{
"ClusterIdentifier": "mycluster-test",
"CreatedAt": 1598323175.823,
"Database": "dev",
"Id": "c016234e-5c6c-4bc5-bb16-2c5b8ff61814",
"SecretArn": "arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn"
}
```
## Exécuter une instruction SQL avec des paramètres
Pour exécuter une instruction SQL, utilisez la `aws redshift-data execute-statement` AWS CLI commande.
La AWS CLI commande suivante exécute une instruction SQL sur un cluster et renvoie un identifiant pour récupérer les résultats. Cet exemple utilise la méthode d’authentification AWS Secrets Manager . Le texte SQL a un paramètre nommé `distance`. Dans ce cas, la distance utilisée dans le prédicat est `5`. Dans une instruction SELECT, les paramètres nommés pour les noms de colonnes ne peuvent être utilisés que dans le prédicat. Les valeurs des paramètres nommés pour l’instruction SQL sont spécifiées dans l’option `parameters`.
```
aws redshift-data execute-statement
--secret-arn arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn
--cluster-identifier mycluster-test
--sql "SELECT ratecode FROM demo_table WHERE trip_distance > :distance"
--parameters "[{\"name\": \"distance\", \"value\": \"5\"}]"
--database dev
```
Voici un exemple de réponse.
```
{
"ClusterIdentifier": "mycluster-test",
"CreatedAt": 1598323175.823,
"Database": "dev",
"Id": "c016234e-5c6c-4bc5-bb16-2c5b8ff61814",
"SecretArn": "arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn"
}
```
L’exemple de requête suivant utilise la table `EVENT` de l’exemple de base de données. Pour plus d’informations, consultez [Table EVENT](https://docs.aws.amazon.com/redshift/latest/dg/r_eventtable.html) dans le *Manuel du développeur de bases de données Amazon Redshift*.
Si la table `EVENT` n’existe pas encore dans votre base de données, vous pouvez en créer une à l’aide de l’API de données comme suit :
```
aws redshift-data execute-statement
--database dev
--cluster-id mycluster-test
--db-user awsuser
--sql "create table event( eventid integer not null distkey,
venueid smallint not null,
catid smallint not null,
dateid smallint not null sortkey,
eventname varchar(200),
starttime timestamp)"
```
L’instruction suivante insère une ligne dans la table `EVENT`.
```
aws redshift-data execute-statement
--database dev
--cluster-id mycluster-test
--db-user awsuser
--sql "insert into event values(:eventid, :venueid::smallint, :catid, :dateid, :eventname, :starttime)"
--parameters "[{\"name\": \"eventid\", \"value\": \"1\"}, {\"name\": \"venueid\", \"value\": \"1\"},
{\"name\": \"catid\", \"value\": \"1\"},
{\"name\": \"dateid\", \"value\": \"1\"},
{\"name\": \"eventname\", \"value\": \"event 1\"},
{\"name\": \"starttime\", \"value\": \"2022-02-22\"}]"
```
L’instruction suivante insère une deuxième ligne dans la table `EVENT`. Cet exemple illustre ce scénario :
+ Le paramètre nommé `id` est utilisé quatre fois dans le texte SQL.
+ La conversion de type implicite est appliquée automatiquement lors de l’insertion d’un paramètre `starttime`.
+ La colonne `venueid` est convertie en type de données SMALLINT.
+ Les chaînes de caractères qui représentent le type de données DATE sont implicitement converties en type de données TIMESTAMP.
+ Les commentaires peuvent être utilisés dans le texte SQL.
```
aws redshift-data execute-statement
--database dev
--cluster-id mycluster-test
--db-user awsuser
--sql "insert into event values(:id, :id::smallint, :id, :id, :eventname, :starttime) /*this is comment, and it won't apply parameterization for :id, :eventname or :starttime here*/"
--parameters "[{\"name\": \"eventname\", \"value\": \"event 2\"},
{\"name\": \"starttime\", \"value\": \"2022-02-22\"},
{\"name\": \"id\", \"value\": \"2\"}]"
```
Voici les deux lignes insérées :
```
eventid | venueid | catid | dateid | eventname | starttime
---------+---------+-------+--------+-----------+---------------------
1 | 1 | 1 | 1 | event 1 | 2022-02-22 00:00:00
2 | 2 | 2 | 2 | event 2 | 2022-02-22 00:00:00
```
La commande suivante utilise un paramètre nommé dans une clause WHERE pour récupérer la ligne où `eventid` est `1`.
```
aws redshift-data execute-statement
--database dev
--cluster-id mycluster-test
--db-user awsuser
--sql "select * from event where eventid=:id"
--parameters "[{\"name\": \"id\", \"value\": \"1\"}]"
```
Exécutez l’instruction suivante pour obtenir les résultats SQL de l’instruction SQL précédente :
```
aws redshift-data get-statement-result --id 7529ad05-b905-4d71-9ec6-8b333836eb5a
```
Fournit les résultats suivants :
```
{
"Records": [
[
{
"longValue": 1
},
{
"longValue": 1
},
{
"longValue": 1
},
{
"longValue": 1
},
{
"stringValue": "event 1"
},
{
"stringValue": "2022-02-22 00:00:00.0"
}
]
],
"ColumnMetadata": [
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "eventid",
"length": 0,
"name": "eventid",
"nullable": 0,
"precision": 10,
"scale": 0,
"schemaName": "public",
"tableName": "event",
"typeName": "int4"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "venueid",
"length": 0,
"name": "venueid",
"nullable": 0,
"precision": 5,
"scale": 0,
"schemaName": "public",
"tableName": "event",
"typeName": "int2"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "catid",
"length": 0,
"name": "catid",
"nullable": 0,
"precision": 5,
"scale": 0,
"schemaName": "public",
"tableName": "event",
"typeName": "int2"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "dateid",
"length": 0,
"name": "dateid",
"nullable": 0,
"precision": 5,
"scale": 0,
"schemaName": "public",
"tableName": "event",
"typeName": "int2"
},
{
"isCaseSensitive": true,
"isCurrency": false,
"isSigned": false,
"label": "eventname",
"length": 0,
"name": "eventname",
"nullable": 1,
"precision": 200,
"scale": 0,
"schemaName": "public",
"tableName": "event",
"typeName": "varchar"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"label": "starttime",
"length": 0,
"name": "starttime",
"nullable": 1,
"precision": 29,
"scale": 6,
"schemaName": "public",
"tableName": "event",
"typeName": "timestamp"
}
],
"TotalNumRows": 1
}
```
## Exécuter plusieurs instructions SQL
Pour exécuter plusieurs instructions SQL avec une seule commande, utilisez la `aws redshift-data batch-execute-statement` AWS CLI commande.
La AWS CLI commande suivante exécute trois instructions SQL sur un cluster et renvoie un identifiant pour récupérer les résultats. Cet exemple utilise la méthode d’authentification par informations d’identification temporaires.
```
aws redshift-data batch-execute-statement
--db-user myuser
--cluster-identifier mycluster-test
--database dev
--sqls "set timezone to BST" "select * from mytable" "select * from another_table"
```
Voici un exemple de réponse.
```
{
"ClusterIdentifier": "mycluster-test",
"CreatedAt": 1598306924.632,
"Database": "dev",
"DbUser": "myuser",
"Id": "d9b6c0c9-0747-4bf4-b142-e8883122f766"
}
```
# Répertorier les métadonnées sur les instructions SQL
Pour répertorier les métadonnées relatives aux instructions SQL, utilisez la `aws redshift-data list-statements` AWS CLI commande. L’autorisation d’exécuter cette commande est basée sur les autorisations IAM de l’appelant.
La AWS CLI commande suivante répertorie les instructions SQL exécutées.
```
aws redshift-data list-statements
--status ALL
```
Voici un exemple de réponse.
```
{
"Statements": [
{
"CreatedAt": 1598306924.632,
"Id": "d9b6c0c9-0747-4bf4-b142-e8883122f766",
"QueryString": "select * from stl_query limit 1",
"Status": "FINISHED",
"UpdatedAt": 1598306926.667
},
{
"CreatedAt": 1598311717.437,
"Id": "e0ebd578-58b3-46cc-8e52-8163fd7e01aa",
"QueryString": "select * from stl_query limit 1",
"Status": "FAILED",
"UpdatedAt": 1598311719.008
},
{
"CreatedAt": 1598313683.65,
"Id": "c361d4f7-8c53-4343-8c45-6b2b1166330c",
"QueryString": "select * from stl_query limit 1",
"Status": "ABORTED",
"UpdatedAt": 1598313685.495
},
{
"CreatedAt": 1598306653.333,
"Id": "a512b7bd-98c7-45d5-985b-a715f3cfde7f",
"QueryString": "select 1",
"Status": "FINISHED",
"UpdatedAt": 1598306653.992
}
]
}
```
# Décrire des métadonnées à propos d’une instruction SQL
Pour obtenir la description des métadonnées d'une instruction SQL, utilisez la `aws redshift-data describe-statement` AWS CLI commande. L’autorisation d’exécuter cette commande est basée sur les autorisations IAM de l’appelant.
La AWS CLI commande suivante décrit une instruction SQL.
```
aws redshift-data describe-statement
--id d9b6c0c9-0747-4bf4-b142-e8883122f766
```
Voici un exemple de réponse.
```
{
"ClusterIdentifier": "mycluster-test",
"CreatedAt": 1598306924.632,
"Duration": 1095981511,
"Id": "d9b6c0c9-0747-4bf4-b142-e8883122f766",
"QueryString": "select * from stl_query limit 1",
"RedshiftPid": 20859,
"RedshiftQueryId": 48879,
"ResultRows": 1,
"ResultSize": 4489,
"Status": "FINISHED",
"UpdatedAt": 1598306926.667
}
```
Voici un exemple de réponse de `describe-statement` après l’exécution d’une commande `batch-execute-statement` avec plusieurs instructions SQL.
```
{
"ClusterIdentifier": "mayo",
"CreatedAt": 1623979777.126,
"Duration": 6591877,
"HasResultSet": true,
"Id": "b2906c76-fa6e-4cdf-8c5f-4de1ff9b7652",
"RedshiftPid": 31459,
"RedshiftQueryId": 0,
"ResultRows": 2,
"ResultSize": 22,
"Status": "FINISHED",
"SubStatements": [
{
"CreatedAt": 1623979777.274,
"Duration": 3396637,
"HasResultSet": true,
"Id": "b2906c76-fa6e-4cdf-8c5f-4de1ff9b7652:1",
"QueryString": "select 1;",
"RedshiftQueryId": -1,
"ResultRows": 1,
"ResultSize": 11,
"Status": "FINISHED",
"UpdatedAt": 1623979777.903
},
{
"CreatedAt": 1623979777.274,
"Duration": 3195240,
"HasResultSet": true,
"Id": "b2906c76-fa6e-4cdf-8c5f-4de1ff9b7652:2",
"QueryString": "select 2;",
"RedshiftQueryId": -1,
"ResultRows": 1,
"ResultSize": 11,
"Status": "FINISHED",
"UpdatedAt": 1623979778.076
}
],
"UpdatedAt": 1623979778.183
}
```
# Récupérer les résultats d’une instruction SQL
Pour récupérer le résultat d'une instruction SQL exécutée, utilisez la `redshift-data get-statement-result-v2` AWS CLI commande `redshift-data get-statement-result` or. Les résultats de `get-statement-result` sont au format JSON. Les résultats de `get-statement-result-v2` sont au format CSV. Vous pouvez spécifier un `Id` que vous recevez en réponse à `execute-statement` ou `batch-execute-statement`. La valeur `Id` d’une instruction SQL exécutée par `batch-execute-statement` peut être récupéré dans le résultat de `describe-statement` et son suffixe est composé de deux points suivis d’un numéro de séquence tel que `b2906c76-fa6e-4cdf-8c5f-4de1ff9b7652:2`. Si vous exécutez plusieurs instructions SQL avec `batch-execute-statement`, chaque instruction SQL a une valeur `Id` comme indiqué dans `describe-statement`. L’autorisation d’exécuter cette commande est basée sur les autorisations IAM de l’appelant.
L’instruction suivante renvoie le résultat d’une instruction SQL exécutée par `execute-statement` laissant le `ResultFormat` par défaut sur `JSON`. Pour récupérer les résultats, appelez l’opération `get-statement-result`.
```
aws redshift-data get-statement-result
--id d9b6c0c9-0747-4bf4-b142-e8883122f766
```
L’instruction suivante renvoie le résultat de la deuxième instruction SQL exécutée par `batch-execute-statement`.
```
aws redshift-data get-statement-result
--id b2906c76-fa6e-4cdf-8c5f-4de1ff9b7652:2
```
Voici un exemple de réponse à un appel de `get-statement-result` où le résultat SQL est renvoyé au format JSON dans la clé `Records` de la réponse.
```
{
"ColumnMetadata": [
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "userid",
"length": 0,
"name": "userid",
"nullable": 0,
"precision": 10,
"scale": 0,
"schemaName": "",
"tableName": "stll_query",
"typeName": "int4"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "query",
"length": 0,
"name": "query",
"nullable": 0,
"precision": 10,
"scale": 0,
"schemaName": "",
"tableName": "stll_query",
"typeName": "int4"
},
{
"isCaseSensitive": true,
"isCurrency": false,
"isSigned": false,
"label": "label",
"length": 0,
"name": "label",
"nullable": 0,
"precision": 320,
"scale": 0,
"schemaName": "",
"tableName": "stll_query",
"typeName": "bpchar"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "xid",
"length": 0,
"name": "xid",
"nullable": 0,
"precision": 19,
"scale": 0,
"schemaName": "",
"tableName": "stll_query",
"typeName": "int8"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "pid",
"length": 0,
"name": "pid",
"nullable": 0,
"precision": 10,
"scale": 0,
"schemaName": "",
"tableName": "stll_query",
"typeName": "int4"
},
{
"isCaseSensitive": true,
"isCurrency": false,
"isSigned": false,
"label": "database",
"length": 0,
"name": "database",
"nullable": 0,
"precision": 32,
"scale": 0,
"schemaName": "",
"tableName": "stll_query",
"typeName": "bpchar"
},
{
"isCaseSensitive": true,
"isCurrency": false,
"isSigned": false,
"label": "querytxt",
"length": 0,
"name": "querytxt",
"nullable": 0,
"precision": 4000,
"scale": 0,
"schemaName": "",
"tableName": "stll_query",
"typeName": "bpchar"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"label": "starttime",
"length": 0,
"name": "starttime",
"nullable": 0,
"precision": 29,
"scale": 6,
"schemaName": "",
"tableName": "stll_query",
"typeName": "timestamp"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"label": "endtime",
"length": 0,
"name": "endtime",
"nullable": 0,
"precision": 29,
"scale": 6,
"schemaName": "",
"tableName": "stll_query",
"type": 93,
"typeName": "timestamp"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "aborted",
"length": 0,
"name": "aborted",
"nullable": 0,
"precision": 10,
"scale": 0,
"schemaName": "",
"tableName": "stll_query",
"typeName": "int4"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "insert_pristine",
"length": 0,
"name": "insert_pristine",
"nullable": 0,
"precision": 10,
"scale": 0,
"schemaName": "",
"tableName": "stll_query",
"typeName": "int4"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "concurrency_scaling_status",
"length": 0,
"name": "concurrency_scaling_status",
"nullable": 0,
"precision": 10,
"scale": 0,
"schemaName": "",
"tableName": "stll_query",
"typeName": "int4"
}
],
"Records": [
[
{
"longValue": 1
},
{
"longValue": 3
},
{
"stringValue": "health"
},
{
"longValue": 1023
},
{
"longValue": 15279
},
{
"stringValue": "dev"
},
{
"stringValue": "select system_status from stv_gui_status;"
},
{
"stringValue": "2020-08-21 17:33:51.88712"
},
{
"stringValue": "2020-08-21 17:33:52.974306"
},
{
"longValue": 0
},
{
"longValue": 0
},
{
"longValue": 6
}
]
],
"TotalNumRows": 1
}
```
L’exemple suivant montre une instruction SQL exécutée par `execute-statement` pour renvoyer des résultats au format JSON. La table `testingtable` comporte trois colonnes entières (col1, col2, col3) et trois lignes contenant des valeurs (1, 2, 3), (4, 5, 6) et (7, 8, 9).
```
aws redshift-data execute-statement
--database dev
--sql "SELECT col1, col2, col3 FROM testingtable"
--cluster-id mycluster-test
--result-format JSON
```
```
{
"ClusterIdentifier": "mycluster-test",
"CreatedAt": "2024-04-02T16:45:25.144000+00:00",
"Database": "dev",
"DbUser": "IAMR:Administrator",
"Id": "d468d942-6df9-4f85-8ae3-bac01a61aec3"
}
```
Voici un exemple de réponse à un appel de `get-statement-result` où le résultat SQL est renvoyé au format JSON dans la clé `Records` de la réponse.
```
aws redshift-data get-statement-result
--id d468d942-6df9-4f85-8ae3-bac01a61aec3
```
```
{
"Records": [
[
{
"longValue": 1
},
{
"longValue": 2
},
{
"longValue": 3
}
],
[
{
"longValue": 4
},
{
"longValue": 5
},
{
"longValue": 6
}
],
[
{
"longValue": 7
},
{
"longValue": 8
},
{
"longValue": 9
}
]
],
"ColumnMetadata": [
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "col1",
"name": "col1",
"nullable": 1,
"precision": 10,
"scale": 0,
"schemaName": "public",
"tableName": "testingtable",
"typeName": "int4",
"length": 0
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "col2",
"name": "col2",
"nullable": 1,
"precision": 10,
"scale": 0,
"schemaName": "public",
"tableName": "testingtable",
"typeName": "int4",
"length": 0
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "col3",
"name": "col3",
"nullable": 1,
"precision": 10,
"scale": 0,
"schemaName": "public",
"tableName": "testingtable",
"typeName": "int4",
"length": 0
}
],
"TotalNumRows": 3
}
```
L’exemple suivant montre une instruction SQL exécutée par `execute-statement` pour renvoyer des résultats au format CSV. La table `testingtable` comporte trois colonnes entières (col1, col2, col3) et trois lignes contenant des valeurs (1, 2, 3), (4, 5, 6) et (7, 8, 9).
```
aws redshift-data execute-statement
--database dev
--sql "SELECT col1, col2, col3 FROM testingtable"
--cluster-id mycluster-test
--result-format CSV
```
```
{
"ClusterIdentifier": "mycluster-test",
"CreatedAt": "2024-04-02T16:45:25.144000+00:00",
"Database": "dev",
"DbUser": "IAMR:Administrator",
"Id": "d468d942-6df9-4f85-8ae3-bac01a61aec3"
}
```
Voici un exemple de réponse à un appel de `get-statement-result-v2` où le résultat SQL est renvoyé au format CSV dans la clé `Records` de la réponse. Les lignes sont séparées par un retour du chariot et par une nouvelle ligne (\$1r\$1n). La première ligne renvoyée dans `Records` correspond aux en-têtes de colonne. Les résultats renvoyés au format CSV sont renvoyés dans un format de 1 Mo, chaque bloc pouvant stocker un nombre quelconque de lignes allant jusqu’à 1 Mo.
```
aws redshift-data get-statement-result-v2
--id d468d942-6df9-4f85-8ae3-bac01a61aec3
```
```
{
"Records": [
{
"CSVRecords": "col1,col2,col3\r\n1,2,3\r\n4,5,6\r\n7,8,9\r\n"
}
],
"ColumnMetadata": [
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "col1",
"name": "col1",
"nullable": 1,
"precision": 10,
"scale": 0,
"schemaName": "public",
"tableName": "testingtable",
"typeName": "int4",
"length": 0
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "col2",
"name": "col2",
"nullable": 1,
"precision": 10,
"scale": 0,
"schemaName": "public",
"tableName": "testingtable",
"typeName": "int4",
"length": 0
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "col3",
"name": "col3",
"nullable": 1,
"precision": 10,
"scale": 0,
"schemaName": "public",
"tableName": "testingtable",
"typeName": "int4",
"length": 0
}
],
"TotalNumRows": 3,
"ResultFormat": "csv"
}
```
# Décrire une table
Pour obtenir des métadonnées décrivant une table, utilisez la `aws redshift-data describe-table` AWS CLI commande.
La AWS CLI commande suivante exécute une instruction SQL sur un cluster et renvoie des métadonnées décrivant une table. Cet exemple utilise la méthode AWS Secrets Manager d'authentification.
```
aws redshift-data describe-table
--cluster-identifier mycluster-test
--database dev
--schema information_schema
--table sql_features
--secret-arn arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn
```
Voici un exemple de réponse.
```
{
"ColumnList": [
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"length": 2147483647,
"name": "feature_id",
"nullable": 1,
"precision": 2147483647,
"scale": 0,
"schemaName": "information_schema",
"tableName": "sql_features",
"typeName": "character_data"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"length": 2147483647,
"name": "feature_name",
"nullable": 1,
"precision": 2147483647,
"scale": 0,
"schemaName": "information_schema",
"tableName": "sql_features",
"typeName": "character_data"
}
]
}
```
La AWS CLI commande suivante exécute une instruction SQL sur un cluster qui décrit une table. Cet exemple utilise la méthode d’authentification par informations d’identification temporaires.
```
aws redshift-data describe-table
--db-user myuser
--cluster-identifier mycluster-test
--database dev
--schema information_schema
--table sql_features
```
Voici un exemple de réponse.
```
{
"ColumnList": [
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"length": 2147483647,
"name": "feature_id",
"nullable": 1,
"precision": 2147483647,
"scale": 0,
"schemaName": "information_schema",
"tableName": "sql_features",
"typeName": "character_data"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"length": 2147483647,
"name": "feature_name",
"nullable": 1,
"precision": 2147483647,
"scale": 0,
"schemaName": "information_schema",
"tableName": "sql_features",
"typeName": "character_data"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"length": 2147483647,
"name": "sub_feature_id",
"nullable": 1,
"precision": 2147483647,
"scale": 0,
"schemaName": "information_schema",
"tableName": "sql_features",
"typeName": "character_data"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"length": 2147483647,
"name": "sub_feature_name",
"nullable": 1,
"precision": 2147483647,
"scale": 0,
"schemaName": "information_schema",
"tableName": "sql_features",
"typeName": "character_data"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"length": 2147483647,
"name": "is_supported",
"nullable": 1,
"precision": 2147483647,
"scale": 0,
"schemaName": "information_schema",
"tableName": "sql_features",
"typeName": "character_data"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"length": 2147483647,
"name": "is_verified_by",
"nullable": 1,
"precision": 2147483647,
"scale": 0,
"schemaName": "information_schema",
"tableName": "sql_features",
"typeName": "character_data"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"length": 2147483647,
"name": "comments",
"nullable": 1,
"precision": 2147483647,
"scale": 0,
"schemaName": "information_schema",
"tableName": "sql_features",
"typeName": "character_data"
}
]
}
```
# Répertorier les bases de données dans un cluster
Pour répertorier les bases de données d'un cluster, utilisez la `aws redshift-data list-databases` AWS CLI commande.
La AWS CLI commande suivante exécute une instruction SQL sur un cluster pour répertorier les bases de données. Cet exemple utilise la méthode AWS Secrets Manager d'authentification.
```
aws redshift-data list-databases
--secret-arn arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn
--cluster-identifier mycluster-test
--database dev
```
Voici un exemple de réponse.
```
{
"Databases": [
"dev"
]
}
```
La AWS CLI commande suivante exécute une instruction SQL sur un cluster pour répertorier les bases de données. Cet exemple utilise la méthode d’authentification par informations d’identification temporaires.
```
aws redshift-data list-databases
--db-user myuser
--cluster-identifier mycluster-test
--database dev
```
Voici un exemple de réponse.
```
{
"Databases": [
"dev"
]
}
```
# Répertorier les schémas dans une base de données
Pour répertorier les schémas d'une base de données, utilisez la `aws redshift-data list-schemas` AWS CLI commande.
La AWS CLI commande suivante exécute une instruction SQL sur un cluster pour répertorier les schémas d'une base de données. Cet exemple utilise la méthode AWS Secrets Manager d'authentification.
```
aws redshift-data list-schemas
--secret-arn arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn
--cluster-identifier mycluster-test
--database dev
```
Voici un exemple de réponse.
```
{
"Schemas": [
"information_schema",
"pg_catalog",
"pg_internal",
"public"
]
}
```
La AWS CLI commande suivante exécute une instruction SQL sur un cluster pour répertorier les schémas d'une base de données. Cet exemple utilise la méthode d’authentification par informations d’identification temporaires.
```
aws redshift-data list-schemas
--db-user mysuser
--cluster-identifier mycluster-test
--database dev
```
Voici un exemple de réponse.
```
{
"Schemas": [
"information_schema",
"pg_catalog",
"pg_internal",
"public"
]
}
```
# Répertorier les tables dans une base de données
Pour répertorier les tables d'une base de données, utilisez la `aws redshift-data list-tables` AWS CLI commande.
La AWS CLI commande suivante exécute une instruction SQL sur un cluster pour répertorier les tables d'une base de données. Cet exemple utilise la méthode AWS Secrets Manager d'authentification.
```
aws redshift-data list-tables
--secret-arn arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn
--cluster-identifier mycluster-test
--database dev
--schema information_schema
```
Voici un exemple de réponse.
```
{
"Tables": [
{
"name": "sql_features",
"schema": "information_schema",
"type": "SYSTEM TABLE"
},
{
"name": "sql_implementation_info",
"schema": "information_schema",
"type": "SYSTEM TABLE"
}
}
```
La AWS CLI commande suivante exécute une instruction SQL sur un cluster pour répertorier les tables d'une base de données. Cet exemple utilise la méthode d’authentification par informations d’identification temporaires.
```
aws redshift-data list-tables
--db-user myuser
--cluster-identifier mycluster-test
--database dev
--schema information_schema
```
Voici un exemple de réponse.
```
{
"Tables": [
{
"name": "sql_features",
"schema": "information_schema",
"type": "SYSTEM TABLE"
},
{
"name": "sql_implementation_info",
"schema": "information_schema",
"type": "SYSTEM TABLE"
}
]
}
```