QUALIFY¶

Syntax¶

QUALIFY <predicate>

Die allgemeine Form einer Anweisung mit QUALIFY ähnelt der folgenden (einige Abweichungen in der Reihenfolge sind zulässig, werden jedoch nicht dargestellt):

SELECT <column_list>
  FROM <data_source>
  [GROUP BY ...]
  [HAVING ...]
  QUALIFY <predicate>
  [ ... ]

Parameter¶

column_list

Dies folgt im Allgemeinen den Regeln für die Projektionsklausel einer SELECT-Anweisung.

data_source

Die Datenquelle ist normalerweise eine Tabelle, kann jedoch auch eine andere tabellenähnliche Datenquelle sein, z. B. eine Ansicht, eine UDTF (benutzerdefinierte Tabellenfunktion) usw.

predicate

Das Prädikat ist ein Ausdruck, der das Ergebnis filtert, nachdem Aggregate und Fensterfunktionen berechnet wurden. Das Prädikat sollte einer HAVING-Klausel ähneln, jedoch ohne das Schlüsselwort HAVING. Darüber hinaus kann das Prädikat auch Fensterfunktionen enthalten.

Beispiele für Prädikate finden Sie im Abschnitt Beispiele (unter diesem Thema).

Nutzungshinweise¶

• Die QUALIFY-Klausel erfordert, dass mindestens eine Fensterfunktion in mindestens einer der folgenden Klauseln der SELECT-Anweisung angegeben wird:

  • Die SELECT-Spaltenliste

  • Das Filterprädikat der QUALIFY-Klausel

  Beispiele dafür sind unten im Abschnitt „Beispiele“ zu finden.

• Ausdrücke in der SELECT-Liste, einschließlich der Fensterfunktionen, können durch den in der SELECT-Liste definierten Spaltenalias referenziert werden.

• QUALIFY unterstützt Aggregate und Unterabfragen im Prädikat. Für Aggregate gelten dieselben Regeln wie für die HAVING-Klausel.

• Das Wort QUALIFY ist ein reserviertes Wort.

• Die Snowflake-Syntax für QUALIFY ist nicht Teil des ANSI-Standards.

Beispiele¶

Die QUALIFY-Klausel vereinfacht Abfragen, bei denen das Ergebnis von Fensterfunktionen gefiltert werden muss. Ohne QUALIFY erfordert das Filtern eine Verschachtelung. Im folgenden Beispiel wird mit der Funktion ROW_NUMBER() nur die erste Zeile in jeder Partition zurückgegeben.

Erstellen und laden Sie eine Tabelle:

CREATE TABLE qt (i INTEGER, p CHAR(1), o INTEGER);
INSERT INTO qt (i, p, o) VALUES
    (1, 'A', 1),
    (2, 'A', 2),
    (3, 'B', 1),
    (4, 'B', 2);

Copy

In dieser Abfrage wird anstelle von QUALIFY eine Verschachtelung verwendet:

SELECT * 
    FROM (
         SELECT i, p, o, 
                ROW_NUMBER() OVER (PARTITION BY p ORDER BY o) AS row_num
            FROM qt
        )
    WHERE row_num = 1
    ;
+---+---+---+---------+
| I | P | O | ROW_NUM |
|---+---+---+---------|
| 1 | A | 1 |       1 |
| 3 | B | 1 |       1 |
+---+---+---+---------+

Copy

In dieser Abfrage wird QUALIFY verwendet:

SELECT i, p, o
    FROM qt
    QUALIFY ROW_NUMBER() OVER (PARTITION BY p ORDER BY o) = 1
    ;
+---+---+---+
| I | P | O |
|---+---+---|
| 1 | A | 1 |
| 3 | B | 1 |
+---+---+---+

Copy

Sie können auch QUALIFY verwenden, um auf Fensterfunktionen in der SELECT-Spaltenliste zu verweisen:

SELECT i, p, o, ROW_NUMBER() OVER (PARTITION BY p ORDER BY o) AS row_num
    FROM qt
    QUALIFY row_num = 1
    ;
+---+---+---+---------+
| I | P | O | ROW_NUM |
|---+---+---+---------|
| 1 | A | 1 |       1 |
| 3 | B | 1 |       1 |
+---+---+---+---------+

Copy

Sie können sehen, wie QUALIFY als Filter fungiert, indem Sie QUALIFY aus der vorherigen Abfrage entfernen und die Ausgabe vergleichen:

SELECT i, p, o, ROW_NUMBER() OVER (PARTITION BY p ORDER BY o) AS row_num
    FROM qt
    ;
+---+---+---+---------+
| I | P | O | ROW_NUM |
|---+---+---+---------|
| 1 | A | 1 |       1 |
| 2 | A | 2 |       2 |
| 3 | B | 1 |       1 |
| 4 | B | 2 |       2 |
+---+---+---+---------+

Copy

Die QUALIFY-Klausel kann auch mit Aggregaten kombiniert werden und Unterabfragen im Prädikat enthalten. Beispiel:

SELECT c2, SUM(c3) OVER (PARTITION BY c2) as r
  FROM t1
  WHERE c3 < 4
  GROUP BY c2, c3
  HAVING SUM(c1) > 3
  QUALIFY r IN (
    SELECT MIN(c1)
      FROM test
      GROUP BY c2
      HAVING MIN(c1) > 3);

Copy