Utilisation du service Query Acceleration¶

Requêtes éligibles¶

En général, les requêtes sont éligibles parce qu’elles comportent une partie du plan de requête qui peut être exécutée en parallèle en utilisant les ressources de calcul de QAS. Ces requêtes peuvent être classées dans l’un des deux modèles suivants :

• Les grandes analyses avec un filtre d’agrégation ou sélectif.

• Les grandes analyses qui insèrent de nombreuses nouvelles lignes.

Snowflake n’a pas fixé de seuil spécifique pour ce qui constitue une analyse « suffisamment importante » pour être éligible. Le seuil d’éligibilité dépend de divers facteurs, notamment du plan de requête et de la taille de l’entrepôt. Snowflake ne marque une requête comme éligible que s’il y a de fortes chances que la requête soit accélérée si QAS est activé.

Raisons courantes pour lesquelles les requêtes ne sont pas é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.

• Même si une requête dispose d’un filtre, il se peut que les filtres ne soient pas suffisamment sélectifs. Par ailleurs, si la requête comporte une agrégation avec GROUP BY, la cardinalité de l’expression GROUP BY peut être trop élevée pour être éligible.

• 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).

Identification des 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.

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

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

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

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

Identification des requêtes et des 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.

USE ROLE ACCOUNTADMIN;

SELECT query_id, eligible_query_acceleration_time
  FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_ACCELERATION_ELIGIBLE
  WHERE start_time > DATEADD('day', -7, CURRENT_TIMESTAMP())
  ORDER BY eligible_query_acceleration_time DESC;

SELECT query_id, eligible_query_acceleration_time
  FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_ACCELERATION_ELIGIBLE
  WHERE warehouse_name = 'MYWH'
  AND start_time > DATEADD('day', -7, CURRENT_TIMESTAMP())
  ORDER BY eligible_query_acceleration_time DESC;

SELECT warehouse_name, COUNT(query_id) AS num_eligible_queries
  FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_ACCELERATION_ELIGIBLE
  WHERE start_time > DATEADD('day', -7, CURRENT_TIMESTAMP())
  GROUP BY warehouse_name
  ORDER BY num_eligible_queries DESC;

SELECT warehouse_name, SUM(eligible_query_acceleration_time) AS total_eligible_time
  FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_ACCELERATION_ELIGIBLE
  WHERE start_time > DATEADD('day', -7, CURRENT_TIMESTAMP())
  GROUP BY warehouse_name
  ORDER BY total_eligible_time DESC;

SELECT MAX(upper_limit_scale_factor)
  FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_ACCELERATION_ELIGIBLE
  WHERE warehouse_name = 'MYWH'
  AND start_time > DATEADD('day', -7, CURRENT_TIMESTAMP());

SELECT upper_limit_scale_factor, COUNT(upper_limit_scale_factor)
  FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_ACCELERATION_ELIGIBLE
  WHERE warehouse_name = 'MYWH'
  AND start_time > DATEADD('day', -7, CURRENT_TIMESTAMP())
  GROUP BY 1 ORDER BY 1;

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 l’accélérations de requêtes (dans ce chapitre).

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

Utilisation de l’interface Web pour surveiller l’utilisation de l’accélération des requêtes¶

Une fois que vous avez activé le service d’accélération des requêtes, vous pouvez consulter le panneau Profile Overview dans l”onglet Profil de requête 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.

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 Statistiques), 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 :

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 l’accélération des requêtes¶

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.

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;

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;

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 :

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.

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;

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.

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;

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.

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).

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;

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.

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_eligible_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_eligible_or_accelerated;

La sortie de l’instruction comprend les colonnes suivantes :