
  OpenGIS <http://www.opengis.org> support in MySQL

------------------------------------------------------------------------
Note: Blue colored lines among the text is features not implemented yet.
They are:

    * Spatial Reference Systems and their IDs (SRIDs) related things:
          o Functions like Length() and Area() assume planar coordinate
            system.
          o All objects are currently considered to be in the same
      planar coordinate system.
    * Function Length() on LineString and MultiLineString currently
      should be called as GLength().
* No binary constructors like GeomFromWKB().

We also have to add "PostGIS compatibility" sections.


  1 Introduction

MySQL implements a subset of *SQL2 with Geometry Types* environment
proposed by OpenGIS consortium's *Simple Features Specification For
SQL*. In this environment a geometry-valued column is implemented as a
column whose SQL type is drawn from the set of Geometry Types. SQL
server supports both textual and binary access to geometry.


  2 OpenGIS Geometry Model in MySQL

MySQL supports the Open GIS Geometry Model based hierarcy of spatial
objects classes, which consists of:

    * Geometry
          o *Point*
          o Curve
          + *LineString*
          o Surface
          + *Polygon*
          o *GeometryCollection*
                + *MultiPoint*
                + MultiCurve
                # *MultiLineString*
                + MultiSurface
                # *MultiPolygon*

The base *Geometry* class has subclasses for Point, Curve, Surface and
GeometryCollection.

Geometry, Curve, Surface, MultiCurve and MultiSurface are defined to be
non-instantiable classes, it is not possible to create an object of
these classes.

Point, LineString, Polygon, GeometryCollection, MultiPoint,
MultiLineString, MultiPolygon are instantiable classes (bolded on the
hierarcy tree). MySQL provides a number of functions to construct
instances of these classes.

TODO: Each spatial object is associated with a Spatial Reference System,
which describes the coordinate space in which the geometric object is
defined.


    2.1 Geometry

Geometry is the root class of the hierarchy. Geometry is an abstract
(non-instantiable) class. The instantiable subclasses of Geometry
defined in this specification are restricted to 0, 1 and two-dimensional
geometric objects that exist in two-dimensional coordinate space. All
instantiable geometry classes are defined so that valid instances of a
geometry class are topologically closed (i.e. all defined geometries
include their boundary).


    2.2 Point

A *Point* is a 0-dimensional geometry and represents a single location
in coordinate space. A Point in the case of 2D has a x-coordinate value
and a y-coordinate value. In the case of more dimensions, a Point has a
coordinate value for each dimension. The boundary of a Point is the
empty set.


    2.3 Curve

A *Curve* is a one-dimensional geometric object usually stored as a
sequence of points, with the subclass of Curve specifying the form of
the interpolation between points. MySQL implementation defines only one
subclass of Curve, LineString, which uses linear interpolation between
points.

A Curve is simple if it does not pass through the same point twice. A
Curve is closed if its start point is equal to its end point. The
boundary of a closed Curve is empty. A Curve that is simple and closed
is a Ring. The boundary of a non-closed Curve consists of its two end
points. A Curve is defined as topologically closed.


    2.4 LineString, Line, LinearRing

A LineString is a Curve with linear interpolation between points. Each
consecutive pair of points defines a line segment. A Line is a
LineString with exactly 2 points. A LinearRing is a LineString that is
both closed and simple.


    2.5 Surface

A *Surface* is a two-dimensional geometric object. The OpenGIS Abstract
Specification defines a simple Surface as consisting of a single 'patch'
that is associated with one 'exterior boundary' and 0 or more 'interior'
boundaries. Simple surfaces in three-dimensional space are isomorphic to
planar surfaces. Polyhedral surfaces are formed by 'stitching' together
simple surfaces along their boundaries, polyhedral surfaces in
three-dimensional space may not be planar as a whole.

The boundary of a simple Surface is the set of closed curves
corresponding to its exterior and interior boundaries.

