> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-fix-nav-issues.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

> Conta o número de linhas ou valores não NULL.

# count

<div id="count">
  ## count
</div>

Introduzido em: v1.1.0

Conta o número de linhas ou de valores não NULL.

O ClickHouse oferece suporte às seguintes sintaxes para `count`:

* `count(expr)` ou `COUNT(DISTINCT expr)`.
* `count()` ou `COUNT(*)`. A sintaxe `count()` é específica do ClickHouse.

**Detalhes**

O ClickHouse oferece suporte à sintaxe `COUNT(DISTINCT ...)`.
O comportamento dessa construção depende da configuração [`count_distinct_implementation`](/pt-BR/reference/settings/session-settings#count_distinct_implementation).
Ela define qual das funções [uniq\*](/pt-BR/reference/functions/aggregate-functions/uniq) é usada para realizar a operação.
O padrão é a função [uniqExact](/pt-BR/reference/functions/aggregate-functions/uniqExact).

A consulta `SELECT count() FROM table` é otimizada por padrão com base nos metadados do MergeTree.
Se você precisar usar segurança em nível de linha, desative essa otimização usando a configuração [`optimize_trivial_count_query`](/pt-BR/reference/settings/session-settings#optimize_trivial_count_query).

No entanto, a consulta `SELECT count(nullable_column) FROM table` pode ser otimizada ativando a configuração [`optimize_functions_to_subcolumns`](/pt-BR/reference/settings/session-settings#optimize_functions_to_subcolumns).
Com `optimize_functions_to_subcolumns = 1`, a função lê apenas a subcoluna [`null`](/pt-BR/reference/data-types/nullable#finding-null), em vez de ler e processar todos os dados da coluna.
A consulta `SELECT count(n) FROM table` é transformada em `SELECT sum(NOT n.null) FROM table`.

<Tip>
  **Melhorando o desempenho de COUNT(DISTINCT expr)**

  Se a sua consulta `COUNT(DISTINCT expr)` estiver lenta, considere adicionar uma cláusula [`GROUP BY`](/pt-BR/reference/statements/select/group-by), pois isso melhora a paralelização.
  Você também pode usar uma [projection](/pt-BR/reference/statements/alter/projection) para criar um índice na coluna de destino usada com `COUNT(DISTINCT target_col)`.
</Tip>

**Sintaxe**

```sql theme={null}
count([expr])
```

**Argumentos**

* `expr` — Opcional. Uma expressão. A função conta quantas vezes essa expressão retornou um valor não nulo. [`Expressão`](/pt-BR/reference/data-types/special-data-types/expression)

**Valor retornado**

Retorna a contagem de linhas se a função for chamada sem parâmetros; caso contrário, retorna a contagem de quantas vezes a expressão fornecida retornou um valor não nulo. [`UInt64`](/pt-BR/reference/data-types/int-uint)

**Exemplos**

**Contagem básica de linhas**

```sql title=Query theme={null}
SELECT count() FROM t
```

```response title=Response theme={null}
┌─count()─┐
│       5 │
└─────────┘
```

**Exemplo de COUNT(DISTINCT)**

```sql title=Query theme={null}
-- Este exemplo mostra que `count(DISTINCT num)` é executado pela função `uniqExact` de acordo com o valor da configuração `count_distinct_implementation`.
SELECT name, value FROM system.settings WHERE name = 'count_distinct_implementation';
SELECT count(DISTINCT num) FROM t
```

```response title=Response theme={null}
┌─name──────────────────────────┬─value─────┐
│ count_distinct_implementation │ uniqExact │
└───────────────────────────────┴───────────┘
┌─uniqExact(num)─┐
│              3 │
└────────────────┘
```