Utilisation du service Query Acceleration

Le service d’accélération des requêtes peut accélérer certaines parties de la charge de travail des requêtes dans un entrepôt. Lorsqu’elle est activée pour un entrepôt, elle peut améliorer les performances globales de l’entrepôt en réduisant l’impact des requêtes aberrantes, qui sont des requêtes qui utilisent plus de ressources que la requête ordinaire. Pour ce faire, le service d’accélération des requêtes décharge des parties du travail de traitement des requêtes sur des ressources de calcul partagées qui sont fournies par le service.

Voici quelques exemples des types de charges de travail qui pourraient bénéficier du service d’accélération des requêtes :

  • Analyses ad hoc.

  • Charges de travail avec un volume de données imprévisible par requête.

  • Requêtes avec de grandes analyses et des filtres sélectifs.

Le service d’accélération des requêtes peut traiter ces types de charges de travail plus efficacement en effectuant davantage de travaux en parallèle et en réduisant le temps de type durée chronométrée consacré à l’analyse et au filtrage.

Note

Query Acceleration Service dépend de la disponibilité des serveurs. Par conséquent, les améliorations des performances peuvent fluctuer dans le temps.

Dans ce chapitre :

Identification des requêtes et des entrepôts qui pourraient bénéficier de Query Acceleration

Pour identifier les requêtes qui pourraient bénéficier du service d’accélération des requêtes, vous pouvez utiliser la fonction SYSTEM$ESTIMATE_QUERY_ACCELERATION ou interroger Vue QUERY_ACCELERATION_ELIGIBLE. La vue QUERY_ACCELERATION_ELIGIBLE identifie également les entrepôts qui pourraient bénéficier du service d’accélération des requêtes.

Requêtes inéligibles

Certaines requêtes ne sont pas éligibles pour l’accélération des requêtes. Voici les raisons courantes pour lesquelles une requête ne peut pas être accélérée :

  • Il n’y a pas assez de partitions. S’il n’existe pas assez de partitions à analyser, les avantages de l’accélération des requêtes sont compensés par la latence nécessaire à l’acquisition des ressources pour le service d’accélération des requêtes.

  • La requête n’est ni filtrée, ni agrégée.

  • Les filtres ne sont pas assez sélectifs. Par ailleurs, l’expression GROUP BY a une cardinalité élevée.

  • La requête comprend une clause LIMIT, mais pas de clause ORDER BY.

  • La requête comprend des fonctions qui renvoient des résultats non déterministes (par exemple, SEQ ou RANDOM).

Identifier les requêtes avec la fonction SYSTEM$ESTIMATE_QUERY_ACCELERATION

La fonction SYSTEM$ESTIMATE_QUERY_ACCELERATION peut aider à déterminer si une requête exécutée précédemment peut bénéficier du service d’accélération des requêtes. Si la requête est éligible à l’accélération des requêtes, la fonction renvoie le temps d’exécution estimé de la requête pour différents facteurs d’échelle d’accélération.

Exemple

Exécutez l’instruction suivante pour déterminer si l’accélération des requêtes peut être bénéfique à une requête spécifique :

SELECT PARSE_JSON(SYSTEM$ESTIMATE_QUERY_ACCELERATION('8cd54bf0-1651-5b1c-ac9c-6a9582ebd20f'));
Copy

Dans cet exemple, la requête est éligible au service d’accélération des requêtes et comprend des temps de requête estimés en utilisant le service :

{
  "estimatedQueryTimes": {
    "1": 171,
    "10": 115,
    "2": 152,
    "4": 133,
    "8": 120
  },
  "originalQueryTime": 300.291,
  "queryUUID": "8cd54bf0-1651-5b1c-ac9c-6a9582ebd20f",
  "status": "eligible",
  "upperLimitScaleFactor": 10
}
Copy

L’exemple suivant montre les résultats d’une requête qui n’est pas éligible au service d’accélération des requêtes :

SELECT PARSE_JSON(SYSTEM$ESTIMATE_QUERY_ACCELERATION('cf23522b-3b91-cf14-9fe0-988a292a4bfa'));
Copy

L’instruction ci-dessus produit le résultat suivant :

{
  "estimatedQueryTimes": {},
  "originalQueryTime": 20.291,
  "queryUUID": "cf23522b-3b91-cf14-9fe0-988a292a4bfa",
  "status": "ineligible",
  "upperLimitScaleFactor": 0
}
Copy

Identifier les requêtes et les entrepôts avec la vue QUERY_ACCELERATION_ELIGIBLE

Interrogez Vue QUERY_ACCELERATION_ELIGIBLE pour identifier les requêtes et les entrepôts qui pourraient bénéficier le plus du service d’accélération des requêtes. Pour chaque requête, la vue inclut la quantité de temps d’exécution de la requête qui est éligible pour le service d’accélération des requêtes.

Exemples

Note

Ces exemples supposent que le rôle ACCOUNTADMIN (ou un rôle ayant obtenu des PRIVILEGES IMPORTED pour la base de données SNOWFLAKE partagée) est utilisé. S’il n’est pas utilisé, exécutez la commande suivante avant d’exécuter les requêtes dans les exemples :

USE ROLE ACCOUNTADMIN;
Copy

Identifiez les requêtes qui pourraient bénéficier le plus du service en fonction du temps d’exécution de la requête qui pourrait être accéléré :

SELECT query_id, eligible_query_acceleration_time
  FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_ACCELERATION_ELIGIBLE
  ORDER BY eligible_query_acceleration_time DESC;
Copy

Identifiez les requêtes qui pourraient bénéficier le plus du service dans un entrepôt spécifique mywh :

SELECT query_id, eligible_query_acceleration_time
  FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_ACCELERATION_ELIGIBLE
  WHERE warehouse_name = 'mywh'
  ORDER BY eligible_query_acceleration_time DESC;
Copy

Identifiez les entrepôts ayant le plus de requêtes éligibles dans une période donnée au service d’accélération des requêtes :

SELECT warehouse_name, COUNT(query_id) AS num_eligible_queries
  FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_ACCELERATION_ELIGIBLE
  WHERE start_time > 'Mon, 29 May 2023 00:00:00'::timestamp
  AND end_time < 'Tue, 30 May 2023 00:00:00'::timestamp
  GROUP BY warehouse_name
  ORDER BY num_eligible_queries DESC;
Copy

Identifiez les entrepôts dont le temps d’éligibilité au service d’accélération des requêtes est le plus élevé :

SELECT warehouse_name, SUM(eligible_query_acceleration_time) AS total_eligible_time
  FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_ACCELERATION_ELIGIBLE
  GROUP BY warehouse_name
  ORDER BY total_eligible_time DESC;
Copy

Identifiez le facteur d’échelle de la limite supérieure pour le service d’accélération des requêtes pour un entrepôt donné :

SELECT MAX(upper_limit_scale_factor)
  FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_ACCELERATION_ELIGIBLE
  WHERE warehouse_name = 'mywh';
Copy

Identifiez la distribution des facteurs d’échelle pour le service d’accélération des requêtes pour un entrepôt donné :

SELECT upper_limit_scale_factor, COUNT(upper_limit_scale_factor)
  FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_ACCELERATION_ELIGIBLE
  WHERE warehouse_name = '<warehouse_name>'
  GROUP BY 1 ORDER BY 1;
Copy

Activation de Query Acceleration

Activez le service d’accélération des requêtes en spécifiant ENABLE_QUERY_ACCELERATION = TRUE lors de la création d’un entrepôt (en utilisant CREATE WAREHOUSE) ou ultérieurement (en utilisant ALTER WAREHOUSE).

Commandes SQL prises en charge

Le service d’accélération des requêtes prend en charge les commandes suivantes SQL :

  • SELECT

  • INSERT (lorsque l’instruction contient une instruction SELECT)

  • CREATE TABLE AS SELECT (CTAS)

Une requête, ou une partie d’une requête (c’est-à-dire une sous-requête ou une clause), avec une commande SQL prise en charge peuvent être accélérées par Query Acceleration Service si elles sont éligibles à l’accélération.

Exemples

L’exemple suivant active Query Acceleration Service pour un entrepôt nommé my_wh :

CREATE WAREHOUSE my_wh WITH
  ENABLE_QUERY_ACCELERATION = true;
Copy

Exécutez la commande SHOW WAREHOUSES pour afficher les détails de l’entrepôt my_wh.

SHOW WAREHOUSES LIKE 'my_wh';

+---------+---------+----------+---------+---------+--------+------------+------------+--------------+-------------+-----------+--------------+-----------+-------+-------------------------------+-------------------------------+-------------------------------+--------------+---------+---------------------------+-------------------------------------+------------------+---------+----------+--------+-----------+------------+
| name    | state   | type     | size    | running | queued | is_default | is_current | auto_suspend | auto_resume | available | provisioning | quiescing | other | created_on                    | resumed_on                    | updated_on                    | owner        | comment | enable_query_acceleration | query_acceleration_max_scale_factor | resource_monitor | actives | pendings | failed | suspended | uuid       |
|---------+---------+----------+---------+---------+--------+------------+------------+--------------+-------------+-----------+--------------+-----------+-------+-------------------------------+-------------------------------+-------------------------------+--------------+---------+---------------------------+-------------------------------------+------------------+---------+----------+--------+-----------+------------|
| MY_WH   | SUSPENDED | STANDARD | Medium |       0 |      0 | N          | N          |          600 | true        |           |              |           |       | 2023-01-20 14:31:49.283 -0800 | 2023-01-20 14:31:49.388 -0800 | 2023-01-20 16:34:28.583 -0800 | ACCOUNTADMIN |         | true                      |                                   8 | null             |       0 |        0 |      0 |         4 | 1132659053 |
+---------+---------+----------+---------+---------+--------+------------+------------+--------------+-------------+-----------+--------------+-----------+-------+-------------------------------+-------------------------------+-------------------------------+--------------+---------+---------------------------+-------------------------------------+------------------+---------+----------+--------+-----------+------------+
Copy

Le service d’accélération des requêtes peut augmenter le taux de consommation des crédits d’un entrepôt. Le facteur d’échelle maximal peut contribuer à limiter le taux de consommation. Voir CREATE WAREHOUSE ou ALTER WAREHOUSE pour plus de détails sur la propriété QUERY_ACCELERATION_MAX_SCALE_FACTOR.

La vue QUERY_ACCELERATION_ELIGIBLE et la fonction SYSTEM$ESTIMATE_QUERY_ACCELERATION peuvent être utiles pour déterminer un facteur d’échelle approprié pour un entrepôt. Pour plus de détails, voir Identification des requêtes et des entrepôts qui pourraient bénéficier de Query Acceleration (dans ce chapitre).

Ajustement du facteur d’échelle

Le facteur d’échelle est un mécanisme de contrôle des coûts qui vous permet de fixer une limite supérieure à la quantité de ressources informatiques qu’un entrepôt peut louer pour l’accélération des requêtes. Cette valeur est utilisée comme un multiplicateur basé sur la taille et le coût de l’entrepôt.

Par exemple, supposons que vous définissiez le facteur d’échelle à 5 pour un entrepôt de taille moyenne. Cela signifie que :

  • L’entrepôt peut louer des ressources informatiques jusqu’à 5 fois la taille d’un entrepôt moyen.

  • Comme un entrepôt moyen coûte 4 crédits par heure, la location de ces ressources peut coûter jusqu’à 20 crédits supplémentaires par heure (4 crédits par entrepôt x 5 fois sa taille).

Le coût est le même, quel que soit le nombre de requêtes qui utilisent Query Acceleration Service en même temps. Query Acceleration Service est facturé à la seconde, uniquement lorsqu’il est utilisé. Ces crédits sont facturés indépendamment de l’utilisation de l’entrepôt.