The only instantiable subclass of Surface defined in this specification,
Polygon, is a simple Surface that is planar.


    2.6 Polygon

A Polygon is a planar Surface, defined by 1 exterior boundary and 0 or
more interior boundaries. Each interior boundary defines a hole in the
Polygon. The assertions for polygons (the rules that define valid
polygons) are:

    * Polygons are topologically closed.
    * The boundary of a Polygon consists of a set of LinearRings (i.e.
      LineStrings which are both simple and closed) that make up its
      exterior and interior boundaries.
    * No two rings in the boundary cross, the rings in the boundary of a
      Polygon may intersect at a Point but only as a tangent.
    * A Polygon may not have cut lines, spikes or punctures.
    * The Interior of every Polygon is a connected point set.
    * The Exterior of a Polygon with 1 or more holes is not connected.
Each hole defines a connected component of the Exterior.

In the above assertions, Interior, Closure and Exterior have the
standard topological definitions. The combination of 1 and 3 make a
Polygon a Regular Closed point set. Polygons are simple geometries.


    2.6 GeometryCollection

A *GeometryCollection* is a geometry that is a collection of 1 or more
geometries of any class. All the elements in a GeometryCollection must
be in the same Spatial Reference (i.e. in the same coordinate system).
GeometryCollection places no other constraints on its elements. However
subclasses of GeometryCollection described below may restrict membership
based on dimension and may also place other constraints on the degree of
spatial overlap between elements.


    2.7 MultiPoint

A *MultiPoint* is a 0 dimensional geometric collection. The elements of
a MultiPoint are restricted to Points. The points are not connected or
ordered. A MultiPoint is simple if no two Points in the MultiPoint are
equal (have identical coordinate values). The boundary of a MultiPoint
is the empty set.


    2.8 MultiCurve

A MultiCurve is a one-dimensional geometry collection whose elements are
Curves. MultiCurve is a non-instantiable class, it defines a set of
methods for its subclasses and is included for reasons of extensibility.

A MultiCurve is simple if and only if all of its elements are simple,
the only intersections between any two elements occur at points that are
on the boundaries of both elements.

The boundary of a MultiCurve is obtained by applying the "mod 2 union
rule": A point is in the boundary of a MultiCurve if it is in the
boundaries of an odd number of elements of the MultiCurve.

A MultiCurve is closed if all of its elements are closed. The boundary
of a closed MultiCurve is always empty. A MultiCurve is defined as
topologically closed.


    2.9 MultiLineString

A *MultiLineString* is a MultiCurve whose elements are LineStrings.


    2.10 MultiSurface

A MultiSurface is a two-dimensional geometric collection whose elements
are surfaces. The interiors of any two surfaces in a MultiSurface may
not intersect. The boundaries of any two elements in a MultiSurface may
intersect at most at a finite number of points.

MultiSurface is a non-instantiable class in this specification, it
defines a set of methods for its subclasses and is included for reasons
of extensibility. The instantiable subclass of MultiSurface is
MultiPolygon, corresponding to a collection of Polygons.


    2.11 MultiPolygon

A MultiPolygon is a MultiSurface whose elements are Polygons.

The assertions for MultiPolygons are :

    * The interiors of 2 Polygons that are elements of a MultiPolygon
      may not intersect.
    * The Boundaries of any 2 Polygons that are elements of a
      MultiPolygon may not cross and may touch at only a finite number
      of points. (Note that crossing is prevented by assertion 1 above).
    * A MultiPolygon is defined as topologically closed.
    * A MultiPolygon may not have cut lines, spikes or punctures, a
      MultiPolygon is a Regular, Closed point set.
    * The interior of a MultiPolygon with more than 1 Polygon is not
      connected, the number of connected components of the interior of a
MultiPolygon is equal to the number of Polygons in the MultiPolygon.

