Amazon Redshift dejará de admitir la creación de nuevas UDF de Python a partir del parche 198. Las UDF de Python existentes seguirán funcionando hasta el 30 de junio de 2026. Para obtener más información, consulte la [publicación del blog](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/).
# Llamadas a la API de datos
Se puede llamar a la API de datos o a la AWS CLI a fin de ejecutar instrucciones SQL en el clúster o grupo de trabajo sin servidor. Las operaciones principales para ejecutar instrucciones SQL son [https://docs.aws.amazon.com/redshift-data/latest/APIReference/API_ExecuteStatement.html](https://docs.aws.amazon.com/redshift-data/latest/APIReference/API_ExecuteStatement.html) y [https://docs.aws.amazon.com/redshift-data/latest/APIReference/API_BatchExecuteStatement.html](https://docs.aws.amazon.com/redshift-data/latest/APIReference/API_BatchExecuteStatement.html) en la *Referencia de API de datos de Amazon Redshift*. La API de datos admite los lenguajes de programación compatibles con el AWS SDK. Para obtener más información sobre estos, consulte [Herramientas para crear en AWS](https://aws.amazon.com/tools/).
Para ver ejemplos de código de llamadas a la API de datos, consulte la [Introducción a la API de datos de Redshift](https://github.com/aws-samples/getting-started-with-amazon-redshift-data-api#getting-started-with-redshift-data-api) en *GitHub*. Este repositorio contiene ejemplos de uso de AWS Lambda para acceder a los datos de Amazon Redshift desde Amazon EC2, AWS Glue Data Catalog y Amazon SageMaker Runtime. Los lenguajes de programación de ejemplo incluyen Python, Go, Java y Javascript.
Puede llamar a la API de datos utilizando la AWS CLI.
En los siguientes ejemplos, se utiliza la AWS CLI para llamar a la API de datos. Para ejecutar los ejemplos, edite los valores de los parámetros para que se ajusten a su entorno. En muchos de los ejemplos se proporciona un `cluster-identifier` que se ejecuta en un clúster. Cuando se ejecuta en un grupo de trabajo sin servidor, se debe proporcionar un `workgroup-name` en su lugar. En estos ejemplos, se demuestran algunas de las operaciones de la API de datos. Para obtener más información, consulte *Referencia de comandos de la AWS CLI*.
Los comandos que figuran en los siguientes ejemplos se han dividido y se han formateado para facilitar su lectura. No todos los parámetros y respuestas se muestran en todos los ejemplos. Para ver la definición de la API de la sintaxis completa de la solicitud, los parámetros de la solicitud, la sintaxis de respuesta y los elementos de respuesta, consulte la [Referencia de la API de datos de Amazon Redshift](https://docs.aws.amazon.com/redshift-data/latest/APIReference/).
# Transferencia de instrucciones SQL a un almacenamiento de datos de Amazon Redshift
Los ejemplos de esta página describen diferentes formas de transferir una instrucción SQL al almacenamiento de datos
## Ejecución de una instrucción SQL
Para ejecutar una instrucción SQL, utilice el comando AWS CLI de la `aws redshift-data execute-statement`.
El siguiente comando de la AWS CLI ejecuta una instrucción SQL en un clúster y devuelve un identificador que permite obtener los resultados. En este ejemplo, se utiliza el método de autenticación de 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
```
A continuación se muestra un ejemplo de respuesta.
```
{
"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"
}
```
El siguiente comando de la AWS CLI ejecuta una instrucción SQL en un clúster y devuelve un identificador que permite obtener los resultados. En este ejemplo, se utiliza el método de autenticación de credenciales temporales.
```
aws redshift-data execute-statement
--db-user myuser
--cluster-identifier mycluster-test
--database dev
--sql "select * from stl_query limit 1"
```
A continuación se muestra un ejemplo de respuesta.
```
{
"ClusterIdentifier": "mycluster-test",
"CreatedAt": 1598306924.632,
"Database": "dev",
"DbUser": "myuser",
"Id": "d9b6c0c9-0747-4bf4-b142-e8883122f766"
}
```
El siguiente comando de la AWS CLI ejecuta una instrucción SQL en un grupo de trabajo sin servidor y devuelve un identificador que permite obtener los resultados. En este ejemplo, se utiliza el método de autenticación de credenciales temporales.
```
aws redshift-data execute-statement
--database dev
--workgroup-name myworkgroup
--sql "select 1;"
```
A continuación se muestra un ejemplo de respuesta.
```
{
"CreatedAt": "2022-02-11T06:25:28.748000+00:00",
"Database": "dev",
"DbUser": "IAMR:RoleName",
"Id": "89dd91f5-2d43-43d3-8461-f33aa093c41e",
"WorkgroupName": "myworkgroup"
}
```
El siguiente comando de la AWS CLI ejecuta una instrucción SQL en un clúster y devuelve un identificador que permite obtener los resultados. En este ejemplo se utiliza el método de autenticación de AWS Secrets Manager y un token de idempotencia.
```
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
```
A continuación se muestra un ejemplo de respuesta.
```
{
"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"
}
```
## Ejecución de una instrucción SQL con parámetros
Para ejecutar una instrucción SQL, utilice el comando AWS CLI de la `aws redshift-data execute-statement`.
El siguiente comando de la AWS CLI ejecuta una instrucción SQL en un clúster y devuelve un identificador que permite obtener los resultados. En este ejemplo, se utiliza el método de autenticación de AWS Secrets Manager. El texto SQL tiene el parámetro con nombre `distance`. En este caso, la distancia utilizada en el predicado es `5`. En una instrucción SELECT, los parámetros con nombre de los nombres de columna solo se pueden usar en el predicado. Los valores de los parámetros con nombre para la instrucción SQL se especifican en la opción `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
```
A continuación se muestra un ejemplo de respuesta.
```
{
"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"
}
```
En el siguiente ejemplo, se utiliza la tabla `EVENT` de la base de datos de muestra. Para obtener más información, consulte [Tabla EVENT](https://docs.aws.amazon.com/redshift/latest/dg/r_eventtable.html) en la *Guía para desarrolladores de bases de datos de Amazon Redshift.*.
Si aún no dispone de una tabla `EVENT` en la base de datos, puede crear una con la API de datos de la siguiente manera:
```
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)"
```
El siguiente comando inserta una fila en la tabla `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\"}]"
```
El siguiente comando inserta una segunda fila en la tabla `EVENT`. Este ejemplo hace lo siguiente:
+ El parámetro con nombre `id` se utiliza cuatro veces en el texto SQL.
+ La conversión del tipo implícita se aplica automáticamente cuando se inserta un parámetro `starttime`.
+ La columna `venueid` se convierte en un tipo de datos SMALLINT.
+ Las cadenas de caracteres que representan el tipo de datos DATE se convierten de forma implícita en el tipo de datos TIMESTAMP.
+ Los comentarios se pueden emplear en el 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\"}]"
```
A continuación, se muestran las dos filas que se han insertado:
```
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
```
El siguiente comando utiliza un parámetro con nombre en una cláusula WHERE que permite recuperar la fila donde `eventid` es `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\"}]"
```
Ejecute el siguiente comando para obtener los resultados SQL de la instrucción SQL precedente:
```
aws redshift-data get-statement-result --id 7529ad05-b905-4d71-9ec6-8b333836eb5a
```
Proporciona los siguientes 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
}
```
## Ejecución de varias instrucciones SQL
Para ejecutar varias instrucciones SQL con un solo comando, utilice el comando `aws redshift-data batch-execute-statement` de la AWS CLI.
El siguiente comando de la AWS CLI ejecuta tres instrucciones SQL en un clúster y devuelve un identificador que permite obtener los resultados. En este ejemplo, se utiliza el método de autenticación de credenciales temporales.
```
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"
```
A continuación se muestra un ejemplo de respuesta.
```
{
"ClusterIdentifier": "mycluster-test",
"CreatedAt": 1598306924.632,
"Database": "dev",
"DbUser": "myuser",
"Id": "d9b6c0c9-0747-4bf4-b142-e8883122f766"
}
```
# Muestra de metadatos sobre las instrucciones SQL
Para enumerar los metadatos relativos a las instrucciones SQL, utilice el comando `aws redshift-data list-statements` de la AWS CLI. La autorización para ejecutar este comando se basa en los permisos de IAM de la persona que llama.
El siguiente comando de la AWS CLI enumera las instrucciones SQL que se ejecutaron.
```
aws redshift-data list-statements
--status ALL
```
A continuación se muestra un ejemplo de respuesta.
```
{
"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
}
]
}
```
# Descripción de metadatos sobre una instrucción SQL
Para obtener descripciones de los metadatos de una instrucción SQL, utilice el comando `aws redshift-data describe-statement` de la AWS CLI. La autorización para ejecutar este comando se basa en los permisos de IAM de la persona que llama.
El siguiente comando de la AWS CLI describe una instrucción SQL.
```
aws redshift-data describe-statement
--id d9b6c0c9-0747-4bf4-b142-e8883122f766
```
A continuación se muestra un ejemplo de respuesta.
```
{
"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
}
```
A continuación, se muestra un ejemplo de una respuesta `describe-statement` que surge después de ejecutar un comando `batch-execute-statement` con varias instrucciones 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
}
```
# Obtención de los resultados de una instrucción SQL
Para obtener el resultado de una instrucción de SQL que ya se ejecutó, utilice el comando `redshift-data get-statement-result` o `redshift-data get-statement-result-v2` de la AWS CLI. Los resultados de `get-statement-result` están en formato JSON. Los resultados de `get-statement-result-v2` están en formato CSV. Puede proporcionar un `Id` que reciba en respuesta a `execute-statement` o `batch-execute-statement`. El valor `Id` para una instrucción SQL ejecutada por `batch-execute-statement` se puede recuperar en el resultado de `describe-statement` y lleva como sufijo dos puntos y un número de secuencia, como `b2906c76-fa6e-4cdf-8c5f-4de1ff9b7652:2`. Si ejecuta varias instrucciones SQL con `batch-execute-statement`, cada una de ellas tiene un valor `Id` como se muestra en `describe-statement`. La autorización para ejecutar este comando se basa en los permisos de IAM de la persona que llama.
La siguiente instrucción devuelve el resultado de una instrucción de SQL que se ejecuta mediante `execute-statement` que hace que `ResultFormat` utilice `JSON` de manera predeterminada. Para recuperar los resultados, llame a la operación `get-statement-result`.
```
aws redshift-data get-statement-result
--id d9b6c0c9-0747-4bf4-b142-e8883122f766
```
La siguiente instrucción devuelve el resultado de la segunda instrucción SQL que se ejecuta mediante `batch-execute-statement`.
```
aws redshift-data get-statement-result
--id b2906c76-fa6e-4cdf-8c5f-4de1ff9b7652:2
```
A continuación, se muestra un ejemplo de una respuesta a una llamada a `get-statement-result` en la que se devuelve el resultado de SQL en formato JSON en la clave `Records` de la respuesta.
```
{
"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
}
```
En el siguiente ejemplo, se muestra una instrucción de SQL ejecutada por `execute-statement` para devolver resultados en formato JSON. La tabla `testingtable` tiene tres columnas de enteros (col1, col2, col3) y hay tres filas con valores (1, 2, 3), (4, 5, 6) y (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"
}
```
A continuación, se muestra un ejemplo de una respuesta a una llamada a `get-statement-result` en la que se devuelve el resultado de SQL en formato JSON en la clave `Records` de la respuesta.
```
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
}
```
En el siguiente ejemplo, se muestra una instrucción de SQL ejecutada por `execute-statement` para devolver resultados en formato CSV. La tabla `testingtable` tiene tres columnas de enteros (col1, col2, col3) y hay tres filas con valores (1, 2, 3), (4, 5, 6) y (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"
}
```
A continuación, se muestra un ejemplo de una respuesta a una llamada a `get-statement-result-v2` en la que se devuelve el resultado de SQL en formato CSV en la clave `Records` de la respuesta. Las filas están separadas por un retorno de carro y una línea nueva (\$1r\$1n). La primera fila devuelta en `Records` son los encabezados de columna. Los resultados en formato CSV se devuelven en fragmentos de 1 MB y cada fragmento puede almacenar cualquier número de filas de hasta 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"
}
```
# Descripción de una tabla
Para obtener los metadatos que describen una tabla, utilice el comando `aws redshift-data describe-table` de la AWS CLI.
El siguiente comando de la AWS CLI ejecuta una instrucción SQL en un clúster y devuelve los metadatos que describen una tabla. En este ejemplo, se utiliza el método de autenticación de 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
```
A continuación se muestra un ejemplo de respuesta.
```
{
"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"
}
]
}
```
El siguiente comando de la AWS CLI ejecuta una instrucción SQL en un clúster que describe una tabla. En este ejemplo, se utiliza el método de autenticación de credenciales temporales.
```
aws redshift-data describe-table
--db-user myuser
--cluster-identifier mycluster-test
--database dev
--schema information_schema
--table sql_features
```
A continuación se muestra un ejemplo de respuesta.
```
{
"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"
}
]
}
```
# Enumeración de las bases de datos de un clúster
Para enumerar las bases de datos de un clúster, utilice el comando `aws redshift-data list-databases` de la AWS CLI.
El siguiente comando de la AWS CLI ejecuta una instrucción SQL en un clúster para mostrar bases de datos. En este ejemplo, se utiliza el método de autenticación de 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
```
A continuación se muestra un ejemplo de respuesta.
```
{
"Databases": [
"dev"
]
}
```
El siguiente comando de la AWS CLI ejecuta una instrucción SQL en un clúster para mostrar bases de datos. En este ejemplo, se utiliza el método de autenticación de credenciales temporales.
```
aws redshift-data list-databases
--db-user myuser
--cluster-identifier mycluster-test
--database dev
```
A continuación se muestra un ejemplo de respuesta.
```
{
"Databases": [
"dev"
]
}
```
# Enumeración de los esquemas de una base de datos
Para enumerar los esquemas de una base de datos, utilice el comando `aws redshift-data list-schemas` de la AWS CLI.
El siguiente comando de la AWS CLI ejecuta una instrucción SQL en un clúster para mostrar esquemas en una base de datos. En este ejemplo, se utiliza el método de autenticación de 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
```
A continuación se muestra un ejemplo de respuesta.
```
{
"Schemas": [
"information_schema",
"pg_catalog",
"pg_internal",
"public"
]
}
```
El siguiente comando de la AWS CLI ejecuta una instrucción SQL en un clúster para mostrar esquemas en una base de datos. En este ejemplo, se utiliza el método de autenticación de credenciales temporales.
```
aws redshift-data list-schemas
--db-user mysuser
--cluster-identifier mycluster-test
--database dev
```
A continuación se muestra un ejemplo de respuesta.
```
{
"Schemas": [
"information_schema",
"pg_catalog",
"pg_internal",
"public"
]
}
```
# Enumeración de tablas de una base de datos
Para enumerar las tablas de una base de datos, utilice el comando `aws redshift-data list-tables` de la AWS CLI.
El siguiente comando de la AWS CLI ejecuta una instrucción SQL en un clúster para mostrar tablas en una base de datos. En este ejemplo, se utiliza el método de autenticación de 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
```
A continuación se muestra un ejemplo de respuesta.
```
{
"Tables": [
{
"name": "sql_features",
"schema": "information_schema",
"type": "SYSTEM TABLE"
},
{
"name": "sql_implementation_info",
"schema": "information_schema",
"type": "SYSTEM TABLE"
}
}
```
El siguiente comando de la AWS CLI ejecuta una instrucción SQL en un clúster para mostrar tablas en una base de datos. En este ejemplo, se utiliza el método de autenticación de credenciales temporales.
```
aws redshift-data list-tables
--db-user myuser
--cluster-identifier mycluster-test
--database dev
--schema information_schema
```
A continuación se muestra un ejemplo de respuesta.
```
{
"Tables": [
{
"name": "sql_features",
"schema": "information_schema",
"type": "SYSTEM TABLE"
},
{
"name": "sql_implementation_info",
"schema": "information_schema",
"type": "SYSTEM TABLE"
}
]
}
```