COUNT¶

Sintaxe¶

Função de agregação

COUNT( [ DISTINCT ] <expr1> [ , <expr2> ... ] )

COUNT( * )

Função de janela

COUNT( [ DISTINCT ] <expr1> [ , <expr2> ... ] ) OVER (
                                                     [ PARTITION BY <expr3> ]
                                                     [ ORDER BY <expr4> [ ASC | DESC ] [ <window_frame> ] ]
                                                     )

Para obter mais detalhes sobre a sintaxe window_frame, consulte Sintaxe e utilização do quadro de janela.

Argumentos¶

expr1

Isto deve ser um ou outro:

• Um nome de coluna, que pode ser um nome qualificado (por exemplo, database.schema.table.column_name).

• Alias.* que indica que a função deve retornar o número de linhas que não contenham nenhum NULLs. Consulte Exemplos para um exemplo.

expr2

Você pode incluir nome(s) de coluna adicional(is), se desejar. Por exemplo, você poderia contar o número de combinações distintas de sobrenome e nome.

expr3

A coluna a ser dividida, se você quiser que o resultado seja dividido em várias janelas.

expr4

A coluna para ordenar cada janela. Note que isto é separado de qualquer cláusula ORDER BY para ordenar o conjunto de resultados finais.

Notas de uso¶

• Esta função trata VARIANT NULL (JSON nulo) como SQL NULL.

• Para obter mais informações sobre valores e funções agregadas NULL, consulte Funções de agregação e valores NULL.

• Quando esta função é chamada como uma função agregada:

  • Se a palavra-chave DISTINCT for usada, ela se aplica a todas as colunas. Por exemplo, DISTINCT col1, col2, col3 significa retornar o número de diferentes combinações de colunas col1, col2 e col3. Por exemplo, se os dados forem:

    1, 1, 1
    1, 1, 1
    1, 1, 1
    1, 1, 2
    

    Copy

    então a função retornará 2, pois esse é o número de combinações distintas de valores nas colunas 3.

• Quando esta função é chamada como uma função de janela (ou seja, com uma cláusula OVER):

  • Se a cláusula OVER contiver uma subcláusula ORDER BY, então:

    • O quadro de janela é exigido. Se nenhum quadro de janela for especificado explicitamente, então o ORDER BY implicará um quadro de janela cumulativo:

      RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW

      Para obter mais informações sobre quadros de janelas, incluindo sintaxe e exemplos, consulte Sintaxe e utilização do quadro de janela.

      Para obter mais informações sobre quadros de janelas implícitos, consulte também Notas de uso dos quadros de janela.

    • O uso da palavra-chave DISTINCT dentro da função de janela é proibido e resulta em um erro de tempo de compilação.

• Para retornar o número de linhas que correspondem a uma condição, use COUNT_IF.

• Quando possível, utilizar a função COUNT em tabelas e exibição sem uma política de acesso a linhas. A consulta com esta função é mais rápida e precisa em tabelas ou exibição sem uma política de acesso a linhas. As razões para a diferença de desempenho incluem:

  • O Snowflake mantém estatísticas em tabelas e exibições, e esta otimização permite que consultas simples sejam executadas mais rapidamente.

  • Quando uma política de acesso a linhas é definida em uma tabela ou exibição e a função COUNT é usada em uma consulta, o Snowflake deve digitalizar cada linha e determinar se o usuário tem permissão para visualizar a linha.

Exemplos¶

Este é um exemplo de utilização de valores COUNT com NULL. A consulta também inclui algumas operações COUNT(DISTINCT):

CREATE TABLE basic_example (i_col INTEGER, j_col INTEGER);
INSERT INTO basic_example VALUES
    (11,101), (11,102), (11,NULL), (12,101), (NULL,101), (NULL,102);

Copy

SELECT *
    FROM basic_example
    ORDER BY i_col;

Copy

+-------+-------+
| I_COL | J_COL |
|-------+-------|
|    11 |   101 |
|    11 |   102 |
|    11 |  NULL |
|    12 |   101 |
|  NULL |   101 |
|  NULL |   102 |
+-------+-------+

SELECT COUNT(*), COUNT(i_col), COUNT(DISTINCT i_col), COUNT(j_col), COUNT(DISTINCT j_col) FROM basic_example;