The boundary of a MultiPolygon is a set of closed curves (LineStrings)
corresponding to the boundaries of its element Polygons. Each Curve in
the boundary of the MultiPolygon is in the boundary of exactly 1 element
Polygon, and every Curve in the boundary of an element Polygon is in the
boundary of the MultiPolygon.


  3 Exchange of spatial data

MySQL provides binary and textual mechanismes to exchange spatial data.
Exchange is provided via so called Well Known Binary (WKB) and Well
Known Textual (WKT) representations of spatial data proposed by OpenGIS
specifications.


    3.1 Well-known Text representation (WKT)

The Well-known Text (WKT) representation of Geometry is designed to
exchange geometry data in textual format.

WKT is defined below in Bechus-Naur forms:

    * the notation {}* denotes 0 or more repetitions of the tokens
      within the braces;
* the braces do not appear in the output token list.

The text representation of the implemented instantiable geometric types
conforms to this grammar:

<Geometry Tagged Text> :=
            <Point Tagged Text>
          | <LineString Tagged Text>
          | <Polygon Tagged Text>
          | <MultiPoint Tagged Text>
          | <MultiLineString Tagged Text>
          | <MultiPolygon Tagged Text>
          | <GeometryCollection Tagged Text>

<Point Tagged Text> :=

            POINT <Point Text>

<LineString Tagged Text> :=

            LINESTRING <LineString Text>

<Polygon Tagged Text> :=

            POLYGON <Polygon Text>

<MultiPoint Tagged Text> :=

            MULTIPOINT <Multipoint Text>

<MultiLineString Tagged Text> :=

            MULTILINESTRING <MultiLineString Text>

<MultiPolygon Tagged Text> :=

            MULTIPOLYGON <MultiPolygon Text>

<GeometryCollection Tagged Text> :=

            GEOMETRYCOLLECTION <GeometryCollection Text>

<Point Text> := EMPTY | ( <Point> )

<Point> := <x> <y>

<x> := double precision literal

<y> := double precision literal

<LineString Text> := EMPTY

          | ( <Point >  {, <Point > }* )

<Polygon Text> := EMPTY

          | ( <LineString Text >  {, < LineString Text > }*)

<Multipoint Text> := EMPTY

          | ( <Point Text >  {, <Point Text > }* )

<MultiLineString Text> := EMPTY

          | ( <LineString Text >  {, < LineString Text > }* )

<MultiPolygon Text> := EMPTY

          | ( < Polygon Text >  {, < Polygon Text > }* )

<GeometryCollection Text> := EMPTY

          | ( <Geometry Tagged Text> {, <Geometry Tagged Text> }* )


      WKT examples

Examples of textual representations of Geometry objects are shown below:

    * |POINT(10 10)| - a Point
    * |LINESTRING( 10 10, 20 20, 30 40)| - a LineString with three points
    * |POLYGON((10 10, 10 20, 20 20,20 15, 10 10))| - a Polygon with one
      exterior ring and 0 interior rings
    * |MULTIPOINT(10 10, 20 20)| - a MultiPoint with two Points
    * |MULTILINESTRING((10 10, 20 20), (15 15, 30 15))| - a
      MultiLineString with two LineStrings
    * |MULTIPOLYGON(((10 10, 10 20, 20 20, 20 15, 10 10)), ((60 60, 70
      70, 80 60, 60 60 ) ))| - a MultiPolygon with two Polygons
    * |GEOMETRYCOLLECTION( POINT (10 10),POINT (30 30), LINESTRING (15
      15, 20 20))| - a GeometryCollection consisting of two Points and
one LineString


    3.2 Well-known Binary representation (WKB)

Well Known Binary Representations is proposed by OpenGIS specifications
to exchange geometry data in binary format. This is WKB description:

// Basic Type definitions
// byte : 1 byte
// uint32 : 32 bit unsigned integer (4 bytes)
// double : double precision number (8 bytes)
// Building Blocks : Point, LinearRing

