mirror of
https://git.osgeo.org/gitea/postgis/postgis
synced 2024-10-25 01:22:47 +00:00
979 lines
26 KiB
XML
979 lines
26 KiB
XML
<?xml version="1.0" encoding="UTF-8"?>
|
|
<sect1 id="Operators">
|
|
<title>Operators</title>
|
|
<refentry id="ST_Geometry_Overlap">
|
|
<refnamediv>
|
|
<refname>&&</refname>
|
|
|
|
<refpurpose>Returns <varname>TRUE</varname> if A's bounding box overlaps B's.</refpurpose>
|
|
</refnamediv>
|
|
|
|
<refsynopsisdiv>
|
|
<funcsynopsis>
|
|
<funcprototype>
|
|
<!-- TODO: Ideally, it would be nice if this could be reordered to
|
|
"boolean (geometry A && geometry B)" instead of
|
|
"boolean &&( geometry A, geometry B)" -->
|
|
<funcdef>boolean <function>&&</function></funcdef>
|
|
|
|
<paramdef>
|
|
<type>geometry </type>
|
|
|
|
<parameter>A</parameter>
|
|
</paramdef>
|
|
|
|
<paramdef>
|
|
<type>geometry </type>
|
|
|
|
<parameter>B</parameter>
|
|
</paramdef>
|
|
</funcprototype>
|
|
<funcprototype>
|
|
<funcdef>boolean <function>&&</function></funcdef>
|
|
|
|
<paramdef>
|
|
<type>geography </type>
|
|
|
|
<parameter>A</parameter>
|
|
</paramdef>
|
|
|
|
<paramdef>
|
|
<type>geography </type>
|
|
|
|
<parameter>B</parameter>
|
|
</paramdef>
|
|
</funcprototype>
|
|
</funcsynopsis>
|
|
</refsynopsisdiv>
|
|
|
|
<refsection>
|
|
<title>Description</title>
|
|
|
|
<para>The <varname>&&</varname> operator returns <varname>TRUE</varname> if the bounding box of geometry A overlaps the bounding box of geometry B.</para>
|
|
|
|
<note><para>This operand will make use of any indexes that may be available on the
|
|
geometries.</para></note>
|
|
|
|
<para>Availability: 1.5.0 support for geography was introduced.</para>
|
|
<para>&curve_support;</para>
|
|
</refsection>
|
|
|
|
<refsection>
|
|
<title>Examples</title>
|
|
|
|
<programlisting>SELECT tbl1.column1, tbl2.column1, tbl1.column2 && tbl2.column2 AS overlaps
|
|
FROM ( VALUES
|
|
(1, 'LINESTRING(0 0, 3 3)'::geometry),
|
|
(2, 'LINESTRING(0 1, 0 5)'::geometry)) AS tbl1,
|
|
( VALUES
|
|
(3, 'LINESTRING(1 2, 4 6)'::geometry)) AS tbl2;
|
|
|
|
column1 | column1 | overlaps
|
|
---------+---------+----------
|
|
1 | 3 | t
|
|
2 | 3 | f
|
|
(2 rows)</programlisting>
|
|
<!-- TODO Add geography examples -->
|
|
</refsection>
|
|
|
|
<refsection>
|
|
<title>See Also</title>
|
|
|
|
<para>
|
|
<xref linkend="ST_Geometry_Overabove" />,
|
|
<xref linkend="ST_Geometry_Overright" />,
|
|
<xref linkend="ST_Geometry_Overbelow" />,
|
|
<xref linkend="ST_Geometry_Overleft" />,
|
|
<xref linkend="ST_Geometry_Contain" />,
|
|
<xref linkend="ST_Geometry_Contained" /></para>
|
|
</refsection>
|
|
</refentry>
|
|
|
|
<refentry id="ST_Geometry_Overleft">
|
|
<refnamediv>
|
|
<refname>&<</refname>
|
|
|
|
<refpurpose>Returns <varname>TRUE</varname> if A's bounding box overlaps or is to the left of B's.</refpurpose>
|
|
</refnamediv>
|
|
|
|
<refsynopsisdiv>
|
|
<funcsynopsis>
|
|
<funcprototype>
|
|
<!-- TODO: Ideally, it would be nice if this could be reordered to
|
|
"boolean (geometry A &< geometry B)" instead of
|
|
"boolean &<( geometry A, geometry B)" -->
|
|
<funcdef>boolean <function>&<</function></funcdef>
|
|
|
|
<paramdef>
|
|
<type>geometry </type>
|
|
|
|
<parameter>A</parameter>
|
|
</paramdef>
|
|
|
|
<paramdef>
|
|
<type>geometry </type>
|
|
|
|
<parameter>B</parameter>
|
|
</paramdef>
|
|
</funcprototype>
|
|
</funcsynopsis>
|
|
</refsynopsisdiv>
|
|
|
|
<refsection>
|
|
<title>Description</title>
|
|
|
|
<para>The <varname>&<</varname> operator returns <varname>TRUE</varname> if the bounding box of geometry A
|
|
overlaps or is to the left of the bounding box of geometry B, or more accurately, overlaps or is NOT to the right
|
|
of the bounding box of geometry B.</para>
|
|
|
|
<note><para>This operand will make use of any indexes that may be available on the
|
|
geometries.</para></note>
|
|
</refsection>
|
|
|
|
<refsection>
|
|
<title>Examples</title>
|
|
|
|
<programlisting>SELECT tbl1.column1, tbl2.column1, tbl1.column2 &< tbl2.column2 AS overleft
|
|
FROM
|
|
( VALUES
|
|
(1, 'LINESTRING(1 2, 4 6)'::geometry)) AS tbl1,
|
|
( VALUES
|
|
(2, 'LINESTRING(0 0, 3 3)'::geometry),
|
|
(3, 'LINESTRING(0 1, 0 5)'::geometry),
|
|
(4, 'LINESTRING(6 0, 6 1)'::geometry)) AS tbl2;
|
|
|
|
column1 | column1 | overleft
|
|
---------+---------+----------
|
|
1 | 2 | f
|
|
1 | 3 | f
|
|
1 | 4 | t
|
|
(3 rows)</programlisting>
|
|
</refsection>
|
|
|
|
<refsection>
|
|
<title>See Also</title>
|
|
|
|
<para>
|
|
<xref linkend="ST_Geometry_Overlap" />,
|
|
<xref linkend="ST_Geometry_Overabove" />,
|
|
<xref linkend="ST_Geometry_Overright" />,
|
|
<xref linkend="ST_Geometry_Overbelow" /></para>
|
|
</refsection>
|
|
</refentry>
|
|
|
|
<refentry id="ST_Geometry_Overbelow">
|
|
<refnamediv>
|
|
<refname>&<|</refname>
|
|
|
|
<refpurpose>Returns <varname>TRUE</varname> if A's bounding box overlaps or is below B's.</refpurpose>
|
|
</refnamediv>
|
|
|
|
<refsynopsisdiv>
|
|
<funcsynopsis>
|
|
<funcprototype>
|
|
<!-- TODO: Ideally, it would be nice if this could be reordered to
|
|
"boolean (geometry A &<| geometry B)" instead of
|
|
"boolean &<|( geometry A, geometry B)" -->
|
|
<funcdef>boolean <function>&<|</function></funcdef>
|
|
|
|
<paramdef>
|
|
<type>geometry </type>
|
|
|
|
<parameter>A</parameter>
|
|
</paramdef>
|
|
|
|
<paramdef>
|
|
<type>geometry </type>
|
|
|
|
<parameter>B</parameter>
|
|
</paramdef>
|
|
</funcprototype>
|
|
</funcsynopsis>
|
|
</refsynopsisdiv>
|
|
|
|
<refsection>
|
|
<title>Description</title>
|
|
|
|
<para>The <varname>&<|</varname> operator returns <varname>TRUE</varname> if the bounding box of geometry A
|
|
overlaps or is below of the bounding box of geometry B, or more accurately, overlaps or is NOT above the bounding
|
|
box of geometry B.</para>
|
|
|
|
<para>&curve_support;</para>
|
|
|
|
<note><para>This operand will make use of any indexes that may be available on the
|
|
geometries.</para></note>
|
|
</refsection>
|
|
|
|
<refsection>
|
|
<title>Examples</title>
|
|
|
|
<programlisting>SELECT tbl1.column1, tbl2.column1, tbl1.column2 &<| tbl2.column2 AS overbelow
|
|
FROM
|
|
( VALUES
|
|
(1, 'LINESTRING(6 0, 6 4)'::geometry)) AS tbl1,
|
|
( VALUES
|
|
(2, 'LINESTRING(0 0, 3 3)'::geometry),
|
|
(3, 'LINESTRING(0 1, 0 5)'::geometry),
|
|
(4, 'LINESTRING(1 2, 4 6)'::geometry)) AS tbl2;
|
|
|
|
column1 | column1 | overbelow
|
|
---------+---------+-----------
|
|
1 | 2 | f
|
|
1 | 3 | t
|
|
1 | 4 | t
|
|
(3 rows)</programlisting>
|
|
</refsection>
|
|
|
|
<refsection>
|
|
<title>See Also</title>
|
|
|
|
<para>
|
|
<xref linkend="ST_Geometry_Overlap" />,
|
|
<xref linkend="ST_Geometry_Overabove" />,
|
|
<xref linkend="ST_Geometry_Overright" />,
|
|
<xref linkend="ST_Geometry_Overleft" /></para>
|
|
</refsection>
|
|
</refentry>
|
|
|
|
<refentry id="ST_Geometry_Overright">
|
|
<refnamediv>
|
|
<refname>&></refname>
|
|
|
|
<refpurpose>Returns <varname>TRUE</varname> if A' bounding box overlaps or is to the right of B's.</refpurpose>
|
|
</refnamediv>
|
|
|
|
<refsynopsisdiv>
|
|
<funcsynopsis>
|
|
<funcprototype>
|
|
<!-- TODO: Ideally, it would be nice if this could be reordered to
|
|
"boolean (geometry A &> geometry B)" instead of
|
|
"boolean &>( geometry A, geometry B)" -->
|
|
<funcdef>boolean <function>&></function></funcdef>
|
|
|
|
<paramdef>
|
|
<type>geometry </type>
|
|
|
|
<parameter>A</parameter>
|
|
</paramdef>
|
|
|
|
<paramdef>
|
|
<type>geometry </type>
|
|
|
|
<parameter>B</parameter>
|
|
</paramdef>
|
|
</funcprototype>
|
|
</funcsynopsis>
|
|
</refsynopsisdiv>
|
|
|
|
<refsection>
|
|
<title>Description</title>
|
|
|
|
<para>The <varname>&></varname> operator returns <varname>TRUE</varname> if the bounding box of geometry A
|
|
overlaps or is to the right of the bounding box of geometry B, or more accurately, overlaps or is NOT to the left
|
|
of the bounding box of geometry B.</para>
|
|
|
|
<note><para>This operand will make use of any indexes that may be available on the
|
|
geometries.</para></note>
|
|
</refsection>
|
|
|
|
<refsection>
|
|
<title>Examples</title>
|
|
|
|
<programlisting>SELECT tbl1.column1, tbl2.column1, tbl1.column2 &> tbl2.column2 AS overright
|
|
FROM
|
|
( VALUES
|
|
(1, 'LINESTRING(1 2, 4 6)'::geometry)) AS tbl1,
|
|
( VALUES
|
|
(2, 'LINESTRING(0 0, 3 3)'::geometry),
|
|
(3, 'LINESTRING(0 1, 0 5)'::geometry),
|
|
(4, 'LINESTRING(6 0, 6 1)'::geometry)) AS tbl2;
|
|
|
|
column1 | column1 | overright
|
|
---------+---------+-----------
|
|
1 | 2 | t
|
|
1 | 3 | t
|
|
1 | 4 | f
|
|
(3 rows)</programlisting>
|
|
</refsection>
|
|
|
|
<refsection>
|
|
<title>See Also</title>
|
|
|
|
<para>
|
|
<xref linkend="ST_Geometry_Overlap" />,
|
|
<xref linkend="ST_Geometry_Overabove" />,
|
|
<xref linkend="ST_Geometry_Overbelow" />,
|
|
<xref linkend="ST_Geometry_Overleft" /></para>
|
|
</refsection>
|
|
</refentry>
|
|
|
|
<refentry id="ST_Geometry_Left">
|
|
<refnamediv>
|
|
<refname><<</refname>
|
|
|
|
<refpurpose>Returns <varname>TRUE</varname> if A's bounding box is strictly to the left of B's.</refpurpose>
|
|
</refnamediv>
|
|
|
|
<refsynopsisdiv>
|
|
<funcsynopsis>
|
|
<funcprototype>
|
|
<!-- TODO: Ideally, it would be nice if this could be reordered to
|
|
"boolean (geometry A << geometry B)" instead of
|
|
"boolean <<( geometry A, geometry B)" -->
|
|
<funcdef>boolean <function><<</function></funcdef>
|
|
|
|
<paramdef>
|
|
<type>geometry </type>
|
|
|
|
<parameter>A</parameter>
|
|
</paramdef>
|
|
|
|
<paramdef>
|
|
<type>geometry </type>
|
|
|
|
<parameter>B</parameter>
|
|
</paramdef>
|
|
</funcprototype>
|
|
</funcsynopsis>
|
|
</refsynopsisdiv>
|
|
|
|
<refsection>
|
|
<title>Description</title>
|
|
|
|
<para>The <varname><<</varname> operator returns <varname>TRUE</varname> if the bounding box of geometry A
|
|
is strictly to the left of the bounding box of geometry B.</para>
|
|
|
|
<note><para>This operand will make use of any indexes that may be available on the
|
|
geometries.</para></note>
|
|
</refsection>
|
|
|
|
<refsection>
|
|
<title>Examples</title>
|
|
|
|
<programlisting>SELECT tbl1.column1, tbl2.column1, tbl1.column2 << tbl2.column2 AS left
|
|
FROM
|
|
( VALUES
|
|
(1, 'LINESTRING (1 2, 1 5)'::geometry)) AS tbl1,
|
|
( VALUES
|
|
(2, 'LINESTRING (0 0, 4 3)'::geometry),
|
|
(3, 'LINESTRING (6 0, 6 5)'::geometry),
|
|
(4, 'LINESTRING (2 2, 5 6)'::geometry)) AS tbl2;
|
|
|
|
column1 | column1 | left
|
|
---------+---------+------
|
|
1 | 2 | f
|
|
1 | 3 | t
|
|
1 | 4 | t
|
|
(3 rows)</programlisting>
|
|
</refsection>
|
|
|
|
<refsection>
|
|
<title>See Also</title>
|
|
|
|
<para><xref linkend="ST_Geometry_Right" />, <xref linkend="ST_Geometry_Above" />, <xref linkend="ST_Geometry_Below" /></para>
|
|
</refsection>
|
|
</refentry>
|
|
|
|
<refentry id="ST_Geometry_Below">
|
|
<refnamediv>
|
|
<refname><<|</refname>
|
|
|
|
<refpurpose>Returns <varname>TRUE</varname> if A's bounding box is strictly below B's.</refpurpose>
|
|
</refnamediv>
|
|
|
|
<refsynopsisdiv>
|
|
<funcsynopsis>
|
|
<funcprototype>
|
|
<!-- TODO: Ideally, it would be nice if this could be reordered to
|
|
"boolean (geometry A <<| geometry B)" instead of
|
|
"boolean <<|( geometry A, geometry B)" -->
|
|
<funcdef>boolean <function><<|</function></funcdef>
|
|
|
|
<paramdef>
|
|
<type>geometry </type>
|
|
|
|
<parameter>A</parameter>
|
|
</paramdef>
|
|
|
|
<paramdef>
|
|
<type>geometry </type>
|
|
|
|
<parameter>B</parameter>
|
|
</paramdef>
|
|
</funcprototype>
|
|
</funcsynopsis>
|
|
</refsynopsisdiv>
|
|
|
|
<refsection>
|
|
<title>Description</title>
|
|
|
|
<para>The <varname><<|</varname> operator returns <varname>TRUE</varname> if the bounding box of geometry A
|
|
is strictly below the bounding box of geometry B.</para>
|
|
|
|
<note><para>This operand will make use of any indexes that may be available on the
|
|
geometries.</para></note>
|
|
</refsection>
|
|
|
|
<refsection>
|
|
<title>Examples</title>
|
|
|
|
<programlisting>SELECT tbl1.column1, tbl2.column1, tbl1.column2 <<| tbl2.column2 AS below
|
|
FROM
|
|
( VALUES
|
|
(1, 'LINESTRING (0 0, 4 3)'::geometry)) AS tbl1,
|
|
( VALUES
|
|
(2, 'LINESTRING (1 4, 1 7)'::geometry),
|
|
(3, 'LINESTRING (6 1, 6 5)'::geometry),
|
|
(4, 'LINESTRING (2 3, 5 6)'::geometry)) AS tbl2;
|
|
|
|
column1 | column1 | below
|
|
---------+---------+-------
|
|
1 | 2 | t
|
|
1 | 3 | f
|
|
1 | 4 | f
|
|
(3 rows)</programlisting>
|
|
</refsection>
|
|
|
|
<refsection>
|
|
<title>See Also</title>
|
|
|
|
<para><xref linkend="ST_Geometry_Left" />, <xref linkend="ST_Geometry_Right" />, <xref linkend="ST_Geometry_Above" /></para>
|
|
</refsection>
|
|
</refentry>
|
|
|
|
<refentry id="ST_Geometry_EQ">
|
|
<refnamediv>
|
|
<refname>=</refname>
|
|
|
|
<refpurpose>Returns <varname>TRUE</varname> if A's bounding box is the same as B's.</refpurpose>
|
|
</refnamediv>
|
|
|
|
<refsynopsisdiv>
|
|
<funcsynopsis>
|
|
<funcprototype>
|
|
<!-- TODO: Ideally, it would be nice if this could be reordered to
|
|
"boolean (geometry A = geometry B)" instead of
|
|
"boolean =( geometry A, geometry B)" -->
|
|
<funcdef>boolean <function>=</function></funcdef>
|
|
|
|
<paramdef>
|
|
<type>geometry </type>
|
|
|
|
<parameter>A</parameter>
|
|
</paramdef>
|
|
|
|
<paramdef>
|
|
<type>geometry </type>
|
|
|
|
<parameter>B</parameter>
|
|
</paramdef>
|
|
</funcprototype>
|
|
|
|
<funcprototype>
|
|
<funcdef>boolean <function>=</function></funcdef>
|
|
|
|
<paramdef>
|
|
<type>geography </type>
|
|
|
|
<parameter>A</parameter>
|
|
</paramdef>
|
|
|
|
<paramdef>
|
|
<type>geography </type>
|
|
|
|
<parameter>B</parameter>
|
|
</paramdef>
|
|
</funcprototype>
|
|
</funcsynopsis>
|
|
</refsynopsisdiv>
|
|
|
|
<refsection>
|
|
<title>Description</title>
|
|
|
|
<para>The <varname>=</varname> operator returns <varname>TRUE</varname> if the bounding box of geometry/geography A
|
|
is the same as the bounding box of geometry/geography B. PostgreSQL uses the =, <, and > operators defined for geometries to
|
|
perform internal orderings and comparison of geometries (ie. in a GROUP BY or ORDER BY clause).</para>
|
|
|
|
<warning>
|
|
<para>This is cause for a lot of confusion. When you compare geometryA =
|
|
geometryB it will return true even when the geometries are clearly
|
|
different IF their bounding boxes are the same. To check for true
|
|
equality use <xref linkend="ST_OrderingEquals" /> or <xref
|
|
linkend="ST_Equals" /></para>
|
|
</warning>
|
|
|
|
<caution><para>This operand will NOT make use of any indexes that may be available on the
|
|
geometries.</para></caution>
|
|
|
|
<para>&curve_support;</para>
|
|
|
|
</refsection>
|
|
|
|
<refsection>
|
|
<title>Examples</title>
|
|
|
|
<programlisting>SELECT 'LINESTRING(0 0, 0 1, 1 0)'::geometry = 'LINESTRING(1 1, 0 0)'::geometry;
|
|
?column?
|
|
----------
|
|
t
|
|
(1 row)
|
|
|
|
SELECT ST_AsText(column1)
|
|
FROM ( VALUES
|
|
('LINESTRING(0 0, 1 1)'::geometry),
|
|
('LINESTRING(1 1, 0 0)'::geometry)) AS foo;
|
|
st_astext
|
|
---------------------
|
|
LINESTRING(0 0,1 1)
|
|
LINESTRING(1 1,0 0)
|
|
(2 rows)
|
|
|
|
-- Note: the GROUP BY uses the "=" to compare for geometry equivalency.
|
|
SELECT ST_AsText(column1)
|
|
FROM ( VALUES
|
|
('LINESTRING(0 0, 1 1)'::geometry),
|
|
('LINESTRING(1 1, 0 0)'::geometry)) AS foo
|
|
GROUP BY column1;
|
|
st_astext
|
|
---------------------
|
|
LINESTRING(0 0,1 1)
|
|
(1 row)</programlisting>
|
|
</refsection>
|
|
|
|
<refsection>
|
|
<title>See Also</title>
|
|
|
|
<para><xref linkend="ST_Equals" />, <xref linkend="ST_OrderingEquals" />, <xref linkend="ST_Geometry_Same" />
|
|
<!--, <xref linkend="ST_Geometry_LT" />, <xref linkend="ST_Geometry_GT" /> --></para>
|
|
</refsection>
|
|
</refentry>
|
|
|
|
<refentry id="ST_Geometry_Right">
|
|
<refnamediv>
|
|
<refname>>></refname>
|
|
|
|
<refpurpose>Returns <varname>TRUE</varname> if A's bounding box is strictly to the right of B's.</refpurpose>
|
|
</refnamediv>
|
|
|
|
<refsynopsisdiv>
|
|
<funcsynopsis>
|
|
<funcprototype>
|
|
<!-- TODO: Ideally, it would be nice if this could be reordered to
|
|
"boolean (geometry A >> geometry B)" instead of
|
|
"boolean >>( geometry A, geometry B)" -->
|
|
<funcdef>boolean <function>>></function></funcdef>
|
|
|
|
<paramdef>
|
|
<type>geometry </type>
|
|
|
|
<parameter>A</parameter>
|
|
</paramdef>
|
|
|
|
<paramdef>
|
|
<type>geometry </type>
|
|
|
|
<parameter>B</parameter>
|
|
</paramdef>
|
|
</funcprototype>
|
|
</funcsynopsis>
|
|
</refsynopsisdiv>
|
|
|
|
<refsection>
|
|
<title>Description</title>
|
|
|
|
<para>The <varname>>></varname> operator returns <varname>TRUE</varname> if the bounding box of geometry A
|
|
is strictly to the right of the bounding box of geometry B.</para>
|
|
|
|
<note><para>This operand will make use of any indexes that may be available on the
|
|
geometries.</para></note>
|
|
</refsection>
|
|
|
|
<refsection>
|
|
<title>Examples</title>
|
|
|
|
<programlisting>SELECT tbl1.column1, tbl2.column1, tbl1.column2 >> tbl2.column2 AS right
|
|
FROM
|
|
( VALUES
|
|
(1, 'LINESTRING (2 3, 5 6)'::geometry)) AS tbl1,
|
|
( VALUES
|
|
(2, 'LINESTRING (1 4, 1 7)'::geometry),
|
|
(3, 'LINESTRING (6 1, 6 5)'::geometry),
|
|
(4, 'LINESTRING (0 0, 4 3)'::geometry)) AS tbl2;
|
|
|
|
column1 | column1 | right
|
|
---------+---------+-------
|
|
1 | 2 | t
|
|
1 | 3 | f
|
|
1 | 4 | f
|
|
(3 rows)</programlisting>
|
|
</refsection>
|
|
|
|
<refsection>
|
|
<title>See Also</title>
|
|
|
|
<para><xref linkend="ST_Geometry_Left" />, <xref linkend="ST_Geometry_Above" />, <xref linkend="ST_Geometry_Below" /></para>
|
|
</refsection>
|
|
</refentry>
|
|
|
|
<refentry id="ST_Geometry_Contained">
|
|
<refnamediv>
|
|
<refname>@</refname>
|
|
|
|
<refpurpose>Returns <varname>TRUE</varname> if A's bounding box is contained by B's.</refpurpose>
|
|
</refnamediv>
|
|
|
|
<refsynopsisdiv>
|
|
<funcsynopsis>
|
|
<funcprototype>
|
|
<!-- TODO: Ideally, it would be nice if this could be reordered to
|
|
"boolean (geometry A @ geometry B)" instead of
|
|
"boolean @( geometry A, geometry B)" -->
|
|
<funcdef>boolean <function>~=</function></funcdef>
|
|
|
|
<paramdef>
|
|
<type>geometry </type>
|
|
|
|
<parameter>A</parameter>
|
|
</paramdef>
|
|
|
|
<paramdef>
|
|
<type>geometry </type>
|
|
|
|
<parameter>B</parameter>
|
|
</paramdef>
|
|
</funcprototype>
|
|
</funcsynopsis>
|
|
</refsynopsisdiv>
|
|
|
|
<refsection>
|
|
<title>Description</title>
|
|
|
|
<para>The <varname>@</varname> operator returns <varname>TRUE</varname> if the bounding box of geometry A is completely
|
|
contained by the bounding box of geometry B.</para>
|
|
|
|
<note>
|
|
<para>This operand will make use of any indexes that may be available on the
|
|
geometries.</para>
|
|
</note>
|
|
</refsection>
|
|
|
|
<refsection>
|
|
<title>Examples</title>
|
|
|
|
<programlisting>SELECT tbl1.column1, tbl2.column1, tbl1.column2 @ tbl2.column2 AS contained
|
|
FROM
|
|
( VALUES
|
|
(1, 'LINESTRING (1 1, 3 3)'::geometry)) AS tbl1,
|
|
( VALUES
|
|
(2, 'LINESTRING (0 0, 4 4)'::geometry),
|
|
(3, 'LINESTRING (2 2, 4 4)'::geometry),
|
|
(4, 'LINESTRING (1 1, 3 3)'::geometry)) AS tbl2;
|
|
|
|
column1 | column1 | contained
|
|
---------+---------+-----------
|
|
1 | 2 | t
|
|
1 | 3 | f
|
|
1 | 4 | t
|
|
(3 rows)</programlisting>
|
|
</refsection>
|
|
|
|
<refsection>
|
|
<title>See Also</title>
|
|
|
|
<para><xref linkend="ST_Geometry_Contain" />, <xref linkend="ST_Geometry_Overlap" /></para>
|
|
</refsection>
|
|
</refentry>
|
|
|
|
<refentry id="ST_Geometry_Overabove">
|
|
<refnamediv>
|
|
<refname>|&></refname>
|
|
|
|
<refpurpose>Returns <varname>TRUE</varname> if A's bounding box overlaps or is above B's.</refpurpose>
|
|
</refnamediv>
|
|
|
|
<refsynopsisdiv>
|
|
<funcsynopsis>
|
|
<funcprototype>
|
|
<!-- TODO: Ideally, it would be nice if this could be reordered to
|
|
"boolean (geometry A |&> geometry B)" instead of
|
|
"boolean |&>( geometry A, geometry B)" -->
|
|
<funcdef>boolean <function>|&></function></funcdef>
|
|
|
|
<paramdef>
|
|
<type>geometry </type>
|
|
|
|
<parameter>A</parameter>
|
|
</paramdef>
|
|
|
|
<paramdef>
|
|
<type>geometry </type>
|
|
|
|
<parameter>B</parameter>
|
|
</paramdef>
|
|
</funcprototype>
|
|
</funcsynopsis>
|
|
</refsynopsisdiv>
|
|
|
|
<refsection>
|
|
<title>Description</title>
|
|
|
|
<para>The <varname>|&></varname> operator returns <varname>TRUE</varname> if the bounding box of geometry A
|
|
overlaps or is above the bounding box of geometry B, or more accurately, overlaps or is NOT below
|
|
the bounding box of geometry B.</para>
|
|
|
|
<note><para>This operand will make use of any indexes that may be available on the
|
|
geometries.</para></note>
|
|
</refsection>
|
|
|
|
<refsection>
|
|
<title>Examples</title>
|
|
|
|
<programlisting>SELECT tbl1.column1, tbl2.column1, tbl1.column2 |&> tbl2.column2 AS overabove
|
|
FROM
|
|
( VALUES
|
|
(1, 'LINESTRING(6 0, 6 4)'::geometry)) AS tbl1,
|
|
( VALUES
|
|
(2, 'LINESTRING(0 0, 3 3)'::geometry),
|
|
(3, 'LINESTRING(0 1, 0 5)'::geometry),
|
|
(4, 'LINESTRING(1 2, 4 6)'::geometry)) AS tbl2;
|
|
|
|
column1 | column1 | overabove
|
|
---------+---------+-----------
|
|
1 | 2 | t
|
|
1 | 3 | f
|
|
1 | 4 | f
|
|
(3 rows)</programlisting>
|
|
</refsection>
|
|
|
|
<refsection>
|
|
<title>See Also</title>
|
|
|
|
<para>
|
|
<xref linkend="ST_Geometry_Overlap" />,
|
|
<xref linkend="ST_Geometry_Overright" />,
|
|
<xref linkend="ST_Geometry_Overbelow" />,
|
|
<xref linkend="ST_Geometry_Overleft" /></para>
|
|
</refsection>
|
|
</refentry>
|
|
|
|
<refentry id="ST_Geometry_Above">
|
|
<refnamediv>
|
|
<refname>|>></refname>
|
|
|
|
<refpurpose>Returns <varname>TRUE</varname> if A's bounding box is strictly above B's.</refpurpose>
|
|
</refnamediv>
|
|
|
|
<refsynopsisdiv>
|
|
<funcsynopsis>
|
|
<funcprototype>
|
|
<!-- TODO: Ideally, it would be nice if this could be reordered to
|
|
"boolean (geometry A |>> geometry B)" instead of
|
|
"boolean |>>( geometry A, geometry B)" -->
|
|
<funcdef>boolean <function>|>></function></funcdef>
|
|
|
|
<paramdef>
|
|
<type>geometry </type>
|
|
|
|
<parameter>A</parameter>
|
|
</paramdef>
|
|
|
|
<paramdef>
|
|
<type>geometry </type>
|
|
|
|
<parameter>B</parameter>
|
|
</paramdef>
|
|
</funcprototype>
|
|
</funcsynopsis>
|
|
</refsynopsisdiv>
|
|
|
|
<refsection>
|
|
<title>Description</title>
|
|
|
|
<para>The <varname>|>></varname> operator returns <varname>TRUE</varname> if the bounding box of geometry A
|
|
is strictly to the right of the bounding box of geometry B.</para>
|
|
|
|
<note><para>This operand will make use of any indexes that may be available on the
|
|
geometries.</para></note>
|
|
</refsection>
|
|
|
|
<refsection>
|
|
<title>Examples</title>
|
|
|
|
<programlisting>SELECT tbl1.column1, tbl2.column1, tbl1.column2 |>> tbl2.column2 AS above
|
|
FROM
|
|
( VALUES
|
|
(1, 'LINESTRING (1 4, 1 7)'::geometry)) AS tbl1,
|
|
( VALUES
|
|
(2, 'LINESTRING (0 0, 4 2)'::geometry),
|
|
(3, 'LINESTRING (6 1, 6 5)'::geometry),
|
|
(4, 'LINESTRING (2 3, 5 6)'::geometry)) AS tbl2;
|
|
|
|
column1 | column1 | above
|
|
---------+---------+-------
|
|
1 | 2 | t
|
|
1 | 3 | f
|
|
1 | 4 | f
|
|
(3 rows)</programlisting>
|
|
</refsection>
|
|
|
|
<refsection>
|
|
<title>See Also</title>
|
|
|
|
<para><xref linkend="ST_Geometry_Left" />, <xref linkend="ST_Geometry_Right" />, <xref linkend="ST_Geometry_Below" /></para>
|
|
</refsection>
|
|
</refentry>
|
|
|
|
<refentry id="ST_Geometry_Contain">
|
|
<refnamediv>
|
|
<refname>~</refname>
|
|
|
|
<refpurpose>Returns <varname>TRUE</varname> if A's bounding box contains B's.</refpurpose>
|
|
</refnamediv>
|
|
|
|
<refsynopsisdiv>
|
|
<funcsynopsis>
|
|
<funcprototype>
|
|
<!-- TODO: Ideally, it would be nice if this could be reordered to
|
|
"boolean (geometry A ~ geometry B)" instead of
|
|
"boolean ~( geometry A, geometry B)" -->
|
|
<funcdef>boolean <function>~</function></funcdef>
|
|
|
|
<paramdef>
|
|
<type>geometry </type>
|
|
|
|
<parameter>A</parameter>
|
|
</paramdef>
|
|
|
|
<paramdef>
|
|
<type>geometry </type>
|
|
|
|
<parameter>B</parameter>
|
|
</paramdef>
|
|
</funcprototype>
|
|
</funcsynopsis>
|
|
</refsynopsisdiv>
|
|
|
|
<refsection>
|
|
<title>Description</title>
|
|
|
|
<para>The <varname>~</varname> operator returns <varname>TRUE</varname> if the bounding box of geometry A completely
|
|
contains the bounding box of geometry B.</para>
|
|
|
|
<note><para>This operand will make use of any indexes that may be available on the
|
|
geometries.</para></note>
|
|
</refsection>
|
|
|
|
<refsection>
|
|
<title>Examples</title>
|
|
|
|
<programlisting>SELECT tbl1.column1, tbl2.column1, tbl1.column2 ~ tbl2.column2 AS contains
|
|
FROM
|
|
( VALUES
|
|
(1, 'LINESTRING (0 0, 3 3)'::geometry)) AS tbl1,
|
|
( VALUES
|
|
(2, 'LINESTRING (0 0, 4 4)'::geometry),
|
|
(3, 'LINESTRING (1 1, 2 2)'::geometry),
|
|
(4, 'LINESTRING (0 0, 3 3)'::geometry)) AS tbl2;
|
|
|
|
column1 | column1 | contains
|
|
---------+---------+----------
|
|
1 | 2 | f
|
|
1 | 3 | t
|
|
1 | 4 | t
|
|
(3 rows)</programlisting>
|
|
</refsection>
|
|
|
|
<refsection>
|
|
<title>See Also</title>
|
|
|
|
<para><xref linkend="ST_Geometry_Contained" />, <xref linkend="ST_Geometry_Overlap" /></para>
|
|
</refsection>
|
|
</refentry>
|
|
|
|
<refentry id="ST_Geometry_Same">
|
|
<refnamediv>
|
|
<refname>~=</refname>
|
|
|
|
<refpurpose>Returns <varname>TRUE</varname> if A's bounding box is the same as B's.</refpurpose>
|
|
</refnamediv>
|
|
|
|
<refsynopsisdiv>
|
|
<funcsynopsis>
|
|
<funcprototype>
|
|
<!-- TODO: Ideally, it would be nice if this could be reordered to
|
|
"boolean (geometry A ~= geometry B)" instead of
|
|
"boolean ~=( geometry A, geometry B)" -->
|
|
<funcdef>boolean <function>~=</function></funcdef>
|
|
|
|
<paramdef>
|
|
<type>geometry </type>
|
|
|
|
<parameter>A</parameter>
|
|
</paramdef>
|
|
|
|
<paramdef>
|
|
<type>geometry </type>
|
|
|
|
<parameter>B</parameter>
|
|
</paramdef>
|
|
</funcprototype>
|
|
<funcprototype>
|
|
<funcdef>boolean <function>~=</function></funcdef>
|
|
|
|
<paramdef>
|
|
<type>geography </type>
|
|
|
|
<parameter>A</parameter>
|
|
</paramdef>
|
|
|
|
<paramdef>
|
|
<type>geography </type>
|
|
|
|
<parameter>B</parameter>
|
|
</paramdef>
|
|
</funcprototype>
|
|
</funcsynopsis>
|
|
</refsynopsisdiv>
|
|
|
|
<refsection>
|
|
<title>Description</title>
|
|
|
|
<para>The <varname>~=</varname> operator returns <varname>TRUE</varname> if the bounding box of geometry/geography A
|
|
is the same as the bounding box of geometry/geography B.</para>
|
|
|
|
<note><para>This operand will make use of any indexes that may be available on the
|
|
geometries.</para></note>
|
|
|
|
<para>Availability: 1.5.0 changed behavior</para>
|
|
</refsection>
|
|
|
|
<warning>
|
|
<para>This operator has changed behavior in PostGIS 1.5
|
|
from testing for actual geometric equality to only
|
|
checking for bounding box equality. To complicate things
|
|
it also depends on if you have done a hard or soft upgrade
|
|
which behavior your database has. To find out which behavior
|
|
your database has you can run the query below.
|
|
To check for true equality use <xref linkend="ST_OrderingEquals" /> or <xref
|
|
linkend="ST_Equals" /> and to check for bounding box equality <xref linkend="ST_Geometry_EQ" />;
|
|
operator is a safer option.</para>
|
|
</warning>
|
|
<refsection>
|
|
<title>Examples</title>
|
|
<programlisting>
|
|
|
|
select 'LINESTRING(0 0, 1 1)'::geometry ~= 'LINESTRING(0 1, 1 0)'::geometry as equality;
|
|
equality |
|
|
-----------------+
|
|
t |
|
|
</programlisting>
|
|
<para>The above can be used to test if you have the new or old behavior of ~= operator.</para>
|
|
</refsection>
|
|
<refsection>
|
|
<title>See Also</title>
|
|
<para><xref linkend="ST_Equals" />, <xref linkend="ST_OrderingEquals" />, <xref linkend="ST_Geometry_EQ" /></para>
|
|
</refsection>
|
|
</refentry>
|
|
|
|
</sect1>
|