COUNT¶

Syntax¶

Aggregatfunktion

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

COUNT(*)

COUNT(<alias>.*)

Fensterfunktionen

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

Die detaillierte Syntax von window_frame finden Sie unter Syntax und Verwendung von Fensterfunktionen.

Argumente¶

expr1

Ein Spaltenname, der ein qualifizierter Name sein kann (z. B. database.schema.table.column_name).

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.

*

Gibt die Gesamtzahl der Datensätze zurück.

Wenn Sie einen Platzhalter an die Funktion übergeben, können Sie den Platzhalter mit dem Namen oder Alias für die Tabelle qualifizieren. Um beispielsweise alle Spalten aus der Tabelle mytable zu übergeben, geben Sie Folgendes ein:

(mytable.*)

Copy

Sie können auch die Schlüsselwörter ILIKE und EXCLUDE zum Filtern verwenden:

• ILIKE filtert nach Spaltennamen, die dem angegebenen Muster entsprechen. Es ist nur ein Muster erlaubt. Beispiel:

  (* ILIKE 'col1%')
  

  Copy

• EXCLUDE filtert Spaltennamen heraus, die nicht mit der angegebenen Spalte oder den angegebenen Spalten übereinstimmen. Beispiel:

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

  Copy

Qualifizierer sind gültig, wenn Sie diese Schlüsselwörter verwenden. Das folgende Beispiel verwendet das Schlüsselwort ILIKE, um nach allen Spalten zu filtern, die dem Muster col1% in der Tabelle mytable entsprechen:

(mytable.* ILIKE 'col1%')

Copy

Die Schlüsselwörter ILIKE und EXCLUDE können nicht in einem einzigen Funktionsaufruf kombiniert werden.

Wenn Sie einen unqualifizierten und ungefilterten Platzhalter (*) angeben, gibt die Funktion die Gesamtzahl der Datensätze zurück, einschließlich der Datensätze mit NULL-Werten.

Wenn Sie einen Platzhalter mit dem Schlüsselwort ILIKE oder EXCLUDE für die Filterung angeben, schließt die Funktion Datensätze mit NULL-Werten aus.

Für diese Funktion sind die Schlüsselwörter ILIKE und EXCLUDE nur in einer SELECT-Liste oder GROUP BY-Klausel gültig.

Weitere Informationen zu den Schlüsselwörtern ILIKE und EXCLUDE finden Sie im Abschnitt „Parameter“ unter SELECT.

alias.*

Gibt die Anzahl der Datensätze zurück, die keine NULL-Werte enthalten. Ein Beispiel finden Sie unter Beispiele.

Rückgabewerte¶

Gibt einen Wert vom Typ NUMBER zurück.

Nutzungshinweise¶

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

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

• Wenn diese Funktion als Aggregatfunktion aufgerufen wird:

  • Wenn das Schlüsselwort DISTINCT verwendet wird, gilt es für alle Spalten. Zum Beispiel bedeutet DISTINCT col1, col2, col3, dass die Anzahl der verschiedenen Kombinationen der Spalten col1, col2 und col3 zurückgegeben werden. Nehmen wir zum Beispiel an, die Daten lauten:

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

    Copy

    In diesem Fall gibt die Funktion 2 zurück, denn das ist die Anzahl der unterschiedlichen Kombinationen von Werten in den drei Spalten.

• Wenn diese Funktion als Fensterfunktion mit einer OVER-Klausel aufgerufen wird, die eine ORDER BY-Klausel enthält:

  • Ein Fensterrahmen ist erforderlich. Wenn kein Fensterrahmen explizit angegeben wird, wird der folgende implizite Fensterrahmen verwendet:

    RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW

    Weitere Informationen über Fensterrahmen, einschließlich Syntax, Nutzungshinweise und Beispiele, finden Sie unter Syntax und Verwendung von Fensterfunktionen.

  • 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¶

Die folgenden Beispiele verwenden die Funktion COUNT für Daten mit NULL-Werten.

Erstellen Sie eine Tabelle, und fügen Sie Zeilen ein:

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

Fragen Sie die Tabelle ab:

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

Die Spalte All in dieser Ausgabe zeigt, dass, wenn ein unqualifizierter und ungefilterter Platzhalter für COUNT angegeben wird, die Funktion die Gesamtzahl der Zeilen in der Tabelle zurückgibt, einschließlich der Zeilen mit NULL-Werten. Die anderen Spalten in der Ausgabe zeigen, dass die Funktion Zeilen mit NULL-Werten ausschließt, wenn eine Spalte oder ein Platzhalter mit Filter angegeben wird.

Die nächste Abfrage verwendet die Funktion COUNT mit der GROUP BY-Klausel:

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

Das folgende Beispiel zeigt, dass COUNT(alias.*) die Anzahl der Zeilen zurückgibt, die keine NULL-Werte enthalten. Die Tabelle basic_example hat insgesamt sechs Zeilen, aber drei Zeilen haben mindestens einen NULL-Wert, und die anderen drei Zeilen haben keine NULL-Werte.

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

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

Das folgende Beispiel zeigt, dass JSON-Null (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 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;

Beachten Sie in diesem SQL-Code folgendes:

• Die erste INSERT INTO-Anweisung fügt eine SQL-NULL sowohl für eine VARIANT-Spalte als auch für eine Nicht-VARIANT-Spalte ein.

• Die zweite INSERT INTO-Anweisung fügt eine JSON-Null (VARIANT-NULL) ein.

• Die letzten beiden INSERT INTO-Anweisungen fügen Nicht-NULL-VARIANT-Werte ein.

Zeigen Sie die Daten an:

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

Zeigen Sie, dass die Funktion COUNT sowohl den Wert NULL als auch den Wert JSON (VARIANT NULL) null als NULLs behandelt. Es gibt vier Zeilen in der Tabelle. Die eine hat eine SQL-NULL und die andere eine JSON-Null. Diese beiden Zeilen sind von der Zählung ausgeschlossen, sodass die Zählung 2 lautet.

SELECT COUNT(v:Title)
    FROM count_example_with_variant_column;

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