Catégories :

Fonctions d’agrégation (Général) , Fonctions de la fenêtre (Général, Cadre de fenêtre)

COUNT

Renvoie soit le nombre d’enregistrements non NULL pour les colonnes spécifiées, soit un nombre total d’enregistrements.

Voir aussi :

COUNT_IF, MIN / MAX , SUM

Syntaxe

Fonction d’agrégation

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

COUNT( * )

Fonction de fenêtre

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

Pour plus d’informations sur la syntaxe cadre_fenêtre , voir Syntaxe et utilisation du cadre de fenêtre .

Arguments

expr1

Cela devrait être soit :

  • Un nom de colonne, qui peut être un nom qualifié (par exemple, database.schema.table.column_name).

  • Alias.*, qui indique que la fonction doit renvoyer le nombre de lignes qui ne contiennent aucun NULLs. Voir Exemples pour un exemple.

expr2

Vous pouvez inclure des noms de colonne supplémentaires si vous le souhaitez. Par exemple, vous pouvez compter le nombre de combinaisons distinctes de nom et prénom.

expr3

La colonne sur laquelle partitionner, si vous voulez que le résultat soit divisé en plusieurs fenêtres.

expr4

La colonne selon laquelle classer chaque fenêtre. Notez que ceci est distinct de toute clause ORDER BY pour classer l’ensemble de résultats final.

Notes sur l’utilisation

  • Cette fonction traite VARIANT NULL (JSON NULL) comme SQL NULL.

  • Pour plus d’informations sur les valeurs NULL et les fonctions d’agrégation, voir Fonctions d’agrégation et valeurs NULL.

  • Lorsque cette fonction est appelée en tant que fonction d’agrégation :

    • Si le mot clé DISTINCT est utilisé, il s’applique à toutes les colonnes. Par exemple, DISTINCT col1, col2, col3 signifie renvoyer le nombre de combinaisons différentes de colonnes col1, col2 et col3. Par exemple, si les données sont :

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

      alors la fonction retourne 2, car c’est le nombre de combinaisons distinctes de valeurs dans les 3 colonnes.

  • Lorsque cette fonction est appelée en tant que fonction de fenêtre :

    • Le mot clé DISTINCT est autorisé syntaxiquement, mais est ignoré.

    • Si une sous-clause ORDER BY est utilisée à l’intérieur de la clause OVER(), un cadre de fenêtre doit être utilisé. Si aucun cadre de fenêtre n’est spécifié, la valeur par défaut est un cadre de fenêtre cumulatif :

      RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW

      Pour plus d’informations sur les cadres de fenêtre, y compris la syntaxe et des exemples, voir Syntaxe et utilisation du cadre de fenêtre. Pour plus d’informations sur les cadres de fenêtre implicites, voir Notes sur l’utilisation du cadre de fenêtre.

  • Pour renvoyer le nombre de lignes correspondant à une condition, utilisez COUNT_IF.

Exemples

Ceci est un exemple d’utilisation de COUNT avec des valeurs NULL. La requête inclut également certaines opérations 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);
SELECT * FROM basic_example;
+-------+-------+
| 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;
+----------+--------------+-----------------------+--------------+-----------------------+
| 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;
+-------+----------+--------------+
| I_COL | COUNT(*) | COUNT(J_COL) |
|-------+----------+--------------|
|    11 |        3 |            2 |
|    12 |        1 |            1 |
|  NULL |        2 |            2 |
+-------+----------+--------------+

L’exemple suivant montre que COUNT(alias.*) renvoie le nombre de lignes qui ne contiennent aucune valeur NULL.

Créer un ensemble de données de sorte que :

  • 1 ligne contienne toutes les valeurs null.

  • 2 lignes contiennent exactement une valeur null.

  • 3 lignes contiennent au moins une valeur null.

  • Il existe un total de 4 valeurs NULL.

  • 5 lignes ne contiennent aucune valeur null.

  • Il y a un total de 8 lignes.

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);

La requête renvoie un nombre de 5, qui correspond au nombre de lignes ne contenant aucune valeur NULL :

SELECT COUNT(n.*)
    FROM non_null_counter AS n;
+------------+
| COUNT(N.*) |
|------------|
|          5 |
+------------+

L’exemple suivant montre que JSON (VARIANT) NULL est traité comme SQL NULL par la fonction COUNT.

Créer la table et insérer des données contenant les valeurs SQL NULL et JSON NULL :

CREATE TABLE count_example_with_variant_column (i_col INTEGER, j_col INTEGER, v VARIANT);
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
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;

Afficher les données :

SELECT i_col, j_col, v, v:Title
    FROM count_example_with_variant_column
    ORDER BY i_col;
+-------+-------+-----------------+---------+
| 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    |
+-------+-------+-----------------+---------+

Montrez que la fonction COUNT traite à la fois les valeurs NULL et VARIANT NULL comme NULLs. Il y a 4 lignes dans la table. L’une a une valeur SQL NULL et l’autre une valeur VARIANT NULL. Ces deux lignes sont exclues du compte. Le nombre est donc de 2.

SELECT COUNT(v:Title)
    FROM count_example_with_variant_column;
+----------------+
| COUNT(V:TITLE) |
|----------------|
|              2 |
+----------------+