Determinando o número de linhas afetadas por instruções SQL

Depois que um comando DML é executado (excluindo o comando TRUNCATE TABLE), o Snowflake Scripting define as seguintes variáveis globais. Você pode usar as variáveis para determinar se a última instrução DML afetou todas as linhas ou quantas linhas foram retornadas por uma consulta.

Variável

Descrição

ACTIVITY_COUNT

Número de linhas afetadas pela última instrução DML ou o número de linhas retornadas pela última consulta SELECT. Definido após a execução de cada instrução.

SQLROWCOUNT

Número de linhas afetadas pela última instrução DML.

Isso é equivalente a getNumRowsAffected() em procedimentos armazenados de JavaScript.

SQLFOUND

true se a última instrução DML tiver afetado uma ou mais linhas.

SQLNOTFOUND

true se a última instrução DML tiver afetado zero linhas.

Nota

O pacote de mudança de comportamento 2025_01 altera o comportamento dessas variáveis. Quando o pacote está ativado, as variáveis retornam NULL quando uma instrução que não é DML é executada após a última instrução DML em um bloco do Snowflake Scripting ou procedimento armazenado. O pacote é ativado por padrão. Para obter mais informações sobre a mudança de comportamento, consulte Snowflake Scripting: alterações das variáveis globais.

Se o pacote estiver desativado, você pode ativá-lo na sua conta executando o seguinte comando:

SELECT SYSTEM$ENABLE_BEHAVIOR_CHANGE_BUNDLE('2025_01');

Para desativar o pacote, execute a seguinte instrução:

SELECT SYSTEM$DISABLE_BEHAVIOR_CHANGE_BUNDLE('2025_01');

Os exemplos nesta seção usam a seguinte tabela:

CREATE OR REPLACE TABLE my_values (value NUMBER);

O exemplo a seguir usa a variável SQLROWCOUNT para retornar o número de linhas afetadas pela última instrução DML (a instrução INSERT).

BEGIN
  LET sql_row_count_var INT := 0;
  INSERT INTO my_values VALUES (1), (2), (3);
  sql_row_count_var := SQLROWCOUNT;
  SELECT * from my_values;
  RETURN sql_row_count_var;
END;

Observação: se você usa a Snowflake CLI, o SnowSQL, o Console clássico, o método execute_stream ou execute_string no código do conector Python, use este exemplo (consulte Using Snowflake Scripting in Snowflake CLI, SnowSQL, and Python Connector):

EXECUTE IMMEDIATE $$
BEGIN
  LET sql_row_count_var INT := 0;
  INSERT INTO my_values VALUES (1), (2), (3);
  sql_row_count_var := SQLROWCOUNT;
  SELECT * from my_values;
  RETURN sql_row_count_var;
END;
$$;
+-----------------+
| anonymous block |
|-----------------|
|               3 |
+-----------------+

O exemplo a seguir usa as variáveis SQLFOUND e SQLNOTFOUND para retornar o número de linhas afetadas pela última instrução DML (a instrução UPDATE).

BEGIN
  LET sql_row_count_var INT := 0;
  LET sql_found_var BOOLEAN := NULL;
  LET sql_notfound_var BOOLEAN := NULL;
  IF ((SELECT MAX(value) FROM my_values) > 2) THEN
    UPDATE my_values SET value = 4 WHERE value < 3;
    sql_row_count_var := SQLROWCOUNT;
    sql_found_var := SQLFOUND;
    sql_notfound_var := SQLNOTFOUND;
  END IF;
  SELECT * from my_values;
  IF (sql_found_var = true) THEN
    RETURN 'Updated ' || sql_row_count_var || ' rows.';
  ELSEIF (sql_notfound_var = true) THEN
    RETURN 'No rows updated.';
  ELSE
    RETURN 'No DML statements executed.';
  END IF;
END;

Observação: se você usa a Snowflake CLI, o SnowSQL, o Console clássico, o método execute_stream ou execute_string no código do conector Python, use este exemplo (consulte Using Snowflake Scripting in Snowflake CLI, SnowSQL, and Python Connector):

