Uso do Query Acceleration Service¶

Consultas qualificadas¶

Em geral, as consultas são qualificadas porque têm uma parte do plano de consulta que pode ser executada em paralelo usando os recursos de computação do QAS. Essas consultas se enquadram em um dos dois padrões:

• Grandes verificações com um filtro de agregação ou seletivo.

• Grandes verificações que inserem muitas linhas novas.

O Snowflake não tem um limite específico para o que constitui uma verificação “grande o suficiente” para ser qualificada. O limite de elegibilidade depende de vários fatores, incluindo o plano de consulta e o tamanho do warehouse. O Snowflake somente marca uma consulta como qualificada se houver um alto nível de confiança de que ela será acelerada com a ativação do QAS.

Motivos comuns pelos quais as consultas não são qualificadas¶

Algumas consultas não são qualificadas para aceleração de consulta. As seguintes são razões comuns pelas quais uma consulta não pode ser acelerada:

• Não há partições suficientes na verificação. Se não houver partições suficientes para verificar, os benefícios da aceleração de consulta serão compensados pela latência na aquisição de recursos para o serviço de aceleração de consulta.

• Mesmo que uma consulta tenha um filtro, os filtros podem não ser seletivos o suficiente. Alternativamente, se a consulta tiver uma agregação com GROUP BY, a cardinalidade da expressão GROUP BY pode ser alta demais para elegibilidade.

• A consulta inclui uma cláusula LIMIT, mas não possui uma cláusula ORDER BY.

• A consulta inclui funções que retornam resultados não determinísticos (por exemplo, SEQ ou RANDOM).

Identificação de consultas com a função SYSTEM$ESTIMATE_QUERY_ACCELERATION¶

A função SYSTEM$ESTIMATE_QUERY_ACCELERATION pode ajudar a determinar se uma consulta previamente executada pode se beneficiar do Query Acceleration Service. Se a consulta for elegível para aceleração de consulta, a função retorna o tempo estimado de execução da consulta para diferentes fatores de escala da aceleração de consultas.

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
}

Identificação de consultas e warehouses com a exibição QUERY_ACCELERATION_ELIGIBLE¶

Consulte o Exibição QUERY_ACCELERATION_ELIGIBLE para identificar as consultas e warehouses que podem se beneficiar ao máximo do Query Acceleration Service. Para cada consulta, a exibição inclui a quantidade de tempo de execução da consulta que é elegível para o Query Acceleration Service.

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;

Exemplos¶

O exemplo a seguir habilita o Query Acceleration Service para um warehouse chamado my_wh:

CREATE WAREHOUSE my_wh WITH
  ENABLE_QUERY_ACCELERATION = true;

Copy

Execute o comando SHOW WAREHOUSES para exibir detalhes sobre o warehouse 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

O Query Acceleration Service pode aumentar a taxa de consumo de crédito de um warehouse. O fator de escala máximo pode ajudar a limitar a taxa de consumo. Consulte CREATE WAREHOUSE ou ALTER WAREHOUSE para mais detalhes sobre a propriedade QUERY_ACCELERATION_MAX_SCALE_FACTOR.

A exibição QUERY_ACCELERATION_ELIGIBLE e a função SYSTEM$ESTIMATE_QUERY_ACCELERATION podem ser úteis para determinar um fator de escala apropriado para um warehouse. Consulte Identificação de consultas e warehouses que podem se beneficiar da aceleração das consultas (neste tópico) para obter mais detalhes.

Exemplo¶

O exemplo a seguir modifica o warehouse chamado my_wh para habilitar o Query Acceleration Service para um fator de escala máximo de 0.

ALTER WAREHOUSE my_wh SET
  ENABLE_QUERY_ACCELERATION = true
  QUERY_ACCELERATION_MAX_SCALE_FACTOR = 0;

Copy

Uso da interface da Web para monitorar o uso da aceleração da consulta¶

Uma vez ativado o Query Acceleration Service, você pode visualizar o painel Profile Overview na guia Perfil de consulta para ver os efeitos dos resultados da aceleração de consulta.

