COUNT¶

Syntax¶

Aggregatfunktion

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

COUNT( * )

Fensterfunktionen

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

Weitere Informationen zur Syntax von window_frame finden Sie unter Syntax und Nutzung von Fensterrahmen.

Argumente¶

expr1

Dieser muss bestehen aus:

• Einem Spaltennamen, der ein qualifizierter Name sein kann (z. B. datenbank.schema.tabelle.spaltenname) oder

• Alias.*, der angibt, dass die Funktion die Anzahl der Zeilen zurückgeben soll, die keine NULL-Werte enthalten. Ein Beispiel finden Sie unter Beispiele.

expr2

Sie können bei Bedarf zusätzliche Spaltennamen hinzufügen. So können Sie beispielsweise die unterschiedlichen Kombinationen von Nachname und Vorname zählen.

expr3

Die Spalte, in der partitioniert werden soll, wenn Sie das Ergebnis in mehrere Fenster aufteilen möchten.

expr4

Die Spalte, in der jedes Fenster sortiert werden soll. Beachten Sie, dass dies unabhängig von jeder ORDER BY-Klausel erfolgt, um das endgültige Resultset zu sortieren.

Nutzungshinweise¶

• Diese Funktion behandelt VARIANT NULL (JSON null) als SQL NULL.

• Weitere Informationen zu NULL-Werten und Aggregatfunktionen finden Sie unter Aggregationsfunktionen und NULL-Werte.

• Wenn diese Funktion als Aggregatfunktion aufgerufen wird:

  • Wenn das Schlüsselwort DISTINCT verwendet wird, gilt es für alle Spalten. Beispielsweise bedeutet DISTINCT col1, col2, col3 die Anzahl der verschiedenen Kombinationen der Spalten col1, col2 und col3. Wenn zum Beispiel folgende Daten vorliegen:

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

    Copy

    Die Funktion gibt 2 zurück, da dies die Anzahl der unterschiedlichen Wertekombinationen in den 3 Spalten ist.

• Wenn diese Funktion als Fensterfunktion (d. h. mit einer OVER-Klausel) aufgerufen wird:

  • Wenn die OVER-Klausel eine ORDER BY-Unterklausel enthält, dann gilt Folgendes:

    • Ein Fensterrahmen ist erforderlich. Wenn kein Fensterrahmen angegeben ist, impliziert das ORDER BY einen kumulativen Fensterrahmen:

      RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW

      Weitere Informationen zu Fensterrahmen, einschließlich Syntax und Beispiele, finden Sie unter Syntax und Nutzung von Fensterrahmen.

      Weitere Informationen zu impliziten Fensterrahmen finden Sie unter Hinweise zur Nutzung von Fensterrahmen.

    • Die Verwendung des Schlüsselworts DISTINCT innerhalb der Fensterfunktion ist nicht zulässig und führt zu einem Kompilierfehler.

• Verwenden Sie COUNT_IF, um die Anzahl der Zeilen zurückzugeben, die eine Bedingung erfüllen.

• Wenn möglich, verwenden Sie die Funktion COUNT für Tabellen und Ansichten, für die keine Zeilenzugriffsrichtlinie festgelegt ist. Eine Abfrage mit dieser Funktion ist schneller und genauer auf Tabellen oder Ansichten, für die keine Zeilenzugriffsrichtlinie eingerichtet ist. Die Gründe für den Leistungsunterschied sind unter anderem:

  • Snowflake führt Statistiken über Tabellen und Ansichten, und durch diese Optimierung können einfache Abfragen schneller ausgeführt werden.

  • Wenn eine Zeilenzugriffsrichtlinie für eine Tabelle oder Ansicht festgelegt ist und die Funktion COUNT in einer Abfrage verwendet wird, muss Snowflake jede Zeile überprüfen um festzustellen, ob die Zeile dem Benutzer angezeigt werden darf.

Beispiele¶

Dies ist ein Beispiel für die Verwendung von COUNT mit NULL-Werten. Die Abfrage enthält auch einige COUNT(DISTINCT)-Operationen:

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

Das folgende Beispiel zeigt, dass COUNT(alias.*) die Anzahl der Zeilen zurückgibt, die keine NULL-Werte enthalten.

Erstellen Sie eine Dataset mit folgenden Eigenschaften:

• 1 Zeile nur Nullen enthält.

• 2 Zeilen genau eine Null enthalten.

• 3 Zeilen mindestens eine Null enthalten.

• es insgesamt 4 NULL-Werte gibt.

• 5 Zeilen keine Nullen enthalten.

• es insgesamt 8 Zeilen gibt.

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

Die Abfrage gibt eine Anzahl von 5 zurück. Dies ist die Anzahl der Zeilen, die keine NULL-Werte enthalten:

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

Copy

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

Das folgende Beispiel zeigt, dass JSON (VARIANT) NULL von der Funktion COUNT als SQL NULL behandelt wird.

Erstellen Sie die Tabelle, und fügen Sie Daten ein, die sowohl SQL NULL- als auch JSON NULL-Werte enthalten:

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

Zeigen Sie die Daten an:

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

Zeigen Sie, dass die Funktion COUNT sowohl den Wert NULL als auch den Wert VARIANT NULL (JSON null) als NULL-Werte behandelt. Die Tabelle enthält 4 Zeilen. Eine hat einen SQL NULL-Wert und die andere eine VARIANT NULL-Wert. Beide Zeilen sind von der Zählung ausgeschlossen, daher ist die Zahl 2.

SELECT COUNT(v:Title)
    FROM count_example_with_variant_column;

Copy

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