Postgres重叠的日期范围供查看

Question

I have three tables

    Table 1              Table 2             Table 3
   start_date          start_date          start_date
   end_date            end_date             end_date
    val                   val                  val

Now lets say I have the following in the tables:

Table 1
start_date    end_date     val
01-01-2000     31-01-2000   APPLE
01-02-2000                  ORANGE

table 2
start_date    end_date     val
01-01-2000     15-01-2000   TOMATO
16-01-2000                  LETTUCE

table 3
start_date    end_date     val
01-12-1999                  CAR

I want the above three tables put into a view with min/max dates. Which would look like this:

start_date     end_date      val_table_1    val_table_2    val_table_3
01-12-1999     31-12-1999       null           null           CAR
01-01-2000     15-01-2000       APPLE          TOMATO         CAR
16-01-2000     31-01-2000       APPLE          LETTUCE        CAR
01-02-2000                      ORANGE         LETTUCE        CAR

Answer 1

I was able to achieve the wanted result with the query below. Also available as a demo here at SQL Fiddle . Leave out the final order by clause if creating a view, it was included here just to present the results sensibly.

PostgreSQL 9.6 Schema Setup :

CREATE TABLE Table1
    ("start_date" timestamp, "end_date" timestamp, "val" varchar(20))
;

INSERT INTO Table1
    ("start_date", "end_date", "val")
VALUES
    ('2000-01-01 00:00:00', '2000-01-31', 'APPLE'),
    ('2000-02-01 00:00:00', NULL, 'ORANGE')
;

CREATE TABLE Table2
    ("start_date" timestamp, "end_date" timestamp, "val" varchar(20))
;

INSERT INTO Table2
    ("start_date", "end_date", "val")
VALUES
    ('2000-01-01', '2000-01-15', 'TOMATO'),
    ('2000-01-16', NULL, 'LETTUCE')
;

CREATE TABLE Table3
    ("start_date" timestamp, "end_date" timestamp, "val" varchar(3))
;

INSERT INTO Table3
    ("start_date", "end_date", "val")
VALUES
    ('1999-01-12 00:00:00', NULL, 'CAR')
;

Query 1 :

with ends as (
          select end_date from Table1 where end_date is not null union
          select end_date from Table2 where end_date is not null union
          select end_date from Table3 where end_date is not null
          )
select
       d.start_date
     , least(e.end_date, lead(d.start_date,1) over(order by d.start_date) - INTERVAL '1 DAY') as end_date
     , table1.val as t1_val
     , table2.val as t2_val
     , table3.val as t3_val
from (
    select start_date from Table1 union
    select start_date from Table2 union
    select start_date from Table3
    ) d
left join lateral (
  select ends.end_date from ends where ends.end_date > d.start_date
  order by end_date
  limit 1
  ) e on true
left join table1 on d.start_date between table1.start_date and coalesce(table1.end_date,current_date)
left join table2 on d.start_date between table2.start_date and coalesce(table2.end_date,current_date)
left join table3 on d.start_date between table3.start_date and coalesce(table3.end_date,current_date)
order by
       start_date, end_date

Results :

|           start_date |             end_date | t1_val |  t2_val | t3_val |
|----------------------|----------------------|--------|---------|--------|
| 1999-01-12T00:00:00Z | 1999-12-31T00:00:00Z | (null) |  (null) |    CAR |
| 2000-01-01T00:00:00Z | 2000-01-15T00:00:00Z |  APPLE |  TOMATO |    CAR |
| 2000-01-16T00:00:00Z | 2000-01-31T00:00:00Z |  APPLE | LETTUCE |    CAR |
| 2000-02-01T00:00:00Z |               (null) | ORANGE | LETTUCE |    CAR |

Answer 2

I think the other answer is more complicated than it need be.

with t as (
      select start_date as dte, val as val1, null as val2, null as val3 from table1
      union all
      select start_date as dte, null as val1, val as val2, null as val3 from table2
      union all
      select start_date as dte, null as val1, null as val2, val as val3 from table3
     ),
     tt as (  -- eliminate duplicates
      select dte, max(val1) as val1, max(val2) as val2, max(val3) as val3
      from t
     )
select dte as start_date,
       lead(dte) over (order by dte) - interval '1 day' as end_date,
       coalesce(val1,
                first_value(val1) over (order by (val1 is not null)::int desc, dte desc)
               ) as val1,
       coalesce(val2,
                first_value(val2) over (order by (val2 is not null)::int desc, dte desc)
               ) as val2,
       coalesce(val3,
                first_value(val3) over (order by (val3 is not null)::int desc, dte desc)
               ) as val3
from tt
order by start_date;

This is using some a key observation from the data: the time frames are "tiled" within each table. They do not overlap and they do not have gaps. For the purposes of this version, the values are also not- NULL (handling NULL values just makes the query look a bit more complicated but the logic is the same). If you need help with that, then please ask another question.

How does this work?

• t shows what happens in each table at each start_date .
• tt handles duplicates on a given date. This provides each row of the result table.
• Finally, what you really want is lag(ignore nulls) , but Postgres does not support it. Instead this uses a first_value() equivalent.

Here is a rextester .