A captura de tela a seguir mostra um exemplo das estatísticas exibidas para a consulta em geral. Se várias operações em uma consulta foram aceleradas, os resultados são agregados nesta exibição para que você possa ver a quantidade total de trabalho realizado pelo Query Acceleration Service.

A seção Query Acceleration do painel Profile Overview inclui as seguintes estatísticas:

• Partitions scanned by service — número de arquivos descarregados para verificação no Query Acceleration Service.

• Scans selected for acceleration — número de verificações de tabela sendo aceleradas.

Nos detalhes do operador (consulte Estatísticas), clique no operador para ver informações detalhadas. A seguinte captura de tela mostra um exemplo das estatísticas exibidas para uma operação TableScan:

A seção Query Acceleration do painel de detalhes TableScan inclui as seguintes estatísticas:

• Partitions scanned by service — número de arquivos descarregados para verificação no Query Acceleration Service.

Uso da exibição Account Usage QUERY_HISTORY para monitorar o uso da aceleração da consulta¶

Para ver os efeitos da aceleração de uma consulta, use as seguintes colunas no Exibição QUERY_HISTORY.

• QUERY_ACCELERATION_BYTES_SCANNED

• QUERY_ACCELERATION_PARTITIONS_SCANNED

• QUERY_ACCELERATION_UPPER_LIMIT_SCALE_FACTOR

Você pode usar estas colunas para identificar as consultas que se beneficiaram com o Query Acceleration Service. Para cada consulta, você também pode determinar o número total de partições e bytes verificados pelo Query Acceleration Service.

Para descrições de cada uma dessas colunas, consulte Exibição QUERY_HISTORY.

Por exemplo, para encontrar as consultas com mais bytes verificados pelo Query Acceleration Service nas últimas 24 horas:

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;

Para encontrar as consultas com o maior número de partições verificadas pelo Query Acceleration Service nas últimas 24 horas:

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;

Visualização de informações de faturamento no console clássico¶

Se você tiver o Query Acceleration Service habilitado para sua conta, a página de faturamento na Classic Console incluirá um warehouse chamado QUERY_ACCELERATION que mostra todos os créditos utilizados pelo serviço em todos os warehouses de sua conta.

A captura de tela abaixo mostra um exemplo das informações de faturamento exibidas para o warehouse QUERY_ACCELERATION:

Visualização do faturamento usando a exibição Account Usage QUERY_ACCELERATION_HISTORY¶

Você pode visualizar os dados de faturamento no Account Usage Exibição QUERY_ACCELERATION_HISTORY.

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;

Visualização do faturamento usando a exibição Organization Usage QUERY_ACCELERATION_HISTORY¶

Você pode visualizar os dados de faturamento do Query Acceleration Service para todas as contas da sua organização no Organization Usage Exibição QUERY_ACCELERATION_HISTORY.

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;

Visualização do faturamento usando a função QUERY_ACCELERATION_HISTORY¶

Você também pode visualizar os dados de faturamento usando a função QUERY_ACCELERATION_HISTORY do Information Schema.

Visualização dos custos de warehouse e Query Acceleration Service¶

A consulta a seguir calcula os custos do warehouse e do Query Acceleration Service para um warehouse específico. Você pode executar esta consulta depois de ativar o Query Acceleration Service para um warehouse para comparar custos antes e depois de ativar a aceleração de consulta. O período da consulta começa 8 semanas antes do primeiro uso de crédito para o Query Acceleration Service até 8 semanas após o último custo incorrido para o Query Acceleration Service (ou até a data atual).

Este exemplo de consulta retorna os custos do warehouse e do Query Acceleration Service para 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;

Visualização do desempenho da consulta¶

Esta consulta retorna o tempo médio de execução para consultas elegíveis para aceleração de consulta para um determinado warehouse. O período da consulta começa 8 semanas antes do primeiro uso de crédito para o Query Acceleration Service até 8 semanas após o último custo incorrido para o Query Acceleration Service (ou até a data atual). Os resultados podem ajudar você a avaliar como o desempenho médio da consulta mudou após a ativação do Query Acceleration Service.

Este exemplo de consulta retorna o tempo de execução da consulta por dia e calcula a média de 7 dias da semana anterior para consultas qualificadas para aceleração no warehouse 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;

A saída da instrução inclui as seguintes colunas: