RESULT_SCAN¶

Sintaxe¶

RESULT_SCAN ( [ { '<query_id>' | <query_index>  | LAST_QUERY_ID() } ] )

Argumentos¶

'query_id' ou query_index ou LAST_QUERY_ID()

Uma especificação de uma consulta executada nas últimas 24 horas em qualquer sessão, um índice inteiro de uma consulta na sessão atual ou a função LAST_QUERY_ID, que retorna o ID de uma consulta dentro de sua sessão atual.

IDs de consulta Snowflake são cadeias de caracteres exclusivas que se assemelham a 01b71944-0001-b181-0000-0129032279f6.

Os índices de consulta são relativos à primeira consulta na sessão atual (se positiva) ou à consulta mais recente (se negativa). Por exemplo, RESULT_SCAN(-1) é equivalente a RESULT_SCAN(LAST_QUERY_ID()).

Este argumento é opcional. Se for omitido, o padrão é RESULT_SCAN(-1), que retorna o conjunto de resultados do comando mais recente.

Notas de uso¶

• Se a consulta original foi executada manualmente, somente o usuário que executou a consulta original pode usar a função RESULT_SCAN para processar a saída da consulta. Mesmo um usuário com o privilégio ACCOUNTADMIN não pode acessar os resultados da consulta de outro usuário chamando RESULT_SCAN.

• Se a consulta original foi executada usando uma tarefa, a função que possui a tarefa, em vez de um usuário específico, acionou e executou a consulta. Se um usuário ou tarefa estiver operando com a mesma função, ele poderá usar RESULT_SCAN para acessar os resultados da consulta.

• O Snowflake armazena todos os resultados das consultas por 24 horas. Esta função só retorna resultados para consultas que foram executadas dentro deste período.

• Os conjuntos de resultados não têm metadados associado a eles, portanto, o processamento de grandes resultados pode ser mais lento do que se você estivesse consultando uma tabela real.

• A consulta contendo RESULT_SCAN pode incluir cláusulas, como filtros e cláusulas ORDER BY que não estavam na consulta original. Você pode usar essas cláusulas para reduzir ou modificar o conjunto de resultados.

• Uma RESULT_SCAN não garante retornar as linhas na mesma ordem em que a consulta original retornou as linhas. Você pode incluir uma cláusula ORDER BY com a consulta RESULT_SCAN para especificar uma ordem específica.

• Para recuperar a ID para uma consulta específica, use qualquer um dos seguintes métodos:

  Snowsight:

  Em qualquer um dos seguintes locais, clique no link fornecido para exibir/copiar o ID:

  • Em Worksheets sob Projects, após executar uma consulta, a opção Query Details inclui um link para o ID.

  • Em Query History sob Monitoring, cada consulta inclui o ID como um link.

  SQL:

  Chame uma das seguintes funções:

  • Função de tabela QUERY_HISTORY , QUERY_HISTORY_BY_*.

  • Função LAST_QUERY_ID (se a consulta foi executada na sessão atual).

    Por exemplo:

    SELECT LAST_QUERY_ID(-2);
    

    Copy

    Note que isso é equivalente a usar LAST_QUERY_ID como a entrada para RESULT_SCAN.

• Se RESULT_SCAN processar a saída de consulta que continha nomes de colunas duplicadas (por exemplo, uma consulta que uniu duas tabelas que têm nomes de colunas sobrepostos), então RESULT_SCAN fará referência às colunas duplicadas com nomes modificados, anexando _1, _2, e assim por diante ao nome original. Para obter um exemplo, consulte o seguinte a seção Exemplos.

• Os carimbos de data/hora em arquivos Parquet consultados usando o verificador vetorizado às vezes exibem a hora em um fuso horário diferente. Use a função CONVERT_TIMEZONE para converter para um fuso horário padrão para todos os dados de carimbo de data/hora.

Detalhes do agrupamento¶

Quando RESULT_SCAN retorna os resultados da instrução anterior, RESULT_SCAN preserva a(s) especificação(ões) de agrupamento dos valores que retorna.

Exemplos¶

Os exemplos a seguir usam a função RESULT_SCAN.

SELECT $1 AS value FROM VALUES (1), (2), (3);

+-------+
| VALUE |
|-------|
|     1 |
|     2 |
|     3 |
+-------+

SELECT * FROM TABLE(RESULT_SCAN(LAST_QUERY_ID())) WHERE value > 1;

+-------+
| VALUE |
|-------|
|     2 |
|     3 |
+-------+

SELECT * FROM TABLE(RESULT_SCAN(LAST_QUERY_ID(-2)));

SELECT * FROM TABLE(RESULT_SCAN(LAST_QUERY_ID(1)));

SELECT c2 FROM TABLE(RESULT_SCAN('ce6687a4-331b-4a57-a061-02b2b0f0c17c'));

DESC USER jessicajones;
SELECT "property", "value" FROM TABLE(RESULT_SCAN(LAST_QUERY_ID()))
  WHERE "property" = 'DEFAULT_ROLE';

SHOW TABLES;
SELECT "database_name", "schema_name", "name" as "table_name", "rows", "created_on"
  FROM table(RESULT_SCAN(LAST_QUERY_ID()))
  WHERE "rows" = 0 AND "created_on" < DATEADD(day, -21, CURRENT_TIMESTAMP())
  ORDER BY "created_on";

-- Show byte counts with suffixes such as "KB", "MB", and "GB".
CREATE OR REPLACE FUNCTION NiceBytes(NUMBER_OF_BYTES INTEGER)
RETURNS VARCHAR
AS
$$
CASE
  WHEN NUMBER_OF_BYTES < 1024
    THEN NUMBER_OF_BYTES::VARCHAR
  WHEN NUMBER_OF_BYTES >= 1024 AND NUMBER_OF_BYTES < 1048576
    THEN (NUMBER_OF_BYTES / 1024)::VARCHAR || 'KB'
  WHEN NUMBER_OF_BYTES >= 1048576 AND NUMBER_OF_BYTES < (POW(2, 30))
    THEN (NUMBER_OF_BYTES / 1048576)::VARCHAR || 'MB'
  ELSE
    (NUMBER_OF_BYTES / POW(2, 30))::VARCHAR || 'GB'
END
$$
;
SHOW TABLES;
-- Show all of my tables in descending order of size.
SELECT "database_name", "schema_name", "name" as "table_name", NiceBytes("bytes") AS "size"
  FROM table(RESULT_SCAN(LAST_QUERY_ID()))
  ORDER BY "bytes" DESC;

CREATE OR REPLACE PROCEDURE return_json()
  RETURNS VARCHAR
  LANGUAGE JavaScript
  AS
  $$
    return '{"keyA": "ValueA", "keyB": "ValueB"}';
  $$
  ;

CALL return_json();

+--------------------------------------+
| RETURN_JSON                          |
|--------------------------------------|
| {"keyA": "ValueA", "keyB": "ValueB"} |
+--------------------------------------+

SELECT $1 AS output_col FROM table(RESULT_SCAN(LAST_QUERY_ID()));

+--------------------------------------+
| OUTPUT_COL                           |
|--------------------------------------|
| {"keyA": "ValueA", "keyB": "ValueB"} |
+--------------------------------------+

SELECT PARSE_JSON(output_col) AS json_col FROM TABLE(RESULT_SCAN(LAST_QUERY_ID()));

+---------------------+
| JSON_COL            |
|---------------------|
| {                   |
|   "keyA": "ValueA", |
|   "keyB": "ValueB"  |
| }                   |
+---------------------+

SELECT json_col:keyB FROM TABLE(RESULT_SCAN(LAST_QUERY_ID()));

+---------------+
| JSON_COL:KEYB |
|---------------|
| "ValueB"      |
+---------------+

CALL return_json();

+--------------------------------------+
| RETURN_JSON                          |
|--------------------------------------|
| {"keyA": "ValueA", "keyB": "ValueB"} |
+--------------------------------------+

SELECT JSON_COL:keyB
 FROM (
      SELECT PARSE_JSON($1::VARIANT) AS json_col
        FROM TABLE(RESULT_SCAN(LAST_QUERY_ID()))
      );

+---------------+
| JSON_COL:KEYB |
|---------------|
| "ValueB"      |
+---------------+

CALL return_json();

+--------------------------------------+
| RETURN_JSON                          |
|--------------------------------------|
| {"keyA": "ValueA", "keyB": "ValueB"} |
+--------------------------------------+

SELECT json_col:keyB
  FROM (
       SELECT PARSE_JSON(RETURN_JSON::VARIANT) AS json_col
         FROM TABLE(RESULT_SCAN(LAST_QUERY_ID()))
       );

+---------------+
| JSON_COL:KEYB |
|---------------|
| "ValueB"      |
+---------------+

CREATE TABLE employees (id INT);

CREATE TABLE dependents (id INT, employee_id INT);

INSERT INTO employees (id) VALUES (11);

INSERT INTO dependents (id, employee_id) VALUES (101, 11);

SELECT *
  FROM employees INNER JOIN dependents
    ON dependents.employee_ID = employees.id
  ORDER BY employees.id, dependents.id;

+----+-----+-------------+
| ID |  ID | EMPLOYEE_ID |
|----+-----+-------------|
| 11 | 101 |          11 |
+----+-----+-------------+

SELECT id, id_1, employee_id
  FROM TABLE(RESULT_SCAN(LAST_QUERY_ID()))
  WHERE id_1 = 101;

+----+------+-------------+
| ID | ID_1 | EMPLOYEE_ID |
|----+------+-------------|
| 11 |  101 |          11 |
+----+------+-------------+