Toutes les requêtes ne nécessitent pas l’ensemble des ressources rendues disponibles par le facteur d’échelle. La quantité de ressources demandées pour le service dépend de la quantité de la requête qui peut être accélérée et de la quantité de données qui seront traitées pour y répondre. Quelle que soit la valeur du facteur d’échelle ou la quantité de ressources demandées, la quantité de ressources informatiques disponibles pour l’accélération des requêtes est limitée par la disponibilité des ressources dans le service et le nombre d’autres requêtes simultanées. Query Acceleration Service n’utilise que les ressources dont il a besoin et qui sont disponibles au moment de l’exécution de la requête.

Si le facteur d’échelle n’est pas explicitement défini, la valeur par défaut est 8. La définition du facteur d’échelle à 0 élimine la limite supérieure et permet aux requêtes de louer autant de ressources que nécessaire et autant de ressources que disponibles pour traiter la requête.

Exemple

L’exemple suivant modifie l’entrepôt nommé my_wh pour activer Query Acceleration Service avec un facteur d’échelle maximum de 0.

ALTER WAREHOUSE my_wh SET
  ENABLE_QUERY_ACCELERATION = true
  QUERY_ACCELERATION_MAX_SCALE_FACTOR = 0;
Copy

Surveillance de l’utilisation du service Query Acceleration

Utilisation de l’interface Web pour surveiller l’utilisation de Query Acceleration

Une fois que vous avez activé le service d’accélération des requêtes, vous pouvez consulter le panneau Présentation du profil dans Profil des requêtes pour voir les effets des résultats de l’accélération des requêtes.

La capture d’écran suivante montre un exemple des statistiques affichées pour la requête globale. Si plusieurs opérations d’une requête ont été accélérées, les résultats sont agrégés dans cette vue afin que vous puissiez voir la quantité totale de travail effectué par le service d’accélération des requêtes.

../_images/query-acceleration-profile-overview.png

La section Query Acceleration du panneau Profile Overview comprend les statistiques suivantes :

  • Partitions analysées par le service — nombre de fichiers déchargés dont l’analyse a été confiée au service d’accélération des requêtes.

  • Analyses sélectionnées pour l’accélération — nombre d’analyses de table en cours d’accélération.

Dans les détails de l’opérateur (voir Vue d’ensemble du profil/détails sur l’opérateur pour plus d’informations), cliquez sur l’opérateur pour voir des informations détaillées. La capture d’écran suivante montre un exemple des statistiques affichées pour une opération TableScan :

../_images/query-acceleration-table-scan.png

La section Query Acceleration du panneau de détails TableScan comprend les statistiques suivantes :

  • Partitions analysées par le service — nombre de fichiers déchargés dont l’analyse a été confiée au service d’accélération des requêtes.

Utilisation de la vue QUERY_HISTORY Account Usage pour surveiller l’utilisation de Query Acceleration

Pour voir les effets de l’accélération des requêtes sur une requête, vous pouvez utiliser les colonnes suivantes dans Vue QUERY_HISTORY.

  • QUERY_ACCELERATION_BYTES_SCANNED

  • QUERY_ACCELERATION_PARTITIONS_SCANNED

  • QUERY_ACCELERATION_UPPER_LIMIT_SCALE_FACTOR

Vous pouvez utiliser ces colonnes pour identifier les requêtes qui ont bénéficié du service d’accélération des requêtes. Pour chaque requête, vous pouvez également déterminer le nombre total de partitions et d’octets analysés par le service d’accélération des requêtes.

Pour la description de chacune de ces colonnes, voir Vue QUERY_HISTORY.

Note

Pour une requête donnée, la somme des colonnes QUERY_ACCELERATION_BYTES_SCANNED et BYTES_SCANNED peut être plus importante lorsque le service d’accélération des requêtes est utilisé que lorsqu’il ne l’est pas. Il en va de même pour la somme des colonnes QUERY_ACCELERATION_PARTITIONS_SCANNED et PARTITIONS_SCANNED.

L’augmentation du nombre d’octets et de partitions est due aux résultats intermédiaires générés par le service pour faciliter l’accélération des requêtes.

Par exemple, pour trouver les requêtes ayant le plus d’octets analysés par le service d’accélération des requêtes au cours des 24 dernières heures :

