Kategorien:

Aggregatfunktionen (Allgemein), Fensterfunktionen (Allgemein, Fensterrahmen)

COUNT

Gibt entweder die Anzahl der Nicht-NULL-Datensätze für die angegebenen Spalten oder die Gesamtzahl von Datensätzen zurück.

Siehe auch:

COUNT_IF, MIN / MAX, SUM

Syntax

Aggregatfunktion

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

COUNT( * )

Fensterfunktionen

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

Weitere Informationen zur Syntax von Fensterrahmen finden Sie unter Fensterrahmensyntax und Verwendung.

Argumente

Ausdruck1

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.

Ausdruck2

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

Ausdruck3

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

Ausdruck4

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

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

  • Wenn diese Funktion als Fensterfunktion aufgerufen wird:

    • Das Schlüsselwort DISTINCT ist syntaktisch zulässig, wird jedoch ignoriert.

    • Wenn in der OVER()-Klausel eine ORDER BY-Unterklausel verwendet wird, muss ein Fensterrahmen verwendet werden. Wenn kein Fensterrahmen angegeben ist, ist der Standard ein kumulativer Fensterrahmen:

      RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW

      Weitere Informationen zu Fensterrahmen, einschließlich Syntax und Beispiele, finden Sie unter Fensterrahmensyntax und Verwendung. Weitere Informationen zu impliziten Fensterrahmen finden Sie unter Hinweise zur Nutzung von Fensterrahmen.

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

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);
SELECT * FROM basic_example;
+-------+-------+
| 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;
+----------+--------------+-----------------------+--------------+-----------------------+
| 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;
+-------+----------+--------------+
| 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);

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

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 VARIANT NULL als NULLs 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;
+----------------+
| COUNT(V:TITLE) |
|----------------|
|              2 |
+----------------+