EXECUTE IMMEDIATE $$
BEGIN
  LET sql_row_count_var INT := 0;
  LET sql_found_var BOOLEAN := NULL;
  LET sql_notfound_var BOOLEAN := NULL;
  IF ((SELECT MAX(value) FROM my_values) > 2) THEN
    UPDATE my_values SET value = 4 WHERE value < 3;
    sql_row_count_var := SQLROWCOUNT;
    sql_found_var := SQLFOUND;
    sql_notfound_var := SQLNOTFOUND;
  END IF;
  SELECT * from my_values;
  IF (sql_found_var = true) THEN
    RETURN 'Updated ' || sql_row_count_var || ' rows.';
  ELSEIF (sql_notfound_var = true) THEN
    RETURN 'No rows updated.';
  ELSE
    RETURN 'No DML statements executed.';
  END IF;
END;
$$;

Quando o bloco anônimo é executado, a variável SQLFOUND é true porque a instrução UPDATE atualiza duas linhas.

+-----------------+
| anonymous block |
|-----------------|
| Updated 2 rows. |
+-----------------+

Consulte a tabela para ver os valores atuais:

SELECT * FROM my_values;
+-------+
| VALUE |
|-------|
|     4 |
|     4 |
|     3 |
+-------+

Execute o mesmo bloco anônimo novamente, e os resultados são os seguintes:

  • A instrução UPDATE é executada porque há um valor na tabela que é maior que 2. Ou seja, a condição IF é satisfeita.

  • A variável SQLNOTFOUND é true porque nenhuma linha é atualizada. A instrução UPDATE não atualiza nenhuma linha porque nenhum dos valores da tabela é menor que 3 (especificado na cláusula WHERE).

A consulta retorna a seguinte saída:

+------------------+
| anonymous block  |
|------------------|
| No rows updated. |
+------------------+

Agora, atualize a tabela para definir todos os valores como 1:

UPDATE my_values SET value = 1;

SELECT * FROM my_values;
+-------+
| VALUE |
|-------|
|     1 |
|     1 |
|     1 |
+-------+

Execute o mesmo bloco anônimo novamente e a instrução UPDATE não será executada porque nenhum dos valores da tabela é maior que 2. Ou seja, a condição IF não é satisfeita, portanto, a instrução UPDATE não é executada.

+-----------------------------+
| anonymous block             |
|-----------------------------|
| No DML statements executed. |
+-----------------------------+

Exemplos ACTIVITY_COUNT

Ao contrário de SQLROWCOUNT, a variável ACTIVITY_COUNT é definida após a execução de cada instrução, incluindo consultas SELECT. Desse modo, ela é útil para rastrear tanto o número de linhas afetadas pelas operações DML quanto o número de linhas retornadas pelas consultas.

O exemplo a seguir demonstra ACTIVITY_COUNT após uma instrução INSERT e uma consulta SELECT:

BEGIN
  INSERT INTO my_values VALUES (1), (2), (3);
  LET insert_count INT := ACTIVITY_COUNT;
  SELECT * FROM my_values WHERE value > 1;
  LET select_count INT := ACTIVITY_COUNT;
  RETURN 'Inserted ' || insert_count || ' rows, query returned ' || select_count || ' rows.';
END;

Observação: se você usa a Snowflake CLI, o SnowSQL, o Console clássico, o método execute_stream ou execute_string no código do conector Python, use este exemplo (consulte Using Snowflake Scripting in Snowflake CLI, SnowSQL, and Python Connector):

EXECUTE IMMEDIATE $$
BEGIN
  INSERT INTO my_values VALUES (1), (2), (3);
  LET insert_count INT := ACTIVITY_COUNT;
  SELECT * FROM my_values WHERE value > 1;
  LET select_count INT := ACTIVITY_COUNT;
  RETURN 'Inserted ' || insert_count || ' rows, query returned ' || select_count || ' rows.';
END;
$$;

Após INSERT, ACTIVITY_COUNT é 3 (três linhas inseridas). Após SELECT, ACTIVITY_COUNT é 2 (duas linhas correspondem à condição WHERE value > 1).

+-------------------------------------------+
| anonymous block                           |
|-------------------------------------------|
| Inserted 3 rows, query returned 2 rows.   |
+-------------------------------------------+