SELECT query_id,
       query_text,
       warehouse_name,
       start_time,
       end_time,
       query_acceleration_bytes_scanned,
       query_acceleration_partitions_scanned,
       query_acceleration_upper_limit_scale_factor
  FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_HISTORY
  WHERE query_acceleration_partitions_scanned > 0 
  AND start_time >= DATEADD(hour, -24, CURRENT_TIMESTAMP())
  ORDER BY query_acceleration_bytes_scanned DESC;
Copy

Trouver les requêtes avec le plus grand nombre de partitions analysées par le service d’accélération des requêtes dans les 24 dernières heures :

SELECT query_id,
       query_text,
       warehouse_name,
       start_time,
       end_time,
       query_acceleration_bytes_scanned,
       query_acceleration_partitions_scanned,
       query_acceleration_upper_limit_scale_factor
  FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_HISTORY
  WHERE query_acceleration_partitions_scanned > 0 
  AND start_time >= DATEADD(hour, -24, CURRENT_TIMESTAMP())
  ORDER BY query_acceleration_partitions_scanned DESC;
Copy

Coût de Query Acceleration Service

L’accélération des requêtes consomme des crédits car elle utilise des ressources de calcul sans serveur pour exécuter des parties de requêtes éligibles.

L’accélération des requêtes est facturée comme les autres fonctionnalités sans serveur de Snowflake, en ce sens que vous payez à la seconde les ressources de calcul utilisées. Pour savoir combien de crédits par heure de calcul sont consommés par Query Acceleration Service, reportez-vous au « Tableau des crédits de fonctionnalité sans serveur » dans le tableau de consommation des services Snowflake.

Affichage des informations de facturation dans la console classique

Si Query Acceleration est activé pour votre compte, la page de facturation de l”Classic Console comprend un entrepôt appelé QUERY_ACCELERATION qui indique tous les crédits utilisés par le service dans tous les entrepôts de votre compte.

La capture d’écran ci-dessous montre un exemple des informations de facturation affichées pour l’entrepôt QUERY_ACCELERATION :

../_images/query-acceleration-billing-ui.png

Visualisation de la facturation en utilisant la vue QUERY_ACCELERATION_HISTORY Account Usage

Vous pouvez voir les données de facturation dans Vue QUERY_ACCELERATION_HISTORY Account Usage.

Exemple

Cette requête renvoie le nombre total de crédits utilisés par chaque entrepôt de votre compte pour Query Acceleration Service (depuis le début du mois) :

SELECT warehouse_name,
       SUM(credits_used) AS total_credits_used
  FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_ACCELERATION_HISTORY
  WHERE start_time >= DATE_TRUNC(month, CURRENT_DATE)
  GROUP BY 1
  ORDER BY 2 DESC;
Copy

Vue de la facturation à l’aide de la vue QUERY_ACCELERATION_HISTORY Utilisation de l’organisation

Vous pouvez voir les données de facturation du service d’accélération des requêtes pour tous les comptes de votre organisation dans la section Vue QUERY_ACCELERATION_HISTORY Utilisation de l’organisation.

Exemple

Cette requête renvoie le nombre total de crédits utilisés par chaque entrepôt dans chaque compte pour le service d’accélération de requêtes (depuis le début du mois) :

SELECT account_name,
       warehouse_name,
       SUM(credits_used) AS total_credits_used
  FROM SNOWFLAKE.ORGANIZATION_USAGE.QUERY_ACCELERATION_HISTORY
  WHERE usage_date >= DATE_TRUNC(month, CURRENT_DATE)
  GROUP BY 1, 2
  ORDER BY 3 DESC;
Copy

Affichage de la facturation à l’aide de la fonction QUERY_ACCELERATION_HISTORY

Vous pouvez également consulter les données de facturation à l’aide de la fonction Information Schema QUERY_ACCELERATION_HISTORY.

Exemple

L’exemple suivant utilise la fonction QUERY_ACCELERATION_HISTORY pour renvoyer des informations sur les requêtes accélérées par ce service au cours des 12 dernières heures :