Point {
	double [numDimentions];
};

LinearRing  {
	uint32 numPoints;
	Point    points[numPoints];
}

enum wkbGeometryType {
	wkbPoint = 1,
	wkbLineString = 2,
	wkbPolygon = 3,
	wkbMultiPoint = 4,
	wkbMultiLineString = 5,
	wkbMultiPolygon = 6,
	wkbGeometryCollection = 7
};

enum wkbByteOrder {
	wkbXDR = 0,    // Big Endian
	wkbNDR = 1    // Little Endian
};

WKBPoint {
	byte    byteOrder;
	uint32    wkbType;     // 1
	Point    point;
}

WKBLineString {
	byte    byteOrder;
	uint32    wkbType;    // 2
	uint32    numPoints;
	Point    points[numPoints];
}

WKBPolygon {
	byte    byteOrder;
	uint32    wkbType;    // 3
	uint32    numRings;
	LinearRing    rings[numRings];
}

WKBMultiPoint {
	byte    byteOrder;
	uint32    wkbType;       // 4
	uint32    num_wkbPoints;
	WKBPoint    WKBPoints[num_wkbPoints];
}

WKBMultiLineString {
	byte    byteOrder;
	uint32    wkbType;    // 5
	uint32    num_wkbLineStrings;
	WKBLineString WKBLineStrings[num_wkbLineStrings];
}

wkbMultiPolygon {
	byte    byteOrder;
	uint32    wkbType;    // 6
	uint32    num_wkbPolygons;
	WKBPolygon    wkbPolygons[num_wkbPolygons];
}

WKBGeometry {
	union {
		WKBPoint    point;
		WKBLineString    linestring;
		WKBPolygon    polygon;
		WKBGeometryCollection    collection;
		WKBMultiPoint    mpoint;
		WKBMultiLineString    mlinestring;
		WKBMultiPolygon    mpolygon;
	}

};

WKBGeometryCollection {
	byte    byte_order;
	uint32    wkbType;    // 7
	uint32    num_wkbGeometries;
	WKBGeometry    wkbGeometries[num_wkbGeometries];
}


    3.3 MySQL data types for spatial objects

MySQL implementation of OpenGIS provides the *GEOMETRY* data type to be
used in CREATE TABLE statements. For example, this statement creates a
table *geom* with spatial field *g*:

CREATE TABLE geom (
	g Geometry;
);

A field of *GEOMETRY* type can store a spatial objects of any OpenGIS
geometry class described above.


    3.4 Internal spatial data representation

Internally (in *.MYD* files) spatial objects are stored in *WKB*,
combined with object's *SRID* (a numeric ID of Spatial Reference System
object associated with). During spatial analysis, for example,
calculating the fact that one object crosses another one, only those
with the same *SRID* are accepted.

*SRID* may affect a way in which various spatial characteristics are
calculated. For example, in different coordinate systems distance
between two objects may differ even objects have the same coordinates,
like distance on plane coordinate system and distance on geocentric
(coordinates on Earth surface) systems are different things.

There is a plan to provide a number of commonly used coordinate systems
in MySQL OpenGIS implementation.


    3.5 INSERTing spatial objects

Spatial data can be INSERTed using a spatial constructor. The term
*spatial constructor* is used in this manual to refer to any function
which can construct a value of GEOMETRY type, i.e. an internal MySQL
representation of spatial data.


      3.5.1 Textual spatial constructors

