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

> Compte le nombre de lignes ou de valeurs non NULL.

# count

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

Introduit dans : v1.1.0

Compte le nombre de lignes ou de valeurs non NULL.

ClickHouse prend en charge les syntaxes suivantes pour `count` :

* `count(expr)` ou `COUNT(DISTINCT expr)`.
* `count()` ou `COUNT(*)`. La syntaxe `count()` est spécifique à ClickHouse.

**Détails**

ClickHouse prend en charge la syntaxe `COUNT(DISTINCT ...)`.
Le comportement de cette construction dépend du paramètre [`count_distinct_implementation`](/fr/reference/settings/session-settings#count_distinct_implementation).
Il détermine quelle fonction de la famille [uniq\*](/fr/reference/functions/aggregate-functions/uniq) est utilisée pour effectuer l'opération.
La valeur par défaut est la fonction [uniqExact](/fr/reference/functions/aggregate-functions/uniqExact).

La requête `SELECT count() FROM table` est optimisée par défaut à l'aide des métadonnées de MergeTree.
Si vous devez utiliser la sécurité au niveau des lignes, désactivez cette optimisation à l'aide du paramètre [`optimize_trivial_count_query`](/fr/reference/settings/session-settings#optimize_trivial_count_query).

Cependant, la requête `SELECT count(nullable_column) FROM table` peut être optimisée en activant le paramètre [`optimize_functions_to_subcolumns`](/fr/reference/settings/session-settings#optimize_functions_to_subcolumns).
Avec `optimize_functions_to_subcolumns = 1`, la fonction lit uniquement la sous-colonne [`null`](/fr/reference/data-types/nullable#finding-null) au lieu de lire et traiter l'ensemble des données de la colonne.
La requête `SELECT count(n) FROM table` est transformée en `SELECT sum(NOT n.null) FROM table`.

<Tip>
  **Améliorer les performances de COUNT(DISTINCT expr)**

  Si votre requête `COUNT(DISTINCT expr)` est lente, envisagez d'ajouter une clause [`GROUP BY`](/fr/reference/statements/select/group-by), car cela améliore la parallélisation.
  Vous pouvez également utiliser une [projection](/fr/reference/statements/alter/projection) pour créer un index sur la colonne cible utilisée avec `COUNT(DISTINCT target_col)`.
</Tip>

**Syntaxe**

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

**Arguments**

* `expr` — Facultatif. Une expression. La fonction compte le nombre de fois où cette expression a renvoyé une valeur non NULL. [`Expression`](/fr/reference/data-types/special-data-types/expression)

**Valeur renvoyée**

Renvoie le nombre de lignes si la fonction est appelée sans paramètres ; sinon, renvoie le nombre de fois où l'expression transmise a renvoyé une valeur non NULL. [`UInt64`](/fr/reference/data-types/int-uint)

**Exemples**

**Comptage simple des lignes**

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

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

**Exemple de COUNT(DISTINCT)**

```sql title=Query theme={null}
-- This example shows that `count(DISTINCT num)` is performed by the `uniqExact` function according to the `count_distinct_implementation` setting value.
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 │
└────────────────┘
```