Categorias:

Funções de agregação (General) , Funções de janela

COUNT

Retorna o número de registros diferentes de NULL para as colunas especificadas ou o número total de registros.

Consulte também:

COUNT_IF, MAX, MIN , SUM

Sintaxe

Função de agregação

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

COUNT(*)

COUNT(<alias>.*)
Copy

Função de janela

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

Para uma sintaxe window_frame detalhada, consulte Sintaxe e uso da função de janela.

Argumentos

expr1

Um nome de coluna, que pode ser um nome qualificado (por exemplo, banco_de_dados.esquema.tabela.nome_da_coluna).

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.

*

Retorna o número total de registros.

Ao passar um curinga para a função, você pode qualificar o curinga com o nome ou alias da tabela. Por exemplo, para passar todas as colunas da tabela nomeadas mytable, especifique o seguinte:

(mytable.*)
Copy

Também é possível usar as palavras-chave ILIKE e EXCLUDE para filtrar:

  • ILIKE filtra nomes de colunas que correspondem ao padrão especificado. Apenas um padrão é permitido. Por exemplo:

    (* ILIKE 'col1%')
    Copy

  • EXCLUDE filtra nomes de coluna que não correspondem à coluna ou colunas especificadas. Por exemplo:

    (* EXCLUDE col1)

(* EXCLUDE (col1, col2))
    Copy

Os qualificadores são válidos quando você usa essas palavras-chave. O exemplo a seguir usa a palavra-chave ILIKE para filtrar todas as colunas que correspondem ao padrão col1% na tabela mytable:

(mytable.* ILIKE 'col1%')
Copy

As palavras-chave ILIKE e EXCLUDE não podem ser combinadas em uma única chamada de função.

Se você especificar um curinga não qualificado e não filtrado (*), a função retornará o número total de registros, incluindo registros com valores NULL.

Se você especificar um curinga com a palavra-chave ILIKE ou EXCLUDE para filtragem, a função excluirá registros com valores NULL.

Para esta função, as palavras-chave ILIKE e EXCLUDE são válidas somente em uma lista SELECT ou cláusula GROUP BY.

Para obter mais informações sobre as palavras-chave ILIKE e EXCLUDE, consulte a seção «Parâmetros» em SELECT.

alias.*

Retorna o número de registros que não contêm nenhum valor NULL. Para um exemplo, consulte Exemplos.

Retornos

Retorna um valor do tipo NUMBER.

Notas de uso

  • Esta função trata JSON nulo (VARIANT NULL) 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 combinações diferentes de colunas col1, col2 e col3. Por exemplo, suponha que os dados sejam:

      1, 1, 1
1, 1, 1
1, 1, 1
1, 1, 2
      Copy

      Nesse caso, a função retorna 2, porque esse é o número de combinações distintas de valores nas três colunas.

  • Quando esta função é chamada como uma função de janela com uma cláusula OVER com uma cláusula ORDER BY:

    • O quadro de janela é exigido. Se nenhum quadro de janela for especificado explicitamente, o seguinte quadro de janela implícito será usado:

      RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW

      Para obter mais informações sobre quadros de janela, incluindo sintaxe, notas de uso e exemplos, consulte Sintaxe e uso da função 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

Os exemplos a seguir usam a função COUNT em dados com valores NULL.

Criar uma tabela e inserir valores:

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

Consultar a tabela:

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(*) AS "All",
       COUNT(* ILIKE 'i_c%') AS "ILIKE",
       COUNT(* EXCLUDE i_col) AS "EXCLUDE",
       COUNT(i_col) AS "i_col", 
       COUNT(DISTINCT i_col) AS "DISTINCT i_col", 
       COUNT(j_col) AS "j_col", 
       COUNT(DISTINCT j_col) AS "DISTINCT j_col"
  FROM basic_example;
Copy
+-----+-------+---------+-------+----------------+-------+----------------+
| All | ILIKE | EXCLUDE | i_col | DISTINCT i_col | j_col | DISTINCT j_col |
|-----+-------+---------+-------+----------------+-------+----------------|
|   6 |     4 |       5 |     4 |              2 |     5 |              2 |
+-----+-------+---------+-------+----------------+-------+----------------+

A coluna All nesta saída mostra que quando um curinga não qualificado e não filtrado é especificado para COUNT, a função retorna o número total de linhas na tabela, incluindo linhas com valores NULL. As outras colunas na saída mostram que quando uma coluna ou um curinga com filtragem é especificado, a função exclui linhas com valores NULL.

A próxima consulta usa a função COUNT com a cláusula GROUP BY.

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. A tabela basic_example tem um total de seis linhas, mas três linhas têm pelo menos um valor NULL, e as outras três linhas não têm valores NULL.

SELECT COUNT(n.*) FROM basic_example AS n;
Copy
+------------+
| COUNT(N.*) |
|------------|
|          3 |
+------------+

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

Crie a tabela e insira dados que contenham SQL NULL e valores nulo JSON:

CREATE OR REPLACE TABLE count_example_with_variant_column (
  i_col INTEGER, 
  j_col INTEGER, 
  v VARIANT);
Copy
BEGIN WORK;

INSERT INTO count_example_with_variant_column (i_col, j_col, v) 
  VALUES (NULL, 10, NULL);
INSERT INTO count_example_with_variant_column (i_col, j_col, v) 
  SELECT 1, 11, PARSE_JSON('{"Title": 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

Neste código SQL, observe o seguinte:

  • A primeira instrução INSERT INTO insere um SQL NULL para uma coluna VARIANT e para uma coluna não VARIANT.

  • A segunda instrução INSERT INTO insere um JSON nulo (VARIANT NULL).

  • As duas últimas instruções INSERT INTO inserem valores não NULL VARIANT.

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 os valores NULL e JSON nulo (VARIANT NULL) como NULLs. Há quatro linhas na tabela. Um tem um SQL NULL e o outro tem um JSON nulo. Ambas as linhas são excluídas da contagem, então a contagem é 2.

SELECT COUNT(v:Title)
    FROM count_example_with_variant_column;
Copy
+----------------+
| COUNT(V:TITLE) |
|----------------|
|              2 |
+----------------+
Linguagem: Português