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.

# SYS\_QUERY\_HISTORY
<a name="SYS_QUERY_HISTORY"></a>

Utilisez SYS\_QUERY\_HISTORY pour afficher les détails des requêtes des utilisateurs. Chaque ligne représente une requête utilisateur avec des statistiques cumulées pour certains des champs. Cette vue contient de nombreux types de requêtes, tels que DDL (Data Definition Language), DML (Data Manipulation Language), copie, déchargement et Amazon Redshift Spectrum. Elle contient à la fois les requêtes en cours d’exécution et terminées.

SVV\_QUERY\_STATE est visible pour tous les utilisateurs. Les super-utilisateurs peuvent voir toutes les lignes, tandis que les utilisateurs standard peuvent voir uniquement leurs propres données. Pour plus d’informations, consultez [Visibilité des données dans les tables et vues système](cm_chap_system-tables.md#c_visibility-of-data).

**Note**  
Pour vérifier si une transaction contenant la requête exécutée a été validée avec succès, vous devez effectuer une opération de jointure entre les tables système et la table `sys_transaction_history`. Par exemple :  

```
SELECT 
    qh.transaction_id,
    qh.query_id,
    qh.status AS query_status,
    qh.query_type,
    TRIM(qh.query_text) AS query_text,
    th.status AS transaction_status
FROM 
    sys_query_history qh
LEFT JOIN 
    sys_transaction_history th ON qh.transaction_id = th.transaction_id;
```

## Colonnes de la table
<a name="SYS_QUERY_HISTORY-table-columns"></a>


| Nom de la colonne  | Type de données  | Description  | 
| --- | --- | --- | 
| user\_id | entier | Identificateur de l’utilisateur qui a envoyé la requête. | 
| query\_id | bigint | Identificateur de requête. | 
| query\_label | caractère (320) | Nom abrégé de la requête. | 
| transaction\_id | bigint | Identificateur de transaction. | 
| session\_id | entier | Identificateur de processus du processus exécutant la requête. | 
| database\_name | character(128) | Nom de la base de données à laquelle l’utilisateur était connecté lorsque la requête a été émise. | 
| query\_type | character(32) | Type de requête, tel que SELECT, INSERT, UPDATE, UNLOAD, COPY, COMMAND, DDL, UTILITY, CTAS et OTHER. | 
| status | character(10) | Statut de la requête. Valeurs valides : planification, mise en file d’attente, exécution, retour, échec, annulation et succès. | 
| result\_cache\_hit | Booléen | Indique si la requête correspond au cache de résultats. | 
| start\_time | timestamp | Heure à laquelle la requête a commencé. | 
| end\_time | timestamp | Heure à laquelle la requête s’est terminée. | 
| elapsed\_time | bigint | Temps total (microsecondes) passé sur la requête. | 
| queue\_time | bigint | Temps total (microsecondes) passé dans la file d’attente de requêtes de classe de service. | 
| execution\_time | bigint | Durée totale (microsecondes) d’exécution dans la classe de service. | 
| error\_message | character(512) | Raison pour laquelle une requête a échoué. | 
| returned\_rows | bigint | Nombre de lignes retournées au client.  | 
| returned\_bytes | bigint | Nombre d’octets retournés au client.  | 
| query\_text | character(4000) | Chaîne de requête. Cette chaîne peut être tronquée.  | 
| redshift\_version | character(256) | Version Amazon Redshift lors de l’exécution de la requête. | 
| usage\_limit | character(150) | Liste des limites d'utilisation IDs atteintes par la requête. | 
| compute\_type | varchar(32) | Indique si la requête s’exécute sur le cluster principal ou sur le cluster de mise à l’échelle de simultanéité. Les valeurs possibles sont primary (la requête s’exécute sur le cluster principal), secondary (la requête s’exécute sur le cluster secondaire), ou primary-scale (la requête s’exécute sur le cluster de simultanéité). Cela ne s’applique qu’au cluster provisionné. | 
| compile\_time | bigint | Le temps total (en microsecondes) consacré à la compilation de la requête. | 
| planning\_time | bigint | Le temps total (en microsecondes) consacré à la planification de la requête. | 
| lock\_wait time | bigint | Le temps total (microsecondes) passé à attendre le verrou relationnel. | 
| service\_class\_id | entier | Identifiant de la classe de service. Pour obtenir la liste des classes de service IDs, rendez-vous sur[Classe de service WLM IDs](cm-c-wlm-system-tables-and-views.md#wlm-service-class-ids).<br />Cette colonne est uniquement utilisée pour les requêtes exécutées sur les clusters alloués. Pour les requêtes exécutées sur Redshift sans serveur, cette colonne contient -1. | 
| service\_class\_name | character(64) | Nom de la classe de service.<br />Cette colonne est uniquement utilisée pour les requêtes exécutées sur les clusters alloués. Pour les requêtes exécutées sur Amazon Redshift Redshift sans serveur, cette colonne est vide. | 
| query\_priority | character(20) | Priorité de la file d’attente dans laquelle la requête a été exécutée. Les valeurs possibles sont les suivantes :[See the AWS documentation website for more details](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/SYS_QUERY_HISTORY.html)<br />NULL signifie que la priorité de la requête n’est pas prise en charge pour la requête.<br />Cette colonne est uniquement utilisée pour les requêtes exécutées sur les clusters alloués. Pour les requêtes exécutées sur Redshift sans serveur, cette colonne est vide. | 
| short\_query\_accelerated | character(10) | Si la requête a été accélérée à l’aide de l’accélération des requêtes courtes (SQA). Les valeurs possibles sont les suivantes :[See the AWS documentation website for more details](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/SYS_QUERY_HISTORY.html)<br />Cette colonne est uniquement utilisée pour les requêtes exécutées sur les clusters alloués. Pour les requêtes exécutées sur Redshift sans serveur, cette colonne est vide. | 
| user\_query\_hash | character(40) | Le hachage de la requête généré à partir de la requête, y compris ses littéraux de requête. Les requêtes répétées avec le même texte de requête auront les mêmes valeurs user\_query\_hash. | 
| generic\_query\_hash | character(40) | Le hachage de la requête généré à partir de la requête, à l’exclusion de ses littéraux de requête. Les requêtes répétées avec le même texte de requête, mais des littéraux de requête différents, auront les mêmes valeurs generic\_query\_hash. | 
| query\_hash\_version | entier | Le numéro de version du hachage de requête généré à partir de la requête. | 
| result\_cache\_query\_id | entier | Si la requête utilisait la mise en cache des résultats, la valeur de ce champ est l’ID de la requête à la source des résultats mis en cache. Si la mise en cache des résultats n’a pas été utilisée, cette valeur de champ est `0`. | 
| nom d’utilisateur | character(128) | Nom d’utilisateur de l’utilisateur qui a envoyé la requête. | 

## Exemples de requêtes
<a name="SYS_QUERY_HISTORY-sample-queries"></a>

La requête suivante renvoie les requêtes en cours d’exécution et en file d’attente.

```
SELECT user_id,
       query_id,
       transaction_id,
       session_id,
       status,
       trim(database_name) AS database_name,
       start_time,
       end_time,
       result_cache_hit,
       elapsed_time,
       queue_time,
       execution_time
FROM sys_query_history
WHERE status IN ('running','queued')
ORDER BY start_time;
```

Exemple de sortie.

```
 user_id | query_id | transaction_id | session_id | status  | database_name |        start_time         |          end_time          | result_cache_hit | elapsed_time | queue_time | execution_time
---------+----------+----------------+------------+---------+---------------+---------------------------+----------------------------+------------------+--------------+------------+----------------
     101 |   760705 |         852337 | 1073832321 | running | tpcds_1t      | 2022-02-15 19:03:19.67849 | 2022-02-15 19:03:19.739811 | f                |        61321 |          0 |              0
```

La requête suivante renvoie l’heure de début, l’heure de fin, la durée de la file d’attente, le temps écoulé, le temps de planification et et d’autres métadonnées pour une requête spécifique.

```
SELECT user_id,
       query_id,
       transaction_id,
       session_id,
       status,
       trim(database_name) AS database_name,
       start_time,
       end_time,
       result_cache_hit,
       elapsed_time,
       queue_time,
       execution_time,
       planning_time,
       trim(query_text) as query_text
FROM sys_query_history
WHERE query_id = 3093;
```

Exemple de sortie.

```
user_id | query_id | transaction_id | session_id |   status   | database_name |         start_time         |          end_time          | result_cache_hit | elapsed_time | queue_time | execution_time | planning_time | query_text
--------+----------+----------------+------------+------------+---------------+----------------------------+----------------------------+------------------+--------------+------------+----------------+---------------+-------------------------------------
    106 |     3093 |          11759 | 1073750146 | success    | dev           | 2023-03-16 16:53:17.840214 | 2023-03-16 16:53:18.106588 | f                |       266374 |          0 |         105725 |        136589 | select count(*) from item;
```

La requête suivante répertorie les 10 requêtes SELECT les plus récentes.

```
SELECT query_id,
       transaction_id,
       session_id,
       start_time,
       elapsed_time,
       queue_time,
       execution_time,
       returned_rows,
       returned_bytes
FROM sys_query_history
WHERE query_type = 'SELECT'
ORDER BY start_time DESC limit 10;
```

Exemple de sortie.

```
 query_id | transaction_id | session_id |         start_time         | elapsed_time | queue_time | execution_time | returned_rows | returned_bytes
----------+----------------+------------+----------------------------+--------------+------------+----------------+---------------+----------------
   526532 |          61093 | 1073840313 | 2022-02-09 04:43:24.149603 |       520571 |          0 |         481293 |             1 |           3794
   526520 |          60850 | 1073840313 | 2022-02-09 04:38:27.24875  |       635957 |          0 |         596601 |             1 |           3679
   526508 |          60803 | 1073840313 | 2022-02-09 04:37:51.118835 |       563882 |          0 |         503135 |             5 |          17216
   526505 |          60763 | 1073840313 | 2022-02-09 04:36:48.636224 |       649337 |          0 |         589823 |             1 |            652
   526478 |          60730 | 1073840313 | 2022-02-09 04:36:11.741471 |     14611321 |          0 |       14544058 |             0 |              0
   526467 |          60636 | 1073840313 | 2022-02-09 04:34:11.91463  |     16711367 |          0 |       16633767 |             1 |            575
   511617 |         617946 | 1074009948 | 2022-01-20 06:21:54.44481  |      9937090 |          0 |        9899271 |           100 |          12500
   511603 |         617941 | 1074259415 | 2022-01-20 06:21:45.71744  |      8065081 |          0 |        7582500 |           100 |           8889
   511595 |         617935 | 1074128320 | 2022-01-20 06:21:44.030876 |      1051270 |          0 |        1014879 |             1 |             72
   511584 |         617931 | 1074030019 | 2022-01-20 06:21:42.764088 |       609033 |          0 |         485887 |           100 |           8438
```

 La requête suivante indique le nombre quotidien de requêtes de sélection et le temps moyen écoulé pour les requêtes. 

```
SELECT date_trunc('day',start_time) AS exec_day,
       status,
       COUNT(*) AS query_cnt,
       AVG(datediff (microsecond,start_time,end_time)) AS elapsed_avg
FROM sys_query_history
WHERE query_type = 'SELECT'
AND start_time >= '2022-01-14'
AND start_time <= '2022-01-18'
GROUP BY exec_day,
         status
ORDER BY exec_day,
         status;
```

Exemple de sortie.

```
      exec_day       | status  | query_cnt | elapsed_avg
---------------------+---------+-----------+------------
 2022-01-14 00:00:00 | success |      5253 |  56608048
 2022-01-15 00:00:00 | success |      7004 |  56995017
 2022-01-16 00:00:00 | success |      5253 |  57016363
 2022-01-17 00:00:00 | success |      5309 |  55236784
 2022-01-18 00:00:00 | success |      8092 |  54355124
```

La requête suivante indique la performance quotidienne du temps moyen écoulé pour les requêtes.

```
SELECT distinct date_trunc('day',start_time) AS exec_day,
       query_count.cnt AS query_count,
       Percentile_cont(0.5) within group(ORDER BY elapsed_time) OVER (PARTITION BY exec_day) AS P50_runtime,
       Percentile_cont(0.8) within group(ORDER BY elapsed_time) OVER (PARTITION BY exec_day) AS P80_runtime,
       Percentile_cont(0.9) within group(ORDER BY elapsed_time) OVER (PARTITION BY exec_day) AS P90_runtime,
       Percentile_cont(0.99) within group(ORDER BY elapsed_time) OVER (PARTITION BY exec_day) AS P99_runtime,
       Percentile_cont(1.0) within group(ORDER BY elapsed_time) OVER (PARTITION BY exec_day) AS max_runtime
FROM sys_query_history
LEFT JOIN (SELECT  date_trunc('day',start_time) AS day, count(*) cnt
           FROM sys_query_history
           WHERE query_type = 'SELECT'
           GROUP by 1) query_count
ON date_trunc('day',start_time) = query_count.day
WHERE query_type = 'SELECT'
ORDER BY exec_day;
```

Exemple de sortie.

```
      exec_day       | query_count | p50_runtime | p80_runtime | p90_runtime | p99_runtime  | max_runtime
---------------------+-------------+-------------+-------------+-------------+--------------+--------------
 2022-01-14 00:00:00 |        5253 |  16816922.0 |  69525096.0 | 158524917.8 | 486322477.52 | 1582078873.0
 2022-01-15 00:00:00 |        7004 |  15896130.5 |  71058707.0 | 164314568.9 | 500331542.07 | 1696344792.0
 2022-01-16 00:00:00 |        5253 |  15750451.0 |  72037082.2 | 159513733.4 | 480372059.24 | 1594793766.0
 2022-01-17 00:00:00 |        5309 |  15394513.0 |  68881393.2 | 160254700.0 | 493372245.84 | 1521758640.0
 2022-01-18 00:00:00 |        8092 |  15575286.5 |  68485955.4 | 154559572.5 | 463552685.39 | 1542783444.0
 2022-01-19 00:00:00 |        5860 |  16648747.0 |  72470482.6 | 166485138.2 | 492038228.67 | 1693483241.0
 2022-01-20 00:00:00 |        1751 |  15422072.0 |  69686381.0 | 162315385.0 | 497066615.00 | 1439319739.0
 2022-02-09 00:00:00 |          13 |   6382812.0 |  17616161.6 |  21197988.4 |  23021343.84 |   23168439.0
```

La requête suivante indique la distribution du type de requête.

```
SELECT query_type,
       COUNT(*) AS query_count
FROM sys_query_history
GROUP BY query_type
ORDER BY query_count DESC;
```

Exemple de sortie.

```
 query_type | query_count
------------+-------------
 UTILITY    |      134486
 SELECT     |       38537
 DDL        |        4832
 OTHER      |         768
 LOAD       |         768
 CTAS       |         748
 COMMAND    |          92
```

L’exemple suivant montre la différence des résultats de hachage des requêtes entre plusieurs requêtes. Observez les requêtes suivantes :

```
CREATE TABLE test_table (col1 INT);

INSERT INTO test_table VALUES (1),(2);

SELECT * FROM test_table;

SELECT * FROM test_table;

SELECT col1 FROM test_table;

SELECT * FROM test_table WHERE col1=1;

SELECT * FROM test_table WHERE col1=2;

SELECT query_id, TRIM(user_query_hash) AS user_query_hash, TRIM(generic_query_hash) AS generic_query_hash, TRIM(query_text) AS text FROM sys_query_history ORDER BY start_time
DESC LIMIT 10;
```

Voici un exemple de sortie :

```
query_id | user_query_hash | generic_query_hash | text
---------+-----------------+--------------------+----------
24723049 | oPuFtjEPLTs=    | oPuFtjEPLTs=       | select query_id, trim(user_query_hash) as user_query_hash, trim(generic_query_hash) as generic_query_hash, query_hash_version, trim(query_text) as text from sys_query_history order by start_time\r\ndesc limit 20
24723045 | Gw2Kwdd8m2I=    | IwfRu8/XAKI=       | select * from test_table where col1=2 limit 100
24723041 | LNw2vx0GDXo=    | IwfRu8/XAKI=       | select * from test_table where col1=1 limit 100
24723036 | H+qep/c82Y8=    | H+qep/c82Y8=       | select col1 from test_table limit 100
24723033 | H+qep/c82Y8=    | H+qep/c82Y8=       | select * from test_table limit 100
24723029 | H+qep/c82Y8=    | H+qep/c82Y8=       | select * from test_table limit 100
24723023 | 50sirx9E1hU=    | uO36Z1a/QYs=       | insert into test_table values (1),(2)
24723021 | YSVnlivZHeo=    | YSVnlivZHeo=       | create table test_table (col1 int)
```

`SELECT * FROM test_table;` et `SELECT col1 FROM test_table;` ont la même valeur user\_query\_hash, puisque test\_table ne possède qu’une seule colonne. `SELECT * FROM test_table WHERE col1=1;` et `SELECT * FROM test_table WHERE col1=2;` ont des valeurs user\_query\_hash différentes, mais des valeurs generic\_query\_hash identiques, car les deux requêtes sont identiques en dehors des littéraux de requête 1 et 2.