COUNT¶

Syntaxe¶

Fonction d’agrégation

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

COUNT( * )

Fonction de fenêtre

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

Pour plus d’informations sur la syntaxe window_frame , 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
    

    Copy

    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 (c’est-à-dire avec une clause OVER) :

  • Si la clause OVER contient une sous-clause ORDER BY, alors :

    • Un cadre de fenêtre est nécessaire. Si aucun cadre de fenêtre n’est spécifié de façon explicite, ORDER BY implique un cadre de fenêtre cumulatif :

      RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW

      Pour des informations sur les cadres de fenêtre, y compris la syntaxe et des exemples, voir Syntaxe et utilisation du cadre de fenêtre.

      Pour des informations sur les cadres de fenêtre implicites, voir Notes sur l’utilisation du cadre de fenêtre.

    • L’utilisation du mot-clé DISTINCT à l’intérieur de la fonction de fenêtre est interdite et entraîne une erreur de compilation.

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

• Lorsque cela est possible, utilisez la fonction COUNT sur les tables et les vues sans politique d’accès aux lignes. La requête avec cette fonction est plus rapide et plus précise sur les tables ou les vues sans politique d’accès aux lignes. Les raisons de cette différence de performance sont les suivantes :

  • Snowflake maintient des statistiques sur les tables et les vues, et cette optimisation permet aux requêtes simples de s’exécuter plus rapidement.

  • Lorsqu’une politique d’accès aux lignes est définie sur une table ou une vue et que la fonction COUNT est utilisée dans une requête, Snowflake doit analyser chaque ligne et déterminer si l’utilisateur est autorisé à la visualiser.

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

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 |
+-------+----------+--------------+

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

Copy

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;

Copy

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

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

Afficher les données :

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    |
+-------+-------+-----------------+---------+

Montrez que la fonction COUNT traite à la fois les valeurs NULL et VARIANT NULL (JSON 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;

Copy

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