Textual spatial constructors take a gemometry description in WKT and
built GEOMETRY value.

    * |*GeomFromText(geometryTaggedText String [, SRID
      Integer]):Geometry *| - constructs a Geometry value from its
      well-known textual representation.

      |*GeomFromText()*| function accepts a WKT of any Geometry class as
      it's first argument.

      For construction of Geometry values restricted to a particular
      subclass, an implementation also provides a class-specific
      construction function for each instantiable subtype as described
      in the list below:

    * |*PointFromText(pointTaggedText String [,SRID Integer]):Point *| -
      constructs a Point

    * |*LineFromText(lineStringTaggedText String [,SRID
      Integer]):LineString *| - constructs a LineString

    * |*PolyFromText(polygonTaggedText String [,SRID Integer]):Polygon
      *|- constructs a Polygon

    * |*MPointFromText(multiPointTaggedText String [,SRID
      Integer]):MultiPoint *| - constructs a MultiPoint

    * |*MLineFromText(multiLineStringTaggedText String [,SRID
      Integer]):MultiLineString *| - constructs a MultiLineString

    * |*MPolyFromText(multiPolygonTaggedText String [,SRID
      Integer]):MultiPolygon *| - constructs a MultiPolygon

    * |*GeomCollFromText(geometryCollectionTaggedText String [,SRID
      Integer]):GeomCollection *| - constructs a GeometryCollection

Usage examples:

INSERT INTO geom VALUES (GeomFromText('POINT(1 1)'))
INSERT INTO geom VALUES (GeomFromText('LINESTRING(0 0,1 1,2 2)'))
INSERT INTO geom VALUES (GeomFromText('POLYGON((0 0,10 0,10 10,0 10,0 0),(5 5,7 5,7 7,5 7, 5 5))'))
INSERT INTO geom VALUES (GeomFromText('GEOMETRYCOLLECTION(POINT(1 1),LINESTRING(0 0,1 1,2 2,3 3,4 4))'))

The second argument of spatial constructirs, described above, is
currently ignored, It will be used to specify SRID in the future.
Nowdays, it is added for reasons of compatibility with OpenGIS
specifications and PostGIS implementation.

As an optional feature, an implementation may also support building of
Polygon or MultiPolygon values given an arbitrary collection of possibly
intersecting rings or closed LineString values. Implementations that
support this feature should include the following functions:

    * |*BdPolyFromText(multiLineStringTaggedText String, SRID
      Integer):Polygon *| - constructs a Polygon given an arbitrary
      collection of closed linestrings as a MultiLineString text
      representation.
    * |*BdMPolyFromText(multiLineStringTaggedText String, SRID
      Integer):MultiPolygon *| - constructs a MultiPolygon given an
      arbitrary collection of closed linestrings as a MultiLineString
text representation.


      3.5.2 Binary spatial constructors

    * |*GeomFromWKB(WKBGeometry Binary, SRID Integer):Geometry *| -
      constructs a Geometry value given its well-known binary
      representation.

      |*GeomFromWKB()*| function can accept in it's first argument a WKB
      of Geometry of any class. For construction of Geometry values
      restricted to a particular subclass, an implementation also
      provides a class-specific construction function for each
      instantiable subclass as described in the list below:

    * |*PointFromWKB(WKBPoint Binary, SRID Integer):Point - *|constructs
      a Point
    * |* LineFromWKB(WKBLineString Binary, SRID Integer):LineString *| -
      constructs a LineString
    * |* PolyFromWKB(WKBPolygon Binary, SRID Integer):Polygon *| -
      constructs a Polygon
    * |* MPointFromWKB(WKBMultiPoint Binary, SRID Integer):MultiPoint *|
      - constructs a MultiPoint
    * |* MLineFromWKB(WKBMultiLineString Binary, SRID
      Integer):MultiLineString *| - constructs a MultiLineString
    * |* MPolyFromWKB(WKBMultiPolygon Binary, SRID Integer):
      MultiPolygon *| - constructs a MultiPolygon
    * |* GeomCollFromWKB(WKBGeometryCollection Binary, SRID Integer):
GeomCollection *| - constructs a GeometryCollection

