Implementations that model the overlaps operator
The function modeled_overlaps(timestamp, timestamp, timestamp, timestamp) returns boolean
This function models the overlaps semantics using two distinct approaches:
- Using the
&&operator with two range values. - From first principles using ordinary if-the-else logic.
It considers just this invocation syntax:
overlaps_result ◄— (left-duration-bound-1, left-duration-bound-2) overlaps (right-duration-bound-1, right-duration-bound-2)
The other overloads:
- that define one duration using a pair of moments and one using a moment and a duration size
- that define both durations using a moment and a duration size
can be trivially expressed as wrappers around the overload that defines both durations using a pair of moments.
The model addresses just the overload that specifies each duration by a pair of plain timestamp bounds. The corresponding overloads for plain time and timestamptz can be trivially derived from this.
This page's parent page, in the section overlaps semantics in prose, explained that the overlaps operator result is insensitive, for each of the two durations on which it acts, to the ordering of the moment arguments that define the duration's bounds—and that it is also insensitive to which duration is given as the left duration and which is given as the right duration. However, the implementation needs to distinguish between the start and the finish moments and needs to know how the two durations are mutually ordered. In other words, it models this invocation syntax:
overlaps_result ◄— (earlier-duration-start-moment, earlier-duration-finish-moment) overlaps (later-duration-start-moment, later-duration-finish-moment)
The implementation therefore starts by deriving these values:
earlier_start, earlier_finish, later_start, later_finish
from these input values:
left_1, left_2, right_1, right_2
Create the function modeled_overlaps() thus:
drop function if exists modeled_overlaps(timestamp, timestamp, timestamp, timestamp) cascade;
create function modeled_overlaps(left_1 in timestamp, left_2 in timestamp, right_1 in timestamp, right_2 in timestamp)
returns boolean
language plpgsql
as $body$
declare
left_start constant timestamp not null := least (left_1, left_2);
left_finish constant timestamp not null := greatest(left_1, left_2);
right_start constant timestamp not null := least (right_1, right_2);
right_finish constant timestamp not null := greatest(right_1, right_2);
left_is_earlier constant boolean not null :=
case
when left_start < right_start then true
when left_start > right_start then false
else
-- Here when left_start and right_start coincide
case
when left_finish < right_finish then true
else false
end
end;
earlier_start timestamp not null := '-infinity'; -- convenient initial value;
earlier_finish timestamp not null := earlier_start;
later_start timestamp not null := earlier_start;
later_finish timestamp not null := earlier_start;
begin
if left_is_earlier then
earlier_start := left_start;
earlier_finish := left_finish;
later_start := right_start;
later_finish := right_finish;
else
earlier_start := right_start;
earlier_finish := right_finish;
later_start := left_start;
later_finish := left_finish;
end if;
declare
-- Modeled using the && operator with two range values.
-- Accommodate the fact that if the bounds of a '[)' range, r, coincide,
-- then isempty(r) evaluates to TRUE by using a '[]' range instead.
r1 constant tsrange not null :=
case
when earlier_start = earlier_finish then tsrange(earlier_start, earlier_finish, '[]')
else tsrange(earlier_start, earlier_finish, '[)')
end;
r2 constant tsrange not null :=
case
when later_start = later_finish then tsrange(later_start, later_finish, '[]')
else tsrange(later_start, later_finish, '[)')
end;
modeled_using_ranges boolean not null := r1 && r2;
-- Modeled from first principles using ordinary if-the-else logic.
modeled_from_first_principles boolean not null :=
case
-- Special case: both are instants
when (earlier_finish = earlier_start) and (later_finish = later_start) then
case
when earlier_start = later_start then true
else false
end
-- Special case: earlier is instant
when (earlier_finish = earlier_start) and (later_finish > later_start) then
case
when earlier_start = later_start then true
else false
end
-- Later is instant doesn't need special case treatment.
-- Neither is instant
else
(earlier_start <= later_start) and (earlier_finish > later_start)
end;
begin
assert (modeled_from_first_principles = modeled_using_ranges), 'Assert failed';
return modeled_from_first_principles;
end;
end;
$body$;
The function modeled_overlaps_vs_overlaps(timestamp, timestamp, timestamp, timestamp) returns modeled_overlaps_vs_overlaps_result
This function returns a user-defined type value that represents the return value from the native overlaps operator together with the return value from modeled_overlaps(), for the same parameterization of the two durations, as a pair of boolean values.
Create the type modeled_overlaps_vs_overlaps_result and the function modeled_overlaps_vs_overlaps) thus:
drop type if exists modeled_overlaps_vs_overlaps_result cascade;
create type modeled_overlaps_vs_overlaps_result as (o boolean, m boolean);
drop function if exists modeled_overlaps_vs_overlaps(timestamp, timestamp, timestamp, timestamp) cascade;
create function modeled_overlaps_vs_overlaps(left_1 in timestamp, left_2 in timestamp, right_1 in timestamp, right_2 in timestamp)
returns modeled_overlaps_vs_overlaps_result
language plpgsql
as $body$
declare
o constant boolean not null := (left_1, left_2) overlaps (right_1, right_2);
m constant boolean not null := modeled_overlaps(left_1, left_2, right_1, right_2);
begin
return (o, m)::modeled_overlaps_vs_overlaps_result;
end;
$body$;
The function modeled_overlaps_vs_overlaps_display(timestamp, timestamp, timestamp, timestamp) returns text
This function creates a text value from the parameterization of the two durations that encodes:
- the left_1, left_2, right_1, and right_2 plain timestamp values
- the result, true or false from the native overlaps operator
- only if the result from modeled_overlaps() is different from the result from the native overlaps operator, then it appends DISAGREE.
It also adds a significant test of its own. For each supplied parameterization, (left_1, left_2, right_1, right_2), it invokes modeled_overlaps_vs_overlaps() with each of the eight parameter orderings that supposedly express the same semantics:
- (left_1, left_2, right_1, right_2)
- (left_2, left_1, right_1, right_2)
- (left_1, left_2, right_2, right_1)
- (left_2, left_1, right_2, right_1)
- (right_1, right_2, left_1, left_2)
- (right_2, right_1, left_1, left_2)
- (right_1, right_2, left_2, left_1)
- (right_2, right_1, left_2, left_1)
and it tests that all of these invocations produce the same result.
First create the helper procedure assert_r1_equals_r(int, modeled_overlaps_vs_overlaps_result, modeled_overlaps_vs_overlaps_result) to test if the result from the invocation that uses one of the second through the eighth orderings is identical to the result from the invocation that uses the first ordering.
drop procedure if exists assert_r1_equals_r(int, modeled_overlaps_vs_overlaps_result, modeled_overlaps_vs_overlaps_result) cascade;
create procedure assert_r1_equals_r(test_nr in int, r1 in modeled_overlaps_vs_overlaps_result, r in modeled_overlaps_vs_overlaps_result)
language plpgsql
as $body$
declare
o1 constant boolean not null := r1.o;
m1 constant boolean not null := r1.m;
o constant boolean not null := r.o;
m constant boolean not null := r.m;
msg constant text not null := 'Test number '||test_nr::text||' assert failed';
begin
assert ((o1 = o) and (m1 = m)), msg;
end;
$body$;
Now create the function modeled_overlaps_vs_overlaps_display():
drop function if exists modeled_overlaps_vs_overlaps_display(timestamp, timestamp, timestamp, timestamp) cascade;
create function modeled_overlaps_vs_overlaps_display(left_1 in timestamp, left_2 in timestamp, right_1 in timestamp, right_2 in timestamp)
returns text
language plpgsql
as $body$
declare
input constant text not null := rpad(left_1||', ' ::text, 29)||
rpad(left_2 ::text, 27)||' | ' ||
rpad(right_1||', ' ::text, 29)||
rpad(right_2 ::text, 27)||' ';
o1 boolean not null := false;
m1 boolean not null := false;
o boolean not null := false;
m boolean not null := false;
r modeled_overlaps_vs_overlaps_result;
r1 modeled_overlaps_vs_overlaps_result;
begin
for j in 1..8 loop
case j
when 1 then
r1 := modeled_overlaps_vs_overlaps(left_1, left_2, right_1, right_2);
o1 := r1.o;
m1 := r1.m;
when 2 then
r := modeled_overlaps_vs_overlaps(left_2, left_1, right_1, right_2);
call assert_r1_equals_r(1, r1, r);
when 3 then
r := modeled_overlaps_vs_overlaps(left_1, left_2, right_2, right_1);
call assert_r1_equals_r(2, r1, r);
when 4 then
r := modeled_overlaps_vs_overlaps(left_2, left_1, right_2, right_1);
call assert_r1_equals_r(3, r1, r);
when 5 then
r := modeled_overlaps_vs_overlaps(right_1, right_2, left_1, left_2);
call assert_r1_equals_r(4, r1, r);
when 6 then
r := modeled_overlaps_vs_overlaps(right_2, right_1, left_1, left_2);
call assert_r1_equals_r(5, r1, r);
when 7 then
r := modeled_overlaps_vs_overlaps(right_1, right_2, left_2, left_1);
call assert_r1_equals_r(6, r1, r);
when 8 then
r := modeled_overlaps_vs_overlaps(right_2, right_1, left_2, left_1);
call assert_r1_equals_r(7, r1, r);
end case;
return
case (m1 = o1)
when true then input||o1::text
else input||rpad(o1::text, 6)||'DISAGREE'
end;
end loop;
end;
$body$;
The function modeled_overlaps_vs_overlaps_report() returns table(z text)
This table function simply invokes modeled_overlaps_vs_overlaps_display() for all of the parameterizations that correspond to the interesting cases that are shown in the picture in this page's parent page in the section overlaps semantics in pictures. It also adds a few more tests. Create it thus:
drop function if exists modeled_overlaps_vs_overlaps_report() cascade;
create function modeled_overlaps_vs_overlaps_report()
returns table(z text)
language plpgsql
as $body$
begin
z := 'TWO FINITE DURATIONS'; return next;
z := '--------------------'; return next;
z := ''; return next;
z := ' 1. Durations do not overlap '||
modeled_overlaps_vs_overlaps_display
('2000-01-15', '2000-05-15', '2000-08-15', '2000-12-15'); return next;
z := ' 2. Right start = left end '||
modeled_overlaps_vs_overlaps_display
('2000-01-15', '2000-05-15', '2000-05-15', '2000-12-15'); return next;
z := ' 3. Durations overlap '||
modeled_overlaps_vs_overlaps_display
('2000-01-15', '2000-08-15', '2000-05-15', '2000-12-15'); return next;
z := ' 3. Durations overlap by 1 microsec '||
modeled_overlaps_vs_overlaps_display
('2000-01-15', '2000-06-15 00:00:00.000001', '2000-06-15', '2000-12-15'); return next;
z := ' 3. Durations overlap by 1 microsec '||
modeled_overlaps_vs_overlaps_display
('2000-06-15', '2000-12-15', '2000-01-15', '2000-06-15 00:00:00.000001'); return next;
z := ' 4. Contained '||
modeled_overlaps_vs_overlaps_display
('2000-01-15', '2000-12-15', '2000-05-15', '2000-08-15'); return next;
z := ' 4. Contained, co-inciding at left '||
modeled_overlaps_vs_overlaps_display
('2000-01-15', '2000-06-15', '2000-01-15', '2000-08-15'); return next;
z := ' 4. Contained, co-inciding at right '||
modeled_overlaps_vs_overlaps_display
('2000-01-15', '2000-06-15', '2000-02-15', '2000-06-15'); return next;
z := ' 4. Durations coincide '||
modeled_overlaps_vs_overlaps_display
('2000-01-15', '2000-06-15', '2000-01-15', '2000-06-15'); return next;
z := ''; return next;
z := 'ONE INSTANT, ONE FINITE DURATION'; return next;
z := '--------------------------------'; return next;
z := ''; return next;
z := ' 5. Instant before duration '||
modeled_overlaps_vs_overlaps_display
('2000-02-15', '2000-02-15', '2000-03-15', '2000-04-15'); return next;
z := ' 6. Instant coincides with duration start '||
modeled_overlaps_vs_overlaps_display
('2000-02-15', '2000-02-15', '2000-02-15', '2000-03-15'); return next;
z := ' 7. Instant within duration '||
modeled_overlaps_vs_overlaps_display
('2000-02-15', '2000-02-15', '2000-01-15', '2000-03-15'); return next;
z := ' 8. Instant coincides with duration end '||
modeled_overlaps_vs_overlaps_display
('2000-02-15', '2000-02-15', '2000-01-15', '2000-02-15'); return next;
z := ' 9. Instant after duration '||
modeled_overlaps_vs_overlaps_display
('2000-05-15', '2000-05-15', '2000-03-15', '2000-04-15'); return next;
z := ''; return next;
z := 'TWO INSTANTS'; return next;
z := '------------'; return next;
z := ''; return next;
z := '10. Instants differ '||
modeled_overlaps_vs_overlaps_display
('2000-01-15', '2000-01-15', '2000-06-15', '2000-06-15'); return next;
z := '11. Instants coincide '||
modeled_overlaps_vs_overlaps_display
('2000-01-15', '2000-01-15', '2000-01-15', '2000-01-15'); return next;
end;
$body$;
Invoke it thus:
select z from modeled_overlaps_vs_overlaps_report();
This is the result:
TWO FINITE DURATIONS
--------------------
1. Durations do not overlap 2000-01-15 00:00:00, 2000-05-15 00:00:00 | 2000-08-15 00:00:00, 2000-12-15 00:00:00 false
2. Right start = left end 2000-01-15 00:00:00, 2000-05-15 00:00:00 | 2000-05-15 00:00:00, 2000-12-15 00:00:00 false
3. Durations overlap 2000-01-15 00:00:00, 2000-08-15 00:00:00 | 2000-05-15 00:00:00, 2000-12-15 00:00:00 true
3. Durations overlap by 1 microsec 2000-01-15 00:00:00, 2000-06-15 00:00:00.000001 | 2000-06-15 00:00:00, 2000-12-15 00:00:00 true
3. Durations overlap by 1 microsec 2000-06-15 00:00:00, 2000-12-15 00:00:00 | 2000-01-15 00:00:00, 2000-06-15 00:00:00.000001 true
4. Contained 2000-01-15 00:00:00, 2000-12-15 00:00:00 | 2000-05-15 00:00:00, 2000-08-15 00:00:00 true
4. Contained, co-inciding at left 2000-01-15 00:00:00, 2000-06-15 00:00:00 | 2000-01-15 00:00:00, 2000-08-15 00:00:00 true
4. Contained, co-inciding at right 2000-01-15 00:00:00, 2000-06-15 00:00:00 | 2000-02-15 00:00:00, 2000-06-15 00:00:00 true
4. Durations coincide 2000-01-15 00:00:00, 2000-06-15 00:00:00 | 2000-01-15 00:00:00, 2000-06-15 00:00:00 true
ONE INSTANT, ONE FINITE DURATION
--------------------------------
5. Instant before duration 2000-02-15 00:00:00, 2000-02-15 00:00:00 | 2000-03-15 00:00:00, 2000-04-15 00:00:00 false
6. Instant coincides with duration start 2000-02-15 00:00:00, 2000-02-15 00:00:00 | 2000-02-15 00:00:00, 2000-03-15 00:00:00 true
7. Instant within duration 2000-02-15 00:00:00, 2000-02-15 00:00:00 | 2000-01-15 00:00:00, 2000-03-15 00:00:00 true
8. Instant coincides with duration end 2000-02-15 00:00:00, 2000-02-15 00:00:00 | 2000-01-15 00:00:00, 2000-02-15 00:00:00 false
9. Instant after duration 2000-05-15 00:00:00, 2000-05-15 00:00:00 | 2000-03-15 00:00:00, 2000-04-15 00:00:00 false
TWO INSTANTS
------------
10. Instants differ 2000-01-15 00:00:00, 2000-01-15 00:00:00 | 2000-06-15 00:00:00, 2000-06-15 00:00:00 false
11. Instants coincide 2000-01-15 00:00:00, 2000-01-15 00:00:00 | 2000-01-15 00:00:00, 2000-01-15 00:00:00 true
This is the same output that was shown on this page's parent page in the section Two implementations that model the 'overlaps' semantics and that produce the same results.