Amazon Redshift dejará de admitir la creación de UDF de Python después del 30 de junio de 2026. Empezaremos a aplicarlo por fases. Para obtener más información sobre los detalles del fin de vida de Python y las opciones de migración, consulte la [entrada del blog](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/) que se publicó el 30 de junio de 2025.
# 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 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"
}
```
## Ejecución de instrucciones con parámetros
Puede utilizar parámetros con nombre asignado en las operaciones `execute-statement` y `batch-execute-statement`. Cuando se utiliza `batch-execute-statement`, los parámetros se comparten entre todas las instrucciones SQL del lote. Cada instrucción SQL puede hacer referencia a un subconjunto de los parámetros proporcionados, pero cada parámetro lo debe utilizar al menos una instrucción SQL.
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
}
```
El comando AWS CLI siguiente ejecuta dos instrucciones SQL con parámetros con nombres compartidos en un clúster que utiliza `batch-execute-statement`. El texto SQL tiene los parámetros con nombre `id` y `name`. La primera instrucción SQL usa el parámetro `id` y la segunda usa el parámetro `name`.
```
aws redshift-data batch-execute-statement
--db-user myuser
--cluster-identifier mycluster-test
--database dev
--sqls "SELECT * FROM mytable WHERE id = :id" "SELECT * FROM mytable WHERE name = :name"
--parameters "[{\"name\": \"id\", \"value\": \"1\"},{\"name\": \"name\", \"value\": \"Alice\"}]"
```
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 comando AWS CLI siguiente ejecuta dos instrucciones SQL en las que se utiliza el mismo parámetro en ambas instrucciones. El parámetro denominado `id` se usa en una instrucción INSERT y una instrucción SELECT.
```
aws redshift-data batch-execute-statement
--db-user myuser
--cluster-identifier mycluster-test
--database dev
--sqls "INSERT INTO mytable VALUES(:id, :name, :address)" "SELECT * FROM mytable WHERE id = :id"
--parameters "[{\"name\": \"id\", \"value\": \"1\"},{\"name\": \"name\", \"value\": \"Alice\"},{\"name\": \"address\", \"value\": \"Seattle\"}]"
```
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"
}
```