As an optional feature, an implementation may also support the uilding'
of Polygon or MultiPolygon values given an arbitrary collection of
possibly intersecting rings or closed LineString values. Implementations
that support this feature should include the following functions:

    * |* BdPolyFromWKB (WKBMultiLineString Binary,SRID Integer): Polygon
      *| - constructs a Polygon given an arbitrary collection of closed
      linestrings as a MultiLineString binary representation.
    * |*BdMPolyFromWKB(WKBMultiLineString Binary, SRID
      Integer):MultiPolygon *| - constructs a MultiPolygon given an
      arbitrary collection of closed linestrings as a MultiLineString
binary representation.

Inserting in *WKB* assumes that |GeomFromWKB()| function argument
contains a buffer with a correctly formed spatial object in WKB. In ODBC
applications it can be done using binding of argument. One also can
insert object in *WKB* using |mysql_escape_string()| in |libmysqlclient|
applications.

For example:

INSERT INTO geom VALUES (GeomFromWKB(buf,SRID));

where |buf| is a binary buffer with a spatial object in *WKB*
representation.


    3.5 SELECTing spatial objects

Spatial objects are selected either in *WKT* or *WKB* representation by
use of AsText() and AsBinary() functions correspondently.


mysql> select AsText(g) as g from geom;
+-------------------------+
| g                       |
+-------------------------+
| POINT(1 1)              |
| LINESTRING(0 0,1 1,2 2) |
+-------------------------+
2 rows in set (0.00 sec)

mysql> 

The query:

SELECT AsBinary(g) FROM geom

returns a BLOB which contains *WKB* representation of object.


  4 Functions for spatial analysis


    4.1 Basic functions on Geometry

    * |*AsText(g:Geometry):String*| - Exports this Geometry to a
      specific well-known text representation of Geometry.
    * |*AsBinary(g:Geometry):Binary*| - Exports this Geometry to a
      specific well-known binary representation of Geometry.
    * |*GeometryType(g:Geometry):String*| - Returns the name of the
      instantiable subtype of Geometry of which this Geometry instance
      is a member. The name of the instantiable subtype of Geometry is
      returned as a string.
    * |*Dimension(g:Geometry):Integer*| - The inherent dimension of this
      Geometry object, which must be less than or equal to the
      coordinate dimension. This specification is restricted to
      geometries in two-dimensional coordinate space.
    * |*IsEmpty(g:Geometry):Integer*| - Returns 1 (TRUE) if this
      Geometry is the empty geometry . If true, then this Geometry
      represents the empty point set, , for the coordinate space.
    * |*IsSimple(g:Geometry):Integer *| - Returns 1 (TRUE) if this
      Geometry has no anomalous geometric points, such as self
      intersection or self tangency. The description of each
      instantiable geometric class includes the specific conditions that
      cause an instance of that class to be classified as not simple.
    * |*SRID(g:Geometry):Integer*| - Returns the Spatial Reference
      System ID for this Geometry.
    * |*Distance(g1:Geometry,g2:Geometry):Double*| - the shortest
distance between any two points in the two geometries.


    4.2 Functions for specific geometry type


      GeometryCollection functions

    * *NumGeometries(g:GeometryCollection ):Integer * -Returns the
      number of geometries in this GeometryCollection.
    * *GeometryN(g:GeometryCollection,N:integer):Geometry * -Returns the
Nth geometry in this GeometryCollection.


      Point functions

    * *X(p:Point):Double* -The x-coordinate value for this Point.
* *Y(p:Point):Double* -The y-coordinate value for this Point.


      LineString functions

    * *StartPoint(l:LineString):Point* The start point of this LineString.
    * *EndPoint(l:LineString):Point* The end point of this LineString.
    * *PointN(l:LineString,N:Integer):Point* Returns the specified point
      N in this Linestring.
    * *Length(l:LineString):Double* The length of this LineString in its
      associated spatial reference.
    * *IsRing(l:LineString):Integer* Returns 1 (TRUE) if this LineString
      is closed (StartPoint ( ) = EndPoint ( )) and this LineString is
      simple (does not pass through the same point more than once).
    * *IsClosed(l:LineString):Integer* Returns 1 (TRUE) if this
      LineString is closed (StartPoint ( ) = EndPoint ( )).
    * *NumPoints(l:LineString):Integer* The number of points in this
