Window function syntax and usage (Ranking)
Returns the last value within an ordered group of values.
LAST_VALUE( <expr> ) [ { IGNORE | RESPECT } NULLS ]
OVER ( [ PARTITION BY <expr1> ] ORDER BY <expr2> [ { ASC | DESC } ] [ NULLS { FIRST | LAST } ] [ <window_frame> ] )
Copy
For detailed window_frame syntax, see Window function syntax and usage.
expr
The expression that determines the return value.
expr1
The expression by which to partition the rows. You can specify a single expression or a comma-separated list of expressions. For example:
PARTITION BY column_1, column_2
Copy
expr2
The expression by which to order the rows. You can specify a single expression or a comma-separated list of expressions. For example:
ORDER BY column_3, column_4
Copy
{ IGNORE | RESPECT } NULLS
Whether to ignore or respect NULL values when an expr contains NULL values:
IGNORE NULLS returns the last non-NULL value.
RESPECT NULLS returns a NULL value if it is the last value in the expression.
Default: RESPECT NULLS
This function is a rank-related function, so it must specify a window. A window clause consists of the following subclauses:
PARTITION BY expr1subclause (optional).
ORDER BY expr2subclause (required). For details about additional supported ordering options (sort order, ordering of NULL values, and so on), see the documentation for the ORDER BY clause, which follows the same rules.
window_framesubclause (optional).
The order of rows in a window (and thus the result of the query) is fully deterministic only if the keys in the ORDER BY clause make each row unique. Consider the following example:
... OVER (PARTITION BY p ORDER BY o COLLATE 'lower') ...
Copy
The query result can vary if any partition contains values of column o that are identical, or would be identical in a case-insensitive comparison.
The ORDER BY clause inside the OVER clause controls the order of rows only within the window, not the order of rows in the output of the entire query. To control output order, use a separate ORDER BY clause at the outermost level of the query.
The optional window_frame specifies the subset of rows within the window for which the function is calculated. If no window frame is specified, the default frame is the entire window:
ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING
This behavior differs from the ANSI standard, which specifies the following default for window frames:
RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW
For detailed window_frame syntax, see Window function syntax and usage.
The first example returns LAST_VALUE results for column2 partitioned by column1:
SELECT
column1,
column2,
LAST_VALUE(column2) OVER (PARTITION BY column1 ORDER BY column2) AS column2_last
FROM VALUES
(1, 10), (1, 11), (1, 12),
(2, 20), (2, 21), (2, 22);
Copy
+---------+---------+--------------+ | COLUMN1 | COLUMN2 | COLUMN2_LAST | |---------+---------+--------------| | 1 | 10 | 12 | | 1 | 11 | 12 | | 1 | 12 | 12 | | 2 | 20 | 22 | | 2 | 21 | 22 | | 2 | 22 | 22 | +---------+---------+--------------+
The following example returns the results of three related functions: FIRST_VALUE, NTH_VALUE, and LAST_VALUE.
The query creates a sliding window frame that is three rows wide, which contains:
The row that precedes the current row.
The current row.
The row that follows the current row.
The 2 in the call NTH_VALUE(i, 2) specifies the second row in the window frame (which, in this case, is also the current row).
When the current row is the very first row in the window frame, there is no preceding row to reference, so FIRST_VALUE returns a NULL for that row.
Frame boundaries sometimes extend beyond the rows in a partition, but non-existent rows are not included in window function calculations. For example, when the current row is the very first row in the partition and the window frame is ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING, there is no preceding row to reference, so the FIRST_VALUE function returns the value of the first row in the partition.
The results never match for all three functions, given the data in the table. These functions select the first, last, or nth value for each row in the frame, and the selection of values applies separately to each partition.
To run this example, first create and load the table:
CREATE TABLE demo1 (i INTEGER, partition_col INTEGER, order_col INTEGER); INSERT INTO demo1 (i, partition_col, order_col) VALUES (1, 1, 1), (2, 1, 2), (3, 1, 3), (4, 1, 4), (5, 1, 5), (1, 2, 1), (2, 2, 2), (3, 2, 3), (4, 2, 4);
Copy
Now run the following query:
SELECT partition_col, order_col, i,
FIRST_VALUE(i) OVER (PARTITION BY partition_col ORDER BY order_col
ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING) AS FIRST_VAL,
NTH_VALUE(i, 2) OVER (PARTITION BY partition_col ORDER BY order_col
ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING) AS NTH_VAL,
LAST_VALUE(i) OVER (PARTITION BY partition_col ORDER BY order_col
ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING) AS LAST_VAL
FROM demo1
ORDER BY partition_col, i, order_col;
Copy
+---------------+-----------+---+-----------+---------+----------+ | PARTITION_COL | ORDER_COL | I | FIRST_VAL | NTH_VAL | LAST_VAL | |---------------+-----------+---+-----------+---------+----------| | 1 | 1 | 1 | 1 | 2 | 2 | | 1 | 2 | 2 | 1 | 2 | 3 | | 1 | 3 | 3 | 2 | 3 | 4 | | 1 | 4 | 4 | 3 | 4 | 5 | | 1 | 5 | 5 | 4 | 5 | 5 | | 2 | 1 | 1 | 1 | 2 | 2 | | 2 | 2 | 2 | 1 | 2 | 3 | | 2 | 3 | 3 | 2 | 3 | 4 | | 2 | 4 | 4 | 3 | 4 | 4 | +---------------+-----------+---+-----------+---------+----------+
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4