COUNT¶

Syntaxe¶

Fonction d’agrégation

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

COUNT(*)

COUNT(<alias>.*)

Fonction de fenêtre

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

Pour plus de détails sur la syntaxe window_frame, voir Syntaxe et utilisation des fonctions de fenêtre.

Arguments¶

expr1

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

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.

*

Renvoie le nombre total d’enregistrements.

Lorsque vous transmettez un caractère générique à la fonction, vous pouvez qualifier le caractère générique avec le nom ou l’alias de la table. Par exemple, pour transmettre toutes les colonnes de la table nommée mytable, précisez les éléments suivants :

(mytable.*)

Copy

Vous pouvez également utiliser les mots-clés ILIKE et EXCLUDE pour le filtrage :

• ILIKE filtre les noms de colonnes qui correspondent au motif spécifié. Un seul motif est autorisé. Par exemple :

  (* ILIKE 'col1%')
  

  Copy

• EXCLUDE filtre les noms de colonnes qui ne correspondent pas à la / aux colonnes spécifiées. Par exemple :

  (* EXCLUDE col1)
  
  (* EXCLUDE (col1, col2))
  

  Copy

Les qualificatifs sont valides lorsque vous utilisez ces mots-clés. L’exemple suivant utilise le mot-clé ILIKE pour filtrer toutes les colonnes qui correspondent au motif col1% dans la table mytable :

(mytable.* ILIKE 'col1%')

Copy

Les mots-clés ILIKE et EXCLUDE ne peuvent pas être combinés dans un seul appel de fonction.

Si vous spécifiez un caractère générique non qualifié et non filtré (*), la fonction renvoie le nombre total d’enregistrements, y compris les enregistrements avec des valeurs NULL.

Si vous spécifiez un caractère générique avec le mot-clé ILIKE ou EXCLUDE pour le filtrage, la fonction exclut les enregistrements avec des valeurs NULL.

Pour cette fonction, les mots-clés ILIKE et EXCLUDE ne sont valables que dans une liste SELECT ou une clause GROUP BY.

Pour plus d’informations sur les mots-clés ILIKE et EXCLUDE, voir la section « Paramètres » dans SELECT.

alias.*

Renvoie le nombre d’enregistrements qui ne contiennent aucune valeur NULL. Pour un exemple, voir Exemples.

Renvoie¶

Renvoie une valeur de type NUMBER.

Notes sur l’utilisation¶

• Cette fonction traite JSON null (VARIANT 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, supposons que les données soient :

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

    Copy

    Dans ce cas, la fonction renvoie 2, car c’est le nombre de combinaisons distinctes de valeurs dans les trois colonnes.

• Lorsque cette fonction est appelée en tant que fonction de fenêtre avec une clause OVER qui contient une clause ORDER BY :

  • Un cadre de fenêtre est nécessaire. Si aucun cadre de fenêtre n’est spécifié explicitement, le cadre de fenêtre implicite suivant est utilisé :

    RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW

    Pour plus d’informations sur les cadres de fenêtre, y compris la syntaxe, les notes sur l’utilisation et les exemples, voir Syntaxe et utilisation des fonctions 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¶

Les exemples suivants utilisent la fonction COUNT sur les données avec des valeurs NULL.

Créer une table et insérer des valeurs :

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

Interrogez la table :

SELECT *
    FROM basic_example
    ORDER BY i_col;

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

+-----+-------+---------+-------+----------------+-------+----------------+
| All | ILIKE | EXCLUDE | i_col | DISTINCT i_col | j_col | DISTINCT j_col |
|-----+-------+---------+-------+----------------+-------+----------------|
|   6 |     4 |       5 |     4 |              2 |     5 |              2 |
+-----+-------+---------+-------+----------------+-------+----------------+

La colonne All de cette sortie montre que lorsqu’un caractère générique non qualifié et non filtré est spécifié pour COUNT, la fonction renvoie le nombre total de lignes dans la table, y compris les lignes avec des valeurs NULL. Les autres colonnes de la sortie montrent que lorsqu’une colonne ou un caractère générique avec filtrage est spécifié, la fonction exclut les lignes avec des valeurs NULL.

La requête suivante utilise la fonction COUNT avec la clause GROUP BY :

SELECT i_col, COUNT(*), COUNT(j_col)
    FROM basic_example
    GROUP BY i_col
    ORDER 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. La table basic_example comporte un total de six lignes, mais trois lignes contiennent au moins une valeur NULL et les trois autres lignes n’ont pas de valeurs NULL.

SELECT COUNT(n.*) FROM basic_example AS n;

+------------+
| COUNT(N.*) |
|------------|
|          3 |
+------------+

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

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

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

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;

Dans ce code SQL, notez ce qui suit :

• La première instruction INSERT INTO insère un SQL NULL pour une colonne VARIANT et une colonne non VARIANT.

• La deuxième instruction INSERT INTO insère un null JSON (VARIANT NULL).

• Les deux dernières instructions INSERT INTO insèrent des valeurs VARIANT non NULL.

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

Montrer que la fonction COUNT traite à la fois les valeurs NULL et null JSON (VARIANT NULL) comme NULLs. Il y a quatre lignes dans la table. L’une a une valeur SQL NULL et l’autre une valeur JSON. 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 |
+----------------+