O Amazon Redshift não permitirá mais a criação de UDFs do Python a partir do Patch 198. As UDFs do Python existentes continuarão a funcionar normalmente até 30 de junho de 2026. Para ter mais informações, consulte a [publicação de blog ](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/).
# Chamar a API de dados
Você pode chamar a API de dados ou a AWS CLI para executar instruções SQL no cluster ou no grupo de trabalho com a tecnologia sem servidor. As principais operações para executar instruções SQL são [https://docs.aws.amazon.com/redshift-data/latest/APIReference/API_ExecuteStatement.html](https://docs.aws.amazon.com/redshift-data/latest/APIReference/API_ExecuteStatement.html) e [https://docs.aws.amazon.com/redshift-data/latest/APIReference/API_BatchExecuteStatement.html](https://docs.aws.amazon.com/redshift-data/latest/APIReference/API_BatchExecuteStatement.html) na *Referência da API de dados do Amazon Redshift*. A API de dados oferece suporte a linguagens de programação aceitas pelos AWS SDKs. Para obter mais informações, consulte [Ferramentas para construir na AWS](https://aws.amazon.com/tools/).
Para ver exemplos de código de chamada da API Data, consulte [Conceitos básicos da API Data do Redshift](https://github.com/aws-samples/getting-started-with-amazon-redshift-data-api#getting-started-with-redshift-data-api) no *GitHub*. Esse repositório tem exemplos de uso do AWS Lambda para acessar dados do Amazon Redshift pelo Amazon EC2, do AWS Glue Data Catalog e do Amazon SageMaker Runtime. Entre os exemplos de linguagens de programação estão: Python, Go, Java e Javascript.
Você pode chamar a API de dados usando a AWS CLI.
Os exemplos a seguir usam a AWS CLI para chamar a API de dados. Para executar os exemplos, edite os valores de parâmetro para corresponder ao seu ambiente. Em muitos dos exemplos, um `cluster-identifier` é fornecido para ser executado em um cluster. Ao executar em um grupo de trabalho com a tecnologia sem servidor, você fornece um `workgroup-name`. Estes exemplos demonstram algumas das operações da API de dados. Para obter mais informações, consulte a *Referência de comandos da AWS CLI*.
Os comandos nos exemplos a seguir foram divididos e formatados para facilitar a leitura. Nem todos os parâmetros e respostas são mostrados em todos os exemplos. Para obter a definição de API da sintaxe completa da solicitação, parâmetros da solicitação, sintaxe da resposta e elementos da resposta, consulte a [Referência de API de dados do Amazon Redshift](https://docs.aws.amazon.com/redshift-data/latest/APIReference/).
# Passar instruções SQL para um data warehouse do Amazon Redshift
Os exemplos nesta página mostram maneiras diferentes de passar uma instrução SQL para o data warehouse.
## Executar uma instrução SQL
Para executar uma instrução SQL, use o comando `aws redshift-data execute-statement` da AWS CLI.
O comando a seguir da AWS CLI executa uma instrução SQL em um cluster e retorna um identificador para obter os resultados. Este exemplo usa o método de autenticação 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
```
Este é um exemplo da resposta.
```
{
"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"
}
```
O comando a seguir da AWS CLI executa uma instrução SQL em um cluster e retorna um identificador para obter os resultados. Este exemplo usa o método de autenticação de credenciais temporárias.
```
aws redshift-data execute-statement
--db-user myuser
--cluster-identifier mycluster-test
--database dev
--sql "select * from stl_query limit 1"
```
Este é um exemplo da resposta.
```
{
"ClusterIdentifier": "mycluster-test",
"CreatedAt": 1598306924.632,
"Database": "dev",
"DbUser": "myuser",
"Id": "d9b6c0c9-0747-4bf4-b142-e8883122f766"
}
```
O comando a seguir da AWS CLI executa uma instrução SQL em um grupo de trabalho com a tecnologia sem servidor e retorna um identificador para obter os resultados. Este exemplo usa o método de autenticação de credenciais temporárias.
```
aws redshift-data execute-statement
--database dev
--workgroup-name myworkgroup
--sql "select 1;"
```
Este é um exemplo da resposta.
```
{
"CreatedAt": "2022-02-11T06:25:28.748000+00:00",
"Database": "dev",
"DbUser": "IAMR:RoleName",
"Id": "89dd91f5-2d43-43d3-8461-f33aa093c41e",
"WorkgroupName": "myworkgroup"
}
```
O comando a seguir da AWS CLI executa uma instrução SQL em um cluster e retorna um identificador para obter os resultados. Este exemplo usa o método de autenticação AWS Secrets Manager e um token de idempotência.
```
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
```
Este é um exemplo da resposta.
```
{
"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"
}
```
## Executar uma instrução SQL com parâmetros
Para executar uma instrução SQL, use o comando `aws redshift-data execute-statement` da AWS CLI.
O comando a seguir da AWS CLI executa uma instrução SQL em um cluster e retorna um identificador para obter os resultados. Este exemplo usa o método de autenticação AWS Secrets Manager. O texto SQL tem o parâmetro nomeado `distance`. Nesse caso, a distância usada no predicado é `5`. Em uma instrução SELECT, os parâmetros nomeados para nomes de colunas só podem ser usados no predicado. Valores para parâmetros nomeados para a instrução SQL são especificados na opção `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
```
Este é um exemplo da resposta.
```
{
"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"
}
```
O exemplo a seguir usa a tabela `EVENT` do banco de dados de amostra. Para obter mais informações, consulte [Tabela EVENT](https://docs.aws.amazon.com/redshift/latest/dg/r_eventtable.html) no *Guia do desenvolvedor de banco de dados do Amazon Redshift*.
Se você ainda não tem a tabela `EVENT` em seu banco de dados, você pode criar uma usando a API de dados da seguinte maneira:
```
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)"
```
O comando a seguir insere uma linha na tabela `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\"}]"
```
O comando a seguir insere uma segunda linha na tabela `EVENT`. Este exemplo demonstra o seguinte:
+ O parâmetro chamado `id` é usado quatro vezes no texto SQL.
+ Conversão de tipo implícita é aplicada automaticamente ao inserir o parâmetro `starttime`.
+ A coluna `venueid` é o tipo de conversão para o tipo de dados SMALLINT.
+ As strings de caracteres que representam o tipo de dados DATE são implicitamente convertidas no tipo de dados TIMESTAMP.
+ Os comentários podem ser usados dentro do texto 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\"}]"
```
O seguinte mostra as duas linhas inseridas:
```
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
```
O comando a seguir usa um parâmetro nomeado em uma cláusula WHERE para recuperar a linha em que `eventid` é `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\"}]"
```
Execute o seguinte comando para obter os resultados SQL da instrução SQL anterior:
```
aws redshift-data get-statement-result --id 7529ad05-b905-4d71-9ec6-8b333836eb5a
```
Fornece os seguintes resultados:
```
{
"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
}
```
## Executar várias instruções SQL
Para executar várias instruções SQL com um comando, use o comando `aws redshift-data batch-execute-statement` da AWS CLI.
O comando a seguir da AWS CLI executa três instruções SQL em um cluster e retorna um identificador para obter os resultados. Este exemplo usa o método de autenticação de credenciais temporárias.
```
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"
```
Este é um exemplo da resposta.
```
{
"ClusterIdentifier": "mycluster-test",
"CreatedAt": 1598306924.632,
"Database": "dev",
"DbUser": "myuser",
"Id": "d9b6c0c9-0747-4bf4-b142-e8883122f766"
}
```
# Listar metadados sobre instruções SQL
Para listar metadados sobre instruções SQL, use o comando `aws redshift-data list-statements` da AWS CLI. A autorização para executar esse comando é baseada nas permissões do IAM do autor da chamada.
O seguinte comando da AWS CLI lista as instruções SQL que foram executadas.
```
aws redshift-data list-statements
--status ALL
```
Este é um exemplo da resposta.
```
{
"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
}
]
}
```
# Descrever metadados sobre uma instrução SQL
Para obter descrições de metadados para uma instrução SQL, use o comando `aws redshift-data describe-statement` da AWS CLI. A autorização para executar esse comando é baseada nas permissões do IAM do autor da chamada.
O comando da AWS CLI a seguir descreve uma instrução SQL.
```
aws redshift-data describe-statement
--id d9b6c0c9-0747-4bf4-b142-e8883122f766
```
Este é um exemplo da resposta.
```
{
"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
}
```
Veja a seguir um exemplo de uma resposta `describe-statement` após a execução de um `batch-execute-statement` com várias instruções 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
}
```
# Buscar os resultados de uma instrução SQL
Para obter o resultado de uma instrução SQL executada, use o comando `redshift-data get-statement-result` ou `redshift-data get-statement-result-v2` da AWS CLI. Os resultados de `get-statement-result` estão no formato JSON. Os resultados de `get-statement-result-v2` estão no formato CSV. Você pode fornecer um `Id` que você recebe em resposta a `execute-statement` ou `batch-execute-statement`. O valor `Id` para uma instrução SQL executada pelo `batch-execute-statement` pode ser recuperado no resultado de `describe-statement` e recebe o sufixo de dois pontos e número de sequência, como `b2906c76-fa6e-4cdf-8c5f-4de1ff9b7652:2`. Se você executar várias instruções SQL com `batch-execute-statement`, cada instrução SQL tem um `Id` como mostrado na `describe-statement`. A autorização para executar esse comando é baseada nas permissões do IAM do autor da chamada.
A instrução a seguir gera o resultado de uma instrução SQL executada por `execute-statement` que permite que o `ResultFormat` tenha `JSON` como padrão. Para obter os resultados, chame a operação `get-statement-result`.
```
aws redshift-data get-statement-result
--id d9b6c0c9-0747-4bf4-b142-e8883122f766
```
A instrução a seguir retorna o resultado da segunda instrução SQL executada pelo `batch-execute-statement`.
```
aws redshift-data get-statement-result
--id b2906c76-fa6e-4cdf-8c5f-4de1ff9b7652:2
```
Veja a seguir um exemplo de resposta a uma chamada para `get-statement-result`, em que o resultado SQL é gerado no formato JSON na chave `Records` da resposta.
```
{
"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
}
```
O exemplo a seguir mostra uma instrução SQL executada por `execute-statement` para gerar resultados como JSON. A tabela `testingtable` tem três colunas inteiras (col1, col2, col3), e há três linhas com valores (1, 2, 3), (4, 5, 6) e (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"
}
```
Veja a seguir um exemplo de resposta a uma chamada para `get-statement-result`, em que o resultado SQL é gerado no formato JSON na chave `Records` da resposta.
```
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
}
```
O exemplo a seguir mostra uma instrução SQL executada por `execute-statement` para gerar resultados como CSV. A tabela `testingtable` tem três colunas inteiras (col1, col2, col3), e há três linhas com valores (1, 2, 3), (4, 5, 6) e (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"
}
```
Veja a seguir um exemplo de resposta a uma chamada para `get-statement-result-v2`, em que o resultado SQL é gerado no formato CSV na chave `Records` da resposta. As linhas são separadas por retorno de carro e nova linha (\$1r\$1n). A primeira linha gerada em `Records` são os títulos das colunas. Os resultados gerados no formato CSV são retornados em 1 MB, em que cada bloco pode armazenar qualquer número de linhas de até 1 MB.
```
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"
}
```
# Descrever uma tabela
Para obter metadados que descrevem uma tabela, use o comando `aws redshift-data describe-table` da AWS CLI.
O comando a seguir da AWS CLI executa uma instrução SQL em um cluster e retorna metadados que descrevem uma tabela. Este exemplo usa o método de autenticação AWS Secrets Manager.
```
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
```
Este é um exemplo da resposta.
```
{
"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"
}
]
}
```
O comando a seguir da AWS CLI executa uma instrução SQL em um cluster que descreve uma tabela. Este exemplo usa o método de autenticação de credenciais temporárias.
```
aws redshift-data describe-table
--db-user myuser
--cluster-identifier mycluster-test
--database dev
--schema information_schema
--table sql_features
```
Este é um exemplo da resposta.
```
{
"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"
}
]
}
```
# Relacionar bancos de dados em um cluster
Para listar os bancos de dados em um cluster, use o comando `aws redshift-data list-databases` da AWS CLI.
O comando a seguir da AWS CLI executa uma instrução SQL em um cluster para listar bancos de dados. Este exemplo usa o método de autenticação AWS Secrets Manager.
```
aws redshift-data list-databases
--secret-arn arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn
--cluster-identifier mycluster-test
--database dev
```
Este é um exemplo da resposta.
```
{
"Databases": [
"dev"
]
}
```
O comando a seguir da AWS CLI executa uma instrução SQL em um cluster para listar bancos de dados. Este exemplo usa o método de autenticação de credenciais temporárias.
```
aws redshift-data list-databases
--db-user myuser
--cluster-identifier mycluster-test
--database dev
```
Este é um exemplo da resposta.
```
{
"Databases": [
"dev"
]
}
```
# Relacionar esquemas em um banco de dados
Para listar os esquemas em um banco de dados, use o comando `aws redshift-data list-schemas` da AWS CLI.
O comando a seguir da AWS CLI executa uma instrução SQL em um cluster para listar esquemas em um banco de dados. Este exemplo usa o método de autenticação AWS Secrets Manager.
```
aws redshift-data list-schemas
--secret-arn arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn
--cluster-identifier mycluster-test
--database dev
```
Este é um exemplo da resposta.
```
{
"Schemas": [
"information_schema",
"pg_catalog",
"pg_internal",
"public"
]
}
```
O comando a seguir da AWS CLI executa uma instrução SQL em um cluster para listar esquemas em um banco de dados. Este exemplo usa o método de autenticação de credenciais temporárias.
```
aws redshift-data list-schemas
--db-user mysuser
--cluster-identifier mycluster-test
--database dev
```
Este é um exemplo da resposta.
```
{
"Schemas": [
"information_schema",
"pg_catalog",
"pg_internal",
"public"
]
}
```
# Relacionar tabelas em um banco de dados
Para listar as tabelas em um banco de dados, use o comando `aws redshift-data list-tables` da AWS CLI.
O comando a seguir da AWS CLI executa uma instrução SQL em um cluster para listar tabelas em um banco de dados. Este exemplo usa o método de autenticação AWS Secrets Manager.
```
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
```
Este é um exemplo da resposta.
```
{
"Tables": [
{
"name": "sql_features",
"schema": "information_schema",
"type": "SYSTEM TABLE"
},
{
"name": "sql_implementation_info",
"schema": "information_schema",
"type": "SYSTEM TABLE"
}
}
```
O comando a seguir da AWS CLI executa uma instrução SQL em um cluster para listar tabelas em um banco de dados. Este exemplo usa o método de autenticação de credenciais temporárias.
```
aws redshift-data list-tables
--db-user myuser
--cluster-identifier mycluster-test
--database dev
--schema information_schema
```
Este é um exemplo da resposta.
```
{
"Tables": [
{
"name": "sql_features",
"schema": "information_schema",
"type": "SYSTEM TABLE"
},
{
"name": "sql_implementation_info",
"schema": "information_schema",
"type": "SYSTEM TABLE"
}
]
}
```