Postgress fill the missed row values with previous values during query

Question

I have some table which has some rows where data is not exists, due to some biz reason I can not show the null or 0 to user during those days, so need to keep previous value of that table.

create table foo (ID VARCHAR(10), foo_value int, foo_date date);

insert into foo (
          values
          ('234534', 100, '2017-01-01'),
          ('234534', 200, '2017-01-02'),
          ('234534', 300, '2017-01-03'),
          ('234534', 180, '2017-01-08')
        );

I want the data like below when I query a table, the missed date should be added with value of previous date

 ID        | foo_value       | foo_date
-----------+-----------------+------------
 234534    | 100             | 2017-01-01
 234534    | 200             | 2017-02-01
 234534    | 300             | 2017-03-01
 234534    | 300             | 2017-04-01
 234534    | 300             | 2017-05-01
 234534    | 300             | 2017-06-01
 234534    | 180             | 2017-07-01

I am using JPA to query the table

@Query(value = "SLECT * FROM Foo where ID=:uid") Lits getFoo(String uid);

Answer 1

Recursive CTEs are a pretty easy way to fill-in-the-gaps like this:

with recursive cte as (
      select f.id, f.foo_value, f.foo_date,
             lead(f.foo_date, 1, f.foo_date) over (partition by f.id order by f.foo_date) - interval '1 day' as next_date
      from foo f
      union all
      select cte.id, cte.foo_value, (cte.foo_date + interval '1 day')::date, cte.next_date
      from cte
      where cte.foo_date < cte.next_date
     )
select *
from cte;

They make it easy to retain the values you want from the previous row.

The most efficient method, though, is probably to use generate_series() -- but within each row:

with  f as (
      select f.id, f.foo_value, f.foo_date,
         coalesce(lead(f.foo_date) over (partition by f.id order by f.foo_date) - interval '1 day', f.foo_date) as next_date
      from foo f
     )
select f.id, f.foo_value, gs.dte
from f left join lateral
     generate_series(f.foo_date, f.next_date, interval '1 day') gs(dte)

Here is a db<>fiddle.

Answer 2

You can use generate_series() to generate the dates of each id, then a lateral join to bring the corresponding value:

select x.id, f.foo_value, x.foo_date
from (
    select f.id, x.foo_date
    from foo f
    cross join lateral generate_series(min(foo_date), max(food_date), '1 day') as x(foo_date)
    group by f.id
) x
cross join lateral (
    select foo_value
    from foo f
    where f.id = x.id and f.foo_date <= x.foo_date
    order by f.foo_date desc
    limit 1
) f

Depending on your dataset, it might be more efficient to use a left join and window functions to bring the last non-null value:

select id, max(foo_value) over(partition by id, grp) as foo_value, foo_date
from (
    select x.id, f.value, x.foo_date, 
        count(f.id) over(partition by x.id order by x.foo_date) grp
    from (
        select f.id, x.foo_date
        from foo f
        cross join lateral generate_series(min(foo_date), max(food_date), '1 day') as x(foo_date)
        group by f.id
    ) x
    left join foo on f.id = x.id and f.food_date = x.foo_date
) t