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/).
# Executar comandos para definir e usar um banco de dados no data warehouse
Tanto os data warehouses do Redshift sem servidor quanto os data warehouses provisionados do Amazon Redshift contêm bancos de dados. Depois que o data warehouse é iniciado, é possível gerenciar a maioria das ações do banco de dados usando comandos SQL. Com poucas exceções, a funcionalidade e a sintaxe do SQL são as mesmas para todos os bancos de dados do Amazon Redshift. Para ter detalhes sobre os comandos SQL disponíveis com o Amazon Redshift, consulte [Comandos SQL](https://docs.aws.amazon.com/redshift/latest/dg/c_SQL_commands.html) no Guia do desenvolvedor de banco de dados do *Amazon Redshift*.
Quando se cria um data warehouse, o Amazon Redshift também cria o banco de dados `dev` padrão na maioria das situações. Após a conexão com o banco de dados `dev`, é possível criar outro banco de dados.
As seções a seguir descrevem tarefas comuns de banco de dados quando se trabalha com bancos de dados do Amazon Redshift. As tarefas começam com a criação de um banco de dados e, se você prosseguir até a última tarefa, poderá descartar o banco de dados para excluir todos os recursos criados.
Para os exemplos nesta seção, suponha o seguinte:
+ Você criou um data warehouse do Amazon Redshift.
+ Você estabeleceu uma conexão com o data warehouse por meio de sua ferramenta de cliente SQL, como o Editor de Consultas do Amazon Redshift v2. Para ter mais informações sobre o Editor de Consultas v2, confira [Consultar um banco de dados usando o editor de consultas v2 do Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2.html) no *Guia de gerenciamento do Amazon Redshift*.
**Topics**
+ [Conectar-se a data warehouses de dados do Amazon Redshift](#connection)
+ [Criar um banco de dados](t_creating_database.md)
+ [Criar um usuário](t_adding_redshift_user_cmd.md)
+ [Criar um esquema](t_creating_schema.md)
+ [Criar uma tabela](t_creating_table.md)
+ [Carregar dados](cm-dev-t-load-sample-data.md)
+ [Consultar as visualizações e tabelas do sistema](t_querying_redshift_system_tables.md)
+ [Cancelar uma consulta](cancel_query.md)
## Conectar-se a data warehouses de dados do Amazon Redshift
Para se conectar a clusters do Amazon Redshift, na página **Clusters** do console do Amazon Redshift, expanda **Conectar-se a clusters do Amazon Redshift** e siga um destes procedimentos:
+ Selecione **Consultar dados** para usar o Editor de Consultas v2 e executar consultas em bancos de dados hospedados pelo cluster do Amazon Redshift. Depois de criar o cluster, é possível executar consultas imediatamente usando o editor de consultas v2.
Para ter mais informações, confira [Consultar um banco de dados usando o editor de consultas v2 do Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2.html) no *Guia de gerenciamento do Amazon Redshift*.
+ Em **Trabalhar com ferramentas de cliente**, selecione o cluster e conecte-se ao Amazon Redshift por meio de suas ferramentas de cliente. Para isso, utilize drivers JDBC ou ODBC copiando o URL do driver JDBC ou ODBC. Use esse URL do computador cliente ou da instância. Escreva o código de suas aplicações de modo que usem as operações de API de acesso a dados do JDBC ou do ODBC ou use as ferramentas do cliente SQL que oferecem suporte a JDBC ou ODBC.
Para obter mais informações sobre como encontrar a string de conexão do cluster, consulte [Encontrar a string de conexão do cluster](https://docs.aws.amazon.com/redshift/latest/mgmt/configuring-connections.html#connecting-drivers.html).
+ Se a ferramenta de cliente SQL exigir um driver, você poderá **Escolher um driver JDBC ou ODBC** para baixar um driver específico do sistema operacional para se conectar ao Amazon Redshift por meio de suas ferramentas de cliente.
Para obter mais informações sobre como instalar o driver apropriado para o cliente SQL, consulte [Configurar uma conexão do driver JDBC versão 2.2](https://docs.aws.amazon.com/redshift/latest/mgmt/jdbc20-install.html).
Para obter mais informações sobre como configurar uma conexão ODBC, consulte [Configurar uma conexão ODBC](https://docs.aws.amazon.com/redshift/latest/mgmt/configure-odbc-connection.html).
Para se conectar ao data warehouse do Redshift sem servidor, na página **Painel da tecnologia sem servidor** do console do Amazon Redshift, faça o seguinte:
+ Use o Editor de Consultas do Amazon Redshift v2 para executar consultas em bancos de dados hospedados pelo data warehouse do Redshift sem servidor. Após a criação do data warehouse, é possível executar consultas imediatamente usando o Editor de Consultas v2.
Para obter mais informações, acesse [Consultar um banco de dados usando o editor de consultas v2 do Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2.html).
+ Conecte-se ao Amazon Redshift a partir de suas ferramentas de cliente com drivers JDBC ou ODBC copiando a URL do driver JDBC ou ODBC.
Para trabalhar com dados no data warehouse, são necessários drivers JDBC ou ODBC para estabelecer conexão do computador cliente ou da instância. Escreva o código de suas aplicações de modo que usem as operações de API de acesso a dados do JDBC ou do ODBC ou use as ferramentas do cliente SQL que oferecem suporte a JDBC ou ODBC.
Para ter mais informações sobre como encontrar a string de conexão, consulte [Conectar-se ao Amazon Redshift Serverless](https://docs.aws.amazon.com/redshift/latest/mgmt/serverless-connecting) no *Guia de gerenciamento do Amazon Redshift*.
# Criar um banco de dados
Depois de verificar se o data warehouse está funcionando, você pode criar um banco de dados. Este banco de dados é onde você realmente cria tabelas, carrega dados e executa consultas. Um data warehouse pode hospedar vários bancos de dados. Por exemplo, é possível ter um banco de dados para dados de vendas denominado `SALESDB` e um banco de dados para dados de pedidos chamado `ORDERSDB` no mesmo data warehouse.
Para criar um banco de dados chamado **SALESDB**, execute o comando a seguir na ferramenta de cliente SQL.
```
CREATE DATABASE salesdb;
```
**nota**
Depois de executar o comando, não se esqueça de atualizar a lista de objetos da ferramenta de cliente SQL no data warehouse para ver o novo `salesdb`.
Para este exercício, aceite os padrões. Para obter informações sobre mais opções de comando, consulte [CREATE DATABASE](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_DATABASE) no *Guia do desenvolvedor de banco de dados do Amazon Redshift*. Para excluir um banco de dados e o respectivo conteúdo, consulte [DROP DATABASE](https://docs.aws.amazon.com/redshift/latest/dg/r_DROP_DATABASE) no *Guia do desenvolvedor do Amazon Redshift*.
Depois de criar o banco de dados SALESDB, você pode se conectar ao novo banco de dados a partir de seu cliente SQL. Use os mesmos parâmetros de conexão usados para a conexão atual, mas altere o nome do banco de dados para `SALESDB`.
# Criar um usuário
Por padrão, apenas o usuário administrador que você criou ao iniciar o data warehouse tem acesso ao banco de dados padrão no data warehouse. Para conceder acesso a outros usuários, crie uma ou mais contas. As contas de usuário do banco de dados são globais em todos os bancos de dados em um data warehouse e não por banco de dados individual.
Use o comando CREATE USER para criar um novo usuário. Ao criar um novo usuário, especifique o nome do novo usuário e uma senha. Recomendamos que você especifique uma senha para o usuário. Deve ter de 8 a 64 caracteres e incluir pelo menos uma letra maiúscula, uma letra minúscula e um numeral.
Por exemplo, para criar um usuário nomeado **GUEST** com senha **ABCd4321**, execute o comando a seguir.
```
CREATE USER GUEST PASSWORD 'ABCd4321';
```
Para se conectar ao banco de dados `SALESDB` como usuário `GUEST`, use a mesma senha quando você criou o usuário, como`ABCd4321`.
Para obter informações sobre mais opções de comando, consulte [CREATE USER](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_USER.html) no *Guia do desenvolvedor de banco de dados do Amazon Redshift*.
# Criar um esquema
Depois de criar um novo banco de dados, você pode criar um novo esquema no banco de dados atual. Um *esquema* um namespace que contém objetos nomeados de banco de dados, como tabelas, exibições e funções definidas pelo usuário (UDFs). Um banco de dados pode conter um ou vários esquemas, e cada esquema pertence a apenas um banco de dados. Dois esquemas podem ter objetos diferentes que compartilham o mesmo nome.
Você pode criar vários esquemas no mesmo banco de dados para organizar dados da maneira que você deseja ou agrupar seus dados funcionalmente. Por exemplo, você pode criar um esquema para armazenar todos os dados de preparação e outro esquema para armazenar todas as tabelas de relatórios. Você também pode criar esquemas diferentes para armazenar dados relevantes para diferentes grupos de negócios que estão no mesmo banco de dados. Cada esquema pode armazenar objetos diferentes de banco de dados, como tabelas, exibições e funções definidas pelo usuário (UDFs). Além disso, você pode criar esquemas com a cláusula AUTHORIZATION. Esta cláusula fornece propriedade a um usuário especificado ou define uma cota na quantidade máxima de espaço em disco que o esquema especificado pode usar.
O Amazon Redshift cria automaticamente um esquema chamado `public` para cada novo banco de dados. Quando você não especifica o nome do esquema ao criar objetos de banco de dados, os objetos entram no esquema `public`.
Para acessar um objeto em um esquema, qualifique o objeto usando a notação `schema_name.table_name`. O nome qualificado do esquema consiste no nome do esquema e no nome da tabela separados por um ponto. Por exemplo, você pode ter um esquema `sales` que tem uma tabela `price` e um esquema `inventory` que também tem uma tabela `price`. Quando você se refere à tabela `price`, você deve qualificá-la como `sales.price` ou `inventory.price`.
O exemplo a seguir cria um esquema chamado **SALES** para o usuário `GUEST`.
```
CREATE SCHEMA SALES AUTHORIZATION GUEST;
```
Para obter informações sobre mais opções de comando, consulte [CREATE SCHEMA](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_SCHEMA.html) no *Guia do desenvolvedor de banco de dados do Amazon Redshift*.
Para visualizar a lista de esquemas em seu banco de dados, execute o seguinte comando.
```
select * from pg_namespace;
```
A saída deve ser semelhante à seguinte.
```
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 obter mais informações sobre como consultar tabelas de catálogo, consulte [Consultar tabelas de catálogo](https://docs.aws.amazon.com/redshift/latest/dg/c_join_PG.html) no *Guia do desenvolvedor de banco de dados do Amazon Redshift*.
Use a instrução GRANT para dar permissões aos usuários para os esquemas.
O exemplo a seguir concede privilégios ao usuário `GUEST` para selecionar dados de todas as tabelas ou visualizações no esquema `SALES` usando uma declaração SELECT.
```
GRANT SELECT ON ALL TABLES IN SCHEMA SALES TO GUEST;
```
O exemplo a seguir concede todos os privilégios disponíveis de uma vez ao usuário `GUEST`.
```
GRANT ALL ON SCHEMA SALES TO GUEST;
```
# Criar uma tabela
Depois de criar seu novo banco de dados, crie tabelas para armazenar seus dados. Especifique as informações de colunas ao criar a tabela.
Por exemplo, para criar uma tabela chamada **DEMO**, execute o comando a seguir.
```
CREATE TABLE Demo (
PersonID int,
City varchar (255)
);
```
Por padrão, novos objetos de banco de dados, como tabelas, são criados no esquema padrão denominado `public` que foi criado simultaneamente com o data warehouse. Você pode usar outro esquema para criar objetos de banco de dados. Para obter mais informações sobre esquemas, consulte [Gerenciando a segurança do banco de dados](https://docs.aws.amazon.com/redshift/latest/dg/r_Database_objects.html) no *Guia do desenvolvedor de banco de dados do Amazon Redshift*.
Você também pode criar uma tabela usando a notação `schema_name.object_name` para criar a tabela no esquema `SALES`.
```
CREATE TABLE SALES.DEMO (
PersonID int,
City varchar (255)
);
```
Para visualizar e inspecionar esquemas e as respectivas tabelas, é possível usar o Editor de Consultas do Amazon Redshift v2. Ou você pode ver a lista de tabelas em esquemas usando visualizações do sistema. Para obter mais informações, consulte [Consultar as visualizações e tabelas do sistema](t_querying_redshift_system_tables.md).
As colunas `encoding`, `distkey` e `sortkey` são usadas pelo Amazon Redshift para processamento paralelo. Para obter mais informações sobre como projetar tabelas que incorporam esses elementos, consulte [Práticas recomendadas do Amazon Redshift para projetar tabelas](https://docs.aws.amazon.com/redshift/latest/dg/c_designing-tables-best-practices.html).
## Inserir linhas de dados em uma tabela
Depois de criar uma tabela, insira linhas de dados nessa tabela.
**nota**
O comando [INSERT](https://docs.aws.amazon.com/redshift/latest/dg/r_INSERT_30.html) linhas em uma tabela. Para carregamentos em massa padrão, use o comando [COPY](https://docs.aws.amazon.com/redshift/latest/dg/r_COPY.html). Para obter mais informações, consulte [Usar um comando COPY para carregar dados](https://docs.aws.amazon.com/redshift/latest/dg/c_best-practices-use-copy.html).
Por exemplo, para inserir valores na tabela `DEMO`, execute o comando a seguir.
```
INSERT INTO DEMO VALUES (781, 'San Jose'), (990, 'Palo Alto');
```
Para inserir dados em uma tabela que está em um esquema específico, execute o comando a seguir.
```
INSERT INTO SALES.DEMO VALUES (781, 'San Jose'), (990, 'Palo Alto');
```
## Selecionar dados de uma tabela
Após criar uma tabela e preenche-la com dados, use a instrução SELECT para exibir os dados contidos na tabela. A instrução SELECT \$1 retorna todos os nomes de colunas e valores de linha de todos os dados de uma tabela. O uso do SELECT é uma boa forma de verificar se os dados adicionados recentemente foram inseridos corretamente na tabela.
Para visualizar os dados inseridos na tabela **DEMO**, execute o comando a seguir.
```
SELECT * from DEMO;
```
O resultado deve ser algo semelhante ao exibido a seguir.
```
personid | city
----------+-----------
781 | San Jose
990 | Palo Alto
(2 rows)
```
Para obter mais informações sobre como usar a instrução SELECT para consultar tabelas, consulte [SELECT](https://docs.aws.amazon.com/redshift/latest/dg/r_SELECT_synopsis.html).
# Carregar dados
A maioria dos exemplos neste guia usa o conjunto de dados de exemplo TICKIT. Baixe o arquivo [tickitdb.zip](samples/tickitdb.zip) que contém os arquivos de dados de amostra individuais. Depois, você pode carregar os dados de exemplo em seu próprio bucket do Amazon S3.
Para carregar os dados de exemplo do banco de dados, primeiro crie as tabelas. Depois, use o comando COPY para carregar as tabelas com os dados de exemplo que estão armazenados em um bucket do Amazon S3. Para ver as etapas de criação de tabelas e carregamento de dados de amostra, consulte [Etapa 4: Carregar dados do Amazon S3 para o Amazon Redshift](new-user.md#rs-gsg-create-sample-db).
# Consultar as visualizações e tabelas do sistema
Além das tabelas que você criou, o data warehouse contém uma série de tabelas e visualizações do sistema. Essas visualizações e tabelas contêm informações sobre a instalação e sobre várias consultas e processos que são executados no sistema. É possível consultar essas visualizações e tabelas do sistema para coletar informações sobre o banco de dados. Para ter mais informações, consulte [Referência de visualizações e tabelas do sistema](https://docs.aws.amazon.com/redshift/latest/dg/cm_chap_system-tables.html) no *Guia do desenvolvedor de banco de dados do Amazon Redshift*. A descrição de cada tabela ou visualização indica se uma tabela é visível para todos os usuários ou apenas para superusuários. Efetue login como superusuário para consultar tabelas que são visíveis apenas para superusuários.
## Visualização de uma lista de nomes de tabelas
Para ver uma lista de todas as tabelas em um esquema, você pode consultar a tabela de catálogo do sistema PG\$1TABLE\$1DEF. Você pode primeiro examinar a configuração para `search_path`.
```
SHOW search_path;
```
O resultado deve ser semelhante ao seguinte:
```
search_path
---------------
$user, public
```
O exemplo a seguir inclui o esquema `SALES` para o caminho de pesquisa e mostra todas as tabelas do 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
```
O exemplo a seguir mostra uma lista de todas as tabelas chamadas `DEMO` em todos os esquemas do banco de dados atual.
```
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 obter mais informações, consulte [PG\$1TABLE\$1DEF](https://docs.aws.amazon.com/redshift/latest/dg/r_PG_TABLE_DEF.html).
Também é possível usar o Editor de Consultas do Amazon Redshift v2 para exibir todas as tabelas em um esquema especificado escolhendo primeiro um banco de dados ao qual você deseja se conectar.
## Visualização dos usuários
Você pode consultar o catálogo PG\$1USER para ver uma lista de todos os usuários, junto com o ID do usuário (USESYSID) e os privilégios do usuário.
```
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 | ******** | |
```
O nome de usuário `rdsdb` é usado internamente pelo Amazon Redshift para realizar tarefas administrativas e de manutenção de rotina. Você pode filtrar sua consulta para mostrar apenas nomes de usuário definidos pelo usuário, adicionando `where usesysid > 1` à sua instrução 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 | ******** | |
```
## Visualização de consultas recentes
No exemplo anterior, o ID do usuário (user\$1id) para `adminuser` é 100. Para listar as quatro consultas mais recentes executadas por `adminuser`, consulte a visualização SYS\$1QUERY\$1HISTORY.
É possível usar essa visualização para localizar o ID da consulta (QUERY) ou o ID do processo (session\$1id) para uma consulta executada recentemente. Você também pode usar esta visualização para verificar quanto tempo levou para uma consulta ser concluída. SYS\$1QUERY\$1HISTORY inclui os primeiros quatro mil caracteres da string de consulta (query\$1text) para ajudar você a localizar uma consulta específica. Use a cláusula LIMIT com a declaração SELECT para limitar os 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;
```
O resultado será semelhante ao seguinte:
```
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);
```
## Determinar o ID da sessão de uma consulta em execução
Para recuperar informações da tabela do sistema sobre uma consulta, pode ser necessário especificar o ID da sessão (ID do processo) associado a essa consulta. Ou pode ser necessário encontrar o ID da sessão de uma consulta que ainda esteja em execução. Por exemplo, você precisará do ID da sessão se houver necessidade de cancelar uma consulta que está demorando muito para ser executada em um cluster provisionado. É possível consultar a tabela do sistema STV\$1RECENTS para ter uma lista de IDs de sessão das consultas em execução, além da string da consulta correspondente. Se a consulta exibir várias sessões, examine o texto da consulta para determinar qual ID de sessão é necessário.
Para determinar o ID da sessão de uma consulta em execução, execute a declaração SELECT a seguir.
```
SELECT session_id, user_id, start_time, query_text
FROM sys_query_history
WHERE status='running';
```
# Cancelar uma consulta
Se você executar uma consulta que esteja demorando muito ou consumindo uma quantidade excessiva de recursos, cancele-a. Por exemplo, crie uma lista de vendedores de ingressos que inclua o nome do vendedor e a quantidade de ingressos vendidos. A consulta a seguir seleciona dados da tabela `SALES` e da tabela `USERS` e une as duas tabelas, correspondendo SELLERID e USERID na 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;
```
O resultado é parecido com o mostrado a seguir.
```
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**
Essa é uma consulta complexa. Para este tutorial, não se preocupe em saber como a consulta foi criada.
A consulta anterior é executada em segundos e retornará 2.102 linhas.
Suponha que você se esqueça de inserir a cláusula WHERE.
```
SELECT sellerid, firstname, lastname, sum(qtysold)
FROM sales, users
GROUP BY sellerid, firstname, lastname
ORDER BY 4 desc;
```
O conjunto de resultados inclui todas as linhas da tabela `SALES` multiplicadas por todas as linhas da tabela `USERS` (49989\$13766). Isso é chamado de junção cartesiana, e não é uma prática recomendada. O resultado é mais de 188 milhões linhas e o tempo de execução é bastante longo.
Para cancelar uma consulta em execução, use o comando CANCEL com o ID da sessão da consulta. Com o Editor de Consultas do Amazon Redshift v2, é possível cancelar uma consulta escolhendo o botão Cancelar enquanto a consulta está em execução.
Para localizar o ID da sessão, inicie uma nova sessão e consulte a tabela STV\$1RECENTS, conforme mostrado na etapa anterior. O exemplo a seguir mostra como você pode fazer os resultados mais legíveis. Para fazer isso, use a função TRIM para cortar os espaços à direita e mostrar somente os 20 primeiros caracteres da consulta.
Para determinar o ID da sessão de uma consulta em execução, execute a declaração SELECT a seguir.
```
SELECT user_id, session_id, start_time, query_text
FROM sys_query_history
WHERE status='running';
```
O resultado é parecido com o mostrado a seguir.
```
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 a consulta com o ID de sessão `1073791534`, execute o comando a seguir.
```
CANCEL 1073791534;
```
**nota**
O comando CANCEL não interrompe uma transação. Para parar ou reverter uma transação, use o comando ABORT ou ROLLBACK. Para cancelar uma consulta associada a uma transação, primeiro cancele a consulta e pare a transação.
Se a consulta que você cancelou estiver associada a uma transação, use o comando ABORT ou ROLLBACK para cancelar a transação e descartar quaisquer alterações feitas nos dados:
```
ABORT;
```
A menos que esteja conectado como um superusuário, você só pode cancelar suas próprias consultas. Os superusuários podem cancelar todas as consultas.
Se sua ferramenta de consulta não oferece suporte à execução de consultas simultaneamente, inicie outra sessão para cancelar a consulta.
Para ter mais informações sobre cancelamento de uma consulta, confira [CANCEL](https://docs.aws.amazon.com/redshift/latest/dg/r_CANCEL.html) no *Guia do desenvolvedor de banco de dados do Amazon Redshift*.
## Cancelar uma consulta usando a fila de superusuários
Se a sua sessão atual tiver muitas consultas sendo executadas simultaneamente, talvez não seja possível executar o comando CANCEL até que uma outra consulta seja concluída. Nesse caso, execute o comando CANCEL usando uma fila de consulta de gerenciamento de workload diferente.
Usando o gerenciamento de workload, você pode executar consultas em diferentes filas de consulta para que não precise esperar a conclusão de outra consulta. O gerenciador de workload cria uma fila separada, chamada a fila de superusuários, que você pode usar quando estiver solucionando problemas. Para usar a fila Superusuário, faça logon em um superusuário e defina o grupo de consulta como “superusuário” usando o comando SET. Depois de executar os comandos, redefina o grupo de consultas usando o comando RESET.
Para cancelar uma consulta usando a fila de superusuários, execute estes comandos:
```
SET query_group TO 'superuser';
CANCEL 1073791534;
RESET query_group;
```