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/).
# Ejecución de comandos para definir y utilizar una base de datos en el almacenamiento de datos
Tanto el almacenamiento de datos de Redshift sin servidor como el almacenamiento de datos aprovisionado de Amazon Redshift contienen bases de datos. Una vez lanzado el almacenamiento de datos, puede administrar la mayoría de las acciones de la base de datos mediante comandos de SQL. Con pocas excepciones, la funcionalidad y la sintaxis de SQL son las mismas para todas las bases de datos de Amazon Redshift. Para obtener más información sobre los comandos de SQL disponibles con Amazon Redshift, consulte [Comandos de SQL](https://docs.aws.amazon.com/redshift/latest/dg/c_SQL_commands.html) en la *Guía para desarrolladores de bases de datos de Amazon Redshift*.
Al crear el almacenamiento de datos, en la mayoría de los casos, Amazon Redshift también crea la base de datos `dev` predeterminada. Después de conectarse a la base de datos `dev`, puede crear otra base de datos.
En las siguientes secciones, se describen las tareas de bases de datos más comunes cuando se trabaja con bases de datos de Amazon Redshift. Las tareas comienzan con la creación de una base de datos y, si continúa hasta la última tarea, puede eliminar todos los recursos que haya creado mediante la eliminación de la base de datos.
Los ejemplos de esta sección suponen lo siguiente:
+ Ha creado un almacenamiento de datos de Amazon Redshift.
+ Ha establecido una conexión con el almacenamiento de datos desde su herramienta de cliente de SQL, como el editor de consultas de Amazon Redshift v2. Para obtener más información acerca del editor de consultas v2, visite [Consulta de una base de datos mediante el editor de consultas v2 de Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2.html) en la *Guía de administración de Amazon Redshift*.
**Topics**
+ [Conexión a almacenamientos de datos de Amazon Redshift](#connection)
+ [Creación de una base de datos de](t_creating_database.md)
+ [Creación de un usuario](t_adding_redshift_user_cmd.md)
+ [Crear un esquema](t_creating_schema.md)
+ [Creación de una tabla](t_creating_table.md)
+ [Carga de datos](cm-dev-t-load-sample-data.md)
+ [Consulta de las tablas y las vistas del sistema](t_querying_redshift_system_tables.md)
+ [Cancelación de una consulta](cancel_query.md)
## Conexión a almacenamientos de datos de Amazon Redshift
Para conectarse a clústeres de Amazon Redshift, en la consola de Amazon Redshift, en la página **Clústeres**, amplíe **Conectarse a clústeres de Amazon Redshift** y realice alguna de las siguientes operaciones:
+ Seleccione **Consultar datos** para usar el editor de consultas v2 para ejecutar consultas en las bases de datos alojadas en el clúster de Amazon Redshift. Después de crear su clúster, puede ejecutar consultas de forma inmediata mediante el editor de consultas v2.
Para obtener más información, consulte [Consulta de una base de datos mediante el editor de consultas de Amazon Redshift v2](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2.html) en la *Guía de administración de Amazon Redshift*.
+ En **Trabajar con las herramientas de cliente**, seleccione el clúster y conéctese a Amazon Redshift desde sus herramientas de cliente mediante controladores JDBC u ODBC. Para ello, copie la URL del controlador JDBC u ODBC. Utilice esta URL desde la instancia o el equipo cliente. Cifre sus aplicaciones para utilizar operaciones de API de acceso a datos JDBC u ODBC o utilice las herramientas de cliente SQL que sean compatibles con JDBC o bien con ODBC.
Para obtener más información acerca de cómo encontrar la cadena de conexión de clúster, consulte [Obtención de la cadena de conexión a su clúster](https://docs.aws.amazon.com/redshift/latest/mgmt/configuring-connections.html#connecting-drivers.html).
+ Si la herramienta de cliente de SQL requiere un controlador, puede **Elegir el controlador JDBC u ODBC** para descargar un controlador específico del sistema operativo para conectarse a Amazon Redshift desde sus herramientas de cliente.
Para obtener más información acerca de cómo instalar el controlador adecuado para su cliente SQL, consulte [Configuración de una conexión de controlador JDBC versión 2.2](https://docs.aws.amazon.com/redshift/latest/mgmt/jdbc20-install.html).
Para obtener más información acerca de cómo configurar una conexión ODBC, consulte [Configuración de una conexión ODBC](https://docs.aws.amazon.com/redshift/latest/mgmt/configure-odbc-connection.html).
Para conectarse al almacenamiento de datos de Redshift sin servidor, desde la página del **Panel sin servidor** de la consola de Amazon Redshift, realice una de las siguientes acciones:
+ Utilice el editor de consultas de Amazon Redshift v2 para ejecutar consultas en las bases de datos alojadas en el almacenamiento de datos de Redshift sin servidor. Después de crear su almacenamiento de datos, puede ejecutar consultas de forma inmediata mediante el editor de consultas v2.
Para obtener más información, vea [Consulta de una base de datos mediante el editor de consultas v2 de Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2.html).
+ Conéctese a Amazon Redshift desde sus herramientas de cliente mediante controladores JDBC u ODBC a través de la copia de la URL del controlador JDBC u ODBC.
Para trabajar con datos en su almacenamiento de datos, necesita controladores JDBC u ODBC con objeto de establecer una conectividad desde su equipo cliente o instancia. Cifre sus aplicaciones para utilizar operaciones de API de acceso a datos JDBC u ODBC o utilice las herramientas de cliente SQL que sean compatibles con JDBC o bien con ODBC.
Para obtener más información sobre cómo encontrar la cadena de conexión, consulte [Conexión a Redshift sin servidor](https://docs.aws.amazon.com/redshift/latest/mgmt/serverless-connecting) en la *Guía de administración de Amazon Redshift*.
# Creación de una base de datos de
Después de comprobar que su almacenamiento de datos está activo y en ejecución, puede crear una base de datos. Esta base de datos es donde crea tablas, carga datos y ejecuta consultas. Un almacenamiento de datos puede alojar varias bases de datos. Por ejemplo, puede tener una base de datos para los datos de ventas llamada `SALESDB` y otra para los datos de los pedidos llamada `ORDERSDB` en el mismo almacenamiento de datos.
Para crear una base de datos denominada **SALESDB**, ejecute el siguiente comando en la herramienta de cliente de SQL.
```
CREATE DATABASE salesdb;
```
**nota**
Tras ejecutar el comando, asegúrese de actualizar la lista de objetos de la herramienta del cliente de SQL del almacenamiento de datos para ver la nueva `salesdb`.
Para este ejercicio, acepte los valores predeterminados. Para obtener más información acerca de opciones de comandos, consulte [CREAR BASE DE DATOS](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_DATABASE) en la *Guía para desarrolladores de bases de datos de Amazon Redshift*. Para eliminar una base de datos y su contenido, consulte [DROP DATABASE](https://docs.aws.amazon.com/redshift/latest/dg/r_DROP_DATABASE) en la *Guía para desarrolladores de bases de datos de Amazon Redshift*.
Después de haber creado la base de datos SALESDB, puede conectarse a la base de datos nueva desde su cliente SQL. Utilice los mismos parámetros de conexión que utilizó en su conexión actual, pero cambie el nombre de la base de datos por `SALESDB`.
# Creación de un usuario
De manera predeterminada, solo el usuario administrador que haya creado cuando lanzó el almacenamiento de datos tiene acceso a la base de datos predeterminada del almacenamiento de datos. Para otorgarles acceso a otros usuarios, cree una o más cuentas. Las cuentas de usuario de base de datos se aplican globalmente a todas las bases de datos de un almacenamiento de datos y no pertenecen a bases de datos individuales.
Utilice el comando CREATE USER para crear un nuevo usuario. Al crear un nuevo usuario, debe especificar el nombre del usuario nuevo y una contraseña. Le recomendamos que especifique una contraseña para el usuario. Debe tener entre 8 y 64 caracteres y debe incluir al menos una letra en mayúsculas, una letra en minúsculas y un número.
Por ejemplo, para crear un usuario llamado **GUEST** con la contraseña **ABCd4321**, ejecute el siguiente comando.
```
CREATE USER GUEST PASSWORD 'ABCd4321';
```
Para conectarse a la base de datos `SALESDB` como el usuario `GUEST`, utilice la misma contraseña que usó al crear el usuario, como `ABCd4321`.
Para obtener información acerca de otras opciones de comandos, consulte [CREATE USER](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_USER.html) en la *Guía para desarrolladores de bases de datos de Amazon Redshift*.
# Crear un esquema
Después de crear una nueva base de datos, puede crear un nuevo esquema en la base de datos actual. Un *esquema* es un espacio de nombres que contiene objetos de base de datos nombrados como tablas, vistas y funciones definidas por el usuario (UDF). Una base de datos puede contener uno o más esquemas, y cada esquema pertenece solo a una base de datos. Dos esquemas pueden tener objetos diferentes que comparten el mismo nombre.
Puede crear varios esquemas en la misma base de datos para organizar los datos de la forma que desee o para agrupar los datos funcionalmente. Por ejemplo, puede crear un esquema para almacenar todos los datos transitorios y otro esquema para almacenar todas las tablas de informes. También puede crear esquemas diferentes para almacenar datos relevantes para diferentes grupos empresariales que se encuentran en la misma base de datos. Cada esquema puede almacenar diferentes objetos de base de datos, como tablas, vistas y funciones definidas por el usuario (UDF). Además, puede crear esquemas con la cláusula AUTHORIZATION. Esta cláusula otorga la propiedad a un usuario especificado o establece una cuota en la cantidad máxima de espacio en disco que puede utilizar el esquema especificado.
Amazon Redshift crea automáticamente un esquema llamado `public` para cada nueva base de datos. Cuando no especifica el nombre del esquema al crear objetos de base de datos, los objetos entran en el esquema `public`.
Para acceder a un objeto de un esquema, califique el objeto mediante la notación `schema_name.table_name`. El nombre calificado del esquema consiste en el nombre del esquema y el nombre de la tabla separados por un punto. Por ejemplo, es posible que tenga un esquema de `sales` que tiene una tabla de `price` y un esquema de `inventory` que también tiene una tabla de `price`. Cuando se refiere a la tabla `price`, debe calificarla como `sales.price` o `inventory.price`.
En el siguiente ejemplo, se crea un esquema denominado **SALES** para el usuario `GUEST`.
```
CREATE SCHEMA SALES AUTHORIZATION GUEST;
```
Para obtener más información acerca de otras opciones de comandos, consulte [CREATE SCHEMA](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_SCHEMA.html) en la *Guía para desarrolladores de bases de datos de Amazon Redshift*.
Para ver la lista de esquemas de la base de datos, ejecute el siguiente comando.
```
select * from pg_namespace;
```
El resultado debería parecerse al siguiente:
```
nspname | nspowner | nspacl
----------------------+----------+--------------------------
sales | 100 |
pg_toast | 1 |
pg_internal | 1 |
catalog_history | 1 |
pg_temp_1 | 1 |
pg_catalog | 1 | {rdsdb=UC/rdsdb,=U/rdsdb}
public | 1 | {rdsdb=UC/rdsdb,=U/rdsdb}
information_schema | 1 | {rdsdb=UC/rdsdb,=U/rdsdb}
```
Para obtener más información acerca de cómo consultar tablas de catálogo, consulte [Consulta de las tablas de catálogos](https://docs.aws.amazon.com/redshift/latest/dg/c_join_PG.html) en la *Guía para desarrolladores de bases de datos de Amazon Redshift*.
Utilice la instrucción GRANT para conceder permisos a usuarios para los esquemas.
En el siguiente ejemplo, se concede privilegio al usuario `GUEST` para seleccionar datos de todas las tablas o vistas en el esquema `SALES` con la instrucción SELECT.
```
GRANT SELECT ON ALL TABLES IN SCHEMA SALES TO GUEST;
```
En el siguiente ejemplo, se conceden a la vez todos los privilegios disponibles al usuario `GUEST`.
```
GRANT ALL ON SCHEMA SALES TO GUEST;
```
# Creación de una tabla
Después de crear su base de datos nueva, cree tablas para almacenar sus datos. Al crear la tabla, especifique la información de las columnas.
Por ejemplo, para crear una tabla llamada **DEMO**, ejecute el siguiente comando.
```
CREATE TABLE Demo (
PersonID int,
City varchar (255)
);
```
De manera predeterminada, los objetos nuevos de la base de datos, como las tablas, se crean en el esquema predeterminado denominado `public`, que se creó con el almacenamiento de datos. Puede utilizar otro esquema para crear objetos de base de datos. Para obtener más información acerca de esquemas, consulte [Administración de la seguridad de las bases de datos](https://docs.aws.amazon.com/redshift/latest/dg/r_Database_objects.html) en la *Guía para desarrolladores de bases de datos de Amazon Redshift*.
También puede crear una tabla con la notación `schema_name.object_name` para crear la tabla en el esquema de `SALES`.
```
CREATE TABLE SALES.DEMO (
PersonID int,
City varchar (255)
);
```
Para ver y revisar esquemas y sus tablas, puede utilizar el editor de consultas de Amazon Redshift v2. También puede ver la lista de tablas en esquemas con las vistas del sistema. Para obtener más información, consulte [Consulta de las tablas y las vistas del sistema](t_querying_redshift_system_tables.md).
Amazon Redshift utiliza las columnas `encoding`, `distkey` y `sortkey` para el procesamiento en paralelo. Para obtener más información acerca del diseño de tablas que incorporan estos elementos, consulte [Prácticas recomendadas de Amazon Redshift para diseñar tablas](https://docs.aws.amazon.com/redshift/latest/dg/c_designing-tables-best-practices.html).
## Inserción de filas de datos en una tabla
Después de crear una tabla, inserte filas de datos en esa tabla.
**nota**
El comando [INSERT](https://docs.aws.amazon.com/redshift/latest/dg/r_INSERT_30.html) inserta filas en una tabla. Para cargas masivas estándar, utilice el comando [COPY](https://docs.aws.amazon.com/redshift/latest/dg/r_COPY.html). Para obtener más información, consulte [Uso del comando COPY para cargar datos](https://docs.aws.amazon.com/redshift/latest/dg/c_best-practices-use-copy.html).
Por ejemplo, para insertar valores en la tabla `DEMO`, ejecute el siguiente comando.
```
INSERT INTO DEMO VALUES (781, 'San Jose'), (990, 'Palo Alto');
```
Para insertar datos en una tabla que está en un esquema específico, ejecute el siguiente comando.
```
INSERT INTO SALES.DEMO VALUES (781, 'San Jose'), (990, 'Palo Alto');
```
## Selección de datos de una tabla
Después de crear una tabla y rellenarla con datos, utilice una instrucción SELECT para mostrar los datos que tiene la tabla. La instrucción SELECT\$1 devuelve todos los nombres de columnas y los valores de filas de todos los datos de una tabla. El uso de SELECT es una buena forma de verificar que los datos que se hayan agregado recientemente se insertaron en la tabla de forma correcta.
Para ver los datos ingresados en la tabla **DEMO**, ejecute el siguiente comando.
```
SELECT * from DEMO;
```
El resultado debe ser similar a lo siguiente.
```
personid | city
----------+-----------
781 | San Jose
990 | Palo Alto
(2 rows)
```
Para obtener más información acerca del uso de la instrucción SELECT para consultar tablas, consulte [SELECT](https://docs.aws.amazon.com/redshift/latest/dg/r_SELECT_synopsis.html).
# Carga de datos
En muchos ejemplos de esta guía, se usa un conjunto de datos de muestra de TICKIT. Puede descargar el archivo [tickitdb.zip](samples/tickitdb.zip) que contiene archivos de datos de muestra individuales. A continuación, puede cargar los datos de muestra en su propio bucket de Amazon S3.
Para cargar los datos de muestra de la base de datos, cree primero las tablas. A continuación, utilice el comando COPY para cargar las tablas con datos de muestra almacenados en un bucket de Amazon S3. Si desea ver los pasos necesarios para crear tablas y cargar datos de muestra, consulte [Paso 4: Cargar datos desde Amazon S3 en Amazon Redshift](new-user.md#rs-gsg-create-sample-db).
# Consulta de las tablas y las vistas del sistema
Además de las tablas que crea, su almacenamiento de datos contiene una serie de tablas y vistas del sistema. Estas tablas y vistas de sistema tienen información relacionada con la instalación y con las diferentes consultas y procesos que se están ejecutando en el sistema. Puede consultar estas tablas y vistas de sistema para recopilar información relacionada con su base de datos. Para obtener más información, consulte [Referencia de las tablas y vistas de sistema](https://docs.aws.amazon.com/redshift/latest/dg/cm_chap_system-tables.html) en la *Guía para desarrolladores de bases de datos de Amazon Redshift*. La descripción de cada tabla o vista indica si una tabla es visible para todos los usuarios o si es visible solo para los superusuarios. Inicie sesión como superusuario para consultar las tablas que son visibles solo para los superusuarios.
## Vista de una lista de los nombres de las tablas
Para ver una lista de todas las tablas de un esquema, puede consultar la tabla de catálogo del sistema PG\$1TABLE\$1DEF. En primer lugar, puede examinar la configuración de `search_path`.
```
SHOW search_path;
```
El resultado debería ser similar al siguiente.
```
search_path
---------------
$user, public
```
En el siguiente ejemplo, se agrega el esquema `SALES` en la ruta de búsqueda y muestra todas las tablas en el esquema `SALES`.
```
set search_path to '$user', 'public', 'sales';
SHOW search_path;
search_path
------------------------
"$user", public, sales
select * from pg_table_def where schemaname = 'sales';
schemaname | tablename | column | type | encoding | distkey | sortkey | notnull
------------+-----------+----------+------------------------+----------+---------+---------+---------
sales | demo | personid | integer | az64 | f | 0 | f
sales | demo | city | character varying(255) | lzo | f | 0 | f
```
En el siguiente ejemplo, se muestra una lista de todas las tablas llamadas `DEMO` en todos los esquemas de la base de datos actual.
```
set search_path to '$user', 'public', 'sales';
select * from pg_table_def where tablename = 'demo';
schemaname | tablename | column | type | encoding | distkey | sortkey | notnull
------------+-----------+----------+------------------------+----------+---------+---------+---------
public | demo | personid | integer | az64 | f | 0 | f
public | demo | city | character varying(255) | lzo | f | 0 | f
sales | demo | personid | integer | az64 | f | 0 | f
sales | demo | city | character varying(255) | lzo | f | 0 | f
```
Para obtener más información, consulte [PG\$1TABLE\$1DEF](https://docs.aws.amazon.com/redshift/latest/dg/r_PG_TABLE_DEF.html).
También puede utilizar el editor de consultas de Amazon Redshift v2 para ver todas las tablas de un esquema especificado si elige primero una base de datos a la que desea conectarse.
## Ver usuarios
Puede consultar el catálogo PG\$1USER para ver una lista de todos los usuarios, junto con el ID de usuario (USESYSID) y los privilegios de usuario.
```
SELECT * FROM pg_user;
usename | usesysid | usecreatedb | usesuper | usecatupd | passwd | valuntil | useconfig
------------+----------+-------------+----------+-----------+----------+----------+-----------
rdsdb | 1 | true | true | true | ******** | infinity |
awsuser | 100 | true | true | false | ******** | |
guest | 104 | true | false | false | ******** | |
```
Amazon Redshift utiliza internamente el nombre de usuario `rdsdb` para realizar tareas administrativas y de mantenimiento de rutina. Puede filtrar su consulta para que solo se vean los nombres de usuario definidos por el usuario si agrega `where usesysid > 1` a la instrucción SELECT.
```
SELECT * FROM pg_user WHERE usesysid > 1;
usename | usesysid | usecreatedb | usesuper | usecatupd | passwd | valuntil | useconfig
------------+----------+-------------+----------+-----------+----------+----------+-----------
awsuser | 100 | true | true | false | ******** | |
guest | 104 | true | false | false | ******** | |
```
## Vista de consultas recientes
En el ejemplo anterior, el ID de usuario (user\$1id) para `adminuser` es 100. Para encontrar las cuatro consultas más recientes que ejecutó `adminuser`, puede consultar la vista SYS\$1QUERY\$1HISTORY.
Puede utilizar esta vista para encontrar el ID de consulta (query\$1id) o el ID de proceso (session\$1id) para una consulta ejecutada recientemente. También puede utilizar esta vista para verificar cuánto demora en completarse una consulta. SYS\$1QUERY\$1HISTORY incluye los primeros 4000 caracteres de la cadena de consulta (query\$1text) para ayudarle a localizar una consulta específica. Utilice la cláusula LIMIT con la instrucción SELECT para limitar los resultados.
```
SELECT query_id, session_id, elapsed_time, query_text
FROM sys_query_history
WHERE user_id = 100
ORDER BY start_time desc
LIMIT 4;
```
El resultado es similar al siguiente:
```
query_id | session_id | elapsed_time | query_text
----------+--------------+---------------+----------------------------------------------------------------
892 | 21046 | 55868 | SELECT query, pid, elapsed, substring from ...
620 | 17635 | 1296265 | SELECT query, pid, elapsed, substring from ...
610 | 17607 | 82555 | SELECT * from DEMO;
596 | 16762 | 226372 | INSERT INTO DEMO VALUES (100);
```
## Determinación del ID de sesión de una consulta en ejecución
Es posible que tenga que especificar el ID de sesión (ID de proceso) asociado a la consulta para recuperar información de las tablas del sistema sobre una consulta. También es posible que necesite encontrar el ID de sesión para una consulta que sigue en ejecución. Por ejemplo, necesita el ID de sesión si debe cancelar una consulta que está tardando mucho en ejecutarse en un clúster aprovisionado. Puede consultar la tabla del sistema STV\$1RECENTS para obtener una lista de los ID de sesión de las consultas en ejecución, junto con la cadena de consulta correspondiente. Si su consulta devuelve múltiples sesiones, puede analizar el texto de la consulta para determinar cuál es el ID de sesión que necesita.
Para determinar el ID de sesión de una consulta en ejecución, ejecute la siguiente instrucción SELECT.
```
SELECT session_id, user_id, start_time, query_text
FROM sys_query_history
WHERE status='running';
```
# Cancelación de una consulta
Si ejecuta una consulta que tarda mucho tiempo o que consume demasiados recursos, cancélela. Por ejemplo, cree una lista de vendedores de tickets que incluya el nombre del vendedor y la cantidad de tickets que vendió. La siguiente consulta selecciona los datos de la tabla `SALES` y de la tabla `USERS` y une las dos tablas haciendo coincidir los parámetros SELLERID y USERID en la cláusula WHERE.
```
SELECT sellerid, firstname, lastname, sum(qtysold)
FROM sales, users
WHERE sales.sellerid = users.userid
GROUP BY sellerid, firstname, lastname
ORDER BY 4 desc;
```
El resultado es similar al siguiente:
```
sellerid | firstname | lastname | sum
----------+-----------+----------+------
48950 | Nayda | Hood | 184
19123 | Scott | Simmons | 164
20029 | Drew | Mcguire | 164
36791 | Emerson | Delacruz | 160
13567 | Imani | Adams | 156
9697 | Dorian | Ray | 156
41579 | Harrison | Durham | 156
15591 | Phyllis | Clay | 152
3008 | Lucas | Stanley | 148
44956 | Rachel |Villarreal| 148
```
**nota**
Se trata de una consulta compleja. Para este tutorial, no necesita preocuparse por cómo se construye esta consulta.
La consulta anterior se ejecuta en segundos y devuelve 2102 filas.
Suponga que se olvida de incorporar la cláusula WHERE.
```
SELECT sellerid, firstname, lastname, sum(qtysold)
FROM sales, users
GROUP BY sellerid, firstname, lastname
ORDER BY 4 desc;
```
El conjunto de resultados incluye todas las filas de la tabla `SALES` multiplicadas por todas las filas de la tabla `USERS` (49 989 x 3766). Esta es una unión cartesiana, la que no se recomienda. El resultado es de más de 188 millones de filas y toma mucho tiempo de ejecución.
Para cancelar una consulta en ejecución, utilice el comando CANCEL con el ID de sesión de la consulta. Con el editor de consultas de Amazon Redshift v2, puede cancelar una consulta pulsando el botón Cancelar mientras la consulta está en ejecución.
Para encontrar el ID de sesión, comience una nueva sesión y consulte la tabla STV\$1RECENTS, tal como se muestra en el paso anterior. En el siguiente ejemplo, se muestra cómo puede hacer que los resultados sean más fáciles de leer. Para ello, utilice la función TRIM para eliminar espacios finales y mostrar solo los primero 20 caracteres de la cadena de consulta.
Para determinar el ID de sesión de una consulta en ejecución, ejecute la siguiente instrucción SELECT.
```
SELECT user_id, session_id, start_time, query_text
FROM sys_query_history
WHERE status='running';
```
El resultado es similar al siguiente:
```
user_id | session_id | start_time | query_text
---------+---------------+----------------------------+----------------------------------------------------------------
100 | 1073791534 | 2024-03-19 22:26:21.205739 | SELECT user_id, session_id, start_time, query_text FROM ...
```
Para cancelar la consulta con el ID de sesión `1073791534`, ejecute el siguiente comando.
```
CANCEL 1073791534;
```
**nota**
El comando CANCEL no detiene una transacción. Para detener o revertir una transacción, debe utilizar el comando ABORT o ROLLBACK. Para cancelar una consulta asociada a una transacción, primero cancele la consulta y, luego, detenga la transacción.
Si la consulta que canceló está asociada con una transacción, utilice el comando ABORT o ROLLBACK para cancelar la transacción y descartar los cambios realizados en los datos:
```
ABORT;
```
A menos que haya iniciado una sesión de superusuario, solo puede cancelar sus propias consultas. Un superusuario puede cancelar todas las consultas.
Si su herramienta de consulta no admite la ejecución de consultas de manera simultánea, inicie otra sesión para cancelar la consulta.
Para obtener más información acerca de la cancelación de una consulta, consulte [CANCEL](https://docs.aws.amazon.com/redshift/latest/dg/r_CANCEL.html) en la *Guía para desarrolladores de bases de datos de Amazon Redshift*.
## Cancelación de una consulta mediante la cola de superusuario
Si su sesión actual tiene demasiadas consultas ejecutándose de forma simultánea, es posible que no pueda ejecutar el comando CANCEL hasta que termine otra consulta. En ese caso, ejecute el comando CANCEL con una cola de consulta de administración de cargas de trabajo diferente.
Al usar la administración de cargas de trabajo, puede ejecutar consultas en diferentes colas de consulta para no tener que esperar que se complete otra consulta. El administrador de cargas de trabajo crea una cola independiente, denominada cola de superusuario, que puede utilizar para solucionar problemas. Para utilizar la cola de superusuario, inicie una sesión de superusuario y configure el grupo de consultas como “superusuario” con el comando SET. Después de ejecutar los comandos, restablezca el grupo de consultas con el comando RESET.
Para cancelar una consulta mediante la cola de superusuario, ejecute estos comandos.
```
SET query_group TO 'superuser';
CANCEL 1073791534;
RESET query_group;
```