LineString.


      MultiLineString functions

    * *Length(m:MultiLineString):Double* The Length of this
      MultiLineString which is equal to the sum of the lengths of the
      elements.
    * *IsClosed(m:MultiLineString):Integer* Returns 1 (TRUE) if this
      MultiLineString is closed (StartPoint() = EndPoint() for each
LineString in this MultiLineString)


      Polygon functions

    * *Area(p:Polygon):Double* The area of this Polygon, as measured in
      the spatial reference system of this Polygon.
    * *Centroid(p:Polygon):Point* The mathematical centroid for this
      Polygon as a Point. The result is not guaranteed to be on this
      Polygon.
    * *PointOnSurface(p:Polygon):Point* A point guaranteed to be on this
      Polygon.
    * *NumInteriorRing(p:Polygon):Integer* Returns the number of
      interior rings in this Polygon.
    * *ExteriorRing(p:Polygon):LineString* Returns the exterior ring of
      this Polygon as a LineString.
    * *InteriorRingN(p:Polygon,N:Integer):LineString* Returns the Nth
interior ring for this Polygon as a LineString.


      MultiPolygon functions

    * *Area(m:MultuSurface):Double* The area of this MultiPolygon, as
      measured in the spatial reference system of this MultiPolygon.
    * *Centroid(m:MultyPolygon):Point* The mathematical centroid for
      this MultiPolygon as a Point. The result is not guaranteed to be
      on this MultiPolygon.
    * *PointOnSurface(m:MultuPolygon):Point* A Point guaranteed to be on
this MultiPolygon.

Notes: /functions for specific geometry type retrun NULL if passed
object type is incorrect. For example Area() returns NULL if object type
is neither Polygon nor MultiPolygon/


    4.3 Spatial operations (compound spatial constructors)

    * |*Envelope(g:Geometry):Geometry*|The minimum bounding box for this
      Geometry, returned as a Geometry. The polygon is defined by the
      corner points of the bounding box
      |POLYGON((MINX,MINY),(MAXX,MINY),(MAXX,MAXY),(MINX,MAXY),(MINX,MINY))|.

    * |*Boundary(g:Geometry):Geometry*| - returns the closure of the
      combinatorial boundary of this Geometry.
    * |*Intersection(g1,g2:Geometry):Geometry*| - a geometry that
      represents the point set intersection of g1 with g2.
    * |*Union(g1,g2:Geometry):Geometry*| - a geometry that represents
      the point set union of g1 with g2.
    * |*Difference(g1,g2:Geometry):Geometry*| - a geometry that
      represents the point set difference of g1 with g2.
    * |*SymDifference(g1,g2:Geometry):Geometry*| - a geometry that
      represents the point set symmetric difference of g1 with g2.
    * |*Buffer(g:Geometry,distance:Double):Geometry*| - a geometry that
      represents all points whose distance from g is less than or equal
      to distance.
    * |*ConvexHull(g:Geometry):Geometry*| - a geometry that represents
the convex hull of g.


    4.4 Functions for testing Spatial Relations between geometric objects

    * |*Equals(g1,g2)*| - Returns 1 if g1 is spatially equal to g2.
    * |*Disjoint(g1,g2)*| - Returns 1 if g1 is spatially disjoint from g2.
    * |*Intersects(g1,g2)*| - Returns 1 if g1 spatially intersects g2.
    * |*Touches(g1,g2)*| - Returns 1 if g1 spatially touches g2.
    * |*Crosses(g1,g2)*| - Returns 1 if g1 spatially crosses g2.
    * |*Within(g1,g2)*| - Returns 1 if g1 is spatially within g2.
    * |*Contains(g1,g2)*| - Returns 1 if g1 spatially contains g2.