SELECT start_time,
       end_time,
       credits_used,
       warehouse_name,
       num_files_scanned,
       num_bytes_scanned
  FROM TABLE(INFORMATION_SCHEMA.QUERY_ACCELERATION_HISTORY(
    date_range_start=>DATEADD(H, -12, CURRENT_TIMESTAMP)));
Copy

Évaluation des coûts et des performances

Cette section comprend des exemples de requêtes qui peuvent vous aider à évaluer les performances et le coût des requêtes avant et après l’activation du service d’accélération des requêtes.

Visualisation des coûts du service d’accélération de l’entrepôt et des requêtes

La requête suivante calcule les coûts de l’entrepôt et du service d’accélération des requêtes pour un entrepôt spécifique. Vous pouvez exécuter cette requête après avoir activé le service d’accélération des requêtes pour un entrepôt afin de comparer les coûts avant et après l’activation de l’accélération des requêtes. La plage de dates pour la requête commence 8 semaines avant la première utilisation du crédit pour le service d’accélération des requêtes et se termine 8 semaines après le dernier coût encouru pour le service d’accélération des requêtes (ou jusqu’à la date actuelle).

Note

  • Cette requête est particulièrement utile pour évaluer le coût du service si les propriétés de l’entrepôt et la charge de travail restent les mêmes avant et après l’activation du service d’accélération des requêtes.

  • Cette requête ne renvoie des résultats que si des crédits ont été utilisés pour des requêtes accélérées dans l’entrepôt.

Cet exemple de requête renvoie les coûts de l’entrepôt et du service d’accélération des requêtes pour my_warehouse :

WITH credits AS (
  SELECT 'QC' AS credit_type,
         TO_DATE(end_time) AS credit_date,
         SUM(credits_used) AS num_credits
    FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_ACCELERATION_HISTORY
    WHERE warehouse_name = 'my_warehouse'
    AND credit_date BETWEEN
           DATEADD(WEEK, -8, (
             SELECT TO_DATE(MIN(end_time))
               FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_ACCELERATION_HISTORY
               WHERE warehouse_name = 'my_warehouse'
           ))
           AND
           DATEADD(WEEK, +8, (
             SELECT TO_DATE(MAX(end_time))
               FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_ACCELERATION_HISTORY
               WHERE warehouse_name = 'my_warehouse'
           ))
  GROUP BY credit_date
  UNION ALL
  SELECT 'WC' AS credit_type,
         TO_DATE(end_time) AS credit_date,
         SUM(credits_used) AS num_credits
    FROM SNOWFLAKE.ACCOUNT_USAGE.WAREHOUSE_METERING_HISTORY
    WHERE warehouse_name = 'my_warehouse'
    AND credit_date BETWEEN
           DATEADD(WEEK, -8, (
             SELECT TO_DATE(MIN(end_time))
               FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_ACCELERATION_HISTORY
               WHERE warehouse_name = 'my_warehouse'
           ))
           AND
           DATEADD(WEEK, +8, (
             SELECT TO_DATE(MAX(end_time))
               FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_ACCELERATION_HISTORY
               WHERE warehouse_name = 'my_warehouse'
           ))
  GROUP BY credit_date
)
SELECT credit_date,
       SUM(IFF(credit_type = 'QC', num_credits, 0)) AS qas_credits,
       SUM(IFF(credit_type = 'WC', num_credits, 0)) AS compute_credits,
       compute_credits + qas_credits AS total_credits,
       AVG(total_credits) OVER (
         PARTITION BY NULL ORDER BY credit_date ROWS BETWEEN 6 PRECEDING AND CURRENT ROW)
         AS avg_total_credits_7days
  FROM credits
  GROUP BY credit_date
  ORDER BY credit_date;
Copy

Affichage des performances des requêtes

Cette requête renvoie le temps d’exécution moyen des requêtes éligibles à l’accélération des requêtes pour un entrepôt donné. La plage de dates pour la requête commence 8 semaines avant la première utilisation du crédit pour le service d’accélération des requêtes et se termine 8 semaines après le dernier coût encouru pour le service d’accélération des requêtes (ou jusqu’à la date actuelle). Les résultats peuvent vous aider à évaluer l’évolution des performances moyennes des requêtes après l’activation du service d’accélération des requêtes.

