Amazon Redshift non supporterà più la creazione di nuovi Python UDFs a partire dalla Patch 198. Python esistente UDFs continuerà a funzionare fino al 30 giugno 2026. Per ulteriori informazioni, consulta il [post del blog](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/).
Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Eseguire comandi per definire e utilizzare un database nel data warehouse
Sia i data warehouse Redshift serverless che i data warehouse con provisioning Amazon Redshift contengono database. Dopo avere avviato il data warehouse, puoi gestire la maggior parte delle azioni del database utilizzando i comandi SQL. Salvo qualche eccezione, la funzionalità e la sintassi di SQL sono le stesse per tutti i database Amazon Redshift. Per i dettagli dei comandi SQL disponibili con Amazon Redshift, consulta [Comandi SQL](https://docs.aws.amazon.com/redshift/latest/dg/c_SQL_commands.html) nella *Guida per sviluppatori di database di Amazon Redshift*.
Quando crei un data warehouse, nella maggior parte degli scenari, Amazon Redshift crea anche il database `dev` predefinito. Dopo la connessione al database `dev` puoi creare un nuovo database.
Nelle sezioni seguenti vengono illustrate le attività comuni dei database quando utilizzi i database Amazon Redshift. Le attività iniziano con la creazione di un database e, se continui fino all’ultima attività, puoi eliminare tutte le risorse create rimuovendo il database.
Per gli esempi in questa sezione si assume quanto riportato di seguito:
+ Hai creato un data warehouse Amazon Redshift.
+ Hai stabilito una connessione al data warehouse dallo strumento del client SQL, come Amazon Redshift Query Editor V2. Per ulteriori informazioni su Query Editor V2, consulta [Esecuzione di query su un database con Amazon Redshift Query Editor V2](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2.html) nella *Guida alla gestione di Amazon Redshift*.
**Topics**
+ [Connessione ai data warehouse Amazon Redshift](#connection)
+ [Creazione di un database](t_creating_database.md)
+ [Creazione di un utente](t_adding_redshift_user_cmd.md)
+ [Creare uno schema](t_creating_schema.md)
+ [Creare una tabella](t_creating_table.md)
+ [Caricare i dati](cm-dev-t-load-sample-data.md)
+ [Eseguire query sulle tabelle e sulle viste di sistema](t_querying_redshift_system_tables.md)
+ [Annullare una query](cancel_query.md)
## Connessione ai data warehouse Amazon Redshift
Per connetterti ai cluster Amazon Redshift, nella pagina **Cluster** della console Amazon Redshift espandi **Connettiti ai cluster Amazon Redshift** ed effettua una delle seguenti operazioni:
+ Scegli **Esegui query sui dati** per utilizzare Query Editor V2 per eseguire query sui database ospitati dal cluster Amazon Redshift. Dopo aver creato il cluster, puoi eseguire immediatamente le query con l'editor della query v2.
Per ulteriori informazioni, consulta [Esecuzione di query su un database con Amazon Redshift Query Editor V2](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2.html) nella *Guida alla gestione di Amazon Redshift*.
+ In **Usa gli strumenti client** scegli il cluster e connettiti ad Amazon Redshift dagli strumenti client con i driver JDBC oppure ODBC copiando l’URL del driver JDBC oppure ODBC. Utilizza questo URL dal computer o dall’istanza client. Codifica le tue applicazioni affinché usino operazioni API di accesso ai dati JDBC o ODBC e gli strumenti del client SQL che supportano JDBC o ODBC.
Per ulteriori informazioni su come trovare la stringa di connessione del cluster, consultare [Ricerca della stringa di connessione al cluster](https://docs.aws.amazon.com/redshift/latest/mgmt/configuring-connections.html#connecting-drivers.html).
+ Se lo strumento del client SQL richiede un driver, puoi **scegliere il driver JDBC oppure ODBC** per scaricare un driver specifico del sistema operativo per connetterti ad Amazon Redshift dagli strumenti client.
Per ulteriori informazioni su come installare il driver appropriato per il client SQL, vedere [Configurazione di una connessione del driver JDBC versione 2.2.](https://docs.aws.amazon.com/redshift/latest/mgmt/jdbc20-install.html)
Per ulteriori informazioni su come configurare una connessione ODBC, consultare [Configurazione di una connessione ODBC](https://docs.aws.amazon.com/redshift/latest/mgmt/configure-odbc-connection.html).
Per connetterti al data warehouse Redshift serverless, dalla pagina **Pannello di controllo serverless** della console Amazon Redshift, esegui una delle seguenti operazioni:
+ Utilizza Amazon Redshift Query Editor V2 per eseguire query sui database ospitati dal data warehouse Redshift serverless. Dopo avere creato il data warehouse, puoi eseguire immediatamente le query utilizzando Query Editor V2.
Per ulteriori informazioni, consultare [Esecuzione di query su un database con l'editor di query v2 di Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2.html).
+ Connettiti ad Amazon Redshift dagli strumenti client utilizzando i driver JDBC o ODBC copiando l'URL del driver JDBC o ODBC.
Per utilizzare i dati nel data warehouse, hai bisogno dei driver JDBC oppure ODBC per stabilire la connettività dal computer o dall’istanza client. Codifica le tue applicazioni affinché usino operazioni API di accesso ai dati JDBC o ODBC e gli strumenti del client SQL che supportano JDBC o ODBC.
Per ulteriori informazioni su come trovare la stringa di connessione, consulta [Connessione a Redshift serverless](https://docs.aws.amazon.com/redshift/latest/mgmt/serverless-connecting) nella *Guida alla gestione di Amazon Redshift*.
# Creazione di un database
Dopo avere verificato che il data warehouse è attivo e in esecuzione, puoi creare un database. Il database è l'elemento in cui effettivamente saranno create tabelle, saranno caricati i dati e saranno eseguite le query. Un data warehouse può ospitare più database. Ad esempio, puoi avere un database per i dati di vendita denominati `SALESDB` e un database per i dati degli ordini denominati `ORDERSDB` nello stesso data warehouse.
Per creare un database denominato **SALESDB**, esegui il comando seguente nello strumento del client SQL.
```
CREATE DATABASE salesdb;
```
**Nota**
Dopo avere eseguito il comando, assicurati di aggiornare l’elenco degli oggetti degli strumenti del client SQL nel data warehouse per visualizzare il nuovo `salesdb`.
Per questo esercizio, accetteremo le impostazioni predefinite. Per informazioni sulle opzioni di altri comandi, consultare [CREATE DATABASE](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_DATABASE) nella *Guida per gli sviluppatori di database di Amazon Redshift*. Per eliminare un database e il relativo contenuto, consulta [DROP DATABASE](https://docs.aws.amazon.com/redshift/latest/dg/r_DROP_DATABASE) nella *Guida per sviluppatori di database di Amazon Redshift*.
Dopo aver creato il database SALESDB, sarà possibile connettersi al nuovo database dal client SQL. Usa gli stessi parametri di connessione usati per la connessione corrente, ma modifica il nome del database in `SALESDB`.
# Creazione di un utente
Per impostazione predefinita, solo l’utente amministratore creato all’avvio del data warehouse ha accesso al database predefinito nel data warehouse. Per concedere l'accesso ad altri utenti, è necessario creare uno o più account. Gli account utente dei database sono globali per tutti i database in un data warehouse e non appartengono a singoli database.
Utilizzare il comando CREATE USER per creare un nuovo utente. Quando crei un nuovo utente, devi specificare il nome del nuovo utente e una password. Si consiglia di specificare una password per l'utente. Deve essere costituita da 8 a 64 caratteri e deve includere almeno una lettera maiuscola, una minuscola e un valore numerico.
Ad esempio, per creare un utente denominato **GUEST** con la password **ABCd4321**, emettere il comando seguente:
```
CREATE USER GUEST PASSWORD 'ABCd4321';
```
Per connettersi al database `SALESDB` come utente `GUEST`, utilizzare la stessa password utilizzata al momento della creazione dell'utente, ad esempio `ABCd4321`.
Per informazioni sulle opzioni di altri comandi, consultare [CREATE USER](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_USER.html) nella *Guida per gli sviluppatori di database di Amazon Redshift*.
# Creare uno schema
Dopo aver creato un nuovo database, è possibile creare un nuovo schema nel database corrente. Uno *schema è uno* spazio dei nomi che contiene oggetti di database denominati come tabelle, viste e funzioni definite dall'utente (). UDFs Un database può contenere uno o più schemi e ogni schema appartiene a un solo database. Due schemi possono avere oggetti diversi che condividono lo stesso nome.
È possibile creare più schemi nello stesso database per organizzare i dati nel modo desiderato o per raggruppare i dati in modo funzionale. Ad esempio, è possibile creare uno schema per memorizzare tutti i dati dell'area di gestione temporanea e un altro schema per memorizzare tutte le tabelle di reporting. È inoltre possibile creare schemi diversi per memorizzare i dati relativi a diversi business group che si trovano nello stesso database. Ogni schema può memorizzare diversi oggetti di database, come tabelle, viste e funzioni definite dall'utente (). UDFs Inoltre, è possibile creare schemi con la clausola AUTHORIZATION. Questa clausola conferisce la proprietà a un utente specificato o imposta una quota sulla quantità massima di spazio su disco che lo schema specificato può utilizzare.
Amazon Redshift crea automaticamente uno schema chiamato `public` per ogni nuovo database. Quando non si specifica il nome dello schema durante la creazione di oggetti di database, gli oggetti vanno nello schema `public`.
Per accedere a un oggetto in uno schema, qualificare l'oggetto utilizzando la notazione `schema_name.table_name`. Il nome qualificato dello schema è costituito dal nome dello schema e dal nome della tabella separati da un punto. Ad esempio, è possibile avere uno schema `sales` che ha una tabella `price` e uno schema `inventory` che ha una tabella `price`. Quando si fa riferimento alla tabella `price`, è necessario qualificarla come `sales.price` o `inventory.price`.
Nell'esempio seguente viene creato uno schema denominato **SALES** per l'utente `GUEST`.
```
CREATE SCHEMA SALES AUTHORIZATION GUEST;
```
Per informazioni sulle opzioni di altri comandi, consultare [CREATE TABLE](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_SCHEMA.html) nella *Guida per gli sviluppatori di database di Amazon Redshift*.
Per visualizzare l'elenco degli schemi nel database, emettere il comando seguente.
```
select * from pg_namespace;
```
L’output visualizzato dovrebbe essere simile al seguente:
```
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}
```
Per ulteriori informazioni su come eseguire query sulle tabelle di catalogo, consultare [Query sulle tabelle di catalogo](https://docs.aws.amazon.com/redshift/latest/dg/c_join_PG.html) nella *Guida per gli sviluppatori di database di Amazon Redshift*.
Utilizzare l'istruzione GRANT per concedere autorizzazioni agli utenti per gli schemi.
Nell’esempio seguente viene concesso il privilegio all’utente `GUEST` per selezionare i dati da tutte le tabelle o viste nello schema `SALES` utilizzando un’istruzione SELECT.
```
GRANT SELECT ON ALL TABLES IN SCHEMA SALES TO GUEST;
```
Nell’esempio seguente vengono concessi tutti i privilegi disponibili all’utente `GUEST` in una sola volta.
```
GRANT ALL ON SCHEMA SALES TO GUEST;
```
# Creare una tabella
Dopo aver creato il nuovo database, è necessario creare le tabelle che conterranno i dati. Quando crei la tabella, specifica le informazioni sulle colonne.
Ad esempio, per creare una tabella denominata **DEMO**, emettere il comando riportato di seguito.
```
CREATE TABLE Demo (
PersonID int,
City varchar (255)
);
```
Per impostazione predefinita, i nuovi oggetti di database, come le tabelle, vengono creati nello schema predefinito denominato `public` generato durante la creazione del data warehouse. È possibile utilizzare un altro schema per creare oggetti di database. Per ulteriori informazioni, consultare [Gestione della sicurezza dei database](https://docs.aws.amazon.com/redshift/latest/dg/r_Database_objects.html) nella *Guida per gli sviluppatori di database di Amazon Redshift*.
È possibile creare una tabella anche utilizzando la notazione `schema_name.object_name` per creare la tabella nello schema `SALES`.
```
CREATE TABLE SALES.DEMO (
PersonID int,
City varchar (255)
);
```
Per visualizzare ed esaminare gli schemi e le relative tabelle, puoi utilizzare Amazon Redshift Query Editor V2. Oppure è possibile visualizzare l'elenco delle tabelle negli schemi usando le viste di sistema. Per ulteriori informazioni, consulta [Eseguire query sulle tabelle e sulle viste di sistema](t_querying_redshift_system_tables.md).
Le colonne `encoding`, `distkey` e `sortkey` vengono utilizzate da Amazon Redshift per l'elaborazione parallela. Per ulteriori informazioni sulla progettazione di tabelle che includono questi elementi, consultare [Best practice di Amazon Redshift per la progettazione di tabelle](https://docs.aws.amazon.com/redshift/latest/dg/c_designing-tables-best-practices.html).
## Inserisci le righe di dati in una tabella
Dopo aver creato una tabella, inserire le righe di dati in questa tabella.
**Nota**
Il comando [INSERT](https://docs.aws.amazon.com/redshift/latest/dg/r_INSERT_30.html) inserisce righe in una tabella. Per caricamenti in blocco standard, utilizzare il comando [COPY](https://docs.aws.amazon.com/redshift/latest/dg/r_COPY.html). Per ulteriori informazioni, consultare [Utilizzo del comando COPY per caricare i dati](https://docs.aws.amazon.com/redshift/latest/dg/c_best-practices-use-copy.html).
Ad esempio, per inserire valori nella tabella `DEMO`, emettere il comando seguente.
```
INSERT INTO DEMO VALUES (781, 'San Jose'), (990, 'Palo Alto');
```
Per inserire dati in una tabella che si trova in uno schema specifico, esegui il comando seguente.
```
INSERT INTO SALES.DEMO VALUES (781, 'San Jose'), (990, 'Palo Alto');
```
## Seleziona dati da una tabella
Dopo aver creato una tabella e averla popolata con dati, puoi usare l'istruzione SELECT per visualizzare i dati contenuti nella tabella. L'istruzione SELECT \$1 restituisce tutti i nomi di colonna e i valori di riga per tutti i dati presenti in una tabella. L'utilizzo di SELECT è un buon metodo per verificare che i dati aggiunti di recente siano stati inseriti correttamente nella tabella.
Per visualizzare i dati inseriti nella tabella **DEMO**, emettere il comando seguente:
```
SELECT * from DEMO;
```
Il risultato sarà simile al seguente:
```
personid | city
----------+-----------
781 | San Jose
990 | Palo Alto
(2 rows)
```
Per ulteriori informazioni sull'uso dell'istruzione SELECT per eseguire query sulle tabelle, consultare [SELECT](https://docs.aws.amazon.com/redshift/latest/dg/r_SELECT_synopsis.html).
# Caricare i dati
Nella maggior parte degli esempi in questa guida viene utilizzato il set di dati di esempio TICKIT. È possibile scaricare il file [tickitdb.zip](samples/tickitdb.zip) contenente i singoli file di dati di esempio. Quindi puoi caricare i dati di esempio nel bucket Amazon S3.
Per caricare i dati campione per il database, creare innanzitutto le tabelle. Quindi utilizzare il comando COPY per caricare le tabelle con dati campione archiviati in un bucket Amazon S3. Per la procedura di creazione tabelle e il caricamento di dati di esempio, consultare [Passaggio 4: caricare i dati da Amazon S3 ad Amazon Redshift](new-user.md#rs-gsg-create-sample-db).
# Eseguire query sulle tabelle e sulle viste di sistema
Oltre alle tabelle che hai creato, il data warehouse contiene numerose tabelle e viste di sistema. Queste tabelle e viste di sistema contengono informazioni sull’installazione e sulle varie query e sui vari processi in esecuzione sul sistema. Puoi eseguire query su queste tabelle e viste di sistema per raccogliere informazioni sul database. Per ulteriori informazioni, consulta [Riferimento di tabelle e viste di sistema](https://docs.aws.amazon.com/redshift/latest/dg/cm_chap_system-tables.html) nella *Guida per sviluppatori di database di Amazon Redshift*. La descrizione per ogni tabella o vista indica se una tabella è visibile a tutti gli utenti o solo agli utenti con privilegi avanzati. Per eseguire una query su tabelle visibili solo agli utenti con privilegi avanzati, è necessario accedere come utente con privilegi avanzati.
## Visualizza un elenco di nomi di tabella
Per visualizzare un elenco di tutte le tabelle in uno schema, è possibile eseguire una query sulla tabella del catalogo di sistema PG\$1TABLE\$1DEF. È possibile prima esaminare l'impostazione per `search_path`.
```
SHOW search_path;
```
Il risultato dovrebbe essere simile al seguente,
```
search_path
---------------
$user, public
```
Nell'esempio seguente lo schema `SALES` viene aggiunto al percorso di ricerca e sono mostrate tutte le tabelle presenti nello schema `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
```
L'esempio seguente mostra un elenco di tutte le tabelle denominate `DEMO` in tutti gli schemi del database corrente.
```
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
```
Per ulteriori informazioni, consultare [PG\$1TABLE\$1DEF](https://docs.aws.amazon.com/redshift/latest/dg/r_PG_TABLE_DEF.html).
Puoi inoltre utilizzare Amazon Redshift Query Editor V2 per visualizzare tutte le tabelle in uno schema specificato scegliendo innanzitutto un database a cui connetterti.
## Visualizzazione degli utenti
È possibile eseguire una query sul catalogo PG\$1USER per visualizzare un elenco di tutti gli utenti del database, insieme all'ID utente (USESYSID) e ai privilegi degli utenti.
```
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 | ******** | |
```
Il nome utente `rdsdb` viene utilizzato internamente da Amazon Redshift per eseguire attività di amministrazione e manutenzione di routine. È possibile filtrare la query in modo da visualizzare solo nomi utente definiti dall'utente aggiungendo `where usesysid > 1` all'istruzione 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 | ******** | |
```
## Visualizza le query recenti
Nell’esempio precedente, l’ID utente (user\$1id) per `adminuser` è 100. Per elencare le quattro query più recenti eseguite da `adminuser`, puoi sottoporre a query la vista SYS\$1QUERY\$1HISTORY.
Puoi utilizzare questa vista per trovare l’ID query (query\$1id) o l’ID processo (session\$1id) per una query eseguita di recente. È inoltre possibile utilizzare questa vista per verificare quanto tempo ha richiesto il completamento di una query. SYS\$1QUERY\$1HISTORY include i primi 4.000 caratteri della stringa di query (query\$1text) per aiutarti a individuare una query specifica. Utilizza la clausola LIMIT con l’istruzione SELECT per limitare i risultati.
```
SELECT query_id, session_id, elapsed_time, query_text
FROM sys_query_history
WHERE user_id = 100
ORDER BY start_time desc
LIMIT 4;
```
Il risultato è simile al seguente.
```
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);
```
## Determinare l’ID sessione di una query in esecuzione
Per recuperare le informazioni sulle tabelle di sistema, potresti dover specificare l’ID sessione (ID processo) associato alla query. Potresti dover trovare l’ID sessione per una query ancora in fase di esecuzione. Ad esempio, hai bisogno dell’ID sessione se devi annullare una query la cui esecuzione dura troppo a lungo su un cluster con provisioning. È possibile interrogare la tabella di sistema STV\$1RECENTS per ottenere un elenco di sessioni IDs per l'esecuzione delle query, insieme alla stringa di query corrispondente. Se la query restituisce più ID sessione, puoi esaminare il testo della query per determinare l’ID sessione necessario.
Per determinare l’ID sessione di una query in esecuzione, esegui l’istruzione SELECT seguente.
```
SELECT session_id, user_id, start_time, query_text
FROM sys_query_history
WHERE status='running';
```
# Annullare una query
Se esegui una query che impiega troppo tempo o utilizza un numero eccessivo di risorse, annullala. Ad esempio, creare un elenco di rivenditori di biglietti che include il nome del rivenditore e la quantità di biglietti venduti. La query seguente seleziona i dati dalle tabelle `SALES` e `USERS` e unisce le due tabelle associando SELLERID e USERID nella clausola WHERE.
```
SELECT sellerid, firstname, lastname, sum(qtysold)
FROM sales, users
WHERE sales.sellerid = users.userid
GROUP BY sellerid, firstname, lastname
ORDER BY 4 desc;
```
Il risultato è simile al seguente.
```
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**
Si tratta di una query complessa. Per questo tutorial, non devi preoccuparti della costruzione di questa query.
La query precedente viene eseguita in alcuni secondi e restituisce 2.102 righe.
Si supponga di aver dimenticato di inserire la clausola WHERE.
```
SELECT sellerid, firstname, lastname, sum(qtysold)
FROM sales, users
GROUP BY sellerid, firstname, lastname
ORDER BY 4 desc;
```
Il set di risultati includerà tutte le righe della tabella `SALES` moltiplicato per tutte le righe della tabella `USERS` (49.989 x 3.766). Questa operazione è denominata unione cartesiana ed è sconsigliata. Il risultato corrisponde a oltre 188 milioni di righe e l'esecuzione della query richiede molto tempo.
Per annullare una query in esecuzione, utilizza il comando CANCEL con l’ID sessione della query. Con Amazon Redshift Query Editor V2 puoi annullare una query scegliendo il pulsante Annulla mentre la query è in esecuzione.
Per trovare l’ID sessione, avvia una nuova sessione ed esegui query sulla tabella STV\$1RECENTS, come illustrato nella fase precedente. Nell'esempio seguente viene mostrato come aumentare la leggibilità dei risultati. In questo caso, utilizzare la funzione TRIM per rimuovere gli spazi finali e visualizzare solo i primi 20 caratteri della stringa di query.
Per determinare l’ID sessione di una query in esecuzione, esegui l’istruzione SELECT seguente.
```
SELECT user_id, session_id, start_time, query_text
FROM sys_query_history
WHERE status='running';
```
Il risultato è simile al seguente.
```
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 ...
```
Per annullare la query con l’ID sessione `1073791534`, esegui il comando seguente.
```
CANCEL 1073791534;
```
**Nota**
Il comando CANCEL non interrompe una transazione. Per l'interruzione o il rollback di una transazione, utilizzare il comando ABORT o ROLLBACK. Per annullare una query associata a una transazione, annullare prima la query e quindi interrompere la transazione.
Se la query annullata è associata a una transazione, utilizzare il comando ABORT o ROLLBACK per annullare la transazione ed eliminare le modifiche apportate ai dati:
```
ABORT;
```
Se non hai effettuato l'accesso come utente con privilegi avanzati, puoi annullare solo le tue query. Un utente con privilegi avanzati può annullare tutte le query.
Se lo strumento di query non supporta l'esecuzione simultanea di query, sarà necessario avviare un'altra sessione per annullare la query.
Per ulteriori informazioni sull’annullamento di una query, consulta [CANCEL](https://docs.aws.amazon.com/redshift/latest/dg/r_CANCEL.html) nella *Guida per sviluppatori di database di Amazon Redshift*.
## Annulla una query tramite la coda dell'utente con privilegi avanzati
Se la sessione corrente comprende troppe query in esecuzione simultaneamente, potresti non essere in grado di eseguire il comando CANCEL fino al termine di un'altra query. In questo caso, eseguire il comando CANCEL usando una coda di query di gestione dei carichi di lavoro diversa.
Con la gestione dei carichi di lavoro è possibile eseguire query in code di query diverse in modo da non dover attendere il completamento di un'altra query. Il gestore dei carichi di lavoro crea una coda separata, denominata coda dell'utente con privilegi avanzati, che puoi usare per la risoluzione dei problemi. Per usare la coda dell'utente con privilegi avanzati, è necessario aver effettuato l'accesso come utente con privilegi avanzati e aver impostato il gruppo di query su "superuser" tramite il comando SET. Dopo aver eseguito i comandi, reimposta il gruppo di query usando il comando RESET (REIMPOSTA).
Per annullare una query utilizzando la coda dell’utente con privilegi avanzati, esegui questi comandi.
```
SET query_group TO 'superuser';
CANCEL 1073791534;
RESET query_group;
```