Copy

+----------+--------------+-----------------------+--------------+-----------------------+
| COUNT(*) | COUNT(I_COL) | COUNT(DISTINCT I_COL) | COUNT(J_COL) | COUNT(DISTINCT J_COL) |
|----------+--------------+-----------------------+--------------+-----------------------|
|        6 |            4 |                     2 |            5 |                     2 |
+----------+--------------+-----------------------+--------------+-----------------------+

SELECT i_col, COUNT(*), COUNT(j_col)
    FROM basic_example
    GROUP BY i_col
    ORDER BY i_col;

Copy

+-------+----------+--------------+
| I_COL | COUNT(*) | COUNT(J_COL) |
|-------+----------+--------------|
|    11 |        3 |            2 |
|    12 |        1 |            1 |
|  NULL |        2 |            2 |
+-------+----------+--------------+

O exemplo a seguir mostra que COUNT(alias.*) retorna o número de linhas que não contêm nenhum valor NULL.

Criar um conjunto de dados de tal forma que:

• 1 linha tem todos os nulos.

• 2 linhas têm exatamente um nulo.

• 3 linhas têm pelo menos um nulo.

• Há um total de 4 valores NULL.

• 5 linhas não têm nulos.

• Há um total de 8 linhas.

CREATE TABLE non_null_counter(col1 INTEGER, col2 INTEGER);
INSERT INTO non_null_counter(col1, col2) VALUES
    (NULL, NULL),   -- all NULL values
    (NULL, 1),      -- one NULL value
    (1, NULL),      -- one NULL value
    (1, 1),
    (2, 2),
    (3, 3),
    (4, 4),
    (5, 5);

Copy

A consulta retorna uma contagem de 5, que é o número de linhas que não contêm nenhum valor NULL:

SELECT COUNT(n.*)
    FROM non_null_counter AS n;

Copy

+------------+
| COUNT(N.*) |
|------------|
|          5 |
+------------+

O exemplo a seguir mostra que JSON (VARIANT) NULL é tratado como SQL NULL pela função COUNT.

Criar a tabela e inserir dados que contenham tanto valores SQL NULL como JSON NULL:

CREATE TABLE count_example_with_variant_column (i_col INTEGER, j_col INTEGER, v VARIANT);

Copy

BEGIN WORK;

-- SQL NULL for both a VARIANT column and a non-VARIANT column.
INSERT INTO count_example_with_variant_column (i_col, j_col, v) VALUES (NULL, 10, NULL);
-- VARIANT NULL (aka JSON null)
INSERT INTO count_example_with_variant_column (i_col, j_col, v) SELECT 1, 11, PARSE_JSON('{"Title": null}');
-- VARIANT NON-NULL
INSERT INTO count_example_with_variant_column (i_col, j_col, v) SELECT 2, 12, PARSE_JSON('{"Title": "O"}');
INSERT INTO count_example_with_variant_column (i_col, j_col, v) SELECT 3, 12, PARSE_JSON('{"Title": "I"}');

COMMIT WORK;

Copy

Exibir os dados:

SELECT i_col, j_col, v, v:Title
    FROM count_example_with_variant_column
    ORDER BY i_col;

Copy

+-------+-------+-----------------+---------+
| I_COL | J_COL | V               | V:TITLE |
|-------+-------+-----------------+---------|
|     1 |    11 | {               | null    |
|       |       |   "Title": null |         |
|       |       | }               |         |
|     2 |    12 | {               | "O"     |
|       |       |   "Title": "O"  |         |
|       |       | }               |         |
|     3 |    12 | {               | "I"     |
|       |       |   "Title": "I"  |         |
|       |       | }               |         |
|  NULL |    10 | NULL            | NULL    |
+-------+-------+-----------------+---------+

Mostrar que a função COUNT trata tanto o valor NULL como o VARIANT NULL (JSON nulo) como NULLs. Há 4 linhas na tabela. Um tem um SQL NULL e o outro tem um VARIANT NULL. Ambas as linhas estão excluídas da contagem, portanto, a contagem é 2.

SELECT COUNT(v:Title)
    FROM count_example_with_variant_column;

Copy

+----------------+
| COUNT(V:TITLE) |
|----------------|
|              2 |
+----------------+