mirror of https://github.com/postgres/postgres
Selectivity estimation functions are missing for some range type operators, which is a TODO. Jeff Davispull/1/head
Heikki Linnakangas
14 years ago
parent
4334289186
commit
4429f6a9e3
@ -0,0 +1,373 @@ |
|||||||
|
<!-- doc/src/sgml/rangetypes.sgml --> |
||||||
|
|
||||||
|
<sect1 id="rangetypes"> |
||||||
|
<title>Range Types</title> |
||||||
|
|
||||||
|
<indexterm> |
||||||
|
<primary>range type</primary> |
||||||
|
</indexterm> |
||||||
|
|
||||||
|
<para> |
||||||
|
Range types are data types representing a range of values over some |
||||||
|
sub-type with a total order. For instance, ranges |
||||||
|
of <type>timestamp</type> might be used to represent the ranges of |
||||||
|
time that a meeting room is reserved. In this case the data type |
||||||
|
is <type>tsrange</type> (short for "timestamp range"), |
||||||
|
and <type>timestamp</type> is the sub-type with a total order. |
||||||
|
</para> |
||||||
|
|
||||||
|
<para> |
||||||
|
Range types are useful because they represent many points in a |
||||||
|
single value. The use of time and date ranges for scheduling |
||||||
|
purposes is the clearest example; but price ranges, measurement |
||||||
|
ranges from an instrument, etc., are also useful. |
||||||
|
</para> |
||||||
|
|
||||||
|
<sect2 id="rangetypes-builtin"> |
||||||
|
<title>Built-in Range Types</title> |
||||||
|
<para> |
||||||
|
PostgreSQL comes with the following built-in range types: |
||||||
|
<itemizedlist> |
||||||
|
<listitem> |
||||||
|
<para> |
||||||
|
<type>INT4RANGE</type> -- Range of <type>INTEGER</type>. This is a discrete range type, see <xref linkend="rangetypes-discrete">. |
||||||
|
</para> |
||||||
|
</listitem> |
||||||
|
<listitem> |
||||||
|
<para> |
||||||
|
<type>INT8RANGE</type> -- Range of <type>BIGINT</type>. This is a discrete range type, see <xref linkend="rangetypes-discrete">. |
||||||
|
</para> |
||||||
|
</listitem> |
||||||
|
<listitem> |
||||||
|
<para> |
||||||
|
<type>NUMRANGE</type> -- Range of <type>NUMERIC</type>. |
||||||
|
</para> |
||||||
|
</listitem> |
||||||
|
<listitem> |
||||||
|
<para> |
||||||
|
<type>TSRANGE</type> -- Range of <type>TIMESTAMP WITHOUT TIME ZONE</type>. |
||||||
|
</para> |
||||||
|
</listitem> |
||||||
|
<listitem> |
||||||
|
<para> |
||||||
|
<type>TSTZRANGE</type> -- Range of <type>TIMESTAMP WITH TIME ZONE</type>. |
||||||
|
</para> |
||||||
|
</listitem> |
||||||
|
<listitem> |
||||||
|
<para> |
||||||
|
<type>DATERANGE</type> -- Range of <type>DATE</type>. This is a discrete range type, see <xref linkend="rangetypes-discrete">. |
||||||
|
</para> |
||||||
|
</listitem> |
||||||
|
</itemizedlist> |
||||||
|
In addition, you can define your own; see <xref linkend="SQL-CREATETYPE"> for more information. |
||||||
|
</para> |
||||||
|
</sect2> |
||||||
|
|
||||||
|
<sect2 id="rangetypes-examples"> |
||||||
|
<title>Examples</title> |
||||||
|
<para> |
||||||
|
<programlisting> |
||||||
|
CREATE TABLE reservation ( during TSRANGE ); |
||||||
|
INSERT INTO reservation VALUES |
||||||
|
( '[2010-01-01 14:30, 2010-01-01 15:30)' ); |
||||||
|
|
||||||
|
-- Containment |
||||||
|
SELECT int4range(10, 20) @> 3; |
||||||
|
|
||||||
|
-- Overlaps |
||||||
|
SELECT numrange(11.1, 22.2) && numrange(20.0, 30.0); |
||||||
|
|
||||||
|
-- Find the upper bound: |
||||||
|
SELECT upper(int8range(15, 25)); |
||||||
|
|
||||||
|
-- Compute the intersection: |
||||||
|
SELECT int4range(10, 20) * int4range(15, 25); |
||||||
|
|
||||||
|
-- Is the range non-empty? |
||||||
|
SELECT numrange(1, 5)? ; |
||||||
|
|
||||||
|
</programlisting> |
||||||
|
|
||||||
|
See <xref linkend="range-functions-table"> |
||||||
|
and <xref linkend="range-operators-table"> for complete lists of |
||||||
|
functions and operators on range types. |
||||||
|
</para> |
||||||
|
</sect2> |
||||||
|
|
||||||
|
<sect2 id="rangetypes-inclusivity"> |
||||||
|
<title>Inclusive and Exclusive Bounds</title> |
||||||
|
<para> |
||||||
|
Every range has two bounds, the lower bound and the upper bound. All |
||||||
|
points in between those values are included in the range. An |
||||||
|
inclusive bound means that the boundary point itself is included in |
||||||
|
the range as well, while an exclusive bound means that the boundary |
||||||
|
point is not included in the range. |
||||||
|
</para> |
||||||
|
<para> |
||||||
|
An inclusive lower bound is represented by <literal>[</literal> |
||||||
|
while an exclusive lower bound is represented |
||||||
|
by <literal>(</literal> (see <xref linkend="rangetypes-construct"> |
||||||
|
and <xref linkend="rangetypes-io"> below). Likewise, an inclusive |
||||||
|
upper bound is represented by <literal>]</literal>, while an |
||||||
|
exclusive upper bound is represented by <literal>)</literal>. |
||||||
|
</para> |
||||||
|
<para> |
||||||
|
Functions <literal>lower_inc</literal> |
||||||
|
and <literal>upper_inc</literal> test the inclusivity of the lower |
||||||
|
and upper bounds of a range, respectively. |
||||||
|
</para> |
||||||
|
</sect2> |
||||||
|
|
||||||
|
<sect2 id="rangetypes-infinite"> |
||||||
|
<title>Infinite (unbounded) Ranges</title> |
||||||
|
<para> |
||||||
|
The lower bound of a range can be omitted, meaning that all points |
||||||
|
less (or equal to, if inclusive) than the upper bound are included |
||||||
|
in the range. Likewise, if the upper bound of the range is omitted, |
||||||
|
then all points greater than (or equal to, if omitted) the lower |
||||||
|
bound are included in the range. If both lower and upper bounds are |
||||||
|
omitted, all points are considered to be in the range. |
||||||
|
</para> |
||||||
|
<para> |
||||||
|
Functions <literal>lower_inf</literal> |
||||||
|
and <literal>upper_inf</literal> test the range for infinite lower |
||||||
|
and upper bounds of a range, respectively. |
||||||
|
</para> |
||||||
|
</sect2> |
||||||
|
|
||||||
|
<sect2 id="rangetypes-io"> |
||||||
|
<title>Input/Output</title> |
||||||
|
<para> |
||||||
|
The input follows one of the following patterns: |
||||||
|
<synopsis> |
||||||
|
(<replaceable>lower-bound</replaceable>,<replaceable>upper-bound</replaceable>) |
||||||
|
(<replaceable>lower-bound</replaceable>,<replaceable>upper-bound</replaceable>] |
||||||
|
[<replaceable>lower-bound</replaceable>,<replaceable>upper-bound</replaceable>) |
||||||
|
[<replaceable>lower-bound</replaceable>,<replaceable>upper-bound</replaceable>] |
||||||
|
empty |
||||||
|
</synopsis> |
||||||
|
Notice that the final pattern is <literal>empty</literal>, which |
||||||
|
represents an empty range (a range that contains no points). |
||||||
|
</para> |
||||||
|
<para> |
||||||
|
The <replaceable>lower-bound</replaceable> may be either a string |
||||||
|
that is valid input for the sub-type, or omitted (to indicate no |
||||||
|
lower bound); and <replaceable>upper-bound</replaceable> may be |
||||||
|
either a string that is valid input for the sub-type, or omitted (to |
||||||
|
indicate no upper bound). |
||||||
|
</para> |
||||||
|
<para> |
||||||
|
Either the <replaceable>lower-bound</replaceable> or |
||||||
|
the <replaceable>upper-bound</replaceable> may be quoted |
||||||
|
using <literal>""</literal> (double quotation marks), which will allow |
||||||
|
special characters such as "<literal>,</literal>". Within quotation |
||||||
|
marks, "<literal>\</literal>" (backslash) serves as an escape |
||||||
|
character. |
||||||
|
</para> |
||||||
|
<para> |
||||||
|
The choice between the other input formats affects the inclusivity |
||||||
|
of the bounds. See <xref linkend="rangetypes-inclusivity">. |
||||||
|
</para> |
||||||
|
<para> |
||||||
|
Examples: |
||||||
|
<programlisting> |
||||||
|
-- includes point 3, does not include point 7, and does include all points in between |
||||||
|
select '[3,7)' |
||||||
|
|
||||||
|
-- does not include either 3 or 7, but includes all points in between |
||||||
|
select '(3,7)' |
||||||
|
|
||||||
|
-- includes only the single point 4 |
||||||
|
select '[4,4]' |
||||||
|
</programlisting> |
||||||
|
</para> |
||||||
|
</sect2> |
||||||
|
|
||||||
|
<sect2 id="rangetypes-construct"> |
||||||
|
<title>Constructing Ranges</title> |
||||||
|
<para> |
||||||
|
Each range type has a constructor by the same name. The constructor |
||||||
|
accepts from zero to three arguments. The zero-argument form |
||||||
|
constructs an empty range; the one-argument form constructs a |
||||||
|
singleton range; the two-argument form constructs a range |
||||||
|
in <literal>[ )</literal> form; and the three-argument form |
||||||
|
constructs a range in a form specified by the third argument. For |
||||||
|
example: |
||||||
|
<programlisting> |
||||||
|
-- Three-argument form: lower bound, upper bound, and third argument indicating |
||||||
|
-- inclusivity/exclusivity of bounds (if omitted, defaults to <literal>'[)'</literal>). |
||||||
|
SELECT numrange(1.0, 14.0, '(]'); |
||||||
|
|
||||||
|
-- The int4range input will exclude the lower bound and include the upper bound; but the |
||||||
|
-- resulting output will appear in the canonical form; see <xref linkend="rangetypes-discrete">. |
||||||
|
SELECT int8range(1, 14, '(]'); |
||||||
|
|
||||||
|
-- Single argument form constructs a singleton range; that is a range consisting of just |
||||||
|
-- one point. |
||||||
|
SELECT numrange(11.1); |
||||||
|
|
||||||
|
-- Zero-argument form constructs and empty range. |
||||||
|
SELECT numrange(); |
||||||
|
|
||||||
|
-- Using NULL for a bound causes the range to be unbounded on that side; that is, negative |
||||||
|
-- infinity for the lower bound or positive infinity for the upper bound. |
||||||
|
SELECT numrange(NULL,2.2); |
||||||
|
</programlisting> |
||||||
|
</para> |
||||||
|
</sect2> |
||||||
|
|
||||||
|
<sect2 id="rangetypes-discrete"> |
||||||
|
<title>Discrete Range Types</title> |
||||||
|
<para> |
||||||
|
Discrete ranges are those that have a |
||||||
|
defined <literal>canonical</literal> function. Loosely speaking, a |
||||||
|
discrete range has a sub-type with a well-defined "step"; |
||||||
|
e.g. <type>INTEGER</type> or <type>DATE</type>. |
||||||
|
</para> |
||||||
|
<para> |
||||||
|
The <literal>canonical</literal> function should take an input range |
||||||
|
value, and return an equal range value that may have a different |
||||||
|
formatting. For instance, the integer range <literal>[1, |
||||||
|
7]</literal> could be represented by the equal integer |
||||||
|
range <literal>[1, 8)</literal>. The two values are equal because |
||||||
|
there are no points within the integer domain |
||||||
|
between <literal>7</literal> and <literal>8</literal>, so not |
||||||
|
including the end point <literal>8</literal> is the same as |
||||||
|
including the end point <literal>7</literal>. The canonical output |
||||||
|
for two values that are equal, like <literal>[1, 7]</literal> |
||||||
|
and <literal>[1, 8)</literal>, must be equal. It doesn't matter |
||||||
|
which representation you choose to be the canonical one, as long as |
||||||
|
two equal values with different formattings are always mapped to the |
||||||
|
same value with the same formatting. If the canonical function is |
||||||
|
not specified, then ranges with different formatting |
||||||
|
(e.g. <literal>[1, 7]</literal> and <literal>[1, 8)</literal>) will |
||||||
|
always be treated as unequal. |
||||||
|
</para> |
||||||
|
<para> |
||||||
|
For types such as <type>NUMRANGE</type>, this is not possible, |
||||||
|
because there are always points in between two |
||||||
|
distinct <type>NUMERIC</type> values. |
||||||
|
</para> |
||||||
|
<para> |
||||||
|
The built-in range |
||||||
|
types <type>INT4RANGE</type>, <type>INT8RANGE</type>, |
||||||
|
and <type>DATERNAGE</type> all use a canonical form that includes |
||||||
|
the lower bound and excludes the upper bound; that is, <literal>[ |
||||||
|
)</literal>. User-defined ranges can use other conventions, however. |
||||||
|
</para> |
||||||
|
</sect2> |
||||||
|
|
||||||
|
<sect2 id="rangetypes-defining"> |
||||||
|
<title>Defining New Range Types</title> |
||||||
|
<para> |
||||||
|
Users can define their own range types. The most common reason to do |
||||||
|
this is to use ranges where the subtype is not among the built-in |
||||||
|
range types, e.g. a range of type <type>FLOAT</type> (or, if the |
||||||
|
subtype itself is a user-defined type). |
||||||
|
</para> |
||||||
|
<para> |
||||||
|
For example: to define a new range type of sub-type <type>DOUBLE PRECISION</type>: |
||||||
|
<programlisting> |
||||||
|
CREATE TYPE FLOATRANGE AS RANGE ( |
||||||
|
SUBTYPE = DOUBLE PRECISION |
||||||
|
); |
||||||
|
|
||||||
|
SELECT '[1.234, 5.678]'::floatrange; |
||||||
|
</programlisting> |
||||||
|
Because <type>DOUBLE PRECISION</type> has no meaningful "step", we |
||||||
|
do not define a <literal>canonical</literal> |
||||||
|
function. See <xref linkend="SQL-CREATETYPE"> for more |
||||||
|
information. |
||||||
|
</para> |
||||||
|
<para> |
||||||
|
Defining your own range type also allows you to specify a different |
||||||
|
operator class or collation to use (which affects the points that |
||||||
|
fall between the range boundaries), or a different canonicalization |
||||||
|
function. |
||||||
|
</para> |
||||||
|
</sect2> |
||||||
|
|
||||||
|
<sect2 id="rangetypes-gist"> |
||||||
|
<indexterm> |
||||||
|
<primary>range type</primary> |
||||||
|
<secondary>gist</secondary> |
||||||
|
</indexterm> |
||||||
|
<title>Indexing</title> |
||||||
|
<para> |
||||||
|
GiST indexes can be applied to a table containing a range type. For instance: |
||||||
|
<programlisting> |
||||||
|
CREATE INDEX reservation_idx ON reservation USING gist (during); |
||||||
|
</programlisting> |
||||||
|
This index may speed up queries |
||||||
|
involving <literal>&&</literal> |
||||||
|
(overlaps), <literal>@></literal> (contains), and all the boolean |
||||||
|
operators found in this |
||||||
|
table: <xref linkend="range-operators-table">. |
||||||
|
</para> |
||||||
|
</sect2> |
||||||
|
|
||||||
|
<sect2 id="rangetypes-constraint"> |
||||||
|
<indexterm> |
||||||
|
<primary>range type</primary> |
||||||
|
<secondary>exclude</secondary> |
||||||
|
</indexterm> |
||||||
|
<title>Constraints on Ranges</title> |
||||||
|
<para> |
||||||
|
While <literal>UNIQUE</literal> is a natural constraint for scalar |
||||||
|
values, it is usually unsuitable for range types. Instead, an |
||||||
|
exclusion constraint is often more appropriate |
||||||
|
(see <link linkend="SQL-CREATETABLE-EXCLUDE">CREATE TABLE |
||||||
|
... CONSTRAINT ... EXCLUDE</link>). Exclusion constraints allow the |
||||||
|
specification of constraints such as "non-overlapping" on a range |
||||||
|
type. For example: |
||||||
|
<programlisting> |
||||||
|
ALTER TABLE reservation |
||||||
|
ADD EXCLUDE USING gist (during WITH &&); |
||||||
|
</programlisting> |
||||||
|
That constraint will prevent any overlapping values from existing |
||||||
|
in the table at the same time: |
||||||
|
<programlisting> |
||||||
|
INSERT INTO reservation VALUES |
||||||
|
( '[2010-01-01 11:30, 2010-01-01 13:00)' ); |
||||||
|
-- Result: INSERT 0 1 |
||||||
|
INSERT INTO reservation VALUES |
||||||
|
( '[2010-01-01 14:45, 2010-01-01 15:45)' ); |
||||||
|
-- Result: |
||||||
|
-- ERROR: conflicting key value violates exclusion constraint "reservation_during_excl" |
||||||
|
-- DETAIL: Key (during)=([ 2010-01-01 14:45:00, 2010-01-01 15:45:00 )) conflicts with |
||||||
|
-- existing key (during)=([ 2010-01-01 14:30:00, 2010-01-01 15:30:00 )). |
||||||
|
</programlisting> |
||||||
|
</para> |
||||||
|
<para> |
||||||
|
Combine range types and exclusion constraints |
||||||
|
with <link linkend="btree-gist">btree_gist</link> for maximum |
||||||
|
flexibility defining |
||||||
|
constraints. After <literal>btree_gist</literal> is installed, the |
||||||
|
following constraint will prevent overlapping ranges only if the |
||||||
|
meeting room numbers are equal: |
||||||
|
<programlisting> |
||||||
|
|
||||||
|
CREATE TABLE room_reservation |
||||||
|
( |
||||||
|
room TEXT, |
||||||
|
during TSRANGE, |
||||||
|
EXCLUDE USING gist (room WITH =, during WITH &&) |
||||||
|
); |
||||||
|
|
||||||
|
INSERT INTO room_reservation VALUES |
||||||
|
( '123A', '[2010-01-01 14:00, 2010-01-01 15:00)' ); |
||||||
|
-- Result: INSERT 0 1 |
||||||
|
INSERT INTO room_reservation VALUES |
||||||
|
( '123A', '[2010-01-01 14:30, 2010-01-01 15:30)' ); |
||||||
|
-- Result: |
||||||
|
-- ERROR: conflicting key value violates exclusion constraint "room_reservation_room_during_excl" |
||||||
|
-- DETAIL: Key (room, during)=(123A, [ 2010-01-01 14:30:00, 2010-01-01 15:30:00 )) conflicts with |
||||||
|
-- existing key (room, during)=(123A, [ 2010-01-01 14:00:00, 2010-01-01 15:00:00 )). |
||||||
|
INSERT INTO room_reservation VALUES |
||||||
|
( '123B', '[2010-01-01 14:30, 2010-01-01 15:30)' ); |
||||||
|
-- Result: INSERT 0 1 |
||||||
|
|
||||||
|
</programlisting> |
||||||
|
</para> |
||||||
|
</sect2> |
||||||
|
</sect1> |
||||||
@ -0,0 +1,136 @@ |
|||||||
|
/*-------------------------------------------------------------------------
|
||||||
|
* |
||||||
|
* pg_range.c |
||||||
|
* routines to support manipulation of the pg_range relation |
||||||
|
* |
||||||
|
* Copyright (c) 2006-2010, PostgreSQL Global Development Group |
||||||
|
* |
||||||
|
* |
||||||
|
* IDENTIFICATION |
||||||
|
* src/backend/catalog/pg_range.c |
||||||
|
* |
||||||
|
*------------------------------------------------------------------------- |
||||||
|
*/ |
||||||
|
#include "postgres.h" |
||||||
|
|
||||||
|
#include "access/genam.h" |
||||||
|
#include "access/heapam.h" |
||||||
|
#include "catalog/dependency.h" |
||||||
|
#include "catalog/indexing.h" |
||||||
|
#include "catalog/pg_collation.h" |
||||||
|
#include "catalog/pg_opclass.h" |
||||||
|
#include "catalog/pg_proc.h" |
||||||
|
#include "catalog/pg_range.h" |
||||||
|
#include "catalog/pg_type.h" |
||||||
|
#include "utils/builtins.h" |
||||||
|
#include "utils/fmgroids.h" |
||||||
|
#include "utils/tqual.h" |
||||||
|
#include "utils/rel.h" |
||||||
|
|
||||||
|
/*
|
||||||
|
* RangeCreate |
||||||
|
* Create an entry in pg_range. |
||||||
|
*/ |
||||||
|
void |
||||||
|
RangeCreate(Oid rangeTypeOid, Oid rangeSubType, Oid rangeCollation, |
||||||
|
Oid rangeSubOpclass, RegProcedure rangeCanonical, |
||||||
|
RegProcedure rangeSubDiff) |
||||||
|
{ |
||||||
|
Relation pg_range; |
||||||
|
Datum values[Natts_pg_range]; |
||||||
|
bool nulls[Natts_pg_range]; |
||||||
|
HeapTuple tup; |
||||||
|
ObjectAddress myself; |
||||||
|
ObjectAddress referenced; |
||||||
|
|
||||||
|
pg_range = heap_open(RangeRelationId, RowExclusiveLock); |
||||||
|
|
||||||
|
memset(nulls, 0, Natts_pg_range * sizeof(bool)); |
||||||
|
|
||||||
|
values[Anum_pg_range_rngtypid - 1] = ObjectIdGetDatum(rangeTypeOid); |
||||||
|
values[Anum_pg_range_rngsubtype - 1] = ObjectIdGetDatum(rangeSubType); |
||||||
|
values[Anum_pg_range_rngcollation - 1] = ObjectIdGetDatum(rangeCollation); |
||||||
|
values[Anum_pg_range_rngsubopc - 1] = ObjectIdGetDatum(rangeSubOpclass); |
||||||
|
values[Anum_pg_range_rngcanonical - 1] = ObjectIdGetDatum(rangeCanonical); |
||||||
|
values[Anum_pg_range_rngsubdiff - 1] = ObjectIdGetDatum(rangeSubDiff); |
||||||
|
|
||||||
|
tup = heap_form_tuple(RelationGetDescr(pg_range), values, nulls); |
||||||
|
simple_heap_insert(pg_range, tup); |
||||||
|
CatalogUpdateIndexes(pg_range, tup); |
||||||
|
heap_freetuple(tup); |
||||||
|
|
||||||
|
/* record dependencies */ |
||||||
|
|
||||||
|
myself.classId = TypeRelationId; |
||||||
|
myself.objectId = rangeTypeOid; |
||||||
|
myself.objectSubId = 0; |
||||||
|
|
||||||
|
referenced.classId = TypeRelationId; |
||||||
|
referenced.objectId = rangeSubType; |
||||||
|
referenced.objectSubId = 0; |
||||||
|
recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL); |
||||||
|
|
||||||
|
referenced.classId = OperatorClassRelationId; |
||||||
|
referenced.objectId = rangeSubOpclass; |
||||||
|
referenced.objectSubId = 0; |
||||||
|
recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL); |
||||||
|
|
||||||
|
if (OidIsValid(rangeCollation)) |
||||||
|
{ |
||||||
|
referenced.classId = CollationRelationId; |
||||||
|
referenced.objectId = rangeCollation; |
||||||
|
referenced.objectSubId = 0; |
||||||
|
recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL); |
||||||
|
} |
||||||
|
|
||||||
|
if (OidIsValid(rangeCanonical)) |
||||||
|
{ |
||||||
|
referenced.classId = ProcedureRelationId; |
||||||
|
referenced.objectId = rangeCanonical; |
||||||
|
referenced.objectSubId = 0; |
||||||
|
recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL); |
||||||
|
} |
||||||
|
|
||||||
|
if (OidIsValid(rangeSubDiff)) |
||||||
|
{ |
||||||
|
referenced.classId = ProcedureRelationId; |
||||||
|
referenced.objectId = rangeSubDiff; |
||||||
|
referenced.objectSubId = 0; |
||||||
|
recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL); |
||||||
|
} |
||||||
|
|
||||||
|
heap_close(pg_range, RowExclusiveLock); |
||||||
|
} |
||||||
|
|
||||||
|
|
||||||
|
/*
|
||||||
|
* RangeDelete |
||||||
|
* Remove the pg_range entry. |
||||||
|
*/ |
||||||
|
void |
||||||
|
RangeDelete(Oid rangeTypeOid) |
||||||
|
{ |
||||||
|
Relation pg_range; |
||||||
|
ScanKeyData key[1]; |
||||||
|
SysScanDesc scan; |
||||||
|
HeapTuple tup; |
||||||
|
|
||||||
|
pg_range = heap_open(RangeRelationId, RowExclusiveLock); |
||||||
|
|
||||||
|
ScanKeyInit(&key[0], |
||||||
|
Anum_pg_range_rngtypid, |
||||||
|
BTEqualStrategyNumber, F_OIDEQ, |
||||||
|
ObjectIdGetDatum(rangeTypeOid)); |
||||||
|
|
||||||
|
scan = systable_beginscan(pg_range, RangeTypidIndexId, true, |
||||||
|
SnapshotNow, 1, key); |
||||||
|
|
||||||
|
while (HeapTupleIsValid(tup = systable_getnext(scan))) |
||||||
|
{ |
||||||
|
simple_heap_delete(pg_range, &tup->t_self); |
||||||
|
} |
||||||
|
|
||||||
|
systable_endscan(scan); |
||||||
|
|
||||||
|
heap_close(pg_range, RowExclusiveLock); |
||||||
|
} |
||||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,587 @@ |
|||||||
|
/*-------------------------------------------------------------------------
|
||||||
|
* |
||||||
|
* rangetypes_gist.c |
||||||
|
* GiST support for range types. |
||||||
|
* |
||||||
|
* Copyright (c) 2006-2011, PostgreSQL Global Development Group |
||||||
|
* |
||||||
|
* |
||||||
|
* IDENTIFICATION |
||||||
|
* src/backend/utils/adt/rangetypes_gist.c |
||||||
|
* |
||||||
|
*------------------------------------------------------------------------- |
||||||
|
*/ |
||||||
|
#include "postgres.h" |
||||||
|
|
||||||
|
#include "access/gist.h" |
||||||
|
#include "access/skey.h" |
||||||
|
#include "utils/builtins.h" |
||||||
|
#include "utils/fmgroids.h" |
||||||
|
#include "utils/lsyscache.h" |
||||||
|
#include "utils/rangetypes.h" |
||||||
|
|
||||||
|
#define RANGESTRAT_EQ 1 |
||||||
|
#define RANGESTRAT_NE 2 |
||||||
|
#define RANGESTRAT_OVERLAPS 3 |
||||||
|
#define RANGESTRAT_CONTAINS_ELEM 4 |
||||||
|
#define RANGESTRAT_ELEM_CONTAINED_BY 5 |
||||||
|
#define RANGESTRAT_CONTAINS 6 |
||||||
|
#define RANGESTRAT_CONTAINED_BY 7 |
||||||
|
#define RANGESTRAT_BEFORE 8 |
||||||
|
#define RANGESTRAT_AFTER 9 |
||||||
|
#define RANGESTRAT_OVERLEFT 10 |
||||||
|
#define RANGESTRAT_OVERRIGHT 11 |
||||||
|
#define RANGESTRAT_ADJACENT 12 |
||||||
|
|
||||||
|
static RangeType *range_super_union(FunctionCallInfo fcinfo, RangeType *r1, |
||||||
|
RangeType *r2); |
||||||
|
static bool range_gist_consistent_int(FunctionCallInfo fcinfo, |
||||||
|
StrategyNumber strategy, RangeType *key, |
||||||
|
RangeType *query); |
||||||
|
static bool range_gist_consistent_leaf(FunctionCallInfo fcinfo, |
||||||
|
StrategyNumber strategy, RangeType *key, |
||||||
|
RangeType *query); |
||||||
|
static int sort_item_cmp(const void *a, const void *b); |
||||||
|
|
||||||
|
/*
|
||||||
|
* Auxiliary structure for picksplit method. |
||||||
|
*/ |
||||||
|
typedef struct |
||||||
|
{ |
||||||
|
int index; |
||||||
|
RangeType *data; |
||||||
|
FunctionCallInfo fcinfo; |
||||||
|
} PickSplitSortItem; |
||||||
|
|
||||||
|
|
||||||
|
Datum |
||||||
|
range_gist_consistent(PG_FUNCTION_ARGS) |
||||||
|
{ |
||||||
|
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); |
||||||
|
Datum dquery = PG_GETARG_DATUM(1); |
||||||
|
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); |
||||||
|
/* Oid subtype = PG_GETARG_OID(3); */ |
||||||
|
bool *recheck = (bool *) PG_GETARG_POINTER(4); |
||||||
|
RangeType *key = DatumGetRangeType(entry->key); |
||||||
|
RangeType *query; |
||||||
|
|
||||||
|
RangeBound lower; |
||||||
|
RangeBound upper; |
||||||
|
bool empty; |
||||||
|
Oid rngtypid; |
||||||
|
|
||||||
|
*recheck = false; |
||||||
|
range_deserialize(fcinfo, key, &lower, &upper, &empty); |
||||||
|
rngtypid = lower.rngtypid; |
||||||
|
|
||||||
|
switch (strategy) |
||||||
|
{ |
||||||
|
RangeBound lower; |
||||||
|
RangeBound upper; |
||||||
|
|
||||||
|
/*
|
||||||
|
* For contains and contained by operators, the other operand is a |
||||||
|
* "point" of the subtype. Construct a singleton range containing just |
||||||
|
* that value. |
||||||
|
*/ |
||||||
|
case RANGESTRAT_CONTAINS_ELEM: |
||||||
|
case RANGESTRAT_ELEM_CONTAINED_BY: |
||||||
|
lower.rngtypid = rngtypid; |
||||||
|
lower.inclusive = true; |
||||||
|
lower.val = dquery; |
||||||
|
lower.lower = true; |
||||||
|
lower.infinite = false; |
||||||
|
upper.rngtypid = rngtypid; |
||||||
|
upper.inclusive = true; |
||||||
|
upper.val = dquery; |
||||||
|
upper.lower = false; |
||||||
|
upper.infinite = false; |
||||||
|
query = DatumGetRangeType( |
||||||
|
make_range(fcinfo, &lower, &upper, false)); |
||||||
|
break; |
||||||
|
|
||||||
|
default: |
||||||
|
query = DatumGetRangeType(dquery); |
||||||
|
break; |
||||||
|
} |
||||||
|
|
||||||
|
if (GIST_LEAF(entry)) |
||||||
|
PG_RETURN_BOOL(range_gist_consistent_leaf( |
||||||
|
fcinfo, strategy, key, query)); |
||||||
|
else |
||||||
|
PG_RETURN_BOOL(range_gist_consistent_int( |
||||||
|
fcinfo, strategy, key, query)); |
||||||
|
} |
||||||
|
|
||||||
|
Datum |
||||||
|
range_gist_union(PG_FUNCTION_ARGS) |
||||||
|
{ |
||||||
|
GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); |
||||||
|
GISTENTRY *ent = entryvec->vector; |
||||||
|
RangeType *result_range; |
||||||
|
int i; |
||||||
|
|
||||||
|
result_range = DatumGetRangeType(ent[0].key); |
||||||
|
|
||||||
|
for (i = 1; i < entryvec->n; i++) |
||||||
|
{ |
||||||
|
result_range = range_super_union(fcinfo, result_range, |
||||||
|
DatumGetRangeType(ent[i].key)); |
||||||
|
} |
||||||
|
|
||||||
|
PG_RETURN_RANGE(result_range); |
||||||
|
} |
||||||
|
|
||||||
|
Datum |
||||||
|
range_gist_compress(PG_FUNCTION_ARGS) |
||||||
|
{ |
||||||
|
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); |
||||||
|
PG_RETURN_POINTER(entry); |
||||||
|
} |
||||||
|
|
||||||
|
Datum |
||||||
|
range_gist_decompress(PG_FUNCTION_ARGS) |
||||||
|
{ |
||||||
|
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); |
||||||
|
PG_RETURN_POINTER(entry); |
||||||
|
} |
||||||
|
|
||||||
|
Datum |
||||||
|
range_gist_penalty(PG_FUNCTION_ARGS) |
||||||
|
{ |
||||||
|
GISTENTRY *origentry = (GISTENTRY *) PG_GETARG_POINTER(0); |
||||||
|
GISTENTRY *newentry = (GISTENTRY *) PG_GETARG_POINTER(1); |
||||||
|
float *penalty = (float *) PG_GETARG_POINTER(2); |
||||||
|
RangeType *orig = DatumGetRangeType(origentry->key); |
||||||
|
RangeType *new = DatumGetRangeType(newentry->key); |
||||||
|
RangeType *s_union = range_super_union(fcinfo, orig, new); |
||||||
|
|
||||||
|
FmgrInfo *subtype_diff; |
||||||
|
|
||||||
|
RangeBound lower1, lower2; |
||||||
|
RangeBound upper1, upper2; |
||||||
|
bool empty1, empty2; |
||||||
|
|
||||||
|
float lower_diff, upper_diff; |
||||||
|
|
||||||
|
RangeTypeInfo rngtypinfo; |
||||||
|
|
||||||
|
range_deserialize(fcinfo, orig, &lower1, &upper1, &empty1); |
||||||
|
range_deserialize(fcinfo, s_union, &lower2, &upper2, &empty2); |
||||||
|
|
||||||
|
range_gettypinfo(fcinfo, lower1.rngtypid, &rngtypinfo); |
||||||
|
subtype_diff = &rngtypinfo.subdiffFn; |
||||||
|
|
||||||
|
Assert(empty1 || !empty2); |
||||||
|
|
||||||
|
if (empty1 && empty2) |
||||||
|
return 0; |
||||||
|
else if (empty1 && !empty2) |
||||||
|
{ |
||||||
|
if (lower2.infinite || upper2.infinite) |
||||||
|
/* from empty to infinite */ |
||||||
|
return get_float8_infinity(); |
||||||
|
else if (subtype_diff->fn_addr != NULL) |
||||||
|
/* from empty to upper2-lower2 */ |
||||||
|
return DatumGetFloat8(FunctionCall2(subtype_diff, |
||||||
|
upper2.val, lower2.val)); |
||||||
|
else |
||||||
|
/* wild guess */ |
||||||
|
return 1.0; |
||||||
|
} |
||||||
|
|
||||||
|
Assert(lower2.infinite || !lower1.infinite); |
||||||
|
|
||||||
|
if (lower2.infinite && !lower1.infinite) |
||||||
|
lower_diff = get_float8_infinity(); |
||||||
|
else if (lower2.infinite && lower1.infinite) |
||||||
|
lower_diff = 0; |
||||||
|
else if (subtype_diff->fn_addr != NULL) |
||||||
|
{ |
||||||
|
lower_diff = DatumGetFloat8(FunctionCall2(subtype_diff, |
||||||
|
lower1.val, lower2.val)); |
||||||
|
if (lower_diff < 0) |
||||||
|
lower_diff = 0; /* subtype_diff is broken */ |
||||||
|
} |
||||||
|
else /* only know whether there is a difference or not */ |
||||||
|
lower_diff = (float) range_cmp_bounds(fcinfo, &lower1, &lower2); |
||||||
|
|
||||||
|
Assert(upper2.infinite || !upper1.infinite); |
||||||
|
|
||||||
|
if (upper2.infinite && !upper1.infinite) |
||||||
|
upper_diff = get_float8_infinity(); |
||||||
|
else if (upper2.infinite && upper1.infinite) |
||||||
|
upper_diff = 0; |
||||||
|
else if (subtype_diff->fn_addr != NULL) |
||||||
|
{ |
||||||
|
upper_diff = DatumGetFloat8(FunctionCall2(subtype_diff, |
||||||
|
upper2.val, upper1.val)); |
||||||
|
if (upper_diff < 0) |
||||||
|
upper_diff = 0; /* subtype_diff is broken */ |
||||||
|
} |
||||||
|
else /* only know whether there is a difference or not */ |
||||||
|
upper_diff = (float) range_cmp_bounds(fcinfo, &upper2, &upper1); |
||||||
|
|
||||||
|
Assert(lower_diff >= 0 && upper_diff >= 0); |
||||||
|
|
||||||
|
*penalty = (float) (lower_diff + upper_diff); |
||||||
|
PG_RETURN_POINTER(penalty); |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
* The GiST PickSplit method for ranges |
||||||
|
* |
||||||
|
* Algorithm based on sorting. Incoming array of periods is sorted using |
||||||
|
* sort_item_cmp function. After that first half of periods goes to the left |
||||||
|
* datum, and the second half of periods goes to the right datum. |
||||||
|
*/ |
||||||
|
Datum |
||||||
|
range_gist_picksplit(PG_FUNCTION_ARGS) |
||||||
|
{ |
||||||
|
GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); |
||||||
|
GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1); |
||||||
|
OffsetNumber i; |
||||||
|
RangeType *pred_left; |
||||||
|
RangeType *pred_right; |
||||||
|
PickSplitSortItem *sortItems; |
||||||
|
int nbytes; |
||||||
|
OffsetNumber split_idx; |
||||||
|
OffsetNumber *left; |
||||||
|
OffsetNumber *right; |
||||||
|
OffsetNumber maxoff; |
||||||
|
|
||||||
|
maxoff = entryvec->n - 1; |
||||||
|
nbytes = (maxoff + 1) * sizeof(OffsetNumber); |
||||||
|
sortItems = (PickSplitSortItem *) palloc( |
||||||
|
maxoff * sizeof(PickSplitSortItem)); |
||||||
|
v->spl_left = (OffsetNumber *) palloc(nbytes); |
||||||
|
v->spl_right = (OffsetNumber *) palloc(nbytes); |
||||||
|
|
||||||
|
/*
|
||||||
|
* Preparing auxiliary array and sorting. |
||||||
|
*/ |
||||||
|
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) |
||||||
|
{ |
||||||
|
sortItems[i - 1].index = i; |
||||||
|
sortItems[i - 1].data = DatumGetRangeType(entryvec->vector[i].key); |
||||||
|
sortItems[i - 1].fcinfo = fcinfo; |
||||||
|
} |
||||||
|
qsort(sortItems, maxoff, sizeof(PickSplitSortItem), sort_item_cmp); |
||||||
|
split_idx = maxoff / 2; |
||||||
|
|
||||||
|
left = v->spl_left; |
||||||
|
v->spl_nleft = 0; |
||||||
|
right = v->spl_right; |
||||||
|
v->spl_nright = 0; |
||||||
|
|
||||||
|
/*
|
||||||
|
* First half of segs goes to the left datum. |
||||||
|
*/ |
||||||
|
pred_left = DatumGetRangeType(sortItems[0].data); |
||||||
|
*left++ = sortItems[0].index; |
||||||
|
v->spl_nleft++; |
||||||
|
for (i = 1; i < split_idx; i++) |
||||||
|
{ |
||||||
|
pred_left = range_super_union(fcinfo, pred_left, |
||||||
|
DatumGetRangeType(sortItems[i].data)); |
||||||
|
*left++ = sortItems[i].index; |
||||||
|
v->spl_nleft++; |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
* Second half of segs goes to the right datum. |
||||||
|
*/ |
||||||
|
pred_right = DatumGetRangeType(sortItems[split_idx].data); |
||||||
|
*right++ = sortItems[split_idx].index; |
||||||
|
v->spl_nright++; |
||||||
|
for (i = split_idx + 1; i < maxoff; i++) |
||||||
|
{ |
||||||
|
pred_right = range_super_union(fcinfo, pred_right, |
||||||
|
DatumGetRangeType(sortItems[i].data)); |
||||||
|
*right++ = sortItems[i].index; |
||||||
|
v->spl_nright++; |
||||||
|
} |
||||||
|
|
||||||
|
*left = *right = FirstOffsetNumber; /* sentinel value, see dosplit() */ |
||||||
|
|
||||||
|
v->spl_ldatum = RangeTypeGetDatum(pred_left); |
||||||
|
v->spl_rdatum = RangeTypeGetDatum(pred_right); |
||||||
|
|
||||||
|
PG_RETURN_POINTER(v); |
||||||
|
} |
||||||
|
|
||||||
|
Datum |
||||||
|
range_gist_same(PG_FUNCTION_ARGS) |
||||||
|
{ |
||||||
|
Datum r1 = PG_GETARG_DATUM(0); |
||||||
|
Datum r2 = PG_GETARG_DATUM(1); |
||||||
|
bool *result = (bool *) PG_GETARG_POINTER(2); |
||||||
|
|
||||||
|
*result = DatumGetBool(OidFunctionCall2(F_RANGE_EQ, r1, r2)); |
||||||
|
PG_RETURN_POINTER(result); |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
*---------------------------------------------------------- |
||||||
|
* STATIC FUNCTIONS |
||||||
|
*---------------------------------------------------------- |
||||||
|
*/ |
||||||
|
|
||||||
|
/* return the smallest range that contains r1 and r2 */ |
||||||
|
static RangeType * |
||||||
|
range_super_union(FunctionCallInfo fcinfo, RangeType *r1, RangeType *r2) |
||||||
|
{ |
||||||
|
RangeBound lower1, lower2; |
||||||
|
RangeBound upper1, upper2; |
||||||
|
bool empty1, empty2; |
||||||
|
RangeBound *result_lower; |
||||||
|
RangeBound *result_upper; |
||||||
|
|
||||||
|
range_deserialize(fcinfo, r1, &lower1, &upper1, &empty1); |
||||||
|
range_deserialize(fcinfo, r2, &lower2, &upper2, &empty2); |
||||||
|
|
||||||
|
if (empty1) |
||||||
|
return r2; |
||||||
|
if (empty2) |
||||||
|
return r1; |
||||||
|
|
||||||
|
if (range_cmp_bounds(fcinfo, &lower1, &lower2) <= 0) |
||||||
|
result_lower = &lower1; |
||||||
|
else |
||||||
|
result_lower = &lower2; |
||||||
|
|
||||||
|
if (range_cmp_bounds(fcinfo, &upper1, &upper2) >= 0) |
||||||
|
result_upper = &upper1; |
||||||
|
else |
||||||
|
result_upper = &upper2; |
||||||
|
|
||||||
|
/* optimization to avoid constructing a new range */ |
||||||
|
if (result_lower == &lower1 && result_upper == &upper1) |
||||||
|
return r1; |
||||||
|
if (result_lower == &lower2 && result_upper == &upper2) |
||||||
|
return r2; |
||||||
|
|
||||||
|
return DatumGetRangeType( |
||||||
|
make_range(fcinfo, result_lower, result_upper, false)); |
||||||
|
} |
||||||
|
|
||||||
|
static bool |
||||||
|
range_gist_consistent_int(FunctionCallInfo fcinfo, StrategyNumber strategy, |
||||||
|
RangeType *key, RangeType *query) |
||||||
|
{ |
||||||
|
Oid proc = InvalidOid; |
||||||
|
|
||||||
|
RangeBound lower1, lower2; |
||||||
|
RangeBound upper1, upper2; |
||||||
|
bool empty1, empty2; |
||||||
|
|
||||||
|
bool retval; |
||||||
|
bool negate = false; |
||||||
|
|
||||||
|
range_deserialize(fcinfo, key, &lower1, &upper1, &empty1); |
||||||
|
range_deserialize(fcinfo, query, &lower2, &upper2, &empty2); |
||||||
|
|
||||||
|
switch (strategy) |
||||||
|
{ |
||||||
|
case RANGESTRAT_EQ: |
||||||
|
proc = F_RANGE_CONTAINS; |
||||||
|
break; |
||||||
|
case RANGESTRAT_NE: |
||||||
|
return true; |
||||||
|
break; |
||||||
|
case RANGESTRAT_OVERLAPS: |
||||||
|
proc = F_RANGE_OVERLAPS; |
||||||
|
break; |
||||||
|
case RANGESTRAT_CONTAINS_ELEM: |
||||||
|
case RANGESTRAT_CONTAINS: |
||||||
|
proc = F_RANGE_CONTAINS; |
||||||
|
break; |
||||||
|
case RANGESTRAT_ELEM_CONTAINED_BY: |
||||||
|
case RANGESTRAT_CONTAINED_BY: |
||||||
|
return true; |
||||||
|
break; |
||||||
|
case RANGESTRAT_BEFORE: |
||||||
|
if (empty1) |
||||||
|
return false; |
||||||
|
proc = F_RANGE_OVERRIGHT; |
||||||
|
negate = true; |
||||||
|
break; |
||||||
|
case RANGESTRAT_AFTER: |
||||||
|
if (empty1) |
||||||
|
return false; |
||||||
|
proc = F_RANGE_OVERLEFT; |
||||||
|
negate = true; |
||||||
|
break; |
||||||
|
case RANGESTRAT_OVERLEFT: |
||||||
|
if (empty1) |
||||||
|
return false; |
||||||
|
proc = F_RANGE_AFTER; |
||||||
|
negate = true; |
||||||
|
break; |
||||||
|
case RANGESTRAT_OVERRIGHT: |
||||||
|
if (empty1) |
||||||
|
return false; |
||||||
|
proc = F_RANGE_BEFORE; |
||||||
|
negate = true; |
||||||
|
break; |
||||||
|
case RANGESTRAT_ADJACENT: |
||||||
|
if (empty1 || empty2) |
||||||
|
return false; |
||||||
|
if (DatumGetBool( |
||||||
|
OidFunctionCall2(F_RANGE_ADJACENT, |
||||||
|
RangeTypeGetDatum(key), |
||||||
|
RangeTypeGetDatum(query)))) |
||||||
|
return true; |
||||||
|
proc = F_RANGE_OVERLAPS; |
||||||
|
break; |
||||||
|
} |
||||||
|
|
||||||
|
retval = DatumGetBool(OidFunctionCall2(proc, RangeTypeGetDatum(key), |
||||||
|
RangeTypeGetDatum(query))); |
||||||
|
|
||||||
|
if (negate) |
||||||
|
retval = !retval; |
||||||
|
|
||||||
|
PG_RETURN_BOOL(retval); |
||||||
|
} |
||||||
|
|
||||||
|
static bool |
||||||
|
range_gist_consistent_leaf(FunctionCallInfo fcinfo, StrategyNumber strategy, |
||||||
|
RangeType *key, RangeType *query) |
||||||
|
{ |
||||||
|
Oid proc = InvalidOid; |
||||||
|
|
||||||
|
RangeBound lower1, lower2; |
||||||
|
RangeBound upper1, upper2; |
||||||
|
bool empty1, empty2; |
||||||
|
|
||||||
|
range_deserialize(fcinfo, key, &lower1, &upper1, &empty1); |
||||||
|
range_deserialize(fcinfo, query, &lower2, &upper2, &empty2); |
||||||
|
|
||||||
|
switch (strategy) |
||||||
|
{ |
||||||
|
case RANGESTRAT_EQ: |
||||||
|
proc = F_RANGE_EQ; |
||||||
|
break; |
||||||
|
case RANGESTRAT_NE: |
||||||
|
proc = F_RANGE_NE; |
||||||
|
break; |
||||||
|
case RANGESTRAT_OVERLAPS: |
||||||
|
proc = F_RANGE_OVERLAPS; |
||||||
|
break; |
||||||
|
case RANGESTRAT_CONTAINS_ELEM: |
||||||
|
case RANGESTRAT_CONTAINS: |
||||||
|
proc = F_RANGE_CONTAINS; |
||||||
|
break; |
||||||
|
case RANGESTRAT_ELEM_CONTAINED_BY: |
||||||
|
case RANGESTRAT_CONTAINED_BY: |
||||||
|
proc = F_RANGE_CONTAINED_BY; |
||||||
|
break; |
||||||
|
case RANGESTRAT_BEFORE: |
||||||
|
if (empty1 || empty2) |
||||||
|
return false; |
||||||
|
proc = F_RANGE_BEFORE; |
||||||
|
break; |
||||||
|
case RANGESTRAT_AFTER: |
||||||
|
if (empty1 || empty2) |
||||||
|
return false; |
||||||
|
proc = F_RANGE_AFTER; |
||||||
|
break; |
||||||
|
case RANGESTRAT_OVERLEFT: |
||||||
|
if (empty1 || empty2) |
||||||
|
return false; |
||||||
|
proc = F_RANGE_OVERLEFT; |
||||||
|
break; |
||||||
|
case RANGESTRAT_OVERRIGHT: |
||||||
|
if (empty1 || empty2) |
||||||
|
return false; |
||||||
|
proc = F_RANGE_OVERRIGHT; |
||||||
|
break; |
||||||
|
case RANGESTRAT_ADJACENT: |
||||||
|
if (empty1 || empty2) |
||||||
|
return false; |
||||||
|
proc = F_RANGE_ADJACENT; |
||||||
|
break; |
||||||
|
} |
||||||
|
|
||||||
|
return DatumGetBool(OidFunctionCall2(proc, RangeTypeGetDatum(key), |
||||||
|
RangeTypeGetDatum(query))); |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
* Compare function for PickSplitSortItem. This is actually the |
||||||
|
* interesting part of the picksplit algorithm. |
||||||
|
* |
||||||
|
* We want to separate out empty ranges, bounded ranges, and unbounded |
||||||
|
* ranges. We assume that "contains" and "overlaps" are the most |
||||||
|
* important queries, so empty ranges will rarely match and unbounded |
||||||
|
* ranges frequently will. Bounded ranges should be in the middle. |
||||||
|
* |
||||||
|
* Empty ranges we push all the way to the left, then bounded ranges |
||||||
|
* (sorted on lower bound, then upper), then ranges with no lower |
||||||
|
* bound, then ranges with no upper bound; and finally, ranges with no |
||||||
|
* upper or lower bound all the way to the right. |
||||||
|
*/ |
||||||
|
static int |
||||||
|
sort_item_cmp(const void *a, const void *b) |
||||||
|
{ |
||||||
|
PickSplitSortItem *i1 = (PickSplitSortItem *)a; |
||||||
|
PickSplitSortItem *i2 = (PickSplitSortItem *)b; |
||||||
|
RangeType *r1 = i1->data; |
||||||
|
RangeType *r2 = i2->data; |
||||||
|
|
||||||
|
RangeBound lower1, lower2; |
||||||
|
RangeBound upper1, upper2; |
||||||
|
bool empty1, empty2; |
||||||
|
|
||||||
|
FunctionCallInfo fcinfo = i1->fcinfo; |
||||||
|
|
||||||
|
int cmp; |
||||||
|
|
||||||
|
range_deserialize(fcinfo, r1, &lower1, &upper1, &empty1); |
||||||
|
range_deserialize(fcinfo, r2, &lower2, &upper2, &empty2); |
||||||
|
|
||||||
|
if (empty1 || empty2) |
||||||
|
{ |
||||||
|
if (empty1 && empty2) |
||||||
|
return 0; |
||||||
|
else if (empty1) |
||||||
|
return -1; |
||||||
|
else if (empty2) |
||||||
|
return 1; |
||||||
|
else |
||||||
|
Assert(false); |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
* If both lower or both upper bounds are infinite, we sort by |
||||||
|
* ascending range size. That means that if both upper bounds are |
||||||
|
* infinite, we sort by the lower bound _descending_. That creates |
||||||
|
* a slightly odd total order, but keeps the pages with very |
||||||
|
* unselective predicates grouped more closely together on the |
||||||
|
* right. |
||||||
|
*/ |
||||||
|
if (lower1.infinite || upper1.infinite || |
||||||
|
lower2.infinite || upper2.infinite) |
||||||
|
{ |
||||||
|
if (lower1.infinite && lower2.infinite) |
||||||
|
return range_cmp_bounds(fcinfo, &upper1, &upper2); |
||||||
|
else if (lower1.infinite) |
||||||
|
return -1; |
||||||
|
else if (lower2.infinite) |
||||||
|
return 1; |
||||||
|
else if (upper1.infinite && upper2.infinite) |
||||||
|
return -1 * range_cmp_bounds(fcinfo, &lower1, &lower2); |
||||||
|
else if (upper1.infinite) |
||||||
|
return 1; |
||||||
|
else if (upper2.infinite) |
||||||
|
return -1; |
||||||
|
else |
||||||
|
Assert(false); |
||||||
|
} |
||||||
|
|
||||||
|
if ((cmp = range_cmp_bounds(fcinfo, &lower1, &lower2)) != 0) |
||||||
|
return cmp; |
||||||
|
|
||||||
|
return range_cmp_bounds(fcinfo, &upper1, &upper2); |
||||||
|
} |
||||||
@ -0,0 +1,84 @@ |
|||||||
|
/*-------------------------------------------------------------------------
|
||||||
|
* |
||||||
|
* pg_range.h |
||||||
|
* definition of the system "range" relation (pg_range) |
||||||
|
* along with the relation's initial contents. |
||||||
|
* |
||||||
|
* |
||||||
|
* Copyright (c) 2006-2010, PostgreSQL Global Development Group |
||||||
|
* |
||||||
|
* src/include/catalog/pg_range.h |
||||||
|
* |
||||||
|
* NOTES |
||||||
|
* the genbki.pl script reads this file and generates .bki |
||||||
|
* information from the DATA() statements. |
||||||
|
* |
||||||
|
* XXX do NOT break up DATA() statements into multiple lines! |
||||||
|
* the scripts are not as smart as you might think... |
||||||
|
* |
||||||
|
*------------------------------------------------------------------------- |
||||||
|
*/ |
||||||
|
#ifndef PG_RANGE_H |
||||||
|
#define PG_RANGE_H |
||||||
|
|
||||||
|
#include "catalog/genbki.h" |
||||||
|
|
||||||
|
/* ----------------
|
||||||
|
* pg_range definition. cpp turns this into |
||||||
|
* typedef struct FormData_pg_range |
||||||
|
* ---------------- |
||||||
|
*/ |
||||||
|
#define RangeRelationId 3541 |
||||||
|
|
||||||
|
CATALOG(pg_range,3541) BKI_WITHOUT_OIDS |
||||||
|
{ |
||||||
|
Oid rngtypid; /* OID of owning range type */ |
||||||
|
Oid rngsubtype; /* OID of range's subtype */ |
||||||
|
Oid rngcollation; /* collation for this range type, or 0 */ |
||||||
|
Oid rngsubopc; /* subtype's btree opclass */ |
||||||
|
regproc rngcanonical; /* canonicalize range, or 0 */ |
||||||
|
regproc rngsubdiff; /* subtype difference as a float8 (for GiST) */ |
||||||
|
} FormData_pg_range; |
||||||
|
|
||||||
|
/* ----------------
|
||||||
|
* Form_pg_range corresponds to a pointer to a tuple with |
||||||
|
* the format of pg_range relation. |
||||||
|
* ---------------- |
||||||
|
*/ |
||||||
|
typedef FormData_pg_range *Form_pg_range; |
||||||
|
|
||||||
|
/* ----------------
|
||||||
|
* compiler constants for pg_range |
||||||
|
* ---------------- |
||||||
|
*/ |
||||||
|
#define Natts_pg_range 6 |
||||||
|
#define Anum_pg_range_rngtypid 1 |
||||||
|
#define Anum_pg_range_rngsubtype 2 |
||||||
|
#define Anum_pg_range_rngcollation 3 |
||||||
|
#define Anum_pg_range_rngsubopc 4 |
||||||
|
#define Anum_pg_range_rngcanonical 5 |
||||||
|
#define Anum_pg_range_rngsubdiff 6 |
||||||
|
|
||||||
|
#define RANGE_DEFAULT_FLAGS "[)" |
||||||
|
|
||||||
|
/*
|
||||||
|
* prototypes for functions in pg_range.c |
||||||
|
*/ |
||||||
|
|
||||||
|
extern void RangeCreate(Oid rangeTypeOid, Oid rangeSubType, Oid rangeCollation, |
||||||
|
Oid rangeSubOpclass, RegProcedure rangeCanonical, |
||||||
|
RegProcedure rangeSubDiff); |
||||||
|
extern void RangeDelete(Oid rangeTypeOid); |
||||||
|
|
||||||
|
/* ----------------
|
||||||
|
* initial contents of pg_range |
||||||
|
* ---------------- |
||||||
|
*/ |
||||||
|
DATA(insert ( 3904 23 0 1978 int4range_canonical int4range_subdiff)); |
||||||
|
DATA(insert ( 3906 1700 0 10037 - numrange_subdiff)); |
||||||
|
DATA(insert ( 3908 1114 0 10054 - tsrange_subdiff)); |
||||||
|
DATA(insert ( 3910 1184 0 10047 - tstzrange_subdiff)); |
||||||
|
DATA(insert ( 3912 1082 0 10019 daterange_canonical daterange_subdiff)); |
||||||
|
DATA(insert ( 3926 20 0 10029 int8range_canonical int8range_subdiff)); |
||||||
|
|
||||||
|
#endif /* PG_RANGE_H */ |
||||||
@ -0,0 +1,159 @@ |
|||||||
|
/*-------------------------------------------------------------------------
|
||||||
|
* |
||||||
|
* rangetypes.h |
||||||
|
* Declarations for Postgres range types. |
||||||
|
* |
||||||
|
*/ |
||||||
|
|
||||||
|
#ifndef RANGETYPES_H |
||||||
|
#define RANGETYPES_H |
||||||
|
|
||||||
|
#include "fmgr.h" |
||||||
|
|
||||||
|
typedef struct varlena RangeType; |
||||||
|
|
||||||
|
typedef struct |
||||||
|
{ |
||||||
|
Datum val; |
||||||
|
Oid rngtypid; |
||||||
|
bool infinite; |
||||||
|
bool lower; |
||||||
|
bool inclusive; |
||||||
|
} RangeBound; |
||||||
|
|
||||||
|
typedef struct |
||||||
|
{ |
||||||
|
FmgrInfo canonicalFn; |
||||||
|
FmgrInfo cmpFn; |
||||||
|
FmgrInfo subdiffFn; |
||||||
|
Oid rngtypid; |
||||||
|
Oid subtype; |
||||||
|
Oid collation; |
||||||
|
int16 subtyplen; |
||||||
|
char subtypalign; |
||||||
|
char subtypstorage; |
||||||
|
bool subtypbyval; |
||||||
|
} RangeTypeInfo; |
||||||
|
|
||||||
|
/*
|
||||||
|
* fmgr macros for range type objects |
||||||
|
*/ |
||||||
|
#define DatumGetRangeType(X) ((RangeType *) PG_DETOAST_DATUM(X)) |
||||||
|
#define DatumGetRangeTypeCopy(X) ((RangeType *) PG_DETOAST_DATUM_COPY(X)) |
||||||
|
#define RangeTypeGetDatum(X) PointerGetDatum(X) |
||||||
|
#define PG_GETARG_RANGE(n) DatumGetRangeType(PG_GETARG_DATUM(n)) |
||||||
|
#define PG_GETARG_RANGE_COPY(n) DatumGetRangeTypeCopy(PG_GETARG_DATUM(n)) |
||||||
|
#define PG_RETURN_RANGE(x) return RangeTypeGetDatum(x) |
||||||
|
|
||||||
|
/*
|
||||||
|
* prototypes for functions defined in rangetypes.c |
||||||
|
*/ |
||||||
|
|
||||||
|
/* IO */ |
||||||
|
extern Datum anyrange_in(PG_FUNCTION_ARGS); |
||||||
|
extern Datum anyrange_out(PG_FUNCTION_ARGS); |
||||||
|
extern Datum range_in(PG_FUNCTION_ARGS); |
||||||
|
extern Datum range_out(PG_FUNCTION_ARGS); |
||||||
|
extern Datum range_recv(PG_FUNCTION_ARGS); |
||||||
|
extern Datum range_send(PG_FUNCTION_ARGS); |
||||||
|
|
||||||
|
/* constructors */ |
||||||
|
extern Datum range_constructor0(PG_FUNCTION_ARGS); |
||||||
|
extern Datum range_constructor1(PG_FUNCTION_ARGS); |
||||||
|
extern Datum range_constructor2(PG_FUNCTION_ARGS); |
||||||
|
extern Datum range_constructor3(PG_FUNCTION_ARGS); |
||||||
|
extern Datum range_make1(PG_FUNCTION_ARGS); |
||||||
|
extern Datum range_linf_(PG_FUNCTION_ARGS); |
||||||
|
extern Datum range_uinf_(PG_FUNCTION_ARGS); |
||||||
|
extern Datum range_linfi(PG_FUNCTION_ARGS); |
||||||
|
extern Datum range_uinfi(PG_FUNCTION_ARGS); |
||||||
|
extern Datum range(PG_FUNCTION_ARGS); |
||||||
|
extern Datum range__(PG_FUNCTION_ARGS); |
||||||
|
extern Datum range_i(PG_FUNCTION_ARGS); |
||||||
|
extern Datum rangei_(PG_FUNCTION_ARGS); |
||||||
|
extern Datum rangeii(PG_FUNCTION_ARGS); |
||||||
|
|
||||||
|
/* range -> subtype */ |
||||||
|
extern Datum range_lower(PG_FUNCTION_ARGS); |
||||||
|
extern Datum range_upper(PG_FUNCTION_ARGS); |
||||||
|
|
||||||
|
/* range -> bool */ |
||||||
|
extern Datum range_empty(PG_FUNCTION_ARGS); |
||||||
|
extern Datum range_lower_inc(PG_FUNCTION_ARGS); |
||||||
|
extern Datum range_upper_inc(PG_FUNCTION_ARGS); |
||||||
|
extern Datum range_lower_inf(PG_FUNCTION_ARGS); |
||||||
|
extern Datum range_upper_inf(PG_FUNCTION_ARGS); |
||||||
|
|
||||||
|
/* range, point -> bool */ |
||||||
|
extern Datum range_contains_elem(PG_FUNCTION_ARGS); |
||||||
|
extern Datum elem_contained_by_range(PG_FUNCTION_ARGS); |
||||||
|
|
||||||
|
/* range, range -> bool */ |
||||||
|
extern Datum range_eq(PG_FUNCTION_ARGS); |
||||||
|
extern Datum range_ne(PG_FUNCTION_ARGS); |
||||||
|
extern Datum range_contains(PG_FUNCTION_ARGS); |
||||||
|
extern Datum range_contained_by(PG_FUNCTION_ARGS); |
||||||
|
extern Datum range_before(PG_FUNCTION_ARGS); |
||||||
|
extern Datum range_after(PG_FUNCTION_ARGS); |
||||||
|
extern Datum range_adjacent(PG_FUNCTION_ARGS); |
||||||
|
extern Datum range_overlaps(PG_FUNCTION_ARGS); |
||||||
|
extern Datum range_overleft(PG_FUNCTION_ARGS); |
||||||
|
extern Datum range_overright(PG_FUNCTION_ARGS); |
||||||
|
|
||||||
|
/* range, range -> range */ |
||||||
|
extern Datum range_minus(PG_FUNCTION_ARGS); |
||||||
|
extern Datum range_union(PG_FUNCTION_ARGS); |
||||||
|
extern Datum range_intersect(PG_FUNCTION_ARGS); |
||||||
|
|
||||||
|
/* BTree support */ |
||||||
|
extern Datum range_cmp(PG_FUNCTION_ARGS); |
||||||
|
extern Datum range_lt(PG_FUNCTION_ARGS); |
||||||
|
extern Datum range_le(PG_FUNCTION_ARGS); |
||||||
|
extern Datum range_ge(PG_FUNCTION_ARGS); |
||||||
|
extern Datum range_gt(PG_FUNCTION_ARGS); |
||||||
|
|
||||||
|
/* Hash support */ |
||||||
|
extern Datum hash_range(PG_FUNCTION_ARGS); |
||||||
|
|
||||||
|
/* GiST support (rangetypes_gist.c) */ |
||||||
|
extern Datum range_gist_consistent(PG_FUNCTION_ARGS); |
||||||
|
extern Datum range_gist_compress(PG_FUNCTION_ARGS); |
||||||
|
extern Datum range_gist_decompress(PG_FUNCTION_ARGS); |
||||||
|
extern Datum range_gist_union(PG_FUNCTION_ARGS); |
||||||
|
extern Datum range_gist_penalty(PG_FUNCTION_ARGS); |
||||||
|
extern Datum range_gist_picksplit(PG_FUNCTION_ARGS); |
||||||
|
extern Datum range_gist_same(PG_FUNCTION_ARGS); |
||||||
|
|
||||||
|
/* Canonical functions */ |
||||||
|
Datum int4range_canonical(PG_FUNCTION_ARGS); |
||||||
|
Datum int8range_canonical(PG_FUNCTION_ARGS); |
||||||
|
Datum daterange_canonical(PG_FUNCTION_ARGS); |
||||||
|
|
||||||
|
/* Subtype Difference functions */ |
||||||
|
Datum int4range_subdiff(PG_FUNCTION_ARGS); |
||||||
|
Datum int8range_subdiff(PG_FUNCTION_ARGS); |
||||||
|
Datum numrange_subdiff(PG_FUNCTION_ARGS); |
||||||
|
Datum daterange_subdiff(PG_FUNCTION_ARGS); |
||||||
|
Datum tsrange_subdiff(PG_FUNCTION_ARGS); |
||||||
|
Datum tstzrange_subdiff(PG_FUNCTION_ARGS); |
||||||
|
|
||||||
|
/* for defining more generic functions */ |
||||||
|
extern Datum make_range(FunctionCallInfo fcinfo, RangeBound *lower, |
||||||
|
RangeBound *upper, bool empty); |
||||||
|
extern void range_deserialize(FunctionCallInfo fcinfo, RangeType *range, |
||||||
|
RangeBound *lower, RangeBound *upper, |
||||||
|
bool *empty); |
||||||
|
extern int range_cmp_bounds(FunctionCallInfo fcinfo, RangeBound *b1, |
||||||
|
RangeBound *b2); |
||||||
|
extern RangeType *make_empty_range(FunctionCallInfo fcinfo, Oid rngtypid); |
||||||
|
extern void range_gettypinfo(FunctionCallInfo fcinfo, Oid rngtypid, |
||||||
|
RangeTypeInfo *rngtypinfo); |
||||||
|
|
||||||
|
/* for defining a range "canonicalize" function */ |
||||||
|
extern Datum range_serialize(FunctionCallInfo fcinfo, RangeBound *lower, |
||||||
|
RangeBound *upper, bool empty); |
||||||
|
|
||||||
|
/* for use in DefineRange */ |
||||||
|
extern char range_parse_flags(char *flags_str); |
||||||
|
|
||||||
|
#endif /* RANGETYPES_H */ |
||||||
@ -0,0 +1,951 @@ |
|||||||
|
-- |
||||||
|
-- test parser |
||||||
|
-- |
||||||
|
create type textrange as range (subtype=text, collation="C"); |
||||||
|
-- negative tests; should fail |
||||||
|
select ''::textrange; |
||||||
|
ERROR: malformed range literal: "" |
||||||
|
LINE 1: select ''::textrange; |
||||||
|
^ |
||||||
|
DETAIL: Missing left parenthesis or bracket. |
||||||
|
select '-[a,z)'::textrange; |
||||||
|
ERROR: malformed range literal: "-[a,z)" |
||||||
|
LINE 1: select '-[a,z)'::textrange; |
||||||
|
^ |
||||||
|
DETAIL: Missing left parenthesis or bracket. |
||||||
|
select '[a,z) - '::textrange; |
||||||
|
ERROR: malformed range literal: "[a,z) - " |
||||||
|
LINE 1: select '[a,z) - '::textrange; |
||||||
|
^ |
||||||
|
DETAIL: Junk after right parenthesis or bracket. |
||||||
|
select '(",a)'::textrange; |
||||||
|
ERROR: malformed range literal: "(",a)" |
||||||
|
LINE 1: select '(",a)'::textrange; |
||||||
|
^ |
||||||
|
DETAIL: Unexpected end of input. |
||||||
|
select '(,,a)'::textrange; |
||||||
|
ERROR: malformed range literal: "(,,a)" |
||||||
|
LINE 1: select '(,,a)'::textrange; |
||||||
|
^ |
||||||
|
DETAIL: Too many boundaries. |
||||||
|
select '(),a)'::textrange; |
||||||
|
ERROR: malformed range literal: "(),a)" |
||||||
|
LINE 1: select '(),a)'::textrange; |
||||||
|
^ |
||||||
|
DETAIL: Missing upper bound. |
||||||
|
select '(a,))'::textrange; |
||||||
|
ERROR: malformed range literal: "(a,))" |
||||||
|
LINE 1: select '(a,))'::textrange; |
||||||
|
^ |
||||||
|
DETAIL: Junk after right parenthesis or bracket. |
||||||
|
select '(],a)'::textrange; |
||||||
|
ERROR: malformed range literal: "(],a)" |
||||||
|
LINE 1: select '(],a)'::textrange; |
||||||
|
^ |
||||||
|
DETAIL: Missing upper bound. |
||||||
|
select '(a,])'::textrange; |
||||||
|
ERROR: malformed range literal: "(a,])" |
||||||
|
LINE 1: select '(a,])'::textrange; |
||||||
|
^ |
||||||
|
DETAIL: Junk after right parenthesis or bracket. |
||||||
|
-- should succeed |
||||||
|
select ' empty '::textrange; |
||||||
|
textrange |
||||||
|
----------- |
||||||
|
empty |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select ' ( empty, empty ) '::textrange; |
||||||
|
textrange |
||||||
|
---------------------- |
||||||
|
(" empty"," empty ") |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select ' ( " a " " a ", " z " " z " ) '::textrange; |
||||||
|
textrange |
||||||
|
-------------------------- |
||||||
|
(" a a "," z z ") |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select '(,z)'::textrange; |
||||||
|
textrange |
||||||
|
----------- |
||||||
|
(,z) |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select '(a,)'::textrange; |
||||||
|
textrange |
||||||
|
----------- |
||||||
|
(a,) |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select '[,z]'::textrange; |
||||||
|
textrange |
||||||
|
----------- |
||||||
|
(,z] |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select '[a,]'::textrange; |
||||||
|
textrange |
||||||
|
----------- |
||||||
|
[a,) |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select '( , )'::textrange; |
||||||
|
textrange |
||||||
|
----------- |
||||||
|
(" "," ") |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select '("","")'::textrange; |
||||||
|
textrange |
||||||
|
----------- |
||||||
|
("","") |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select '["",""]'::textrange; |
||||||
|
textrange |
||||||
|
----------- |
||||||
|
["",""] |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select '(",",",")'::textrange; |
||||||
|
textrange |
||||||
|
----------- |
||||||
|
(",",",") |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select '("\\","\\")'::textrange |
||||||
|
select '(\\,a)'::textrange; |
||||||
|
ERROR: syntax error at or near "select" |
||||||
|
LINE 2: select '(\\,a)'::textrange; |
||||||
|
^ |
||||||
|
select '((,z)'::textrange; |
||||||
|
textrange |
||||||
|
----------- |
||||||
|
("(",z) |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select '([,z)'::textrange; |
||||||
|
textrange |
||||||
|
----------- |
||||||
|
("[",z) |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select '(!,()'::textrange; |
||||||
|
textrange |
||||||
|
----------- |
||||||
|
(!,"(") |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select '(!,[)'::textrange; |
||||||
|
textrange |
||||||
|
----------- |
||||||
|
(!,"[") |
||||||
|
(1 row) |
||||||
|
|
||||||
|
drop type textrange; |
||||||
|
-- |
||||||
|
-- create some test data and test the operators |
||||||
|
-- |
||||||
|
CREATE TABLE numrange_test (nr NUMRANGE); |
||||||
|
create index numrange_test_btree on numrange_test(nr); |
||||||
|
SET enable_seqscan = f; |
||||||
|
INSERT INTO numrange_test VALUES('[,)'); |
||||||
|
INSERT INTO numrange_test VALUES('[3,]'); |
||||||
|
INSERT INTO numrange_test VALUES('[, 5)'); |
||||||
|
INSERT INTO numrange_test VALUES(numrange(1.1, 2.2)); |
||||||
|
INSERT INTO numrange_test VALUES('empty'); |
||||||
|
INSERT INTO numrange_test VALUES(numrange(1.7)); |
||||||
|
SELECT isempty(nr) FROM numrange_test; |
||||||
|
isempty |
||||||
|
--------- |
||||||
|
f |
||||||
|
f |
||||||
|
f |
||||||
|
f |
||||||
|
t |
||||||
|
f |
||||||
|
(6 rows) |
||||||
|
|
||||||
|
SELECT lower_inc(nr), lower(nr), upper(nr), upper_inc(nr) FROM numrange_test |
||||||
|
WHERE NOT isempty(nr) AND NOT lower_inf(nr) AND NOT upper_inf(nr); |
||||||
|
lower_inc | lower | upper | upper_inc |
||||||
|
-----------+-------+-------+----------- |
||||||
|
t | 1.1 | 2.2 | f |
||||||
|
t | 1.7 | 1.7 | t |
||||||
|
(2 rows) |
||||||
|
|
||||||
|
SELECT * FROM numrange_test WHERE contains(nr, numrange(1.9,1.91)); |
||||||
|
nr |
||||||
|
----------- |
||||||
|
(,) |
||||||
|
(,5) |
||||||
|
[1.1,2.2) |
||||||
|
(3 rows) |
||||||
|
|
||||||
|
SELECT * FROM numrange_test WHERE nr @> numrange(1.0,10000.1); |
||||||
|
nr |
||||||
|
----- |
||||||
|
(,) |
||||||
|
(1 row) |
||||||
|
|
||||||
|
SELECT * FROM numrange_test WHERE contained_by(numrange(-1e7,-10000.1), nr); |
||||||
|
nr |
||||||
|
------ |
||||||
|
(,) |
||||||
|
(,5) |
||||||
|
(2 rows) |
||||||
|
|
||||||
|
SELECT * FROM numrange_test WHERE 1.9 <@ nr; |
||||||
|
nr |
||||||
|
----------- |
||||||
|
(,) |
||||||
|
(,5) |
||||||
|
[1.1,2.2) |
||||||
|
(3 rows) |
||||||
|
|
||||||
|
SELECT * FROM numrange_test WHERE nr = 'empty'; |
||||||
|
nr |
||||||
|
------- |
||||||
|
empty |
||||||
|
(1 row) |
||||||
|
|
||||||
|
SELECT * FROM numrange_test WHERE range_eq(nr, '(1.1, 2.2)'); |
||||||
|
nr |
||||||
|
---- |
||||||
|
(0 rows) |
||||||
|
|
||||||
|
SELECT * FROM numrange_test WHERE nr = '[1.1, 2.2)'; |
||||||
|
nr |
||||||
|
----------- |
||||||
|
[1.1,2.2) |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select numrange(2.0, 1.0); |
||||||
|
ERROR: range lower bound must be less than or equal to range upper bound |
||||||
|
select numrange(2.0, 3.0) -|- numrange(3.0, 4.0); |
||||||
|
?column? |
||||||
|
---------- |
||||||
|
t |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select adjacent(numrange(2.0, 3.0), numrange(3.1, 4.0)); |
||||||
|
adjacent |
||||||
|
---------- |
||||||
|
f |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select numrange(2.0, 3.0, '[]') -|- numrange(3.0, 4.0, '()'); |
||||||
|
?column? |
||||||
|
---------- |
||||||
|
t |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select numrange(1.0, 2.0) -|- numrange(2.0, 3.0,'[]'); |
||||||
|
?column? |
||||||
|
---------- |
||||||
|
t |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select adjacent(numrange(2.0, 3.0, '(]'), numrange(1.0, 2.0, '(]')); |
||||||
|
adjacent |
||||||
|
---------- |
||||||
|
t |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select numrange(1.1, 3.3) <@ numrange(0.1,10.1); |
||||||
|
?column? |
||||||
|
---------- |
||||||
|
t |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select numrange(0.1, 10.1) <@ numrange(1.1,3.3); |
||||||
|
?column? |
||||||
|
---------- |
||||||
|
f |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select numrange(1.1, 2.2) - numrange(2.0, 3.0); |
||||||
|
?column? |
||||||
|
----------- |
||||||
|
[1.1,2.0) |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select numrange(1.1, 2.2) - numrange(2.2, 3.0); |
||||||
|
?column? |
||||||
|
----------- |
||||||
|
[1.1,2.2) |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select numrange(1.1, 2.2,'[]') - numrange(2.0, 3.0); |
||||||
|
?column? |
||||||
|
----------- |
||||||
|
[1.1,2.0) |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select minus(numrange(10.1,12.2,'[]'), numrange(110.0,120.2,'(]')); |
||||||
|
minus |
||||||
|
------------- |
||||||
|
[10.1,12.2] |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select minus(numrange(10.1,12.2,'[]'), numrange(0.0,120.2,'(]')); |
||||||
|
minus |
||||||
|
------- |
||||||
|
empty |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select numrange(4.5, 5.5, '[]') && numrange(5.5, 6.5); |
||||||
|
?column? |
||||||
|
---------- |
||||||
|
t |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select numrange(1.0, 2.0) << numrange(3.0, 4.0); |
||||||
|
?column? |
||||||
|
---------- |
||||||
|
t |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select numrange(1.0, 2.0) >> numrange(3.0, 4.0); |
||||||
|
?column? |
||||||
|
---------- |
||||||
|
f |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select numrange(3.0, 70.0) &< numrange(6.6, 100.0); |
||||||
|
?column? |
||||||
|
---------- |
||||||
|
t |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select numrange(1.1, 2.2) < numrange(1.0, 200.2); |
||||||
|
?column? |
||||||
|
---------- |
||||||
|
f |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select numrange(1.1, 2.2) < numrange(1.1, 1.2); |
||||||
|
?column? |
||||||
|
---------- |
||||||
|
f |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select numrange(1.0, 2.0) + numrange(2.0, 3.0); |
||||||
|
?column? |
||||||
|
----------- |
||||||
|
[1.0,3.0) |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select numrange(1.0, 2.0) + numrange(1.5, 3.0); |
||||||
|
?column? |
||||||
|
----------- |
||||||
|
[1.0,3.0) |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select numrange(1.0, 2.0) + numrange(2.5, 3.0); |
||||||
|
ERROR: result range is not contiguous |
||||||
|
select numrange(1.0, 2.0) * numrange(2.0, 3.0); |
||||||
|
?column? |
||||||
|
---------- |
||||||
|
empty |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select numrange(1.0, 2.0) * numrange(1.5, 3.0); |
||||||
|
?column? |
||||||
|
----------- |
||||||
|
[1.5,2.0) |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select numrange(1.0, 2.0) * numrange(2.5, 3.0); |
||||||
|
?column? |
||||||
|
---------- |
||||||
|
empty |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select * from numrange_test where nr < numrange(-1000.0, -1000.0,'[]'); |
||||||
|
nr |
||||||
|
------- |
||||||
|
(,) |
||||||
|
(,5) |
||||||
|
empty |
||||||
|
(3 rows) |
||||||
|
|
||||||
|
select * from numrange_test where nr < numrange(0.0, 1.0,'[]'); |
||||||
|
nr |
||||||
|
------- |
||||||
|
(,) |
||||||
|
(,5) |
||||||
|
empty |
||||||
|
(3 rows) |
||||||
|
|
||||||
|
select * from numrange_test where nr < numrange(1000.0, 1001.0,'[]'); |
||||||
|
nr |
||||||
|
----------- |
||||||
|
(,) |
||||||
|
[3,) |
||||||
|
(,5) |
||||||
|
[1.1,2.2) |
||||||
|
empty |
||||||
|
[1.7,1.7] |
||||||
|
(6 rows) |
||||||
|
|
||||||
|
select * from numrange_test where nr > numrange(-1001.0, -1000.0,'[]'); |
||||||
|
nr |
||||||
|
----------- |
||||||
|
[3,) |
||||||
|
[1.1,2.2) |
||||||
|
[1.7,1.7] |
||||||
|
(3 rows) |
||||||
|
|
||||||
|
select * from numrange_test where nr > numrange(0.0, 1.0,'[]'); |
||||||
|
nr |
||||||
|
----------- |
||||||
|
[3,) |
||||||
|
[1.1,2.2) |
||||||
|
[1.7,1.7] |
||||||
|
(3 rows) |
||||||
|
|
||||||
|
select * from numrange_test where nr > numrange(1000.0, 1000.0,'[]'); |
||||||
|
nr |
||||||
|
---- |
||||||
|
(0 rows) |
||||||
|
|
||||||
|
create table numrange_test2(nr numrange); |
||||||
|
create index numrange_test2_hash_idx on numrange_test2 (nr); |
||||||
|
INSERT INTO numrange_test2 VALUES('[, 5)'); |
||||||
|
INSERT INTO numrange_test2 VALUES(numrange(1.1, 2.2)); |
||||||
|
INSERT INTO numrange_test2 VALUES(numrange(1.1, 2.2)); |
||||||
|
INSERT INTO numrange_test2 VALUES(numrange(1.1, 2.2,'()')); |
||||||
|
INSERT INTO numrange_test2 VALUES('empty'); |
||||||
|
select * from numrange_test2 where nr = 'empty'::numrange; |
||||||
|
nr |
||||||
|
------- |
||||||
|
empty |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select * from numrange_test2 where nr = numrange(1.1, 2.2); |
||||||
|
nr |
||||||
|
----------- |
||||||
|
[1.1,2.2) |
||||||
|
[1.1,2.2) |
||||||
|
(2 rows) |
||||||
|
|
||||||
|
select * from numrange_test2 where nr = numrange(1.1, 2.3); |
||||||
|
nr |
||||||
|
---- |
||||||
|
(0 rows) |
||||||
|
|
||||||
|
set enable_nestloop=t; |
||||||
|
set enable_hashjoin=f; |
||||||
|
set enable_mergejoin=f; |
||||||
|
select * from numrange_test natural join numrange_test2 order by nr; |
||||||
|
nr |
||||||
|
----------- |
||||||
|
empty |
||||||
|
(,5) |
||||||
|
[1.1,2.2) |
||||||
|
[1.1,2.2) |
||||||
|
(4 rows) |
||||||
|
|
||||||
|
set enable_nestloop=f; |
||||||
|
set enable_hashjoin=t; |
||||||
|
set enable_mergejoin=f; |
||||||
|
select * from numrange_test natural join numrange_test2 order by nr; |
||||||
|
nr |
||||||
|
----------- |
||||||
|
empty |
||||||
|
(,5) |
||||||
|
[1.1,2.2) |
||||||
|
[1.1,2.2) |
||||||
|
(4 rows) |
||||||
|
|
||||||
|
set enable_nestloop=f; |
||||||
|
set enable_hashjoin=f; |
||||||
|
set enable_mergejoin=t; |
||||||
|
select * from numrange_test natural join numrange_test2 order by nr; |
||||||
|
nr |
||||||
|
----------- |
||||||
|
empty |
||||||
|
(,5) |
||||||
|
[1.1,2.2) |
||||||
|
[1.1,2.2) |
||||||
|
(4 rows) |
||||||
|
|
||||||
|
set enable_nestloop to default; |
||||||
|
set enable_hashjoin to default; |
||||||
|
set enable_mergejoin to default; |
||||||
|
SET enable_seqscan TO DEFAULT; |
||||||
|
DROP TABLE numrange_test; |
||||||
|
DROP TABLE numrange_test2; |
||||||
|
-- test canonical form for int4range |
||||||
|
select int4range(1,10,'[]'); |
||||||
|
int4range |
||||||
|
----------- |
||||||
|
[1,11) |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select int4range(1,10,'[)'); |
||||||
|
int4range |
||||||
|
----------- |
||||||
|
[1,10) |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select int4range(1,10,'(]'); |
||||||
|
int4range |
||||||
|
----------- |
||||||
|
[2,11) |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select int4range(1,10,'[]'); |
||||||
|
int4range |
||||||
|
----------- |
||||||
|
[1,11) |
||||||
|
(1 row) |
||||||
|
|
||||||
|
-- test canonical form for daterange |
||||||
|
select daterange('2000-01-10'::date, '2000-01-20'::date,'[]'); |
||||||
|
daterange |
||||||
|
------------------------- |
||||||
|
[01-10-2000,01-21-2000) |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select daterange('2000-01-10'::date, '2000-01-20'::date,'[)'); |
||||||
|
daterange |
||||||
|
------------------------- |
||||||
|
[01-10-2000,01-20-2000) |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select daterange('2000-01-10'::date, '2000-01-20'::date,'(]'); |
||||||
|
daterange |
||||||
|
------------------------- |
||||||
|
[01-11-2000,01-21-2000) |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select daterange('2000-01-10'::date, '2000-01-20'::date,'[]'); |
||||||
|
daterange |
||||||
|
------------------------- |
||||||
|
[01-10-2000,01-21-2000) |
||||||
|
(1 row) |
||||||
|
|
||||||
|
create table test_range_gist(ir int4range); |
||||||
|
create index test_range_gist_idx on test_range_gist using gist (ir); |
||||||
|
insert into test_range_gist select int4range(g, g+10) from generate_series(1,2000) g; |
||||||
|
insert into test_range_gist select 'empty'::int4range from generate_series(1,500) g; |
||||||
|
insert into test_range_gist select int4range(g, g+10000) from generate_series(1,1000) g; |
||||||
|
insert into test_range_gist select 'empty'::int4range from generate_series(1,500) g; |
||||||
|
insert into test_range_gist select int4range(NULL,g*10,'(]') from generate_series(1,100) g; |
||||||
|
insert into test_range_gist select int4range(g*10,NULL,'(]') from generate_series(1,100) g; |
||||||
|
insert into test_range_gist select int4range(g, g+10) from generate_series(1,2000) g; |
||||||
|
BEGIN; |
||||||
|
SET LOCAL enable_seqscan = t; |
||||||
|
SET LOCAL enable_bitmapscan = f; |
||||||
|
SET LOCAL enable_indexscan = f; |
||||||
|
select count(*) from test_range_gist where ir @> 'empty'::int4range; |
||||||
|
count |
||||||
|
------- |
||||||
|
6200 |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select count(*) from test_range_gist where ir = int4range(10,20); |
||||||
|
count |
||||||
|
------- |
||||||
|
2 |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select count(*) from test_range_gist where ir @> 10; |
||||||
|
count |
||||||
|
------- |
||||||
|
130 |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select count(*) from test_range_gist where ir @> int4range(10,20); |
||||||
|
count |
||||||
|
------- |
||||||
|
111 |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select count(*) from test_range_gist where ir && int4range(10,20); |
||||||
|
count |
||||||
|
------- |
||||||
|
158 |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select count(*) from test_range_gist where ir <@ int4range(10,50); |
||||||
|
count |
||||||
|
------- |
||||||
|
1062 |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select count(*) from (select * from test_range_gist where not isempty(ir)) s where ir << int4range(100,500); |
||||||
|
count |
||||||
|
------- |
||||||
|
189 |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select count(*) from (select * from test_range_gist where not isempty(ir)) s where ir >> int4range(100,500); |
||||||
|
count |
||||||
|
------- |
||||||
|
3554 |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select count(*) from (select * from test_range_gist where not isempty(ir)) s where ir &< int4range(100,500); |
||||||
|
count |
||||||
|
------- |
||||||
|
1029 |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select count(*) from (select * from test_range_gist where not isempty(ir)) s where ir &> int4range(100,500); |
||||||
|
count |
||||||
|
------- |
||||||
|
4794 |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select count(*) from (select * from test_range_gist where not isempty(ir)) s where ir -|- int4range(100,500); |
||||||
|
count |
||||||
|
------- |
||||||
|
5 |
||||||
|
(1 row) |
||||||
|
|
||||||
|
COMMIT; |
||||||
|
BEGIN; |
||||||
|
SET LOCAL enable_seqscan = f; |
||||||
|
SET LOCAL enable_bitmapscan = f; |
||||||
|
SET LOCAL enable_indexscan = t; |
||||||
|
select count(*) from test_range_gist where ir @> 'empty'::int4range; |
||||||
|
count |
||||||
|
------- |
||||||
|
6200 |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select count(*) from test_range_gist where ir = int4range(10,20); |
||||||
|
count |
||||||
|
------- |
||||||
|
2 |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select count(*) from test_range_gist where ir @> 10; |
||||||
|
count |
||||||
|
------- |
||||||
|
130 |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select count(*) from test_range_gist where ir @> int4range(10,20); |
||||||
|
count |
||||||
|
------- |
||||||
|
111 |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select count(*) from test_range_gist where ir && int4range(10,20); |
||||||
|
count |
||||||
|
------- |
||||||
|
158 |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select count(*) from test_range_gist where ir <@ int4range(10,50); |
||||||
|
count |
||||||
|
------- |
||||||
|
1062 |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select count(*) from test_range_gist where ir << int4range(100,500); |
||||||
|
count |
||||||
|
------- |
||||||
|
189 |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select count(*) from test_range_gist where ir >> int4range(100,500); |
||||||
|
count |
||||||
|
------- |
||||||
|
3554 |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select count(*) from test_range_gist where ir &< int4range(100,500); |
||||||
|
count |
||||||
|
------- |
||||||
|
1029 |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select count(*) from test_range_gist where ir &> int4range(100,500); |
||||||
|
count |
||||||
|
------- |
||||||
|
4794 |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select count(*) from test_range_gist where ir -|- int4range(100,500); |
||||||
|
count |
||||||
|
------- |
||||||
|
5 |
||||||
|
(1 row) |
||||||
|
|
||||||
|
COMMIT; |
||||||
|
drop index test_range_gist_idx; |
||||||
|
create index test_range_gist_idx on test_range_gist using gist (ir); |
||||||
|
BEGIN; |
||||||
|
SET LOCAL enable_seqscan = f; |
||||||
|
SET LOCAL enable_bitmapscan = f; |
||||||
|
SET LOCAL enable_indexscan = t; |
||||||
|
select count(*) from test_range_gist where ir @> 'empty'::int4range; |
||||||
|
count |
||||||
|
------- |
||||||
|
6200 |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select count(*) from test_range_gist where ir = int4range(10,20); |
||||||
|
count |
||||||
|
------- |
||||||
|
2 |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select count(*) from test_range_gist where ir @> 10; |
||||||
|
count |
||||||
|
------- |
||||||
|
130 |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select count(*) from test_range_gist where ir @> int4range(10,20); |
||||||
|
count |
||||||
|
------- |
||||||
|
111 |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select count(*) from test_range_gist where ir && int4range(10,20); |
||||||
|
count |
||||||
|
------- |
||||||
|
158 |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select count(*) from test_range_gist where ir <@ int4range(10,50); |
||||||
|
count |
||||||
|
------- |
||||||
|
1062 |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select count(*) from test_range_gist where ir << int4range(100,500); |
||||||
|
count |
||||||
|
------- |
||||||
|
189 |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select count(*) from test_range_gist where ir >> int4range(100,500); |
||||||
|
count |
||||||
|
------- |
||||||
|
3554 |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select count(*) from test_range_gist where ir &< int4range(100,500); |
||||||
|
count |
||||||
|
------- |
||||||
|
1029 |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select count(*) from test_range_gist where ir &> int4range(100,500); |
||||||
|
count |
||||||
|
------- |
||||||
|
4794 |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select count(*) from test_range_gist where ir -|- int4range(100,500); |
||||||
|
count |
||||||
|
------- |
||||||
|
5 |
||||||
|
(1 row) |
||||||
|
|
||||||
|
COMMIT; |
||||||
|
drop table test_range_gist; |
||||||
|
-- |
||||||
|
-- Btree_gist is not included by default, so to test exclusion |
||||||
|
-- constraints with range types, use singleton int ranges for the "=" |
||||||
|
-- portion of the constraint. |
||||||
|
-- |
||||||
|
create table test_range_excl( |
||||||
|
room int4range, |
||||||
|
speaker int4range, |
||||||
|
during tsrange, |
||||||
|
exclude using gist (room with =, during with &&), |
||||||
|
exclude using gist (speaker with =, during with &&) |
||||||
|
); |
||||||
|
NOTICE: CREATE TABLE / EXCLUDE will create implicit index "test_range_excl_room_during_excl" for table "test_range_excl" |
||||||
|
NOTICE: CREATE TABLE / EXCLUDE will create implicit index "test_range_excl_speaker_during_excl" for table "test_range_excl" |
||||||
|
insert into test_range_excl |
||||||
|
values(int4range(123), int4range(1), '[2010-01-02 10:00, 2010-01-02 11:00)'); |
||||||
|
insert into test_range_excl |
||||||
|
values(int4range(123), int4range(2), '[2010-01-02 11:00, 2010-01-02 12:00)'); |
||||||
|
insert into test_range_excl |
||||||
|
values(int4range(123), int4range(3), '[2010-01-02 10:10, 2010-01-02 11:10)'); |
||||||
|
ERROR: conflicting key value violates exclusion constraint "test_range_excl_room_during_excl" |
||||||
|
DETAIL: Key (room, during)=([123,124), ["Sat Jan 02 10:10:00 2010","Sat Jan 02 11:10:00 2010")) conflicts with existing key (room, during)=([123,124), ["Sat Jan 02 10:00:00 2010","Sat Jan 02 11:00:00 2010")). |
||||||
|
insert into test_range_excl |
||||||
|
values(int4range(124), int4range(3), '[2010-01-02 10:10, 2010-01-02 11:10)'); |
||||||
|
insert into test_range_excl |
||||||
|
values(int4range(125), int4range(1), '[2010-01-02 10:10, 2010-01-02 11:10)'); |
||||||
|
ERROR: conflicting key value violates exclusion constraint "test_range_excl_speaker_during_excl" |
||||||
|
DETAIL: Key (speaker, during)=([1,2), ["Sat Jan 02 10:10:00 2010","Sat Jan 02 11:10:00 2010")) conflicts with existing key (speaker, during)=([1,2), ["Sat Jan 02 10:00:00 2010","Sat Jan 02 11:00:00 2010")). |
||||||
|
drop table test_range_excl; |
||||||
|
-- test bigint ranges |
||||||
|
select int8range(10000000000::int8, 20000000000::int8,'(]'); |
||||||
|
int8range |
||||||
|
--------------------------- |
||||||
|
[10000000001,20000000001) |
||||||
|
(1 row) |
||||||
|
|
||||||
|
-- test tstz ranges |
||||||
|
set timezone to '-08'; |
||||||
|
select '[2010-01-01 01:00:00 -05, 2010-01-01 02:00:00 -08)'::tstzrange; |
||||||
|
tstzrange |
||||||
|
----------------------------------------------------------------- |
||||||
|
["Thu Dec 31 22:00:00 2009 -08","Fri Jan 01 02:00:00 2010 -08") |
||||||
|
(1 row) |
||||||
|
|
||||||
|
-- should fail |
||||||
|
select '[2010-01-01 01:00:00 -08, 2010-01-01 02:00:00 -05)'::tstzrange; |
||||||
|
ERROR: range lower bound must be less than or equal to range upper bound |
||||||
|
LINE 1: select '[2010-01-01 01:00:00 -08, 2010-01-01 02:00:00 -05)':... |
||||||
|
^ |
||||||
|
set timezone to default; |
||||||
|
-- |
||||||
|
-- Test user-defined range of floats |
||||||
|
-- |
||||||
|
--should fail |
||||||
|
create type float8range as range (subtype=float8, subtype_diff=float4mi); |
||||||
|
ERROR: function float4mi(double precision, double precision) does not exist |
||||||
|
--should succeed |
||||||
|
create type float8range as range (subtype=float8, subtype_diff=float8mi); |
||||||
|
select '[123.001, 5.e9)'::float8range @> 888.882::float8; |
||||||
|
?column? |
||||||
|
---------- |
||||||
|
t |
||||||
|
(1 row) |
||||||
|
|
||||||
|
create table float8range_test(f8r float8range, i int); |
||||||
|
insert into float8range_test values(float8range(-100.00007, '1.111113e9')); |
||||||
|
select * from float8range_test; |
||||||
|
f8r | i |
||||||
|
-------------------------+--- |
||||||
|
[-100.00007,1111113000) | |
||||||
|
(1 row) |
||||||
|
|
||||||
|
drop table float8range_test; |
||||||
|
drop type float8range; |
||||||
|
-- |
||||||
|
-- Test range types over domains |
||||||
|
-- |
||||||
|
create domain mydomain as int4; |
||||||
|
create type mydomainrange as range(subtype=mydomain); |
||||||
|
select '[4,50)'::mydomainrange @> 7::mydomain; |
||||||
|
?column? |
||||||
|
---------- |
||||||
|
t |
||||||
|
(1 row) |
||||||
|
|
||||||
|
drop type mydomainrange; |
||||||
|
drop domain mydomain; |
||||||
|
-- |
||||||
|
-- Test domains over range types |
||||||
|
-- |
||||||
|
create domain restrictedrange as int4range check (upper(value) < 10); |
||||||
|
select '[4,5)'::restrictedrange @> 7; |
||||||
|
?column? |
||||||
|
---------- |
||||||
|
f |
||||||
|
(1 row) |
||||||
|
|
||||||
|
select '[4,50)'::restrictedrange @> 7; -- should fail |
||||||
|
ERROR: value for domain restrictedrange violates check constraint "restrictedrange_check" |
||||||
|
drop domain restrictedrange; |
||||||
|
-- |
||||||
|
-- Test multiple range types over the same subtype |
||||||
|
-- |
||||||
|
create type textrange1 as range(subtype=text, collation="C"); |
||||||
|
create type textrange2 as range(subtype=text, collation="C"); |
||||||
|
select textrange1('a','Z') @> 'b'::text; |
||||||
|
ERROR: range lower bound must be less than or equal to range upper bound |
||||||
|
select textrange2('a','z') @> 'b'::text; |
||||||
|
?column? |
||||||
|
---------- |
||||||
|
t |
||||||
|
(1 row) |
||||||
|
|
||||||
|
drop type textrange1; |
||||||
|
drop type textrange2; |
||||||
|
-- |
||||||
|
-- Test out polymorphic type system |
||||||
|
-- |
||||||
|
create function anyarray_anyrange_func(a anyarray, r anyrange) |
||||||
|
returns anyelement as 'select $1[1] + lower($2);' language sql; |
||||||
|
select anyarray_anyrange_func(ARRAY[1,2], int4range(10,20)); |
||||||
|
anyarray_anyrange_func |
||||||
|
------------------------ |
||||||
|
11 |
||||||
|
(1 row) |
||||||
|
|
||||||
|
-- should fail |
||||||
|
select anyarray_anyrange_func(ARRAY[1,2], numrange(10,20)); |
||||||
|
ERROR: function anyarray_anyrange_func(integer[], numrange) does not exist |
||||||
|
LINE 1: select anyarray_anyrange_func(ARRAY[1,2], numrange(10,20)); |
||||||
|
^ |
||||||
|
HINT: No function matches the given name and argument types. You might need to add explicit type casts. |
||||||
|
drop function anyarray_anyrange_func(anyarray, anyrange); |
||||||
|
-- should fail |
||||||
|
create function bogus_func(anyelement) |
||||||
|
returns anyrange as 'select int4range(1,10)' language sql; |
||||||
|
ERROR: cannot determine result data type |
||||||
|
DETAIL: A function returning ANYRANGE must have at least one ANYRANGE argument. |
||||||
|
-- should fail |
||||||
|
create function bogus_func(int) |
||||||
|
returns anyrange as 'select int4range(1,10)' language sql; |
||||||
|
ERROR: cannot determine result data type |
||||||
|
DETAIL: A function returning a polymorphic type must have at least one polymorphic argument. |
||||||
|
create function range_add_bounds(anyrange) |
||||||
|
returns anyelement as 'select lower($1) + upper($1)' language sql; |
||||||
|
select range_add_bounds(numrange(1.0001, 123.123)); |
||||||
|
range_add_bounds |
||||||
|
------------------ |
||||||
|
124.1231 |
||||||
|
(1 row) |
||||||
|
|
||||||
|
-- |
||||||
|
-- Arrays of ranges |
||||||
|
-- |
||||||
|
select ARRAY[numrange(1.1), numrange(12.3,155.5)]; |
||||||
|
array |
||||||
|
------------------------------ |
||||||
|
{"[1.1,1.1]","[12.3,155.5)"} |
||||||
|
(1 row) |
||||||
|
|
||||||
|
-- |
||||||
|
-- Ranges of arrays |
||||||
|
-- |
||||||
|
create type arrayrange as range (subtype=int4[]); |
||||||
|
select arrayrange(ARRAY[1,2], ARRAY[2,1]); |
||||||
|
arrayrange |
||||||
|
------------------- |
||||||
|
["{1,2}","{2,1}") |
||||||
|
(1 row) |
||||||
|
|
||||||
|
drop type arrayrange; |
||||||
|
-- |
||||||
|
-- OUT/INOUT/TABLE functions |
||||||
|
-- |
||||||
|
create function outparam_succeed(i anyrange, out r anyrange, out t text) |
||||||
|
as $$ select $1, 'foo' $$ language sql; |
||||||
|
create function inoutparam_succeed(out i anyelement, inout r anyrange) |
||||||
|
as $$ select $1, $2 $$ language sql; |
||||||
|
create function table_succeed(i anyelement, r anyrange) returns table(i anyelement, r anyrange) |
||||||
|
as $$ select $1, $2 $$ language sql; |
||||||
|
-- should fail |
||||||
|
create function outparam_fail(i anyelement, out r anyrange, out t text) |
||||||
|
as $$ select '[1,10]', 'foo' $$ language sql; |
||||||
|
ERROR: cannot determine result data type |
||||||
|
DETAIL: A function returning ANYRANGE must have at least one ANYRANGE argument. |
||||||
|
--should fail |
||||||
|
create function inoutparam_fail(inout i anyelement, out r anyrange) |
||||||
|
as $$ select $1, '[1,10]' $$ language sql; |
||||||
|
ERROR: cannot determine result data type |
||||||
|
DETAIL: A function returning ANYRANGE must have at least one ANYRANGE argument. |
||||||
|
--should fail |
||||||
|
create function table_succeed(i anyelement) returns table(i anyelement, r anyrange) |
||||||
|
as $$ select $1, '[1,10]' $$ language sql; |
||||||
|
ERROR: cannot determine result data type |
||||||
|
DETAIL: A function returning ANYRANGE must have at least one ANYRANGE argument. |
||||||
@ -0,0 +1,371 @@ |
|||||||
|
|
||||||
|
-- |
||||||
|
-- test parser |
||||||
|
-- |
||||||
|
|
||||||
|
create type textrange as range (subtype=text, collation="C"); |
||||||
|
|
||||||
|
-- negative tests; should fail |
||||||
|
select ''::textrange; |
||||||
|
select '-[a,z)'::textrange; |
||||||
|
select '[a,z) - '::textrange; |
||||||
|
select '(",a)'::textrange; |
||||||
|
select '(,,a)'::textrange; |
||||||
|
select '(),a)'::textrange; |
||||||
|
select '(a,))'::textrange; |
||||||
|
select '(],a)'::textrange; |
||||||
|
select '(a,])'::textrange; |
||||||
|
|
||||||
|
-- should succeed |
||||||
|
select ' empty '::textrange; |
||||||
|
select ' ( empty, empty ) '::textrange; |
||||||
|
select ' ( " a " " a ", " z " " z " ) '::textrange; |
||||||
|
select '(,z)'::textrange; |
||||||
|
select '(a,)'::textrange; |
||||||
|
select '[,z]'::textrange; |
||||||
|
select '[a,]'::textrange; |
||||||
|
select '( , )'::textrange; |
||||||
|
select '("","")'::textrange; |
||||||
|
select '["",""]'::textrange; |
||||||
|
select '(",",",")'::textrange; |
||||||
|
select '("\\","\\")'::textrange |
||||||
|
select '(\\,a)'::textrange; |
||||||
|
select '((,z)'::textrange; |
||||||
|
select '([,z)'::textrange; |
||||||
|
select '(!,()'::textrange; |
||||||
|
select '(!,[)'::textrange; |
||||||
|
|
||||||
|
drop type textrange; |
||||||
|
|
||||||
|
-- |
||||||
|
-- create some test data and test the operators |
||||||
|
-- |
||||||
|
|
||||||
|
CREATE TABLE numrange_test (nr NUMRANGE); |
||||||
|
create index numrange_test_btree on numrange_test(nr); |
||||||
|
SET enable_seqscan = f; |
||||||
|
|
||||||
|
INSERT INTO numrange_test VALUES('[,)'); |
||||||
|
INSERT INTO numrange_test VALUES('[3,]'); |
||||||
|
INSERT INTO numrange_test VALUES('[, 5)'); |
||||||
|
INSERT INTO numrange_test VALUES(numrange(1.1, 2.2)); |
||||||
|
INSERT INTO numrange_test VALUES('empty'); |
||||||
|
INSERT INTO numrange_test VALUES(numrange(1.7)); |
||||||
|
|
||||||
|
SELECT isempty(nr) FROM numrange_test; |
||||||
|
SELECT lower_inc(nr), lower(nr), upper(nr), upper_inc(nr) FROM numrange_test |
||||||
|
WHERE NOT isempty(nr) AND NOT lower_inf(nr) AND NOT upper_inf(nr); |
||||||
|
|
||||||
|
SELECT * FROM numrange_test WHERE contains(nr, numrange(1.9,1.91)); |
||||||
|
SELECT * FROM numrange_test WHERE nr @> numrange(1.0,10000.1); |
||||||
|
SELECT * FROM numrange_test WHERE contained_by(numrange(-1e7,-10000.1), nr); |
||||||
|
SELECT * FROM numrange_test WHERE 1.9 <@ nr; |
||||||
|
SELECT * FROM numrange_test WHERE nr = 'empty'; |
||||||
|
SELECT * FROM numrange_test WHERE range_eq(nr, '(1.1, 2.2)'); |
||||||
|
SELECT * FROM numrange_test WHERE nr = '[1.1, 2.2)'; |
||||||
|
|
||||||
|
select numrange(2.0, 1.0); |
||||||
|
|
||||||
|
select numrange(2.0, 3.0) -|- numrange(3.0, 4.0); |
||||||
|
select adjacent(numrange(2.0, 3.0), numrange(3.1, 4.0)); |
||||||
|
select numrange(2.0, 3.0, '[]') -|- numrange(3.0, 4.0, '()'); |
||||||
|
select numrange(1.0, 2.0) -|- numrange(2.0, 3.0,'[]'); |
||||||
|
select adjacent(numrange(2.0, 3.0, '(]'), numrange(1.0, 2.0, '(]')); |
||||||
|
|
||||||
|
select numrange(1.1, 3.3) <@ numrange(0.1,10.1); |
||||||
|
select numrange(0.1, 10.1) <@ numrange(1.1,3.3); |
||||||
|
|
||||||
|
select numrange(1.1, 2.2) - numrange(2.0, 3.0); |
||||||
|
select numrange(1.1, 2.2) - numrange(2.2, 3.0); |
||||||
|
select numrange(1.1, 2.2,'[]') - numrange(2.0, 3.0); |
||||||
|
select minus(numrange(10.1,12.2,'[]'), numrange(110.0,120.2,'(]')); |
||||||
|
select minus(numrange(10.1,12.2,'[]'), numrange(0.0,120.2,'(]')); |
||||||
|
|
||||||
|
select numrange(4.5, 5.5, '[]') && numrange(5.5, 6.5); |
||||||
|
select numrange(1.0, 2.0) << numrange(3.0, 4.0); |
||||||
|
select numrange(1.0, 2.0) >> numrange(3.0, 4.0); |
||||||
|
select numrange(3.0, 70.0) &< numrange(6.6, 100.0); |
||||||
|
|
||||||
|
select numrange(1.1, 2.2) < numrange(1.0, 200.2); |
||||||
|
select numrange(1.1, 2.2) < numrange(1.1, 1.2); |
||||||
|
|
||||||
|
select numrange(1.0, 2.0) + numrange(2.0, 3.0); |
||||||
|
select numrange(1.0, 2.0) + numrange(1.5, 3.0); |
||||||
|
select numrange(1.0, 2.0) + numrange(2.5, 3.0); |
||||||
|
|
||||||
|
select numrange(1.0, 2.0) * numrange(2.0, 3.0); |
||||||
|
select numrange(1.0, 2.0) * numrange(1.5, 3.0); |
||||||
|
select numrange(1.0, 2.0) * numrange(2.5, 3.0); |
||||||
|
|
||||||
|
select * from numrange_test where nr < numrange(-1000.0, -1000.0,'[]'); |
||||||
|
select * from numrange_test where nr < numrange(0.0, 1.0,'[]'); |
||||||
|
select * from numrange_test where nr < numrange(1000.0, 1001.0,'[]'); |
||||||
|
select * from numrange_test where nr > numrange(-1001.0, -1000.0,'[]'); |
||||||
|
select * from numrange_test where nr > numrange(0.0, 1.0,'[]'); |
||||||
|
select * from numrange_test where nr > numrange(1000.0, 1000.0,'[]'); |
||||||
|
|
||||||
|
create table numrange_test2(nr numrange); |
||||||
|
create index numrange_test2_hash_idx on numrange_test2 (nr); |
||||||
|
INSERT INTO numrange_test2 VALUES('[, 5)'); |
||||||
|
INSERT INTO numrange_test2 VALUES(numrange(1.1, 2.2)); |
||||||
|
INSERT INTO numrange_test2 VALUES(numrange(1.1, 2.2)); |
||||||
|
INSERT INTO numrange_test2 VALUES(numrange(1.1, 2.2,'()')); |
||||||
|
INSERT INTO numrange_test2 VALUES('empty'); |
||||||
|
|
||||||
|
select * from numrange_test2 where nr = 'empty'::numrange; |
||||||
|
select * from numrange_test2 where nr = numrange(1.1, 2.2); |
||||||
|
select * from numrange_test2 where nr = numrange(1.1, 2.3); |
||||||
|
|
||||||
|
set enable_nestloop=t; |
||||||
|
set enable_hashjoin=f; |
||||||
|
set enable_mergejoin=f; |
||||||
|
select * from numrange_test natural join numrange_test2 order by nr; |
||||||
|
set enable_nestloop=f; |
||||||
|
set enable_hashjoin=t; |
||||||
|
set enable_mergejoin=f; |
||||||
|
select * from numrange_test natural join numrange_test2 order by nr; |
||||||
|
set enable_nestloop=f; |
||||||
|
set enable_hashjoin=f; |
||||||
|
set enable_mergejoin=t; |
||||||
|
select * from numrange_test natural join numrange_test2 order by nr; |
||||||
|
|
||||||
|
set enable_nestloop to default; |
||||||
|
set enable_hashjoin to default; |
||||||
|
set enable_mergejoin to default; |
||||||
|
SET enable_seqscan TO DEFAULT; |
||||||
|
DROP TABLE numrange_test; |
||||||
|
DROP TABLE numrange_test2; |
||||||
|
|
||||||
|
-- test canonical form for int4range |
||||||
|
select int4range(1,10,'[]'); |
||||||
|
select int4range(1,10,'[)'); |
||||||
|
select int4range(1,10,'(]'); |
||||||
|
select int4range(1,10,'[]'); |
||||||
|
|
||||||
|
-- test canonical form for daterange |
||||||
|
select daterange('2000-01-10'::date, '2000-01-20'::date,'[]'); |
||||||
|
select daterange('2000-01-10'::date, '2000-01-20'::date,'[)'); |
||||||
|
select daterange('2000-01-10'::date, '2000-01-20'::date,'(]'); |
||||||
|
select daterange('2000-01-10'::date, '2000-01-20'::date,'[]'); |
||||||
|
|
||||||
|
create table test_range_gist(ir int4range); |
||||||
|
create index test_range_gist_idx on test_range_gist using gist (ir); |
||||||
|
|
||||||
|
insert into test_range_gist select int4range(g, g+10) from generate_series(1,2000) g; |
||||||
|
insert into test_range_gist select 'empty'::int4range from generate_series(1,500) g; |
||||||
|
insert into test_range_gist select int4range(g, g+10000) from generate_series(1,1000) g; |
||||||
|
insert into test_range_gist select 'empty'::int4range from generate_series(1,500) g; |
||||||
|
insert into test_range_gist select int4range(NULL,g*10,'(]') from generate_series(1,100) g; |
||||||
|
insert into test_range_gist select int4range(g*10,NULL,'(]') from generate_series(1,100) g; |
||||||
|
insert into test_range_gist select int4range(g, g+10) from generate_series(1,2000) g; |
||||||
|
|
||||||
|
BEGIN; |
||||||
|
SET LOCAL enable_seqscan = t; |
||||||
|
SET LOCAL enable_bitmapscan = f; |
||||||
|
SET LOCAL enable_indexscan = f; |
||||||
|
|
||||||
|
select count(*) from test_range_gist where ir @> 'empty'::int4range; |
||||||
|
select count(*) from test_range_gist where ir = int4range(10,20); |
||||||
|
select count(*) from test_range_gist where ir @> 10; |
||||||
|
select count(*) from test_range_gist where ir @> int4range(10,20); |
||||||
|
select count(*) from test_range_gist where ir && int4range(10,20); |
||||||
|
select count(*) from test_range_gist where ir <@ int4range(10,50); |
||||||
|
select count(*) from (select * from test_range_gist where not isempty(ir)) s where ir << int4range(100,500); |
||||||
|
select count(*) from (select * from test_range_gist where not isempty(ir)) s where ir >> int4range(100,500); |
||||||
|
select count(*) from (select * from test_range_gist where not isempty(ir)) s where ir &< int4range(100,500); |
||||||
|
select count(*) from (select * from test_range_gist where not isempty(ir)) s where ir &> int4range(100,500); |
||||||
|
select count(*) from (select * from test_range_gist where not isempty(ir)) s where ir -|- int4range(100,500); |
||||||
|
COMMIT; |
||||||
|
|
||||||
|
BEGIN; |
||||||
|
SET LOCAL enable_seqscan = f; |
||||||
|
SET LOCAL enable_bitmapscan = f; |
||||||
|
SET LOCAL enable_indexscan = t; |
||||||
|
|
||||||
|
select count(*) from test_range_gist where ir @> 'empty'::int4range; |
||||||
|
select count(*) from test_range_gist where ir = int4range(10,20); |
||||||
|
select count(*) from test_range_gist where ir @> 10; |
||||||
|
select count(*) from test_range_gist where ir @> int4range(10,20); |
||||||
|
select count(*) from test_range_gist where ir && int4range(10,20); |
||||||
|
select count(*) from test_range_gist where ir <@ int4range(10,50); |
||||||
|
select count(*) from test_range_gist where ir << int4range(100,500); |
||||||
|
select count(*) from test_range_gist where ir >> int4range(100,500); |
||||||
|
select count(*) from test_range_gist where ir &< int4range(100,500); |
||||||
|
select count(*) from test_range_gist where ir &> int4range(100,500); |
||||||
|
select count(*) from test_range_gist where ir -|- int4range(100,500); |
||||||
|
COMMIT; |
||||||
|
|
||||||
|
drop index test_range_gist_idx; |
||||||
|
create index test_range_gist_idx on test_range_gist using gist (ir); |
||||||
|
|
||||||
|
BEGIN; |
||||||
|
SET LOCAL enable_seqscan = f; |
||||||
|
SET LOCAL enable_bitmapscan = f; |
||||||
|
SET LOCAL enable_indexscan = t; |
||||||
|
|
||||||
|
select count(*) from test_range_gist where ir @> 'empty'::int4range; |
||||||
|
select count(*) from test_range_gist where ir = int4range(10,20); |
||||||
|
select count(*) from test_range_gist where ir @> 10; |
||||||
|
select count(*) from test_range_gist where ir @> int4range(10,20); |
||||||
|
select count(*) from test_range_gist where ir && int4range(10,20); |
||||||
|
select count(*) from test_range_gist where ir <@ int4range(10,50); |
||||||
|
select count(*) from test_range_gist where ir << int4range(100,500); |
||||||
|
select count(*) from test_range_gist where ir >> int4range(100,500); |
||||||
|
select count(*) from test_range_gist where ir &< int4range(100,500); |
||||||
|
select count(*) from test_range_gist where ir &> int4range(100,500); |
||||||
|
select count(*) from test_range_gist where ir -|- int4range(100,500); |
||||||
|
COMMIT; |
||||||
|
|
||||||
|
drop table test_range_gist; |
||||||
|
|
||||||
|
-- |
||||||
|
-- Btree_gist is not included by default, so to test exclusion |
||||||
|
-- constraints with range types, use singleton int ranges for the "=" |
||||||
|
-- portion of the constraint. |
||||||
|
-- |
||||||
|
|
||||||
|
create table test_range_excl( |
||||||
|
room int4range, |
||||||
|
speaker int4range, |
||||||
|
during tsrange, |
||||||
|
exclude using gist (room with =, during with &&), |
||||||
|
exclude using gist (speaker with =, during with &&) |
||||||
|
); |
||||||
|
|
||||||
|
insert into test_range_excl |
||||||
|
values(int4range(123), int4range(1), '[2010-01-02 10:00, 2010-01-02 11:00)'); |
||||||
|
insert into test_range_excl |
||||||
|
values(int4range(123), int4range(2), '[2010-01-02 11:00, 2010-01-02 12:00)'); |
||||||
|
insert into test_range_excl |
||||||
|
values(int4range(123), int4range(3), '[2010-01-02 10:10, 2010-01-02 11:10)'); |
||||||
|
insert into test_range_excl |
||||||
|
values(int4range(124), int4range(3), '[2010-01-02 10:10, 2010-01-02 11:10)'); |
||||||
|
insert into test_range_excl |
||||||
|
values(int4range(125), int4range(1), '[2010-01-02 10:10, 2010-01-02 11:10)'); |
||||||
|
|
||||||
|
drop table test_range_excl; |
||||||
|
|
||||||
|
-- test bigint ranges |
||||||
|
select int8range(10000000000::int8, 20000000000::int8,'(]'); |
||||||
|
-- test tstz ranges |
||||||
|
set timezone to '-08'; |
||||||
|
select '[2010-01-01 01:00:00 -05, 2010-01-01 02:00:00 -08)'::tstzrange; |
||||||
|
-- should fail |
||||||
|
select '[2010-01-01 01:00:00 -08, 2010-01-01 02:00:00 -05)'::tstzrange; |
||||||
|
set timezone to default; |
||||||
|
|
||||||
|
-- |
||||||
|
-- Test user-defined range of floats |
||||||
|
-- |
||||||
|
|
||||||
|
--should fail |
||||||
|
create type float8range as range (subtype=float8, subtype_diff=float4mi); |
||||||
|
|
||||||
|
--should succeed |
||||||
|
create type float8range as range (subtype=float8, subtype_diff=float8mi); |
||||||
|
select '[123.001, 5.e9)'::float8range @> 888.882::float8; |
||||||
|
create table float8range_test(f8r float8range, i int); |
||||||
|
insert into float8range_test values(float8range(-100.00007, '1.111113e9')); |
||||||
|
select * from float8range_test; |
||||||
|
drop table float8range_test; |
||||||
|
drop type float8range; |
||||||
|
|
||||||
|
-- |
||||||
|
-- Test range types over domains |
||||||
|
-- |
||||||
|
|
||||||
|
create domain mydomain as int4; |
||||||
|
create type mydomainrange as range(subtype=mydomain); |
||||||
|
select '[4,50)'::mydomainrange @> 7::mydomain; |
||||||
|
drop type mydomainrange; |
||||||
|
drop domain mydomain; |
||||||
|
|
||||||
|
-- |
||||||
|
-- Test domains over range types |
||||||
|
-- |
||||||
|
|
||||||
|
create domain restrictedrange as int4range check (upper(value) < 10); |
||||||
|
select '[4,5)'::restrictedrange @> 7; |
||||||
|
select '[4,50)'::restrictedrange @> 7; -- should fail |
||||||
|
drop domain restrictedrange; |
||||||
|
|
||||||
|
-- |
||||||
|
-- Test multiple range types over the same subtype |
||||||
|
-- |
||||||
|
|
||||||
|
create type textrange1 as range(subtype=text, collation="C"); |
||||||
|
create type textrange2 as range(subtype=text, collation="C"); |
||||||
|
|
||||||
|
select textrange1('a','Z') @> 'b'::text; |
||||||
|
select textrange2('a','z') @> 'b'::text; |
||||||
|
|
||||||
|
drop type textrange1; |
||||||
|
drop type textrange2; |
||||||
|
|
||||||
|
-- |
||||||
|
-- Test out polymorphic type system |
||||||
|
-- |
||||||
|
|
||||||
|
create function anyarray_anyrange_func(a anyarray, r anyrange) |
||||||
|
returns anyelement as 'select $1[1] + lower($2);' language sql; |
||||||
|
|
||||||
|
select anyarray_anyrange_func(ARRAY[1,2], int4range(10,20)); |
||||||
|
|
||||||
|
-- should fail |
||||||
|
select anyarray_anyrange_func(ARRAY[1,2], numrange(10,20)); |
||||||
|
|
||||||
|
drop function anyarray_anyrange_func(anyarray, anyrange); |
||||||
|
|
||||||
|
-- should fail |
||||||
|
create function bogus_func(anyelement) |
||||||
|
returns anyrange as 'select int4range(1,10)' language sql; |
||||||
|
|
||||||
|
-- should fail |
||||||
|
create function bogus_func(int) |
||||||
|
returns anyrange as 'select int4range(1,10)' language sql; |
||||||
|
|
||||||
|
create function range_add_bounds(anyrange) |
||||||
|
returns anyelement as 'select lower($1) + upper($1)' language sql; |
||||||
|
|
||||||
|
select range_add_bounds(numrange(1.0001, 123.123)); |
||||||
|
|
||||||
|
-- |
||||||
|
-- Arrays of ranges |
||||||
|
-- |
||||||
|
|
||||||
|
select ARRAY[numrange(1.1), numrange(12.3,155.5)]; |
||||||
|
|
||||||
|
-- |
||||||
|
-- Ranges of arrays |
||||||
|
-- |
||||||
|
|
||||||
|
create type arrayrange as range (subtype=int4[]); |
||||||
|
|
||||||
|
select arrayrange(ARRAY[1,2], ARRAY[2,1]); |
||||||
|
|
||||||
|
drop type arrayrange; |
||||||
|
|
||||||
|
-- |
||||||
|
-- OUT/INOUT/TABLE functions |
||||||
|
-- |
||||||
|
|
||||||
|
create function outparam_succeed(i anyrange, out r anyrange, out t text) |
||||||
|
as $$ select $1, 'foo' $$ language sql; |
||||||
|
|
||||||
|
create function inoutparam_succeed(out i anyelement, inout r anyrange) |
||||||
|
as $$ select $1, $2 $$ language sql; |
||||||
|
|
||||||
|
create function table_succeed(i anyelement, r anyrange) returns table(i anyelement, r anyrange) |
||||||
|
as $$ select $1, $2 $$ language sql; |
||||||
|
|
||||||
|
-- should fail |
||||||
|
create function outparam_fail(i anyelement, out r anyrange, out t text) |
||||||
|
as $$ select '[1,10]', 'foo' $$ language sql; |
||||||
|
|
||||||
|
--should fail |
||||||
|
create function inoutparam_fail(inout i anyelement, out r anyrange) |
||||||
|
as $$ select $1, '[1,10]' $$ language sql; |
||||||
|
|
||||||
|
--should fail |
||||||
|
create function table_succeed(i anyelement) returns table(i anyelement, r anyrange) |
||||||
|
as $$ select $1, '[1,10]' $$ language sql; |
||||||
Loading…
Reference in new issue