Kategorien:

Abfragesyntax

QUALIFY

In einer SELECT-Anweisung filtert die QUALIFY-Klausel die Ergebnisse von Fensterfunktionen.

QUALIFY hat für Fensterfunktionen dieselbe Bedeutung, die HAVING für Aggregatfunktionen und die GROUP BY-Klauseln hat.

In der Ausführungsreihenfolge einer Abfrage wird daher QUALIFY ausgewertet, nachdem Fensterfunktionen berechnet wurden. In der Regel werden die Klauseln einer SELECT -Anweisung in der folgenden Reihenfolge ausgewertet:

  1. From

  2. Where

  3. Group by

  4. Having

  5. Window

  6. QUALIFY

  7. Distinct

  8. Order by

  9. Limit

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>
  [ ... ]
Spaltenliste

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

Datenquelle

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

Prädikat

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

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

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

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