* |*Overlaps(g1,g2)*| - Returns 1 if g1 spatially overlaps g2.


  5 Optimizing spatial analysis


    5.1 MBR

MBR is a minimal bounding rectangle (box) for spatial object. It can be
represented as a set of min and max values of each dimension.

For example:

(Xmin,Xmax,Ymin,Ymax)


    5.2 Using SPATIAL indexes

To optimize spatial object relationships analysis it is possible to
create a spatial index on geometry field using R-tree algorythm. R-tree
based spatial indexes store MBRs of spatial objects as a key values.

CREATE SPATIAL INDEX gind ON geom (g);

Or together with table definition:

CREATE TABLE geom (
  g GEOMETRY,
  SPATIAL INDEX(g)
);

Optimizer attaches R-tree based SPATIAL index when a query with spatial
objects relationship functions is executed in WHERE clause.

For example:

SELECT geom.name FROM geom 
       WHERE Within(geom.g,GeomFromText('POLYGON((0 0, 1 0, 1 1, 0 1, 0 0))',SRID));


    8 OpenGIS extensions implemented in MySQL

MySQL provides it's own constructors to build geometry objects:

    * |*Point(double,double,SRID)*| - constructs a geometry of Point
      class using it's coordinates and SRID.
    * |*MultiPoint(Point,Point,...,Point)*| - constructs a MultiPoint
      using Points. When any argument is not a geometry of Point class
      the return value is NULL.
    * |*LineString(Point,Point,...,Point)*| - constructs a LineString
      from a number of Points. When any argument is not a geometry of
      Point class the return value is NULL. When the number of Points is
      less than two the return value is NULL.
    * |*MultiLineString(LineString,LineString,...,LineString)*| -
      constructs a MultiLineString using using LineStrings. When any
      argument is not a geometry of LineStringClass return value is NULL.
    * |*Polygon(LineString,LineString,...,LineString)*| - constructs a
      Polygon from a number of LineStrings. When any argument is not a
      LinearRing (i.e. not closed and simple geometry of class
      LineString) the return value is NULL.
    * |*MultiPolygon(Polygon,Polygon,...,Polygon)*| - constructs a
      MultiPolygon from a set of Polygons. When any argument is not a
      Polygon, the rerurn value is NULL.
    * |*GeometryCollection(Geometry,Geometry,..,Geometry)*| - constucts
      a GeometryCollection. When any argument is not a valid geometry
object of any instantiable class, the return value is NULL.

The above functions (except Point()) return NULL if arguments are not in
the same spatial reference system (i.e. have different SRIDs).


        Examples:

INSERT INTO geom SELECT Point(x,y,SRID) FROM coords;
SELECT AsText(g) FROM geom WHERE 
  Contains(Polygon(LineString(Point(0,0),Point(0,1),Point(1,1),Point(1,0),Point(0,0)),SRID),geom.g);


    9 Things that differ in MySQL implemention and OpenGIS specifications


      9.1 Single GEOMETRY type

Besides a GEOMETRY type, OpenGIS consortium specifications suggest the
implementation of several spatial field types correspondent to every
instansiable object subclass. For example a *Point* type is proposed to
restrict data stored in a field of this type to only Point OpenGIS
subclass. MySQL provides an implementation of single GEOMETRY type which
doesn't restrict objects to certain OpenGIS subclass.


      9.2 No additional Metadata Views

OpenGIS specifications propose several additional metadata views. For
example, a system view named GEOMETRY_COLUMNS contains a description of
geometry columns, one row for each geometry column in the database.


      9.3 No functions to add/drop spatial columns

OpenGIS assumes that columns can be added/dropped using
AddGeometryColumn() and DropGeometryColumn() functions correspondently.
In MySQL implementation one should use ALTER TABLE instead.
