USAGE
=====
-The access method for SEG is a GiST (gist_seg_ops), which is a
+The access method for SEG is a GiST index (gist_seg_ops), which is a
generalization of R-tree. GiSTs allow the postgres implementation of
R-tree, originally encoded to support 2-D geometric types such as
boxes and polygons, to be used with any data type whose data domain
[a, b] >> [c, d] Is right of
[a, b] is occurs entirely to the right of [c, d].
- [a, b] >> [c, d] is true if b > c and false otherwise
+ [a, b] >> [c, d] is true if a > d and false otherwise
-[a, b] &< [c, d] Over left
+[a, b] &< [c, d] Overlaps or is left of
- The segment [a, b] overlaps the segment [c, d] in such a way
- that a <= c <= b and b <= d
+ This might be better read as "does not extend to right of".
+ It is true when b <= d.
-[a, b] &> [c, d] Over right
+[a, b] &> [c, d] Overlaps or is right of
- The segment [a, b] overlaps the segment [c, d] in such a way
- that a > c and b <= c <= d
+ This might be better read as "does not extend to left of".
+ It is true when a >= c.
[a, b] = [c, d] Same as
The segments [a, b] and [c, d] are identical, that is, a == b
and c == d
+[a, b] && [c, d] Overlaps
+
+ The segments [a, b] and [c, d] overlap.
+
[a, b] @ [c, d] Contains
The segment [a, b] contains the segment [c, d], that is,
SELECT '1'::seg &< '2'::seg AS bool;
bool
------
- f
+ t
(1 row)
SELECT '0 .. 1'::seg &< '0'::seg AS bool;
SELECT '0 .. 1'::seg &< '2'::seg AS bool;
bool
------
- f
+ t
(1 row)
SELECT '0 .. 1'::seg &< '0 .. 0.5'::seg AS bool;
SELECT '0 .. 1'::seg &< '2 .. 3'::seg AS bool;
bool
------
- f
+ t
(1 row)
-- overlap on the right
SELECT '2'::seg &> '1'::seg AS bool;
bool
------
- f
+ t
(1 row)
SELECT '0'::seg &> '0 .. 1'::seg AS bool;
SELECT '2'::seg &> '0 .. 1'::seg AS bool;
bool
------
- f
+ t
(1 row)
SELECT '0 .. 0.5'::seg &> '0 .. 1'::seg AS bool;
SELECT '2 .. 3'::seg &> '0 .. 1'::seg AS bool;
bool
------
- f
+ t
(1 row)
-- left
SELECT '1'::seg &< '2'::seg AS bool;
bool
------
- f
+ t
(1 row)
SELECT '0 .. 1'::seg &< '0'::seg AS bool;
SELECT '0 .. 1'::seg &< '2'::seg AS bool;
bool
------
- f
+ t
(1 row)
SELECT '0 .. 1'::seg &< '0 .. 0.5'::seg AS bool;
SELECT '0 .. 1'::seg &< '2 .. 3'::seg AS bool;
bool
------
- f
+ t
(1 row)
-- overlap on the right
SELECT '2'::seg &> '1'::seg AS bool;
bool
------
- f
+ t
(1 row)
SELECT '0'::seg &> '0 .. 1'::seg AS bool;
SELECT '2'::seg &> '0 .. 1'::seg AS bool;
bool
------
- f
+ t
(1 row)
SELECT '0 .. 0.5'::seg &> '0 .. 1'::seg AS bool;
SELECT '2 .. 3'::seg &> '0 .. 1'::seg AS bool;
bool
------
- f
+ t
(1 row)
-- left
StrategyNumber strategy)
{
/*
- * * if entry is not leaf, use gseg_internal_consistent, * else use
+ * if entry is not leaf, use gseg_internal_consistent, else use
* gseg_leaf_consistent
*/
if (GIST_LEAF(entry))
switch (strategy)
{
case RTLeftStrategyNumber:
+ retval = (bool) !seg_over_right(key, query);
+ break;
case RTOverLeftStrategyNumber:
- retval = (bool) seg_over_left(key, query);
+ retval = (bool) !seg_right(key, query);
break;
case RTOverlapStrategyNumber:
retval = (bool) seg_overlap(key, query);
break;
case RTOverRightStrategyNumber:
+ retval = (bool) !seg_left(key, query);
+ break;
case RTRightStrategyNumber:
- retval = (bool) seg_right(key, query);
+ retval = (bool) !seg_over_left(key, query);
break;
case RTSameStrategyNumber:
case RTContainsStrategyNumber:
);
}
-/* seg_overleft -- is the right edge of (a) located to the left of the right edge of (b)?
+/* seg_overleft -- is the right edge of (a) located at or left of the right edge of (b)?
*/
bool
seg_over_left(SEG * a, SEG * b)
{
- return (a->upper <= b->upper && !seg_left(a, b) && !seg_right(a, b));
+ return (a->upper <= b->upper);
}
/* seg_left -- is (a) entirely on the left of (b)?
return (a->lower > b->upper);
}
-/* seg_overright -- is the left edge of (a) located to the right of the left edge of (b)?
+/* seg_overright -- is the left edge of (a) located at or right of the left edge of (b)?
*/
bool
seg_over_right(SEG * a, SEG * b)
{
- return (a->lower >= b->lower && !seg_left(a, b) && !seg_right(a, b));
+ return (a->lower >= b->lower);
}
CREATE FUNCTION seg_over_left(seg, seg)
RETURNS bool
AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict);
+LANGUAGE 'C' STRICT IMMUTABLE;
COMMENT ON FUNCTION seg_over_left(seg, seg) IS
-'is over and left of';
+'overlaps or is left of';
CREATE FUNCTION seg_over_right(seg, seg)
RETURNS bool
AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict);
+LANGUAGE 'C' STRICT IMMUTABLE;
COMMENT ON FUNCTION seg_over_right(seg, seg) IS
-'is over and right of';
+'overlaps or is right of';
CREATE FUNCTION seg_left(seg, seg)
RETURNS bool
AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict);
+LANGUAGE 'C' STRICT IMMUTABLE;
COMMENT ON FUNCTION seg_left(seg, seg) IS
'is left of';
CREATE FUNCTION seg_right(seg, seg)
RETURNS bool
AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict);
+LANGUAGE 'C' STRICT IMMUTABLE;
COMMENT ON FUNCTION seg_right(seg, seg) IS
'is right of';
--- Comparison methods
+-- Scalar comparison methods
CREATE FUNCTION seg_lt(seg, seg)
RETURNS bool
AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict);
+LANGUAGE 'C' STRICT IMMUTABLE;
COMMENT ON FUNCTION seg_lt(seg, seg) IS
'less than';
CREATE FUNCTION seg_le(seg, seg)
RETURNS bool
AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict);
+LANGUAGE 'C' STRICT IMMUTABLE;
COMMENT ON FUNCTION seg_le(seg, seg) IS
'less than or equal';
CREATE FUNCTION seg_gt(seg, seg)
RETURNS bool
AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict);
+LANGUAGE 'C' STRICT IMMUTABLE;
COMMENT ON FUNCTION seg_gt(seg, seg) IS
'greater than';
CREATE FUNCTION seg_ge(seg, seg)
RETURNS bool
AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict);
+LANGUAGE 'C' STRICT IMMUTABLE;
COMMENT ON FUNCTION seg_ge(seg, seg) IS
'greater than or equal';
CREATE FUNCTION seg_contains(seg, seg)
RETURNS bool
AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict);
+LANGUAGE 'C' STRICT IMMUTABLE;
COMMENT ON FUNCTION seg_contains(seg, seg) IS
'contains';
CREATE FUNCTION seg_contained(seg, seg)
RETURNS bool
AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict);
+LANGUAGE 'C' STRICT IMMUTABLE;
COMMENT ON FUNCTION seg_contained(seg, seg) IS
'contained in';
CREATE FUNCTION seg_overlap(seg, seg)
RETURNS bool
AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict);
+LANGUAGE 'C' STRICT IMMUTABLE;
COMMENT ON FUNCTION seg_overlap(seg, seg) IS
'overlaps';
CREATE FUNCTION seg_same(seg, seg)
RETURNS bool
AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict);
+LANGUAGE 'C' STRICT IMMUTABLE;
COMMENT ON FUNCTION seg_same(seg, seg) IS
'same as';
CREATE FUNCTION seg_different(seg, seg)
RETURNS bool
AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict);
+LANGUAGE 'C' STRICT IMMUTABLE;
COMMENT ON FUNCTION seg_different(seg, seg) IS
'different';
CREATE OR REPLACE FUNCTION seg_cmp(seg, seg)
RETURNS int4
AS 'MODULE_PATHNAME'
-LANGUAGE 'C' STRICT;
+LANGUAGE 'C' STRICT IMMUTABLE;
COMMENT ON FUNCTION seg_cmp(seg, seg) IS 'btree comparison function';
CREATE FUNCTION seg_union(seg, seg)
RETURNS seg
AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict);
+LANGUAGE 'C' STRICT IMMUTABLE;
CREATE FUNCTION seg_inter(seg, seg)
RETURNS seg
AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict);
+LANGUAGE 'C' STRICT IMMUTABLE;
CREATE FUNCTION seg_size(seg)
RETURNS float4
AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict);
+LANGUAGE 'C' STRICT IMMUTABLE;
-- miscellaneous
CREATE FUNCTION seg_upper(seg)
RETURNS float4
AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict);
+LANGUAGE 'C' STRICT IMMUTABLE;
CREATE FUNCTION seg_lower(seg)
RETURNS float4
AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict);
+LANGUAGE 'C' STRICT IMMUTABLE;
--
LEFTARG = seg,
RIGHTARG = seg,
PROCEDURE = seg_over_left,
- COMMUTATOR = '&>',
RESTRICT = positionsel,
JOIN = positionjoinsel
);
RIGHTARG = seg,
PROCEDURE = seg_overlap,
COMMUTATOR = '&&',
- RESTRICT = positionsel,
- JOIN = positionjoinsel
+ RESTRICT = areasel,
+ JOIN = areajoinsel
);
CREATE OPERATOR &> (
LEFTARG = seg,
RIGHTARG = seg,
PROCEDURE = seg_over_right,
- COMMUTATOR = '&<',
RESTRICT = positionsel,
JOIN = positionjoinsel
);
CREATE FUNCTION gseg_penalty(internal,internal,internal)
RETURNS internal
AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict);
+LANGUAGE 'C' STRICT;
CREATE FUNCTION gseg_picksplit(internal, internal)
RETURNS internal
projects / postgresql / commitdiff