COUNT¶

语法¶

聚合函数

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

COUNT(*)

COUNT(<alias>.*)

窗口函数

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

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

实参¶

expr1

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

expr2

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

expr3

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

expr4

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

*

返回记录总数。

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

CopyExpand

(mytable.*)

Show lessSee more

Scroll to top

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

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

  CopyExpand

  (* ILIKE 'col1%')
  

  Show lessSee more

  Scroll to top

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

  CopyExpand

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

  Show lessSee more

  Scroll to top

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

CopyExpand

(mytable.* ILIKE 'col1%')

Show lessSee more

Scroll to top

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 的不同组合数量。例如，如果数据为：

    CopyExpand

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

    Show lessSee more

    Scroll to top

    在这种情况下，函数返回 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);

查询表：

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

该输出中的 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;

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

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

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;

在该 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;

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

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