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

+-------------------------+
| number of rows inserted |
|-------------------------|
|                       4 |
+-------------------------+

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

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

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

Sie können sehen, wie QUALIFY als Filter fungiert, indem Sie sie 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 |
+---+---+---+---------+

Die QUALIFY-Klausel kann auch mit Aggregatfunktionen und Unterabfragen im Prädikat kombiniert werden. In einer solchen Abfrage filtert HAVING Zeilen nach der GROUP BY-Aggregation, währendQUALIFY Zeilen nach der Berechnung von Fensterfunktionen filtert. Beide Klauseln können zusammen verwendet werden, wenn eine Abfrage beide Arten von Filtern erfordert. Beispiel:

SELECT p, SUM(o) OVER (PARTITION BY p) AS r
  FROM qt
  WHERE o < 4
  GROUP BY p, o
  HAVING SUM(i) > 3
  QUALIFY r IN (
    SELECT MIN(i)
      FROM qt
      GROUP BY p
      HAVING MIN(i) > 3);