Create a 'partial' window function to update data in SQL Server - sql

Question

I have a table where I want to use window functions to fill in some NULLs, but I only want data to flow downwards, based on a Rank column in the table. Using window functions (PARTITION BY), all rows get assigned the same data, which is not the requirement here.
The initial table has NULL values for columns A and B where Rank=2 and ID=1, which I want to populate with the values where Rank=1. Column C is NULL where Rank=1, and 15 where Rank=2 and ID=1, which needs to stay the same way.
Here is the structure of the initial table, the desired output, as well as some sample code. I am unsure how to incorporate the rank into the partition by statement
Initial Table
ID A B C Rank
---------------------------------
1 10 10 NULL 1
1 NULL NULL 15 2
2 10 NULL NULL 1
2 NULL NULL 15 2
2 NULL NULL 15 3
Target table
ID A B C Rank
---------------------------------
1 10 10 NULL 1
1 10 10 15 2
2 10 NULL NULL 1
2 10 NULL 15 2
2 10 NULL 15 3
SQL query:
SELECT
ID,
MAX(A) OVER (PARTITION BY ID),
MAX(B) OVER (PARTITION BY ID),
MAX(C) OVER (PARTITION BY ID),
Rank
FROM
TBL;
As expected, partitioning by both, ID and Rank leads to no changes in the initial table

Answer 1

You can use first_value():
select
id,
coalesce(a, first_value(a) over (partition by id order by rnk)) a,
coalesce(b, first_value(b) over (partition by id order by rnk)) b,
coalesce(c, first_value(c) over (partition by id order by rnk)) c,
rnk
from tbl;
Note that rank is a language keyword (as in window function rank() over()), hence not a good choice for a column name. I renamed it to rnk in the query.
Demo on DB Fiddle:
id | a | b | c | rnk
-: | -: | ---: | ---: | --:
1 | 10 | 10 | null | 1
1 | 10 | 10 | 15 | 2
2 | 10 | null | null | 1
2 | 10 | null | 15 | 2
2 | 10 | null | 15 | 3

Answer 2

Unfortunately, SQL Server doesn't support ignore nulls in any window function. That is the best approach. In your example, you only have a value or NULL. If this is the case, you can use a cumulative max:
select id,
coalesce(a, max(a) over (partition by id order by rank)) as a,
coalesce(b, max(b) over (partition by id order by rank)) as b,
coalesce(c, max(c) over (partition by id order by rank)) as c,
rank
from tbl;
If this is not the case, the logic is trickier. But actually, I would suggest that you ask a new question if that is the case. Let this one be about the data as you have presented it.

Answer 3

You were almost there by the partitioning. You need to use a relatively infrequently used approach that limits the partition size - in this case, all the preceding rows only (so as to not use any 'future' when calculating the row's values).
CREATE TABLE #Temp (ID int, Rnk int, A int, B int, C int)
INSERT INTO #Temp (ID, Rnk, A, B, C)
VALUES (1, 1, 10, 10, NULL),
(1, 2, NULL, NULL, 15),
(2, 1, 10, NULL, NULL),
(2, 2, NULL, NULL, 15),
(2, 3, NULL, NULL, 15)
SELECT ID, Rnk,
MAX(A) OVER (PARTITION BY ID ORDER BY Rnk ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS A_Fill,
MAX(B) OVER (PARTITION BY ID ORDER BY Rnk ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS B_Fill,
MAX(C) OVER (PARTITION BY ID ORDER BY Rnk ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS C_Fill
FROM #Temp
I believe this outputs the same results as above e.g.,
ID | Rnk | A_Fill | B_Fill | C_Fill
1 | 1 | 10 | 10 | NULL
1 | 2 | 10 | 10 | 15
2 | 1 | 10 | NULL | NULL
2 | 2 | 10 | NULL | 15
2 | 3 | 10 | NULL | 15
Note that if you add two more rows for ID = 2 (with rnks 4 and 5) and the rest NULL, this approach puts 15 into the 'C' Columns, which the above (COALESCE/FIRST_VALUE) doesn't, I believe.
ID | Rnk | A_Fill | B_Fill | C_Fill
1 | 1 | 10 | 10 | NULL
1 | 2 | 10 | 10 | 15
2 | 1 | 10 | NULL | NULL
2 | 2 | 10 | NULL | 15
2 | 3 | 10 | NULL | 15
2 | 4 | 10 | NULL | 15
2 | 5 | 10 | NULL | 15
Here is a DB_Fiddle showing differences (based on previous ones above)