Amazon Redshift ne prendra plus en charge la création de nouveaux Python à UDFs partir du patch 198. UDFs Le Python existant continuera de fonctionner jusqu'au 30 juin 2026. Pour plus d’informations, consultez le [ billet de blog ](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/).
Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Exécuter des commandes pour définir et utiliser une base de données dans votre entrepôt de données
Les entrepôts de données Redshift sans serveur et les entrepôts de données alloués Amazon Redshift contiennent des bases de données. Après avoir lancé votre entrepôt de données, vous pouvez gérer la plupart des actions de base de données à l’aide de commandes SQL. À quelques exceptions près, les fonctionnalités et la syntaxe SQL sont les mêmes pour toutes les bases de données Amazon Redshift. Pour en savoir plus sur les commandes SQL disponibles avec Amazon Redshift, consultez [Commandes SQL](https://docs.aws.amazon.com/redshift/latest/dg/c_SQL_commands.html) dans le *Guide du développeur de base de données Amazon Redshift*.
Lorsque vous créez votre entrepôt de données, dans la plupart des scénarios, Amazon Redshift crée également la base de données `dev` par défaut. Une fois que vous vous êtes connecté à la base de données `dev`, vous pouvez créer une autre base de données.
Les sections suivantes présentent les tâches de base de données courantes lorsque vous travaillez avec des bases de données Amazon Redshift. Les tâches commencent par la création d’une base de données et si vous continuez jusqu’à la dernière tâche, vous pouvez supprimer toutes les ressources que vous créez en supprimant la base de données.
Les exemples de cette section supposent ce qui suit :
+ Vous avez créé un entrepôt de données Amazon Redshift.
+ Vous avez établi une connexion à l’entrepôt de données à partir de votre outil client SQL, tel que Amazon Redshift Query Editor V2. Pour plus d’informations sur l’utilisation d’Amazon Redshift Query Editor V2, veuillez consulter [Interrogation d’une base de données à l’aide d’Amazon Redshift Query Editor V2](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2.html) dans le *Guide de gestion Amazon Redshift*.
**Topics**
+ [Connexion aux entrepôts de données Amazon Redshift](#connection)
+ [Créer une base de données](t_creating_database.md)
+ [Créez un utilisateur](t_adding_redshift_user_cmd.md)
+ [Créer un schéma](t_creating_schema.md)
+ [Création d’une table](t_creating_table.md)
+ [Charger des données](cm-dev-t-load-sample-data.md)
+ [Interroger les tables et les vues système](t_querying_redshift_system_tables.md)
+ [Annuler une requête](cancel_query.md)
## Connexion aux entrepôts de données Amazon Redshift
Pour se connecter à des clusters Amazon Redshift, à partir de la page **Clusters** de la console Amazon Redshift, développez **Se connecter aux clusters Amazon Redshift)** et effectuez l’une des actions suivantes :
+ Choisissez **Interroger des données** pour utiliser l’éditeur de requêtes v2 pour exécuter des requêtes sur les bases de données hébergées par votre cluster Amazon Redshift. Après avoir créé votre cluster, vous pouvez exécuter immédiatement des requêtes en utilisant l’éditeur de requêtes v2.
Pour plus d’informations, consultez [Interrogation d’une base de données à l’aide d’Amazon Redshift Query Editor V2](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2.html) dans le *Guide de gestion Amazon Redshift*.
+ Dans **Utiliser vos outils clients**, choisissez votre cluster et connectez-vous à Amazon Redshift depuis vos outils client à l’aide de pilotes JDBC ou ODBC en copiant l’URL du pilote JDBC ou ODBC. Utilisez cette URL depuis votre ordinateur ou instance client. Codez vos applications afin d’utiliser des opérations d’API d’accès aux données ODBC ou JDBC ou utilisez des outils clients SQL qui prennent en charge JDBC ou ODBC.
Pour plus d’informations sur la façon de trouver la chaîne de connexion de votre cluster, consultez [Recherche de votre chaîne de connexion au cluster](https://docs.aws.amazon.com/redshift/latest/mgmt/configuring-connections.html#connecting-drivers.html).
+ Si votre outil client SQL nécessite un pilote, vous pouvez **Choisir votre pilote JDBC ou ODBC** pour télécharger un pilote spécifique au système d’exploitation pour vous connecter à Amazon Redshift à partir de vos outils client.
Pour plus d'informations sur la façon d'installer le pilote approprié pour votre client SQL, voir [Configuration d'une connexion au pilote JDBC version 2.2](https://docs.aws.amazon.com/redshift/latest/mgmt/jdbc20-install.html).
Pour plus d’informations sur la façon de configurer une connexion ODBC, consultez [Configuration d’une connexion ODBC](https://docs.aws.amazon.com/redshift/latest/mgmt/configure-odbc-connection.html).
Pour vous connecter à l’entrepôt de données Redshift sans serveur, depuis la page du **Tableau de bord sans serveur** de la console Amazon Redshift, effectuez l’une des opérations suivantes :
+ Utilisez Amazon Redshift Query Editor V2 pour exécuter des requêtes sur les bases de données hébergées par votre entrepôt de données Redshift sans serveur. Après avoir créé votre entrepôt de données, vous pouvez exécuter immédiatement des requêtes en utilisant l’éditeur de requêtes v2.
Pour plus d’informations, consultez [Interrogation d’une base de données à l’aide d’Amazon Redshift Query Editor V2](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2.html).
+ Connectez-vous à Amazon Redshift depuis vos outils client à l’aide de pilotes JDBC ou ODBC en copiant l’URL du pilote JDBC ou ODBC.
Pour utiliser les données de votre entrepôt de données, vous avez besoin de pilotes ODBC ou JDBC pour la connectivité dans votre ordinateur ou instance client. Codez vos applications afin d’utiliser des opérations d’API d’accès aux données ODBC ou JDBC ou utilisez des outils clients SQL qui prennent en charge JDBC ou ODBC.
Pour plus d’informations sur la façon de trouver votre chaîne de connexion, consultez [Connexion à Redshift sans serveur](https://docs.aws.amazon.com/redshift/latest/mgmt/serverless-connecting) dans le *Guide de gestion Amazon Redshift*.
# Créer une base de données
Après avoir vérifié que votre entrepôt de données fonctionne, vous pouvez créer une base de données. Cette base de données est l’emplacement où vous créez des tables, chargez des données et exécutez des requêtes. Un entrepôt de données peut héberger plusieurs bases de données. Par exemple, vous pouvez avoir une base de données pour les données de vente nommée `SALESDB` et une base de données pour les données de commandes nommée `ORDERSDB` dans le même entrepôt de données.
Pour créer une base de données nommée **SALESDB**, exécutez l’instruction suivante dans votre outil de client SQL.
```
CREATE DATABASE salesdb;
```
**Note**
Après avoir exécuté la commande, veillez à actualiser la liste d’objets de votre outil client SQL dans votre entrepôt de donnée pour voir la nouvelle base de données `salesdb`.
Pour cet exercice, acceptez les valeurs par défaut. Pour plus d’informations sur davantage d’options de commande, consultez [CREATE TABLE](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_DATABASE) dans le *Guide du développeur de la base de données Amazon Redshift*. Pour supprimer une base de données et son contenu, consultez [DROP DATABASE](https://docs.aws.amazon.com/redshift/latest/dg/r_DROP_DATABASE) dans le *Guide du développeur de base de données Amazon Redshift*.
Une fois que vous avez créé la base de données SALESDB, vous pouvez vous connecter à la nouvelle base de données depuis votre client SQL. Utilisez les mêmes paramètres de connexion que ceux dont vous vous êtes servi pour votre connexion en cours, mais modifiez le nom de base de données en `SALESDB`.
# Créez un utilisateur
Par défaut, seul l’utilisateur administrateur que vous avez créé lorsque vous avez lancé l’entrepôt de données a accès à la base de données par défaut de l’entrepôt de données. Pour accorder l’accès à d’autres utilisateurs, créez un ou plusieurs comptes. Les comptes d’utilisateur de base de données appartiennent à toutes les bases de données d’un entrepôt de données, et non à une base de données spécifique.
Utilisez l’instruction CREATE USER pour créer un nouvel utilisateur de base de données. Lorsque vous créez un nouvel utilisateur, vous spécifiez le nom du nouvel utilisateur et un mot de passe. Nous vous recommandons de spécifier un mot de passe pour l’utilisateur. Celui-ci doit comprendre entre 8 et 64 caractères et inclure au moins une lettre majuscule, une lettre minuscule et un chiffre.
Par exemple, pour créer un utilisateur nommé **GUEST** avec le mot de passe **ABCd4321**, exécutez la commande suivante.
```
CREATE USER GUEST PASSWORD 'ABCd4321';
```
Pour vous connecter à la base de données `SALESDB` en tant qu’utilisateur `GUEST`, utilisez le même mot de passe que lors de la création de l’utilisateur, tel que `ABCd4321`.
Pour plus d’informations sur les autres options de commande, consultez [CREATE USER](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_USER.html) dans le *Guide du développeur de la base de données Amazon Redshift*.
# Créer un schéma
Après avoir créé une base de données, vous pouvez créer un schéma dans la base de données actuelle. Un *schéma* est un espace de noms qui contient des objets de base de données nommés tels que des tables, des vues et des fonctions définies par l'utilisateur ()UDFs. Une base de données peut contenir un ou plusieurs schémas, et chaque schéma appartient à une seule base de données. Deux schémas peuvent avoir des objets différents qui partagent le même nom.
Vous pouvez créer plusieurs schémas dans la même base de données pour organiser les données comme vous le souhaitez ou pour regrouper vos données de manière fonctionnelle. Par exemple, vous pouvez créer un schéma pour stocker toutes vos données intermédiaires et un autre schéma pour stocker toutes les tables de reporting. Vous pouvez également créer différents schémas pour stocker des données pertinentes pour différents groupes professionnels qui se trouvent dans la même base de données. Chaque schéma peut stocker différents objets de base de données, tels que des tables, des vues et des fonctions définies par l'utilisateur (UDFs). De plus, vous pouvez créer des schémas avec la clause AUTHORIZATION. Cette clause donne la propriété à un utilisateur spécifié ou définit un quota sur la quantité maximale d’espace disque que le schéma spécifié peut utiliser.
Amazon Redshift crée automatiquement un schéma appelé `public` pour chaque nouvelle base de données. Lorsque vous ne spécifiez pas le nom du schéma lors de la création d’objets de base de données, les objets sont placés dans le schéma `public`.
Pour accéder à un objet dans un schéma, qualifiez l’objet en utilisant la notation `schema_name.table_name`. Le nom qualifié du schéma se compose du nom du schéma et du nom de la table séparés par un point. Par exemple, vous pouvez avoir un schéma `sales` qui possède une table `price` et un schéma `inventory` qui possède également une table `price`. Lorsque vous faites référence à la table `price`, vous devez la qualifier comme `sales.price` ou `inventory.price`.
L’exemple suivant crée un schéma nommé **SALES** pour l’utilisateur `GUEST`.
```
CREATE SCHEMA SALES AUTHORIZATION GUEST;
```
Pour plus d’informations sur davantage d’options de commande, consultez [CREATE SCHEMA](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_SCHEMA.html) dans le *Guide du développeur de la base de données Amazon Redshift*.
Pour afficher la liste des schémas de votre base de données, exécutez l’instruction suivante.
```
select * from pg_namespace;
```
La sortie doit ressembler à ce qui suit :
```
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}
```
Pour plus d’informations sur la façon d’interroger les tables de catalogue, consultez [Interroger les tables de catalogue](https://docs.aws.amazon.com/redshift/latest/dg/c_join_PG.html) dans le *Guide du développeur de la base de données Amazon Redshift*.
Utilisez l’instruction GRANT pour octroyer des privilèges aux utilisateurs pour les schémas.
L’exemple suivant octroie à l’utilisateur `GUEST` le privilège de sélectionner des données dans toutes les tables ou vues dans le schéma `SALES` à l’aide d’une instruction SELECT.
```
GRANT SELECT ON ALL TABLES IN SCHEMA SALES TO GUEST;
```
L’exemple suivant octroie tous les privilèges disponibles en une seule fois à l’utilisateur `GUEST`.
```
GRANT ALL ON SCHEMA SALES TO GUEST;
```
# Création d’une table
Une fois que vous avez créé votre base de données, créez les tables qui contiendront vos données. Spécifiez les informations sur les colonnes lorsque vous créez la table.
Par exemple, exécutez la commande suivante pour créer une table nommée **DEMO**.
```
CREATE TABLE Demo (
PersonID int,
City varchar (255)
);
```
Par défaut, les nouveaux objets de base de données, tels que les tables, sont créés dans le schéma par défaut nommé `public`, généré lors de la création de l’entrepôt de données. Vous pouvez utiliser un autre schéma pour créer des objets de base de données. Pour plus d’informations sur les schémas, consultez [Gestion de la sécurité des bases de données](https://docs.aws.amazon.com/redshift/latest/dg/r_Database_objects.html) dans le *Manuel du développeur de base de données Amazon Redshift*.
Vous pouvez également créer une table en utilisant la notation `schema_name.object_name` afin de créer la table dans le schéma `SALES`.
```
CREATE TABLE SALES.DEMO (
PersonID int,
City varchar (255)
);
```
Pour afficher et inspecter les schémas et leurs tables, vous pouvez utiliser Amazon Redshift Query Editor V2. Vous pouvez également voir la liste des tables dans les schémas à l’aide des vues système. Pour plus d’informations, consultez [Interroger les tables et les vues système](t_querying_redshift_system_tables.md).
Les colonnes `encoding`, `distkey` et `sortkey` sont utilisés par Amazon Redshift pour le traitement parallèle. Pour plus d’informations sur la conception de tables qui intègrent ces éléments, consultez [Bonnes pratiques Amazon Redshift pour la conception de tables](https://docs.aws.amazon.com/redshift/latest/dg/c_designing-tables-best-practices.html).
## Insérer des lignes de données dans une table
Une fois que vous avez créé une table, insérez des lignes de données dans cette table.
**Note**
La commande [INSERT](https://docs.aws.amazon.com/redshift/latest/dg/r_INSERT_30.html) insère des lignes dans une table. Pour les charges en bloc standard, utilisez la commande [COPY](https://docs.aws.amazon.com/redshift/latest/dg/r_COPY.html). Pour plus d’informations, consultez [Utilisation d’une commande COPY pour charger les données](https://docs.aws.amazon.com/redshift/latest/dg/c_best-practices-use-copy.html).
Par exemple, pour insérer des valeurs dans la table `DEMO`, exécutez l’instruction suivante.
```
INSERT INTO DEMO VALUES (781, 'San Jose'), (990, 'Palo Alto');
```
Pour insérer des données dans une table qui se trouve dans un schéma spécifique, exécutez la commande suivante.
```
INSERT INTO SALES.DEMO VALUES (781, 'San Jose'), (990, 'Palo Alto');
```
## Sélectionner les données dans une table
Une fois que vous avez créé une table et l’avez remplie avec des données, utilisez une instruction SELECT pour afficher les données de la table. L’instruction SELECT \$1 renvoie tous les noms de colonne et toutes les valeurs de ligne de toutes les données d’une table. L’utilisation de SELECT est un bon moyen de vérifier que les données récemment ajoutées ont été correctement insérées dans la table.
Pour afficher les données que vous avez saisies dans la table **DEMO**, saisissez la commande suivante.
```
SELECT * from DEMO;
```
Le résultat doit avoir l’aspect suivant.
```
personid | city
----------+-----------
781 | San Jose
990 | Palo Alto
(2 rows)
```
Pour plus d’informations sur l’utilisation de l’instruction SELECT pour interroger les tables, consultez [SELECT](https://docs.aws.amazon.com/redshift/latest/dg/r_SELECT_synopsis.html).
# Charger des données
De nombreux exemples de ce guide utilisent l’exemple de jeu de données TICKIT. Vous pouvez télécharger le fichier [tickitdb.zip](samples/tickitdb.zip), qui contient des exemples de fichiers individuels de données. Vous pouvez ensuite charger les exemples de données dans votre propre compartiment Amazon S3.
Pour charger les exemples de données de votre base de données, commencez par créer les tables. Utilisez ensuite la commande COPY pour charger les tables avec des exemples de données stockés dans un compartiment Amazon S3. Pour connaître les étapes pour créer les tables et charger les exemples de données, consultez [Étape 4 : Charger les données d’Amazon S3 vers Amazon Redshift](new-user.md#rs-gsg-create-sample-db).
# Interroger les tables et les vues système
Outre les tables que vous créez, votre entrepôt de données contient un certain nombre de tables et de vues système. Ces tables et vues système contiennent des informations sur votre installation et sur les différents processus et requêtes qui s’exécutent sur le système. Vous pouvez interroger les tables et les vues système pour recueillir les informations sur votre base de données. Pour plus d’informations, consultez [Informations de référence sur les tables et les vues système](https://docs.aws.amazon.com/redshift/latest/dg/cm_chap_system-tables.html) dans le *Guide du développeur de base de données Amazon Redshift*. La description de chaque table ou vue indique si une table est visible par tous les utilisateurs ou par les super-utilisateurs uniquement. Connectez-vous en tant que super-utilisateur pour interroger les tables visibles uniquement des super-utilisateurs.
## Afficher la liste des noms de table
Pour afficher la liste de toutes les tables d’un schéma, vous pouvez interroger la table catalogue système PG\$1TABLE\$1DEF. Vous pouvez d’abord examiner le paramétrage de `search_path`.
```
SHOW search_path;
```
Le résultat devrait être similaire à ce qui suit :
```
search_path
---------------
$user, public
```
L’exemple suivant ajoute le schéma `SALES` au chemin de recherche et affiche toutes les tables du schéma `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’exemple suivant illustre une liste de toutes les tables appelées `DEMO` dans tous les schémas de la base de données actuelle.
```
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
```
Pour plus d’informations, consultez [PG\$1TABLE\$1DEF](https://docs.aws.amazon.com/redshift/latest/dg/r_PG_TABLE_DEF.html).
Vous pouvez également utiliser Amazon Redshift Query Editor V2 pour afficher toutes les tables d’un schéma spécifié en choisissant d’abord une base de données à laquelle vous souhaitez vous connecter.
## Afficher les utilisateurs
Vous pouvez interroger la table catalogue PG\$1USER pour afficher la liste de tous les utilisateurs, ainsi que l’ID utilisateur (USESYSID) et les privilèges utilisateur.
```
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 | ******** | |
```
Le nom d’utilisateur `rdsdb` est utilisé en interne par Amazon Redshift pour effectuer les tâches habituelles d’administration et de maintenance. Vous pouvez filtrer votre requête pour afficher uniquement les noms d’utilisateur définis par l’utilisateur en ajoutant `where usesysid > 1` à votre instruction 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 | ******** | |
```
## Afficher les requêtes récentes
Dans l’exemple précédent, l’ID utilisateur (user\$1id) pour `adminuser` est 100. Pour afficher les quatre requêtes les plus récentes exécutées par `adminuser`, vous pouvez interroger la vue SYS\$1QUERY\$1HISTORY.
Vous pouvez utiliser cette vue pour trouver l’ID de requête (query\$1id) ou l’ID de processus (session\$1id) d’une requête récemment exécutée. Vous pouvez également l’utiliser pour connaître le temps mis par une requête pour s’exécuter. SYS\$1QUERY\$1HISTORY inclut les 4 000 premiers caractères de la chaîne de requête (query\$1text) pour vous aider à localiser une requête spécifique. Utilisez la clause LIMIT avec votre instruction SELECT pour limiter les résultats.
```
SELECT query_id, session_id, elapsed_time, query_text
FROM sys_query_history
WHERE user_id = 100
ORDER BY start_time desc
LIMIT 4;
```
Le résultat ressemble à ce qui suit.
```
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);
```
## Déterminer l’ID de session d’une requête en cours d’exécution
Vous devrez peut-être spécifier l’ID de session (ID de processus) associé à une requête pour récupérer les informations de la table système sur cette requête. Il se peut que vous ayez besoin de trouver l’ID de session d’une requête qui est toujours en cours d’exécution. Par exemple, vous avez besoin de l’ID de session si vous devez annuler une requête qui prend trop de temps pour s’exécuter sur un cluster alloué. Vous pouvez interroger la table système STV\$1RECENTS pour obtenir une liste des sessions IDs pour exécuter des requêtes, ainsi que la chaîne de requête correspondante. Si votre requête retourne plusieurs sessions, vous pouvez examiner le texte de la requête pour déterminer l’ID de session dont vous avez besoin.
Pour déterminer l’ID de session d’une requête en cours d’exécution, exécutez l’instruction SELECT suivante.
```
SELECT session_id, user_id, start_time, query_text
FROM sys_query_history
WHERE status='running';
```
# Annuler une requête
Si vous exécutez une requête qui prend trop de temps ou consomme des ressources excessives, annulez-la. Par exemple, vous créez une liste de vendeurs de billets comprenant le nom du vendeur et la quantité de billets vendus. La requête suivante sélectionne les données des tables `SALES` et `USERS`, et joint les deux tables en associant SELLERID et USERID dans la clause WHERE.
```
SELECT sellerid, firstname, lastname, sum(qtysold)
FROM sales, users
WHERE sales.sellerid = users.userid
GROUP BY sellerid, firstname, lastname
ORDER BY 4 desc;
```
Le résultat ressemble à ce qui suit.
```
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
```
**Note**
Il s’agit d’une requête complexe. Pour ce didacticiel, vous n’avez pas à vous préoccuper de la façon dont la requête est construite.
La requête précédente s’exécute en quelques secondes et retourne 2 102 lignes.
Supposons vous oubliez de placer la clause WHERE.
```
SELECT sellerid, firstname, lastname, sum(qtysold)
FROM sales, users
GROUP BY sellerid, firstname, lastname
ORDER BY 4 desc;
```
L’ensemble de résultats contient le nombre de toutes les lignes de la table `SALES` multiplié par le nombre de toutes les lignes de la table `USERS` (49989 \$1 3766). Cette jointure est appelée jointure cartésienne et n’est pas recommandée. Le résultat est supérieur à 188 millions de lignes et son exécution prend beaucoup de temps.
Pour annuler une requête en cours d’exécution, utilisez la commande CANCEL avec l’ID de session de la requête. Avec Amazon Redshift Query Editor V2, vous pouvez annuler une requête en cliquant sur le bouton Annuler pendant que la requête est en cours d’exécution.
Pour obtenir l’ID de session, démarrez une nouvelle séance et interrogez la table STV\$1RECENTS, comme illustré dans l’étape précédente. L’exemple suivant montre comment vous pouvez rendre les résultats plus lisibles. Pour ce faire, utilisez la fonction TRIM pour couper les espaces de fin de ligne et n’afficher que les 20 premiers caractères de la chaîne de requête.
Pour déterminer l’ID de session d’une requête en cours d’exécution, exécutez l’instruction SELECT suivante.
```
SELECT user_id, session_id, start_time, query_text
FROM sys_query_history
WHERE status='running';
```
Le résultat ressemble à ce qui suit.
```
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 ...
```
Pour annuler la requête avec l’I de session `1073791534`, exécutez la commande suivante.
```
CANCEL 1073791534;
```
**Note**
La commande CANCEL n’arrête pas une transaction. Pour arrêter ou restaurer une transaction, utilisez la commande ABORT ou ROLLBACK. Pour annuler une requête associée à une transaction, annulez d’abord la requête, puis arrêtez la transaction.
Si la requête que vous avez annulée est associée à une transaction, utilisez la commande ABORT ou ROLLBACK. pour annuler la transaction et ignorer toutes les modifications apportées aux données :
```
ABORT;
```
Sauf si vous êtes connecté comme super-utilisateur, vous pouvez annuler uniquement vos propres requêtes. Un super-utilisateur peut annuler toutes les requêtes.
Si votre outil de requête ne prend pas en charge l’exécution simultanée de requêtes, démarrez une nouvelle séance pour annuler la requête.
Pour plus d’informations sur l’annulation d’une requête, consultez [CANCEL](https://docs.aws.amazon.com/redshift/latest/dg/r_CANCEL.html) dans le *Guide du développeur de la base de données Amazon Redshift*.
## Annuler une requête à l’aide de la file d’attente super-utilisateur
Si votre séance en cours a un trop grand nombre de requêtes s’exécutant en même temps, il se peut que vous ne soyez pas en mesure d’exécuter la commande CANCEL tant qu’une autre requête n’est pas terminée. Dans ce cas, exécutez la commande CANCEL en utilisant une autre file d’attente de requêtes de gestion de la charge de travail.
La gestion de la charge de travail vous permet d’exécuter les requêtes dans différentes files d’attente de afin que vous n’ayez pas besoin d’attendre qu’une autre requête se termine. Le gestionnaire de la charge de travail crée une file d’attente distincte, appelée file d’attente super-utilisateur, que vous pouvez utiliser à des fins de dépannage. Pour utiliser la file d’attente super-utilisateur, connectez-vous en tant que super-utilisateur et définissez le groupe de requêtes avec la valeur « superuser » à l’aide de la commande SET. Après l’exécution de vos commandes, réinitialisez le groupe de requêtes à l’aide de la commande RESET.
Pour annuler une requête à l’aide de la file d’attente super-utilisateur, exécutez ces commandes.
```
SET query_group TO 'superuser';
CANCEL 1073791534;
RESET query_group;
```