类别：

/sql-reference/functions-aggregation`（通用）、:doc:/sql-reference/functions-window`

COUNT

返回指定列的非 NULL 记录数或记录总数。

另请参阅：

COUNT_IF、MAX、MIN、SUM

语法

聚合函数

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

COUNT(*)

COUNT(<alias>.*)
Copy

窗口函数

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

有关 window_frame 语法的详细信息，请参阅 窗口函数的语法和用法。

实参

expr1

列名，可以是限定名称（例如 database.schema.table.column_name）。

expr2

如果需要，可以包含其他列名。例如，可以计算姓氏和名字的不同组合的数量。

expr3

要分区的列（如果想将结果拆分为多个窗口）。

expr4

要对每个窗口进行排序的列。请注意，这是与对最终结果集进行排序的任何 ORDER BY 子句分开的。

*

返回记录总数。

当您将通配符传递给函数时，您可以使用表的名称或别名来限定通配符。例如，要传入名为 mytable 的表中的所有列，请指定以下内容：

(mytable.*)
Copy

您还可以使用 ILIKE 和 EXCLUDE 关键字进行筛选：

  • ILIKE 筛选条件，用于查找与指定模式匹配的列名。只允许使用一种模式。例如：

    (* ILIKE 'col1%')
    Copy

  • EXCLUDE 筛选出与指定列或列不匹配的列名。例如：

    (* EXCLUDE col1)

(* EXCLUDE (col1, col2))
    Copy

使用这些关键字时，限定符有效。以下示例使用 ILIKE 关键字筛选出与表 mytable 中的模式 col1% 相匹配的所有列：

(mytable.* ILIKE 'col1%')
Copy

ILIKE 和 EXCLUDE 关键字不能组合在单个函数调用中。

如果指定非限定且未过滤的通配符 (*)，该函数将返回记录总数，包括带有 NULL 值的记录。

如果指定带有 ILIKE 或 EXCLUDE 关键字的通配符进行筛选时，该函数会排除带有 NULL 值的记录。

对于此函数，ILIKE 和 EXCLUDE 关键字仅在 SELECT 列表或 GROUP BY 子句中有效。

关于 ILIKE 和 EXCLUDE 关键字的更多信息，请参阅 SELECT 中的“参数”部分。

alias.*

返回不包含任何 NULL 值的记录数。相关示例请参阅 示例。

返回

返回类型 NUMBER 的值。

使用说明

  • 该函数将 JSON null (VARIANT NULL) 视作为 SQL NULL。

  • 有关 NULL 值和聚合函数的更多信息，请参阅 聚合函数和 NULL 值。

  • 当此函数作为聚合函数调用时：

    • 如果使用 DISTINCT 关键字，则它适用于所有列。例如，DISTINCT col1, col2, col3 表示返回列 col1、col2 和 col3 的不同组合数量。例如，如果数据为：

      1, 1, 1
1, 1, 1
1, 1, 1
1, 1, 2
      Copy

      在这种情况下，函数返回 2，因为这是三列中值的不同组合数量。

  • 当此函数作为窗口函数调用，且其中的 OVER 子句包含 ORDER BY 子句时：

    • 需要窗口框架。如果没有明确指定窗口框架，则使用以下默认窗口框架：

      RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW

      有关窗口框架的更多信息（包括语法、使用说明和示例），请参阅 窗口函数的语法和用法。

    • 禁止在窗口函数中使用关键字 DISTINCT，否则会导致编译时错误。

  • 若要返回与条件匹配的行数，请使用 COUNT_IF。

  • 如可能，请使用表和视图上的 COUNT 函数，无需 行访问策略。在没有行访问策略的情况下，使用此函数的查询在表或视图上运行更快、更准确。性能差异的原因包括：

    • Snowflake 维护表和视图上的统计信息，此项优化可让简单查询运行得更快。

    • 在表或视图上设置行访问策略并在查询中使用 COUNT 函数时，Snowflake 必须扫描每一行并确定是否允许用户查看该行。

示例

以下示例对带有 NULL 值的数据使用 COUNT 函数。

创建表并插入值：

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(*) 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;
Copy
+-----+-------+---------+-------+----------------+-------+----------------+
| All | ILIKE | EXCLUDE | i_col | DISTINCT i_col | j_col | DISTINCT j_col |
|-----+-------+---------+-------+----------------+-------+----------------|
|   6 |     4 |       5 |     4 |              2 |     5 |              2 |
+-----+-------+---------+-------+----------------+-------+----------------+

该输出中的 All 列显示，当为 COUNT 指定未限定和未筛选的通配符时，该函数返回表中的总行数，包括带有 NULL 值的行数。该输出中的其他列显示，当指定具有筛选功能的列或通配符时，该函数会排除带有 NULL 值的行数。

下一个查询使用具有 GROUP BY 子句的 COUNT 函数：

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

以下示例显示了 COUNT(alias.*) 返回不包含任何 NULL 值的行数。basic_example 表总共有六行，但有三行至少有一个 NULL 值，而其他三行没有 NULL 值。

SELECT COUNT(n.*) FROM basic_example AS n;
Copy
+------------+
| COUNT(N.*) |
|------------|
|          3 |
+------------+

以下示例显示了，COUNT 函数将 JSON null (VARIANT NULL) 视为 SQL NULL。

创建表并插入包含 SQL NULL 值和 JSON null 值的数据：

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

在该 SQL 代码中，请注意以下情况：

  • 第一个 INSERT INTO 语句为 VARIANT 列和非 VARIANT 列插入一个 SQL NULL。

  • 第二个 INSERT INTO 语句插入一个 JSON null (VARIANT NULL)。

  • 最后两个 INSERT INTO 语句插入非 NULL VARIANT 值。

显示数据：

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

显示 COUNT 函数将 NULL 和 JSON null (VARIANT NULL) 值都视为 NULLs。表中有四行。一行具有 SQL NULL，另一行具有 JSON null。这两行都从计数中排除，因此计数为 2。

SELECT COUNT(v:Title)
    FROM count_example_with_variant_column;
Copy
+----------------+
| COUNT(V:TITLE) |
|----------------|
|              2 |
+----------------+
语言: 中文