Как я могу использовать функцию LAG в сочетании с предложением WHERE?

(ПРИМЕЧАНИЕ: это было опубликовано ДО того, как к вопросу был добавлен precise_date )

Если у вас есть индекс на id:

-- drop table mytable;
create table mytable (
  id integer,
  value_date varchar(20),
  future_availability integer);

insert into mytable values
(1,'Current EOD',             10),
(2,'reimbursment',            2 ),
(3,'reimbursment',            3 ),                       
(4,'reimbursment',            4 ),
(5,'reimbursment',            5 ),
(6,'utilization',             6 ),
(7,'reimbursment',            7 ),
(8,'Limit Maturity',          8 ),
(9,'reimbursment',            9 );


select 
   value_date, 
   future_availability,
   (select TOP 1 m2.future_availability 
    from mytable m2 
    where m2.id<m1.id and m2.value_date<>'reimbursment' 
    order by id desc
    ) as previous_availability
from mytable m1;

вывод будет:

+ --------------- + ------------------------ + -------------------------- +
| value_date      | future_availability      | previous_availability      |
+ --------------- + ------------------------ + -------------------------- +
| Current EOD     | 10                       |                            |
| reimbursment    | 2                        | 10                         |
| reimbursment    | 3                        | 10                         |
| reimbursment    | 4                        | 10                         |
| reimbursment    | 5                        | 10                         |
| utilization     | 6                        | 10                         |
| reimbursment    | 7                        | 6                          |
| Limit Maturity  | 8                        | 6                          |
| reimbursment    | 9                        | 8                          |
+ --------------- + ------------------------ + -------------------------- +

Но он не использует функцию LAG.

Обновлено: удалено limit 1 и добавлено TOP 1, потому что речь идет о MSSQL.

Во-первых: чтобы вопрос имел смысл, вам нужен столбец, определяющий порядок строк — я предположил id.

Тогда, я думаю, вы хотите что-то вроде этого:

select id, value_date, future_availability,
    lag(future_availability, rn) over(order by id) as previous_availability
from (
    select t.*,
        row_number() over(partition by grp order by id) as rn
    from (
        select t.*,
            sum(case when value_date = 'reimbursment' then 0 else 1 end) 
                over(order by id rows between unbounded preceding and 1 preceding) as grp
        from mytable t
    ) t
) t

Это рассматривает вопрос как проблему пробелов и островов. Идея состоит в том, чтобы использовать оконную сумму для идентификации группы смежных записей; затем мы можем ранжировать записи и использовать эту информацию для передачи правильного смещения в lag().

Демо на DB Fiddle:

id | value_date     | future_availability | previous_availability
-: | :------------- | ------------------: | --------------------:
 1 | Current EOD    |                  10 |                  null
 2 | reimbursment   |                   2 |                    10
 3 | reimbursment   |                   3 |                    10
 4 | reimbursment   |                   4 |                    10
 5 | reimbursment   |                   5 |                    10
 6 | utilization    |                   6 |                    10
 7 | reimbursment   |                   7 |                     6
 8 | Limit Maturity |                   8 |                     6
 9 | reimbursment   |                   9 |                     8

Если вам нужна «предыдущая доступность», вы можете сделать это с помощью одной оконной функции и соединения.

select t.*, t2.future_availability
from (select t.*,
             max(case when value_date <> 'reimbursment' then precise_date end) over
                 (order by precise_date
                  rows between unbounded preceding and 1 preceding
                 ) as the_date
      from t
     ) t left join
     t t2
     on t.the_date = t2.precise_date
order by precise_date;

Здесь db<>рабочий пример.

Я ожидаю, что это будет иметь лучшую производительность, чем решение с использованием боковых соединений, предложенное Лууком, особенно с индексом (precise_date).