Note

  • Cette requête est particulièrement utile pour évaluer les performances des requêtes si la charge de travail de l’entrepôt reste la même avant et après l’activation du service d’accélération des requêtes.

  • Si la charge de travail de l’entrepôt reste stable, la valeur de la colonne num_execs devrait rester la même.

  • Si la valeur de la colonne num_execs des résultats de la requête augmente ou diminue de façon spectaculaire, les résultats de cette requête ne seront probablement pas utiles pour l’évaluation des performances de la requête.

Cet exemple de requête renvoie le temps d’exécution des requêtes par jour et calcule la moyenne des 7 jours de la semaine précédente pour les requêtes éligibles à l’accélération dans l’entrepôt my_warehouse :

WITH qas_eligble_or_accelerated AS (
  SELECT TO_DATE(qh.end_time) AS exec_date,
        COUNT(*) AS num_execs,
        SUM(qh.execution_time) AS exec_time,
        MAX(IFF(qh.query_acceleration_bytes_scanned > 0, 1, NULL)) AS qas_accel_flag
    FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_HISTORY AS qh
    WHERE qh.warehouse_name = 'my_warehouse'
    AND TO_DATE(qh.end_time) BETWEEN
           DATEADD(WEEK, -8, (
             SELECT TO_DATE(MIN(end_time))
               FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_ACCELERATION_HISTORY
              WHERE warehouse_name = 'my_warehouse'
           ))
           AND
           DATEADD(WEEK, +8, (
             SELECT TO_DATE(MAX(end_time))
               FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_ACCELERATION_HISTORY
              WHERE warehouse_name = 'my_warehouse'
           ))
    AND (qh.query_acceleration_bytes_scanned > 0
          OR
          EXISTS (
            SELECT 1
              FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_ACCELERATION_ELIGIBLE AS qae
               WHERE qae.query_id = qh.query_id
               AND qae.warehouse_name = qh.warehouse_name
          )
         )
    GROUP BY exec_date
)
SELECT exec_date,
       SUM(exec_time) OVER (
         PARTITION BY NULL ORDER BY exec_date ROWS BETWEEN 6 PRECEDING AND CURRENT ROW
       ) /
       NULLIFZERO(SUM(num_execs) OVER (
         PARTITION BY NULL ORDER BY exec_date ROWS BETWEEN 6 PRECEDING AND CURRENT ROW)
       ) AS avg_exec_time_7days,
      exec_time / NULLIFZERO(num_execs) AS avg_exec_time,
      qas_accel_flag,
      num_execs,
      exec_time
  FROM qas_eligble_or_accelerated;
Copy

La sortie de l’instruction comprend les colonnes suivantes :

Colonne

Description

EXEC_DATE

Date d’exécution des requêtes.

AVG_EXEC_TIME_7DAYS

Le temps d’exécution moyen pour les 7 jours précédents, y compris EXEC_DATE.

AVG_EXEC_TIME

Le temps moyen d’exécution de la requête.

QAS_ACCEL_FLAG

1 si des requêtes ont été accélérées ; NULL si aucune requête n’a été accélérée.

NUM_EXECS

Nombre de requêtes accélérées.

EXEC_TIME

Temps d’exécution total de toutes les requêtes éligibles à l’accélération des requêtes.

Compatibilité avec l’optimisation de la recherche

L’accélération des requêtes et l”optimisation de la recherche peuvent fonctionner ensemble pour optimiser les performances des requêtes. Tout d’abord, l’optimisation de la recherche permet d’assainir les micro-partitions qui ne sont pas nécessaires pour une requête. Ensuite, pour les requêtes éligibles, l’accélération des requêtes peut décharger une partie du reste du travail sur des ressources de calcul partagées fournies par le service.

Les performances des requêtes accélérées par les deux services varient en fonction de la charge de travail et des ressources disponibles.