Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Fensterfunktionen
Mit Fensterfunktionen können Sie analytische geschäftliche Abfragen effizienter erstellen. Fensterfunktionen werden für eine Partition bzw. ein „Fenster“ eines Ergebnissatzes ausgeführt und geben für jede Zeile in diesem Fenster einen Wert zurück. Funktionen ohne Fenster führen ihre Berechnungen dagegen für alle Zeilen des Ergebnissatzes aus. Im Gegensatz zu Gruppenfunktionen, die die Ergebniszeilen aggregieren, behalten Fensterfunktionen alle Zeilen im Tabellenausdruck bei.
Die zurückgegebenen Werte werden mithilfe von Werten aus den Sätzen von Zeilen in diesem Fenster berechnet. Das Fenster definiert für jede Zeile in der Tabelle einen Satz von Zeilen, der für die Verarbeitung zusätzlicher Attribute verwendet wird. Ein Fenster wird mithilfe einer Fensterspezifikation (der OVER-Klausel) definiert und basiert auf drei Hauptkonzepten:
+ *Fensterpartitionierung*, die Gruppen von Zeilen bildet (PARTITION-Klausel)
+ *Fensteranordnung*, die eine Reihenfolge oder Sequenz von Zeilen innerhalb der einzelnen Partitionen definiert (ORDER BY-Klausel)
+ *Fensterrahmen*, die in Bezug auf die einzelnen Zeilen definiert werden, um den Satz von Zeilen weiter einzuschränken (ROWS-Spezifikation)
Fensterfunktionen sind der letzte Satz von Operationen, die in einer Abfrage ausgeführt werden, abgesehen von der abschließenden ORDER BY-Klausel. Alle Joins und alle -, - und -Klauseln werden abgeschlossen, bevor die Fensterfunktionen verarbeitet werden. Daher können Fensterfunktionen nur in der Auswahlliste oder in der ORDER BY-Klausen enthalten sein. Innerhalb einer einzelnen Abfrage können mehrere Fensterfunktionen mit unterschiedlichen Rahmenklauseln verwendet werden. Außerdem können Sie Fensterfunktionen in anderen skalaren Ausdrücken verwenden, beispielsweise CASE.
## Übersicht über die Syntax von Fensterfunktionen
Fensterfunktionen folgen einer Standardsyntax, die wie folgt lautet.
```
function (expression) OVER (
[ PARTITION BY expr_list ]
[ ORDER BY order_list [ frame_clause ] ] )
```
Hier ist *function* eine der in diesem Abschnitt beschriebenen Funktionen.
Die *expr\$1list* lautet wie folgt.
```
expression | column_name [, expr_list ]
```
Die *order\$1list* lautet wie folgt.
```
expression | column_name [ ASC | DESC ]
[ NULLS FIRST | NULLS LAST ]
[, order_list ]
```
Die *frame\$1clause* lautet wie folgt.
```
ROWS
{ UNBOUNDED PRECEDING | unsigned_value PRECEDING | CURRENT ROW } |
{ BETWEEN
{ UNBOUNDED PRECEDING | unsigned_value { PRECEDING | FOLLOWING } | CURRENT ROW}
AND
{ UNBOUNDED FOLLOWING | unsigned_value { PRECEDING | FOLLOWING } | CURRENT ROW }}
```
### Argumente
*Funktion*
Die Fensterfunktion. Details finden Sie in den Beschreibungen der einzelnen Funktionen.
OVER
Die Klausel, die die Fensterspezifikation definiert. Die OVER-Klausel ist für Fensterfunktionen obligatorisch und differenziert Fensterfunktionen von anderen SQL-Funktionen.
PARTITION BY *expr\$1list*
(Optional) Die PARTITION-BY-Klausel unterteilt den Ergebnissatz in Partitionen, ähnlich wie die GROUP-BY-Klausel. Wenn eine Partitionsklausel vorhanden ist, wird die Funktion für die Zeilen in den einzelnen Partitionen berechnet. Wenn keine Partitionsklausel angegeben ist, enthält eine einzige Partition die gesamte Tabelle und die Funktion wird für die gesamte Tabelle berechnet.
Die Rangfestlegungsfunktionen DENSE\$1RANK, NTILE, RANK und ROW\$1NUMBER erfordern einen globalen Vergleich aller Zeilen im Ergebnissatz. Wenn eine PARTITION BY-Klausel verwendet wird, kann die Abfrageoptimierung die einzelnen Aggregationen parallel ausführen, indem der Workload entsprechend den Partitionen über mehrere Slices verteilt wird. Wenn die PARTITION BY-Klausel nicht vorhanden ist, muss der Aggregationsschritt seriell für einen einzelnen Slice ausgeführt werden. Dies kann erhebliche negative Auswirkungen auf die Leistung haben, besonders für größere Cluster.
AWS Clean Roomsunterstützt keine Zeichenkettenliterale in PARTITION BY-Klauseln.
ORDER BY *order\$1list*
(Optional) Die Fensterfunktion wird auf die Zeilen innerhalb der einzelnen Partitionen angewendet, sortiert entsprechend der Reihenfolgenspezifikation in ORDER BY. Diese ORDER BY-Klausel unterscheidet sich von der ORDER BY-Klausel in der *frame\$1clause*und ist mit dieser in keiner Weise verwandt. Die ORDER BY-Klausel kann ohne die PARTITION BY-Klausel verwendet werden.
Für Rangfestlegungsfunktionen identifiziert die ORDER BY-Klausel die Messwerte für die Rangfestlegungswerte. Für Aggregationsfunktionen müssen die partitionierten Zeilen angeordnet werden, bevor die jeweilige Aggregationsfunktion für die einzelnen Rahmen berechnet wird. Weitere Informationen zu den Arten von Windowsfunktionen finden Sie unter [Fensterfunktionen](#Window_functions).
In der Reihenfolgenliste werden Spaltenbezeichner oder Ausdrücke, die zu Spaltenbezeichnern ausgewertet werden, benötigt. Konstanten oder Konstantenausdrücke können nicht als Ersatz für Spaltennamen verwendet werden.
NULL-Werte werden als eigene Gruppe behandelt und entsprechend der Option NULLS FIRST oder NULLS LAST sortiert und angeordnet. Standardmäßig werden NULL-Werte in einer ASC-Reihenfolge an letzter Stelle sortiert und aufgeführt und in einer DESC-Reihenfolge an erster Stelle sortiert und aufgeführt.
AWS Clean Roomsunterstützt keine Zeichenkettenliterale in ORDER BY-Klauseln.
Wenn die ORDER BY-Klausel ausgelassen wird, ist die Reihenfolge der Zeilen nicht deterministisch.
In jedem parallel SystemAWS Clean Rooms, z. B. wenn eine ORDER BY-Klausel keine eindeutige und vollständige Reihenfolge der Daten erzeugt, ist die Reihenfolge der Zeilen nicht deterministisch. Das heißt, wenn der ORDER BY-Ausdruck doppelte Werte erzeugt (eine teilweise Reihenfolge), kann die Reihenfolge der Rückgabe dieser Zeilen von einem Lauf AWS Clean Rooms zum nächsten variieren. In diesem Fall können Fensterfunktionen unerwartete oder inkonsistente Ergebnisse zurückgeben. Weitere Informationen finden Sie unter [Spezifisches Anordnen von Daten für Fensterfunktionen](#Examples_order_by_WF).
*column\$1name*
Der Name einer Spalte, nach der die Partitionierung oder Anordnung erfolgen soll.
ASC \$1 DESC
Eine Option, die die Sortierreihenfolge für den Ausdruck wie folgt definiert:
+ ASC: aufsteigend (beispielsweise niedrig nach hoch für numerische Werte und A bis Z für Zeichenfolgen). Wenn keine Option angegeben wird, werden die Daten standardmäßig in aufsteigender Reihenfolge sortiert.
+ DESC: absteigend (beispielsweise hoch nach niedrig für numerische Werte und Z bis A für Zeichenfolgen).
NULLS FIRST \$1 NULLS LAST
Option, die angibt, ob NULL-Werte an erster Stelle vor Nicht-Null-Werten oder an letzter Stelle nach Nicht-Null-Werten aufgelistet werden sollen. Standardmäßig werden NULL-Werte in einer ASC-Reihenfolge an letzter Stelle sortiert und aufgeführt und in einer DESC-Reihenfolge an erster Stelle sortiert und aufgeführt.
*frame\$1clause*
Die Rahmenklausel gibt für Aggregationsfunktionen den Satz von Zeilen im Fenster einer Funktion bei Verwendung von ORDER BY noch genauer an. Sie ermöglicht das Ein- oder Ausschließen von Sätzen von Zeilen innerhalb des geordneten Ergebnisses. Die Rahmenklausel besteht aus dem Schlüsselwort ROWS und verknüpften Spezifikatoren.
Die Rahmenklausel kann nicht auf Rangfestlegungsfunktionen angewendet werden. Außerdem ist sie nicht erforderlich, wenn in der ORDER-BY-Klausel für eine Aggregationsfunktion keine OVER-Klausel verwendet wird. Wenn eine ORDER BY-Klausel für eine Aggregationsfunktion verwendet wird, ist eine explizite Rahmenklausel erforderlich.
Wenn keine ORDER-BY-Klausel angegeben ist, ist der implizierte Rahmen unbegrenzt, äquivalent zu ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING.
ROWS
Diese Klausel definiert den Fensterrahmen durch Angabe eines physischen Offsets von der aktuellen Zeile.
Diese Klausel gibt die Zeilen im aktuellen Fenster oder in der aktuellen Partition an, mit denen der Wert in der aktuellen Zeile kombiniert werden soll. Sie verwendet Argumente, die die Zeilenposition angeben. Diese kann sich vor oder nach der aktuellen Zeile befinden. Der Referenzpunkt für alle Fensterrahmen ist die aktuelle Zeile. Alle Zeilen werden nacheinander zur aktuellen Zeile, während der Fensterrahmen in der Partition vorwärts gleitet.
Beim Rahmen kann es sich um einen einfachen Satz von Zeilen bis zur und einschließlich der aktuellen Zeile handeln.
```
{UNBOUNDED PRECEDING | offset PRECEDING | CURRENT ROW}
```
Es kann sich auch um einen Satz von Zeilen zwischen zwei Grenzen handeln.
```
BETWEEN
{ UNBOUNDED PRECEDING | offset { PRECEDING | FOLLOWING } | CURRENT ROW }
AND
{ UNBOUNDED FOLLOWING | offset { PRECEDING | FOLLOWING } | CURRENT ROW }
```
UNBOUNDED PRECEDING zeigt an, dass das Fenster an der ersten Zeile der Partition beginnt; *offset* PRECEDING zeigt an, dass das Fenster um eine Zahl von Reihen vor der aktuellen Zeile beginnt, die dem Offset-Wert entspricht. UNBOUNDED PRECEDING ist der Standardwert.
CURRENT ROW zeigt an, dass das Fenster an der aktuellen Zeile beginnt oder endet.
UNBOUNDED FOLLOWING zeigt an, dass das Fenster an der letzten Zeile der Partition endet; *offset* FOLLOWING zeigt an, dass das Fenster um eine Zahl von Reihen nach der aktuellen Zeile endet, die dem Offset-Wert entspricht.
*offset* bezeichnet eine physische Anzahl von Zeilen vor oder nach der aktuellen Zeile. In diesem Fall muss *offset* eine Konstante sein, der zu einem positiven numerischen Wert ausgewertet wird. Beispielsweise wird bei 5 FOLLOWING der Rahmen fünf Zeilen nach der aktuellen Zeile beendet.
Wenn BETWEEN nicht angegeben ist, wird der Rahmen implizit von der aktuellen Zeile begrenzt. Beispielsweise ist `ROWS 5 PRECEDING` gleich `ROWS BETWEEN 5 PRECEDING AND CURRENT ROW`. Ebenso ist `ROWS UNBOUNDED FOLLOWING` gleich `ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING`.
Sie können keinen Rahmen angeben, in dem die Startgrenze größer als die Endgrenze ist. Sie können beispielsweise keinen der folgenden Rahmen angeben.
```
between 5 following and 5 preceding
between current row and 2 preceding
between 3 following and current row
```
## Spezifisches Anordnen von Daten für Fensterfunktionen
Wenn eine ORDER-BY-Klausel für eine Fensterfunktion keine spezifische und globale Anordnung der Daten generiert, ist die Reihenfolge der Zeilen nicht deterministisch. Wenn der ORDER-BY-Ausdruck duplizierte Werte generiert (eine partielle Anordnung), kann sich die Rückgabereihenfolge dieser Zeilen zwischen verschiedenen Ausführungen unterscheiden. In diesem Fall geben Fensterfunktionen möglicherweise unerwartete oder inkonsistente Ergebnisse zurück.
Beispielsweise gibt die folgende Abfrage in verschiedenen Ausführen unterschiedliche Ergebnisse zurück. Diese unterschiedlichen Ergebnisse treten auf, da `order by dateid` keine spezifische Reihenfolge der Daten für die SUM-Fensterfunktion erzeugt.
```
select dateid, pricepaid,
sum(pricepaid) over(order by dateid rows unbounded preceding) as sumpaid
from sales
group by dateid, pricepaid;
dateid | pricepaid | sumpaid
--------+-----------+-------------
1827 | 1730.00 | 1730.00
1827 | 708.00 | 2438.00
1827 | 234.00 | 2672.00
...
select dateid, pricepaid,
sum(pricepaid) over(order by dateid rows unbounded preceding) as sumpaid
from sales
group by dateid, pricepaid;
dateid | pricepaid | sumpaid
--------+-----------+-------------
1827 | 234.00 | 234.00
1827 | 472.00 | 706.00
1827 | 347.00 | 1053.00
...
```
In diesem Fall kann das Hinzufügen einer zweiten ORDER-BY-Spalte zur Fensterfunktion das Problem lösen.
```
select dateid, pricepaid,
sum(pricepaid) over(order by dateid, pricepaid rows unbounded preceding) as sumpaid
from sales
group by dateid, pricepaid;
dateid | pricepaid | sumpaid
--------+-----------+---------
1827 | 234.00 | 234.00
1827 | 337.00 | 571.00
1827 | 347.00 | 918.00
...
```
## Unterstützte Funktionen
AWS Clean RoomsSpark SQL unterstützt zwei Arten von Fensterfunktionen: Aggregat- und Rangfunktionen.
Die folgenden Aggregationsfunktionen werden unterstützt:
+ [CUME\$1DIST-Fensterfunktion](WF_CUME_DIST.md)
+ [Die Fensterfunktion DENSE\$1RANK](WF_DENSE_RANK.md)
+ [Funktion „ERSTES Fenster“](WF_FIRST.md)
+ [Die Fensterfunktion FIRST\$1VALUE](WF_first_value.md)
+ [Die Fensterfunktion LAG](WF_LAG.md)
+ [Funktion „LETZTES Fenster“](WF-LAST.md)
+ [Die Fensterfunktion LAST\$1VALUE](WF_last_value.md)
+ [Die Fensterfunktion LEAD](WF_LEAD.md)
Die folgenden Rangfestlegungsfunktionen werden unterstützt:
+ [Die Fensterfunktion DENSE\$1RANK](WF_DENSE_RANK.md)
+ [Die Fensterfunktion PERCENT\$1RANK](WF_PERCENT_RANK.md)
+ [Die Fensterfunktion RANK](WF_RANK.md)
+ [Die Fensterfunktion ROW\$1NUMBER](WF_ROW_NUMBER.md)
## Beispieltabelle mit Beispielen von Fensterfunktionen
Zu jeder Funktionsbeschreibung gehören spezifische Fensterfunktionsbeispiele. In einigen Beispielen wird eine Tabelle mit dem Namen WINSALES verwendet, die 11 Zeilen enthält, wie in der folgenden Tabelle dargestellt.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/clean-rooms/latest/sql-reference/Window_functions.html)
# CUME\$1DIST-Fensterfunktion
Berechnet die kumulative Verteilung eines Werts in einem Fenster oder einer Partition. Bei aufsteigender Anordnung wird die kumulative Verteilung anhand der folgenden Formel festgelegt:
`count of rows with values <= x / count of rows in the window or partition`
wobei *x* gleich dem Wert in der aktuellen Zeile der Spalte ist, die in der ORDER BY-Klausel angegeben wird. Der folgende Datensatz zeigt die Verwendung dieser Formel:
```
Row# Value Calculation CUME_DIST
1 2500 (1)/(5) 0.2
2 2600 (2)/(5) 0.4
3 2800 (3)/(5) 0.6
4 2900 (4)/(5) 0.8
5 3100 (5)/(5) 1.0
```
Der Rückgabewertbereich ist >0 bis 1 (einschließlich).
## Syntax
```
CUME_DIST ()
OVER (
[ PARTITION BY partition_expression ]
[ ORDER BY order_list ]
)
```
## Argumente
OVER
Eine Klausel, die die Fensterpartitionierung angibt. Die OVER-Klausel darf keine Fensterrahmenspezifikation enthalten.
PARTITION BY *partition\$1expression*
Optional. Ein Ausdruck, der den Datensatzbereich für die einzelnen Gruppen in der OVER-Klausel festlegt.
ORDER BY *order\$1list*
Der Ausdruck, anhand dessen die kumulative Verteilung berechnet wird. Der Datentyp des Ausdrucks muss entweder numerisch sein oder implizit in einen solchen konvertierbar sein. Wenn ORDER BY ausgelassen wird, ist der Rückgabewert für alle Zeilen 1.
Wenn ORDER-BY nicht zu einer spezifischen Reihenfolge führt, ist die Reihenfolge der Zeilen nicht deterministisch. Weitere Informationen finden Sie unter [Spezifisches Anordnen von Daten für Fensterfunktionen](Window_functions.md#Examples_order_by_WF).
## Rückgabetyp
FLOAT8
## Beispiele
Im folgenden Beispiel wird die kumulative Verteilung der Menge für die einzelnen Verkäufer berechnet:
```
select sellerid, qty, cume_dist()
over (partition by sellerid order by qty)
from winsales;
sellerid qty cume_dist
--------------------------------------------------
1 10.00 0.33
1 10.64 0.67
1 30.37 1
3 10.04 0.25
3 15.15 0.5
3 20.75 0.75
3 30.55 1
2 20.09 0.5
2 20.12 1
4 10.12 0.5
4 40.23 1
```
Eine Beschreibung der Tabelle WINSALES finden Sie unter [Beispieltabelle mit Beispielen von Fensterfunktionen](Window_functions.md#Window_function_example).
# Die Fensterfunktion DENSE\$1RANK
Die Fensterfunktion DENSE\$1RANK legt den Rang eines Werts in einer Gruppe von Werten fest, basierend auf dem ORDER BY-Ausdruck in der OVER-Klausel. Wenn die optionale PARTITION BY-Klausel vorhanden ist, wird die Rangfolge für jede Gruppe von Zeilen neu festgelegt. Zeilen mit gleichen Werten in Bezug auf die Rangfestlegungskriterien erhalten den gleichen Rang. Die Funktion DENSE\$1RANK unterscheidet sich nur in einer Hinsicht von RANK: Wenn zwei oder mehr Zeilen den gleichen Rang erhalten, entsteht in der Rangfolge der Werte keine Lücke. Wenn beispielsweise zwei Zeilen den Rang 1 erhalten, ist der nächste Rang 2.
Sie können in derselben Abfrage Rangfestlegungsfunktionen mit unterschiedlichen PARTITION BY- und ORDER BY-Klauseln verwenden.
## Syntax
```
DENSE_RANK () OVER
(
[ PARTITION BY expr_list ]
[ ORDER BY order_list ]
)
```
## Argumente
( )
Die Funktion verwendet keine Argumente. Es ist jedoch eine leere Klammer erforderlich.
OVER
Die Fensterklauseln für die Funktion DENSE\$1RANK.
PARTITION BY *expr\$1list*
Optional. Ein oder mehrere Ausdrücke, der/die das Fenster definiert/definieren.
ORDER BY *order\$1list*
Optional. Der Ausdruck, auf dem die Rangfestlegungwerte basieren. Wenn PARTITION BY nicht angegeben ist, verwendet ORDER BY die gesamte Tabelle. Wenn ORDER BY ausgelassen wird, ist der Rückgabewert für alle Zeilen 1.
Wenn ORDER-BY nicht zu einer spezifischen Reihenfolge führt, ist die Reihenfolge der Zeilen nicht deterministisch. Weitere Informationen finden Sie unter [Spezifisches Anordnen von Daten für Fensterfunktionen](Window_functions.md#Examples_order_by_WF).
## Rückgabetyp
INTEGER
## Beispiele
Im folgenden Beispiel wird die Tabelle nach der verkauften Menge (in absteigender Reihenfolge) geordnet und jeder Zeile ein DENSE\$1RANK-Wert und ein regulärer Rang zugewiesen. Die Ergebnisse werden sortiert, nachdem die Fensterfunktionsergebnisse angewendet wurden.
```
select salesid, qty,
dense_rank() over(order by qty desc) as d_rnk,
rank() over(order by qty desc) as rnk
from winsales
order by 2,1;
salesid | qty | d_rnk | rnk
---------+-----+-------+-----
10001 | 10 | 5 | 8
10006 | 10 | 5 | 8
30001 | 10 | 5 | 8
40005 | 10 | 5 | 8
30003 | 15 | 4 | 7
20001 | 20 | 3 | 4
20002 | 20 | 3 | 4
30004 | 20 | 3 | 4
10005 | 30 | 2 | 2
30007 | 30 | 2 | 2
40001 | 40 | 1 | 1
(11 rows)
```
Beachten Sie den Unterschied bei den Rängen, die demselben Satz von Zeilen zugewiesen werden, wenn die Funktionen DENSE\$1RANK und RANK zusammen in derselben Umfrage verwendet werden. Eine Beschreibung der Tabelle WINSALES finden Sie unter [Beispieltabelle mit Beispielen von Fensterfunktionen](Window_functions.md#Window_function_example).
Im folgenden Beispiel wird die Tabelle nach SELLERID partitioniert, die einzelnen Partitionen nach Menge (in absteigender Reihenfolge) geordnet und jeder Zeile ein DENSE\$1RANK-Wert zugewiesen. Die Ergebnisse werden sortiert, nachdem die Fensterfunktionsergebnisse angewendet wurden.
```
select salesid, sellerid, qty,
dense_rank() over(partition by sellerid order by qty desc) as d_rnk
from winsales
order by 2,3,1;
salesid | sellerid | qty | d_rnk
---------+----------+-----+-------
10001 | 1 | 10 | 2
10006 | 1 | 10 | 2
10005 | 1 | 30 | 1
20001 | 2 | 20 | 1
20002 | 2 | 20 | 1
30001 | 3 | 10 | 4
30003 | 3 | 15 | 3
30004 | 3 | 20 | 2
30007 | 3 | 30 | 1
40005 | 4 | 10 | 2
40001 | 4 | 40 | 1
(11 rows)
```
Eine Beschreibung der Tabelle WINSALES finden Sie unter [Beispieltabelle mit Beispielen von Fensterfunktionen](Window_functions.md#Window_function_example).
# Funktion „ERSTES Fenster“
Bei einer bestimmten Anzahl von Zeilen gibt FIRST den Wert des angegebenen Ausdrucks in Bezug auf die erste Zeile im Fensterrahmen zurück.
Informationen zur Auswahl der letzten Zeile im Rahmen finden Sie unter [Funktion „LETZTES Fenster“](WF-LAST.md).
## Syntax
```
FIRST( expression )[ IGNORE NULLS | RESPECT NULLS ]
OVER (
[ PARTITION BY expr_list ]
[ ORDER BY order_list frame_clause ]
)
```
## Argumente
*expression*
Die Zielspalte oder der Ausdruck, für die/den die Funktion ausgeführt wird.
IGNORE NULLS
Wenn diese Option mit FIRST verwendet wird, gibt die Funktion den ersten Wert im Frame zurück, der nicht NULL ist (oder NULL, wenn alle Werte NULL sind).
RESPECT NULLS
Gibt an, dass Nullwerte bei der Bestimmung der zu verwendenden Zeile berücksichtigt werden AWS Clean Rooms sollen. Wenn Sie IGNORE NULLS nicht angeben, wird RESPECT NULLS standardmäßig unterstützt.
OVER
Führt die Fensterklauseln für die Funktion ein.
PARTITION BY *expr\$1list*
Definiert das Fenster für die Funktion in Bezug auf mindestens einen Ausdruck.
ORDER BY *order\$1list*
Sortiert die Zeilen innerhalb der einzelnen Partitionen. Wenn die PARTITION BY-Klausel nicht angegeben ist, sortiert ORDER BY die gesamte Tabelle. Wenn Sie eine ORDER BY-Klausel angeben, müssen Sie auch eine *frame\$1clause* angeben.
Die Ergebnisse der FIRST-Funktion hängen von der Reihenfolge der Daten ab. Die Ergebnisse sind in den folgenden Fällen nicht deterministisch:
+ Wenn keine ORDER BY-Klausel angegeben ist und eine Partition zwei verschiedene Werte für einen Ausdruck enthält
+ Wenn der Ausdruck zu verschiedenen Werten ausgewertet wird, die demselben Wert in der ORDER BY-Liste entsprechen
*frame\$1clause*
Wenn eine ORDER BY-Klausel für eine Aggregationsfunktion verwendet wird, ist eine explizite Rahmenklausel erforderlich. Die Rahmenklausel gibt den Satz von Zeilen im Fenster einer Funktion genauer an, einschließlich oder ausschließlich Sätzen von Zeilen im geordneten Ergebnis. Die Rahmenklausel besteht aus dem Schlüsselwort ROWS und verknüpften Spezifikatoren. Siehe [Übersicht über die Syntax von Fensterfunktionen](Window_functions.md#Window_function_synopsis).
## Rückgabetyp
Diese Funktionen unterstützen Ausdrücke, die primitive AWS Clean Rooms Datentypen verwenden. Der Rückgabetyp ist mit dem Datentyp von *expression* identisch.
## Beispiele
Im folgenden Beispiel wird die Sitzplatzkapazität für die einzelnen Veranstaltungsorte in der Tabelle VENUE zurückgegeben, wobei die Ergebnisse nach Kapazität (hoch zu niedrig) geordnet sind. Die FIRST-Funktion wird verwendet, um den Namen des Veranstaltungsorts auszuwählen, der der ersten Reihe im Frame entspricht: in diesem Fall der Zeile mit der höchsten Anzahl von Sitzplätzen. Die Ergebnisse werden nach Bundesstaat partitioniert. Wenn der Wert für VENUESTATE geändert wird, wird daher ein neuer erster Wert ausgewählt. Der Fensterrahmen ist unbegrenzt. Daher wird für jede Zeile in jeder Partition derselbe erste Wert ausgewählt.
Im Fall von Kalifornien hat `Qualcomm Stadium` die größte Zahl von Sitzplätzen (`70561`). Daher ist dieser Name der erste Wert für alle Zeilen in der Partition `CA`.
```
select venuestate, venueseats, venuename,
first(venuename)
over(partition by venuestate
order by venueseats desc
rows between unbounded preceding and unbounded following)
from (select * from venue where venueseats >0)
order by venuestate;
venuestate | venueseats | venuename | first
-----------+------------+--------------------------------+------------------------------
CA | 70561 | Qualcomm Stadium | Qualcomm Stadium
CA | 69843 | Monster Park | Qualcomm Stadium
CA | 63026 | McAfee Coliseum | Qualcomm Stadium
CA | 56000 | Dodger Stadium | Qualcomm Stadium
CA | 45050 | Angel Stadium of Anaheim | Qualcomm Stadium
CA | 42445 | PETCO Park | Qualcomm Stadium
CA | 41503 | AT&T Park | Qualcomm Stadium
CA | 22000 | Shoreline Amphitheatre | Qualcomm Stadium
CO | 76125 | INVESCO Field | INVESCO Field
CO | 50445 | Coors Field | INVESCO Field
DC | 41888 | Nationals Park | Nationals Park
FL | 74916 | Dolphin Stadium | Dolphin Stadium
FL | 73800 | Jacksonville Municipal Stadium | Dolphin Stadium
FL | 65647 | Raymond James Stadium | Dolphin Stadium
FL | 36048 | Tropicana Field | Dolphin Stadium
...
```
# Die Fensterfunktion FIRST\$1VALUE
Bei einem geordneten Satz von Zeilen gibt FIRST\$1VALUE den Wert des angegebenen Ausdrucks in Bezug auf die erste Zeile im Fensterrahmen zurück.
Informationen zur Auswahl der letzten Zeile im Rahmen finden Sie unter [Die Fensterfunktion LAST\$1VALUE](WF_last_value.md).
## Syntax
```
FIRST_VALUE( expression )[ IGNORE NULLS | RESPECT NULLS ]
OVER (
[ PARTITION BY expr_list ]
[ ORDER BY order_list frame_clause ]
)
```
## Argumente
*expression*
Die Zielspalte oder der Ausdruck, für die/den die Funktion ausgeführt wird.
IGNORE NULLS
Bei Verwendung dieser Option für FIRST\$1VALUE gibt die Funktion den ersten Wert im Rahmen zurück, der nicht NULL ist (oder NULL, wenn alle Werte NULL sind).
RESPECT NULLS
Gibt an, dass bei der Bestimmung der zu verwendenden Zeile Nullwerte berücksichtigt werden AWS Clean Rooms sollen. Wenn Sie IGNORE NULLS nicht angeben, wird RESPECT NULLS standardmäßig unterstützt.
OVER
Führt die Fensterklauseln für die Funktion ein.
PARTITION BY *expr\$1list*
Definiert das Fenster für die Funktion in Bezug auf mindestens einen Ausdruck.
ORDER BY *order\$1list*
Sortiert die Zeilen innerhalb der einzelnen Partitionen. Wenn die PARTITION BY-Klausel nicht angegeben ist, sortiert ORDER BY die gesamte Tabelle. Wenn Sie eine ORDER BY-Klausel angeben, müssen Sie auch eine *frame\$1clause* angeben.
Die Ergebnisse der Funktion FIRST\$1VALUE sind von der Anordnung der Daten abhängig. Die Ergebnisse sind in den folgenden Fällen nicht deterministisch:
+ Wenn keine ORDER BY-Klausel angegeben ist und eine Partition zwei verschiedene Werte für einen Ausdruck enthält
+ Wenn der Ausdruck zu verschiedenen Werten ausgewertet wird, die demselben Wert in der ORDER BY-Liste entsprechen
*frame\$1clause*
Wenn eine ORDER BY-Klausel für eine Aggregationsfunktion verwendet wird, ist eine explizite Rahmenklausel erforderlich. Die Rahmenklausel gibt den Satz von Zeilen im Fenster einer Funktion genauer an, einschließlich oder ausschließlich Sätzen von Zeilen im geordneten Ergebnis. Die Rahmenklausel besteht aus dem Schlüsselwort ROWS und verknüpften Spezifikatoren. Siehe [Übersicht über die Syntax von Fensterfunktionen](Window_functions.md#Window_function_synopsis).
## Rückgabetyp
Diese Funktionen unterstützen Ausdrücke, die primitive AWS Clean Rooms Datentypen verwenden. Der Rückgabetyp ist mit dem Datentyp von *expression* identisch.
## Beispiele
Im folgenden Beispiel wird die Sitzplatzkapazität für die einzelnen Veranstaltungsorte in der Tabelle VENUE zurückgegeben, wobei die Ergebnisse nach Kapazität (hoch zu niedrig) geordnet sind. Die Funktion FIRST\$1VALUE wird verwendet, um den Namen des Veranstaltungsorts auszuwählen, der der ersten Zeile im Rahmen entspricht, in diesem Fall der Zeile mit der größten Zahl von Sitzplätzen. Die Ergebnisse werden nach Bundesstaat partitioniert. Wenn der Wert für VENUESTATE geändert wird, wird daher ein neuer erster Wert ausgewählt. Der Fensterrahmen ist unbegrenzt. Daher wird für jede Zeile in jeder Partition derselbe erste Wert ausgewählt.
Im Fall von Kalifornien hat `Qualcomm Stadium` die größte Zahl von Sitzplätzen (`70561`). Daher ist dieser Name der erste Wert für alle Zeilen in der Partition `CA`.
```
select venuestate, venueseats, venuename,
first_value(venuename)
over(partition by venuestate
order by venueseats desc
rows between unbounded preceding and unbounded following)
from (select * from venue where venueseats >0)
order by venuestate;
venuestate | venueseats | venuename | first_value
-----------+------------+--------------------------------+------------------------------
CA | 70561 | Qualcomm Stadium | Qualcomm Stadium
CA | 69843 | Monster Park | Qualcomm Stadium
CA | 63026 | McAfee Coliseum | Qualcomm Stadium
CA | 56000 | Dodger Stadium | Qualcomm Stadium
CA | 45050 | Angel Stadium of Anaheim | Qualcomm Stadium
CA | 42445 | PETCO Park | Qualcomm Stadium
CA | 41503 | AT&T Park | Qualcomm Stadium
CA | 22000 | Shoreline Amphitheatre | Qualcomm Stadium
CO | 76125 | INVESCO Field | INVESCO Field
CO | 50445 | Coors Field | INVESCO Field
DC | 41888 | Nationals Park | Nationals Park
FL | 74916 | Dolphin Stadium | Dolphin Stadium
FL | 73800 | Jacksonville Municipal Stadium | Dolphin Stadium
FL | 65647 | Raymond James Stadium | Dolphin Stadium
FL | 36048 | Tropicana Field | Dolphin Stadium
...
```
# Die Fensterfunktion LAG
Die Fensterfunktion LAG gibt die Werte für eine Zeile in einem bestimmten Offset oberhalb (vor) der aktuellen Zeile in der Partition zurück.
## Syntax
```
LAG (value_expr [, offset ])
[ IGNORE NULLS | RESPECT NULLS ]
OVER ( [ PARTITION BY window_partition ] ORDER BY window_ordering )
```
## Argumente
*value\$1expr*
Die Zielspalte oder der Ausdruck, für die/den die Funktion ausgeführt wird.
*offset*
Ein optionaler Parameter, der die Anzahl der Zeilen vor der aktuellen Zeile angibt, für die Werte zurückgegeben werden sollen. Beim Offset kann es sich um eine ganzzahlige Konstante oder um einen Ausdruck handeln, der zu einer Ganzzahl ausgewertet wird. Wenn Sie keinen Offset angeben, AWS Clean Rooms verwendet `1` als Standardwert. Ein Offset von `0` gibt die aktuelle Zeile an.
IGNORE NULLS
Eine optionale Angabe, die angibt, dass Nullwerte bei der Bestimmung der zu verwendenden Zeile übersprungen werden AWS Clean Rooms sollen. Wenn IGNORE NULLS nicht angegeben wird, werden Null-Werte berücksichtigt.
Sie können einen NVL- oder COALESCE-Ausdruck verwenden, um die Null-Werte durch einen anderen Wert zu ersetzen.
RESPECT NULLS
Gibt an, dass Nullwerte bei der Bestimmung der zu verwendenden Zeile berücksichtigt werden AWS Clean Rooms sollen. Wenn Sie IGNORE NULLS nicht angeben, wird RESPECT NULLS standardmäßig unterstützt.
OVER
Gibt die Fensterpartitionierung und -anordnung an. Die OVER-Klausel darf keine Fensterrahmenspezifikation enthalten.
PARTITION BY *window\$1partition*
Ein optionales Argument, das den Datensatzbereich für die einzelnen Gruppen in der OVER-Klausel festlegt.
ORDER BY *window\$1ordering*
Sortiert die Zeilen innerhalb der einzelnen Partitionen.
Die LAG-Fensterfunktion unterstützt Ausdrücke, die einen der AWS Clean Rooms Datentypen verwenden. Der Rückgabetyp ist mit dem Typ von *value\$1expr* identisch.
## Beispiele
Im folgenden Beispiel wird die Menge der Tickets gezeigt, die an den Käufer mit der Käufer-ID 3 verkauft wurden, sowie die Uhrzeit, zu der Käufer 3 die Tickets gekauft hat. Um jeden Verkauf mit dem vorherigen Kauf für Käufer 3 zu vergleichen, gibt die Abfrage für jeden Verkauf die vorherige Menge zurück, die verkauft wurde. Da vor dem 16.01.2008 kein Kauf stattfand, ist der erste Wert für die vorherige verkaufte Menge null:
```
select buyerid, saletime, qtysold,
lag(qtysold,1) over (order by buyerid, saletime) as prev_qtysold
from sales where buyerid = 3 order by buyerid, saletime;
buyerid | saletime | qtysold | prev_qtysold
---------+---------------------+---------+--------------
3 | 2008-01-16 01:06:09 | 1 |
3 | 2008-01-28 02:10:01 | 1 | 1
3 | 2008-03-12 10:39:53 | 1 | 1
3 | 2008-03-13 02:56:07 | 1 | 1
3 | 2008-03-29 08:21:39 | 2 | 1
3 | 2008-04-27 02:39:01 | 1 | 2
3 | 2008-08-16 07:04:37 | 2 | 1
3 | 2008-08-22 11:45:26 | 2 | 2
3 | 2008-09-12 09:11:25 | 1 | 2
3 | 2008-10-01 06:22:37 | 1 | 1
3 | 2008-10-20 01:55:51 | 2 | 1
3 | 2008-10-28 01:30:40 | 1 | 2
(12 rows)
```
# Funktion „LETZTES Fenster“
Bei einer bestimmten Anzahl von Zeilen gibt die Funktion LAST den Wert des Ausdrucks in Bezug auf die letzte Zeile im Frame zurück.
Informationen zur Auswahl der ersten Zeile im Rahmen finden Sie unter [Funktion „ERSTES Fenster“](WF_FIRST.md).
## Syntax
```
LAST( expression )[ IGNORE NULLS | RESPECT NULLS ]
OVER (
[ PARTITION BY expr_list ]
[ ORDER BY order_list frame_clause ]
)
```
## Argumente
*expression*
Die Zielspalte oder der Ausdruck, für die/den die Funktion ausgeführt wird.
IGNORE NULLS
Die Funktion gibt den letzten Wert im Rahmen zurück, der nicht NULL ist (oder NULL, wenn alle Werte NULL sind).
RESPECT NULLS
Gibt an, dass bei der Bestimmung der zu verwendenden Zeile Nullwerte berücksichtigt werden AWS Clean Rooms sollen. Wenn Sie IGNORE NULLS nicht angeben, wird RESPECT NULLS standardmäßig unterstützt.
OVER
Führt die Fensterklauseln für die Funktion ein.
PARTITION BY *expr\$1list*
Definiert das Fenster für die Funktion in Bezug auf mindestens einen Ausdruck.
ORDER BY *order\$1list*
Sortiert die Zeilen innerhalb der einzelnen Partitionen. Wenn die PARTITION BY-Klausel nicht angegeben ist, sortiert ORDER BY die gesamte Tabelle. Wenn Sie eine ORDER BY-Klausel angeben, müssen Sie auch eine *frame\$1clause* angeben.
Die Ergebnisse sind von der Anordnung der Daten abhängig. Die Ergebnisse sind in den folgenden Fällen nicht deterministisch:
+ Wenn keine ORDER BY-Klausel angegeben ist und eine Partition zwei verschiedene Werte für einen Ausdruck enthält
+ Wenn der Ausdruck zu verschiedenen Werten ausgewertet wird, die demselben Wert in der ORDER BY-Liste entsprechen
*frame\$1clause*
Wenn eine ORDER BY-Klausel für eine Aggregationsfunktion verwendet wird, ist eine explizite Rahmenklausel erforderlich. Die Rahmenklausel gibt den Satz von Zeilen im Fenster einer Funktion genauer an, einschließlich oder ausschließlich Sätzen von Zeilen im geordneten Ergebnis. Die Rahmenklausel besteht aus dem Schlüsselwort ROWS und verknüpften Spezifikatoren. Siehe [Übersicht über die Syntax von Fensterfunktionen](Window_functions.md#Window_function_synopsis).
## Rückgabetyp
Diese Funktionen unterstützen Ausdrücke, die primitive AWS Clean Rooms Datentypen verwenden. Der Rückgabetyp ist mit dem Datentyp von *expression* identisch.
## Beispiele
Im folgenden Beispiel wird die Sitzplatzkapazität für die einzelnen Veranstaltungsorte in der Tabelle VENUE zurückgegeben, wobei die Ergebnisse nach Kapazität (hoch zu niedrig) geordnet sind. Die Funktion LAST wird verwendet, um den Namen des Veranstaltungsorts auszuwählen, der der letzten Zeile im Frame entspricht: in diesem Fall der Zeile mit der geringsten Anzahl von Sitzplätzen. Die Ergebnisse werden nach Bundesstaat partitioniert. Wenn der Wert für VENUESTATE geändert wird, wird daher ein neuer letzter Wert ausgewählt. Der Fensterrahmen ist unbegrenzt. Daher wird für jede Zeile in jeder Partition derselbe letzte Wert ausgewählt.
Im Fall von Kalifornien wird `Shoreline Amphitheatre` für jede Zeile in der Partition zurückgegeben, da es die kleinste Zahl von Sitzplätzen hat (`22000`).
```
select venuestate, venueseats, venuename,
last(venuename)
over(partition by venuestate
order by venueseats desc
rows between unbounded preceding and unbounded following)
from (select * from venue where venueseats >0)
order by venuestate;
venuestate | venueseats | venuename | last
-----------+------------+--------------------------------+------------------------------
CA | 70561 | Qualcomm Stadium | Shoreline Amphitheatre
CA | 69843 | Monster Park | Shoreline Amphitheatre
CA | 63026 | McAfee Coliseum | Shoreline Amphitheatre
CA | 56000 | Dodger Stadium | Shoreline Amphitheatre
CA | 45050 | Angel Stadium of Anaheim | Shoreline Amphitheatre
CA | 42445 | PETCO Park | Shoreline Amphitheatre
CA | 41503 | AT&T Park | Shoreline Amphitheatre
CA | 22000 | Shoreline Amphitheatre | Shoreline Amphitheatre
CO | 76125 | INVESCO Field | Coors Field
CO | 50445 | Coors Field | Coors Field
DC | 41888 | Nationals Park | Nationals Park
FL | 74916 | Dolphin Stadium | Tropicana Field
FL | 73800 | Jacksonville Municipal Stadium | Tropicana Field
FL | 65647 | Raymond James Stadium | Tropicana Field
FL | 36048 | Tropicana Field | Tropicana Field
...
```
# Die Fensterfunktion LAST\$1VALUE
Bei einem geordneten Satz von Zeilen gibt die Funktion LAST\$1VALUE den Wert des Ausdrucks in Bezug auf die letzte Zeile im Rahmen zurück.
Informationen zur Auswahl der ersten Zeile im Rahmen finden Sie unter [Die Fensterfunktion FIRST\$1VALUE](WF_first_value.md).
## Syntax
```
LAST_VALUE( expression )[ IGNORE NULLS | RESPECT NULLS ]
OVER (
[ PARTITION BY expr_list ]
[ ORDER BY order_list frame_clause ]
)
```
## Argumente
*expression*
Die Zielspalte oder der Ausdruck, für die/den die Funktion ausgeführt wird.
IGNORE NULLS
Die Funktion gibt den letzten Wert im Rahmen zurück, der nicht NULL ist (oder NULL, wenn alle Werte NULL sind).
RESPECT NULLS
Gibt an, dass bei der Bestimmung der zu verwendenden Zeile Nullwerte berücksichtigt werden AWS Clean Rooms sollen. Wenn Sie IGNORE NULLS nicht angeben, wird RESPECT NULLS standardmäßig unterstützt.
OVER
Führt die Fensterklauseln für die Funktion ein.
PARTITION BY *expr\$1list*
Definiert das Fenster für die Funktion in Bezug auf mindestens einen Ausdruck.
ORDER BY *order\$1list*
Sortiert die Zeilen innerhalb der einzelnen Partitionen. Wenn die PARTITION BY-Klausel nicht angegeben ist, sortiert ORDER BY die gesamte Tabelle. Wenn Sie eine ORDER BY-Klausel angeben, müssen Sie auch eine *frame\$1clause* angeben.
Die Ergebnisse sind von der Anordnung der Daten abhängig. Die Ergebnisse sind in den folgenden Fällen nicht deterministisch:
+ Wenn keine ORDER BY-Klausel angegeben ist und eine Partition zwei verschiedene Werte für einen Ausdruck enthält
+ Wenn der Ausdruck zu verschiedenen Werten ausgewertet wird, die demselben Wert in der ORDER BY-Liste entsprechen
*frame\$1clause*
Wenn eine ORDER BY-Klausel für eine Aggregationsfunktion verwendet wird, ist eine explizite Rahmenklausel erforderlich. Die Rahmenklausel gibt den Satz von Zeilen im Fenster einer Funktion genauer an, einschließlich oder ausschließlich Sätzen von Zeilen im geordneten Ergebnis. Die Rahmenklausel besteht aus dem Schlüsselwort ROWS und verknüpften Spezifikatoren. Siehe [Übersicht über die Syntax von Fensterfunktionen](Window_functions.md#Window_function_synopsis).
## Rückgabetyp
Diese Funktionen unterstützen Ausdrücke, die primitive AWS Clean Rooms Datentypen verwenden. Der Rückgabetyp ist mit dem Datentyp von *expression* identisch.
## Beispiele
Im folgenden Beispiel wird die Sitzplatzkapazität für die einzelnen Veranstaltungsorte in der Tabelle VENUE zurückgegeben, wobei die Ergebnisse nach Kapazität (hoch zu niedrig) geordnet sind. Die Funktion LAST\$1VALUE wird verwendet, um den Namen des Veranstaltungsorts auszuwählen, der der letzten Zeile im Rahmen entspricht, in diesem Fall der Zeile mit der geringsten Anzahl von Sitzplätzen. Die Ergebnisse werden nach Bundesstaat partitioniert. Wenn der Wert für VENUESTATE geändert wird, wird daher ein neuer letzter Wert ausgewählt. Der Fensterrahmen ist unbegrenzt. Daher wird für jede Zeile in jeder Partition derselbe letzte Wert ausgewählt.
Im Fall von Kalifornien wird `Shoreline Amphitheatre` für jede Zeile in der Partition zurückgegeben, da es die kleinste Zahl von Sitzplätzen hat (`22000`).
```
select venuestate, venueseats, venuename,
last_value(venuename)
over(partition by venuestate
order by venueseats desc
rows between unbounded preceding and unbounded following)
from (select * from venue where venueseats >0)
order by venuestate;
venuestate | venueseats | venuename | last_value
-----------+------------+--------------------------------+------------------------------
CA | 70561 | Qualcomm Stadium | Shoreline Amphitheatre
CA | 69843 | Monster Park | Shoreline Amphitheatre
CA | 63026 | McAfee Coliseum | Shoreline Amphitheatre
CA | 56000 | Dodger Stadium | Shoreline Amphitheatre
CA | 45050 | Angel Stadium of Anaheim | Shoreline Amphitheatre
CA | 42445 | PETCO Park | Shoreline Amphitheatre
CA | 41503 | AT&T Park | Shoreline Amphitheatre
CA | 22000 | Shoreline Amphitheatre | Shoreline Amphitheatre
CO | 76125 | INVESCO Field | Coors Field
CO | 50445 | Coors Field | Coors Field
DC | 41888 | Nationals Park | Nationals Park
FL | 74916 | Dolphin Stadium | Tropicana Field
FL | 73800 | Jacksonville Municipal Stadium | Tropicana Field
FL | 65647 | Raymond James Stadium | Tropicana Field
FL | 36048 | Tropicana Field | Tropicana Field
...
```
# Die Fensterfunktion LEAD
Die Fensterfunktion LEAD gibt die Werte für eine Zeile in einem bestimmten Offset unterhalb (nach) der aktuellen Zeile in der Partition zurück.
## Syntax
```
LEAD (value_expr [, offset ])
[ IGNORE NULLS | RESPECT NULLS ]
OVER ( [ PARTITION BY window_partition ] ORDER BY window_ordering )
```
## Argumente
*value\$1expr*
Die Zielspalte oder der Ausdruck, für die/den die Funktion ausgeführt wird.
*offset*
Ein optionaler Parameter, der die Anzahl der Zeilen unterhalb der aktuellen Zeile angibt, für die Werte zurückgegeben werden sollen. Beim Offset kann es sich um eine ganzzahlige Konstante oder um einen Ausdruck handeln, der zu einer Ganzzahl ausgewertet wird. Wenn Sie keinen Offset angeben, AWS Clean Rooms verwendet `1` als Standardwert. Ein Offset von `0` gibt die aktuelle Zeile an.
IGNORE NULLS
Eine optionale Angabe, die angibt, dass Nullwerte bei der Bestimmung der zu verwendenden Zeile übersprungen werden AWS Clean Rooms sollen. Wenn IGNORE NULLS nicht angegeben wird, werden Null-Werte berücksichtigt.
Sie können einen NVL- oder COALESCE-Ausdruck verwenden, um die Null-Werte durch einen anderen Wert zu ersetzen.
RESPECT NULLS
Gibt an, dass Nullwerte bei der Bestimmung der zu verwendenden Zeile berücksichtigt werden AWS Clean Rooms sollen. Wenn Sie IGNORE NULLS nicht angeben, wird RESPECT NULLS standardmäßig unterstützt.
OVER
Gibt die Fensterpartitionierung und -anordnung an. Die OVER-Klausel darf keine Fensterrahmenspezifikation enthalten.
PARTITION BY *window\$1partition*
Ein optionales Argument, das den Datensatzbereich für die einzelnen Gruppen in der OVER-Klausel festlegt.
ORDER BY *window\$1ordering*
Sortiert die Zeilen innerhalb der einzelnen Partitionen.
Die LEAD-Fensterfunktion unterstützt Ausdrücke, die einen der AWS Clean Rooms Datentypen verwenden. Der Rückgabetyp ist mit dem Typ von *value\$1expr* identisch.
## Beispiele
Im folgenden Beispiel wird die Provision für Veranstaltungen in der Tabelle SALES angegeben, für die am 1. und 2. Januar 2008 Tickets verkauft wurden, sowie die Provision, die für verkaufte Tickets im anschließenden Verkauf gezahlt wurden.
```
select eventid, commission, saletime,
lead(commission, 1) over (order by saletime) as next_comm
from sales where saletime between '2008-01-01 00:00:00' and '2008-01-02 12:59:59'
order by saletime;
eventid | commission | saletime | next_comm
---------+------------+---------------------+-----------
6213 | 52.05 | 2008-01-01 01:00:19 | 106.20
7003 | 106.20 | 2008-01-01 02:30:52 | 103.20
8762 | 103.20 | 2008-01-01 03:50:02 | 70.80
1150 | 70.80 | 2008-01-01 06:06:57 | 50.55
1749 | 50.55 | 2008-01-01 07:05:02 | 125.40
8649 | 125.40 | 2008-01-01 07:26:20 | 35.10
2903 | 35.10 | 2008-01-01 09:41:06 | 259.50
6605 | 259.50 | 2008-01-01 12:50:55 | 628.80
6870 | 628.80 | 2008-01-01 12:59:34 | 74.10
6977 | 74.10 | 2008-01-02 01:11:16 | 13.50
4650 | 13.50 | 2008-01-02 01:40:59 | 26.55
4515 | 26.55 | 2008-01-02 01:52:35 | 22.80
5465 | 22.80 | 2008-01-02 02:28:01 | 45.60
5465 | 45.60 | 2008-01-02 02:28:02 | 53.10
7003 | 53.10 | 2008-01-02 02:31:12 | 70.35
4124 | 70.35 | 2008-01-02 03:12:50 | 36.15
1673 | 36.15 | 2008-01-02 03:15:00 | 1300.80
...
(39 rows)
```
# Die Fensterfunktion PERCENT\$1RANK
Berechnet den prozentualen Rang einer bestimmten Zeile. Der prozentuale Rang wird anhand der folgenden Formel festgelegt:
`(x - 1) / (the number of rows in the window or partition - 1)`
wobei *x* der Rang der aktuellen Zeile ist. Der folgende Datensatz zeigt die Verwendung dieser Formel:
```
Row# Value Rank Calculation PERCENT_RANK
1 15 1 (1-1)/(7-1) 0.0000
2 20 2 (2-1)/(7-1) 0.1666
3 20 2 (2-1)/(7-1) 0.1666
4 20 2 (2-1)/(7-1) 0.1666
5 30 5 (5-1)/(7-1) 0.6666
6 30 5 (5-1)/(7-1) 0.6666
7 40 7 (7-1)/(7-1) 1.0000
```
Der Rückgabewertbereich ist 0 bis 1 (einschließlich). Die erste Zeile in jedem Satz besitzt den PERCENT\$1RANK 0.
## Syntax
```
PERCENT_RANK ()
OVER (
[ PARTITION BY partition_expression ]
[ ORDER BY order_list ]
)
```
## Argumente
( )
Die Funktion verwendet keine Argumente. Es ist jedoch eine leere Klammer erforderlich.
OVER
Eine Klausel, die die Fensterpartitionierung angibt. Die OVER-Klausel darf keine Fensterrahmenspezifikation enthalten.
PARTITION BY *partition\$1expression*
Optional. Ein Ausdruck, der den Datensatzbereich für die einzelnen Gruppen in der OVER-Klausel festlegt.
ORDER BY *order\$1list*
Optional. Der Ausdruck, anhand dessen der prozentuale Rang berechnet wird. Der Datentyp des Ausdrucks muss entweder numerisch sein oder implizit in einen solchen konvertierbar sein. Wenn ORDER BY ausgelassen wird, ist der Rückgabewert für alle Zeilen 0.
Wenn ORDER BY nicht zu einer spezifischen Reihenfolge führt, ist die Reihenfolge der Zeilen nicht deterministisch. Weitere Informationen finden Sie unter [Spezifisches Anordnen von Daten für Fensterfunktionen](Window_functions.md#Examples_order_by_WF).
## Rückgabetyp
FLOAT8
## Beispiele
Im folgenden Beispiel wird der prozentuale Rang der Verkaufsmengen für die einzelnen Verkäufer berechnet:
```
select sellerid, qty, percent_rank()
over (partition by sellerid order by qty)
from winsales;
sellerid qty percent_rank
----------------------------------------
1 10.00 0.0
1 10.64 0.5
1 30.37 1.0
3 10.04 0.0
3 15.15 0.33
3 20.75 0.67
3 30.55 1.0
2 20.09 0.0
2 20.12 1.0
4 10.12 0.0
4 40.23 1.0
```
Eine Beschreibung der Tabelle WINSALES finden Sie unter [Beispieltabelle mit Beispielen von Fensterfunktionen](Window_functions.md#Window_function_example).
# Die Fensterfunktion RANK
Die Fensterfunktion RANK legt den Rang eines Werts in einer Gruppe von Werten fest, basierend auf dem ORDER BY-Ausdruck in der OVER-Klausel. Wenn die optionale PARTITION BY-Klausel vorhanden ist, wird die Rangfolge für jede Gruppe von Zeilen neu festgelegt. Zeilen mit gleichen Werten für die Rangkriterien erhalten denselben Rang. AWS Clean Roomsaddiert die Anzahl der gleichwertigen Zeilen zum gleichen Rang, um den nächsten Rang zu berechnen, sodass es sich bei den Rängen möglicherweise nicht um fortlaufende Zahlen handelt. Wenn beispielsweise zwei Zeilen den Rang 1 erhalten, ist der nächste Rang 3.
RANK unterscheidet sich in einer Hinsicht von [Die Fensterfunktion DENSE\$1RANK](WF_DENSE_RANK.md): Wenn zwei oder mehr Zeilen den gleichen Rang erhalten, entsteht bei DENSE\$1RANK in der Rangfolge der Werte keine Lücke. Wenn beispielsweise zwei Zeilen den Rang 1 erhalten, ist der nächste Rang 2.
Sie können in derselben Abfrage Rangfestlegungsfunktionen mit unterschiedlichen PARTITION BY- und ORDER BY-Klauseln verwenden.
## Syntax
```
RANK () OVER
(
[ PARTITION BY expr_list ]
[ ORDER BY order_list ]
)
```
## Argumente
( )
Die Funktion verwendet keine Argumente. Es ist jedoch eine leere Klammer erforderlich.
OVER
Die Fensterklauseln für die Funktion RANK.
PARTITION BY *expr\$1list*
Optional. Ein oder mehrere Ausdrücke, der/die das Fenster definiert/definieren.
ORDER BY *order\$1list*
Optional. Definiert die Spalten, auf denen die Rangfestlegungswerte basieren. Wenn PARTITION BY nicht angegeben ist, verwendet ORDER BY die gesamte Tabelle. Wenn ORDER BY ausgelassen wird, ist der Rückgabewert für alle Zeilen 1.
Wenn ORDER BY nicht zu einer spezifischen Reihenfolge führt, ist die Reihenfolge der Zeilen nicht deterministisch. Weitere Informationen finden Sie unter [Spezifisches Anordnen von Daten für Fensterfunktionen](Window_functions.md#Examples_order_by_WF).
## Rückgabetyp
INTEGER
## Beispiele
Im folgenden Beispiel wird die Tabelle nach der verkauften Menge (standardmäßig in aufsteigender Reihenfolge) geordnet und jeder Zeile einen Rang zugewiesen. Der Rangwert 1 ist der Wert mit dem höchsten Rang. Die Ergebnisse werden sortiert, nachdem die Fensterfunktionsergebnisse angewendet wurden:
```
select salesid, qty,
rank() over (order by qty) as rnk
from winsales
order by 2,1;
salesid | qty | rnk
--------+-----+-----
10001 | 10 | 1
10006 | 10 | 1
30001 | 10 | 1
40005 | 10 | 1
30003 | 15 | 5
20001 | 20 | 6
20002 | 20 | 6
30004 | 20 | 6
10005 | 30 | 9
30007 | 30 | 9
40001 | 40 | 11
(11 rows)
```
Beachten Sie, dass die äußere ORDER BY-Klausel in diesem Beispiel die Spalten 2 und 1 enthält, um sicherzustellen, dass bei jeder Ausführung dieser Abfrage konsistent sortierte Ergebnisse AWS Clean Rooms zurückgegeben werden. Zeilen mit den Umsätzen IDs 10001 und 10006 haben beispielsweise identische QTY- und RNK-Werte. Durch die Anordnung des endgültigen Ergebnissatzes nach Spalte 1 wird sichergestellt, dass die Zeile 10001 stets vor der Zeile 10006 angeordnet wird. Eine Beschreibung der Tabelle WINSALES finden Sie unter [Beispieltabelle mit Beispielen von Fensterfunktionen](Window_functions.md#Window_function_example).
Im folgenden Beispiel wird die Anordnung für die Fensterfunktion () umgekehrt. (`order by qty desc`). Jetzt wird der höchste Rangwert auf den größten QTY-Wert angewendet.
```
select salesid, qty,
rank() over (order by qty desc) as rank
from winsales
order by 2,1;
salesid | qty | rank
---------+-----+-----
10001 | 10 | 8
10006 | 10 | 8
30001 | 10 | 8
40005 | 10 | 8
30003 | 15 | 7
20001 | 20 | 4
20002 | 20 | 4
30004 | 20 | 4
10005 | 30 | 2
30007 | 30 | 2
40001 | 40 | 1
(11 rows)
```
Eine Beschreibung der Tabelle WINSALES finden Sie unter [Beispieltabelle mit Beispielen von Fensterfunktionen](Window_functions.md#Window_function_example).
Im folgenden Beispiel wird die Tabelle nach SELLERID partitioniert, die einzelnen Partitionen nach Menge (in absteigender Reihenfolge) geordnet und jeder Zeile ein Rang zugewiesen. Die Ergebnisse werden sortiert, nachdem die Fensterfunktionsergebnisse angewendet wurden.
```
select salesid, sellerid, qty, rank() over
(partition by sellerid
order by qty desc) as rank
from winsales
order by 2,3,1;
salesid | sellerid | qty | rank
--------+----------+-----+-----
10001 | 1 | 10 | 2
10006 | 1 | 10 | 2
10005 | 1 | 30 | 1
20001 | 2 | 20 | 1
20002 | 2 | 20 | 1
30001 | 3 | 10 | 4
30003 | 3 | 15 | 3
30004 | 3 | 20 | 2
30007 | 3 | 30 | 1
40005 | 4 | 10 | 2
40001 | 4 | 40 | 1
(11 rows)
```
# Die Fensterfunktion ROW\$1NUMBER
Legt die Ordnungszahl der aktuellen Zeile innerhalb einer Gruppe von Zeilen fest, ab 1 zählend, basierend auf dem ORDER BY-Ausdruck in der OVER-Klausel. Wenn die optionale PARTITION BY-Klausel vorhanden ist, werden die Ordnungszahlen für jede Gruppe von Zeilen neu festgelegt. Zeilen mit gleichen Werten für die ORDER BY-Ausdrücke erhalten auf nicht deterministische Weise unterschiedliche Zeilenzahlen.
## Syntax
```
ROW_NUMBER () OVER
(
[ PARTITION BY expr_list ]
[ ORDER BY order_list ]
)
```
## Argumente
( )
Die Funktion verwendet keine Argumente. Es ist jedoch eine leere Klammer erforderlich.
OVER
Die Fensterklauseln für die Funktion ROW\$1NUMBER.
PARTITION BY *expr\$1list*
Optional. Ein oder mehrere Ausdrücke, der/die die Funktion ROW\$1NUMBER definiert/definieren.
ORDER BY *order\$1list*
Optional. Der Ausdruck, der die Spalten definiert, auf denen die Zeilennummern basieren. Wenn PARTITION BY nicht angegeben ist, verwendet ORDER BY die gesamte Tabelle.
Wenn ORDER BY nicht zu einer eindeutigen Reihenfolge führt oder ausgelassen wird, ist die Reihenfolge der Zeilen nicht deterministisch. Weitere Informationen finden Sie unter [Spezifisches Anordnen von Daten für Fensterfunktionen](Window_functions.md#Examples_order_by_WF).
## Rückgabetyp
BIGINT
## Beispiele
Im folgenden Beispiel werden die Tabelle nach SELLERID partitioniert und die einzelnen Partitionen nach QTY angeordnet (in aufsteigender Reihenfolge). Anschließend wird jeder Zeile eine Zeilennummer zugewiesen. Die Ergebnisse werden sortiert, nachdem die Fensterfunktionsergebnisse angewendet wurden.
```
select salesid, sellerid, qty,
row_number() over
(partition by sellerid
order by qty asc) as row
from winsales
order by 2,4;
salesid | sellerid | qty | row
---------+----------+-----+-----
10006 | 1 | 10 | 1
10001 | 1 | 10 | 2
10005 | 1 | 30 | 3
20001 | 2 | 20 | 1
20002 | 2 | 20 | 2
30001 | 3 | 10 | 1
30003 | 3 | 15 | 2
30004 | 3 | 20 | 3
30007 | 3 | 30 | 4
40005 | 4 | 10 | 1
40001 | 4 | 40 | 2
(11 rows)
```
Eine Beschreibung der Tabelle WINSALES finden Sie unter [Beispieltabelle mit Beispielen von Fensterfunktionen](Window_functions.md#Window_function_example).