This is an automated email from the ASF dual-hosted git repository.
jiayu pushed a commit to branch sedonasnow-doc
in repository https://gitbox.apache.org/repos/asf/sedona.git
commit 67552a48f1d85cfe85278b209fcc5f43d8dab79a
Author: Jia Yu <ji...@apache.org>
AuthorDate: Thu Jan 11 00:15:23 2024 -0800
Added the tutorial. API references and installation are to be updated.
---
.../api/snowflake/vector-data/AggregateFunction.md | 53 +
docs/api/snowflake/vector-data/Constructor.md | 440 +++++
docs/api/snowflake/vector-data/Function.md | 1712 ++++++++++++++++++++
docs/api/snowflake/vector-data/Overview.md | 15 +
docs/api/snowflake/vector-data/Predicate.md | 159 ++
docs/setup/snowflake/install.md | 11 +
docs/setup/snowflake/modules.md | 13 +
docs/tutorial/snowflake/sql.md | 434 +++++
mkdocs.yml | 13 +
9 files changed, 2850 insertions(+)
diff --git a/docs/api/snowflake/vector-data/AggregateFunction.md
b/docs/api/snowflake/vector-data/AggregateFunction.md
new file mode 100644
index 000000000..deec717d8
--- /dev/null
+++ b/docs/api/snowflake/vector-data/AggregateFunction.md
@@ -0,0 +1,53 @@
+## ST_Envelope_Aggr
+
+Introduction: Return the entire envelope boundary of all geometries in A
+
+Format: `ST_Envelope_Aggr (A:geometryColumn)`
+
+SQL example:
+
+```sql
+SELECT ST_Envelope_Aggr(ST_GeomFromText('MULTIPOINT(1.1 101.1,2.1 102.1,3.1
103.1,4.1 104.1,5.1 105.1,6.1 106.1,7.1 107.1,8.1 108.1,9.1 109.1,10.1 110.1)'))
+```
+
+Output:
+
+```
+POLYGON ((1.1 101.1, 1.1 120.1, 20.1 120.1, 20.1 101.1, 1.1 101.1))
+```
+
+## ST_Intersection_Aggr
+
+Introduction: Return the polygon intersection of all polygons in A
+
+Format: `ST_Intersection_Aggr (A:geometryColumn)`
+
+SQL example:
+
+```sql
+SELECT ST_Intersection_Aggr(ST_GeomFromText('MULTIPOINT(1.1 101.1,2.1
102.1,3.1 103.1,4.1 104.1,5.1 105.1,6.1 106.1,7.1 107.1,8.1 108.1,9.1
109.1,10.1 110.1)'))
+```
+
+Output:
+
+```
+MULTIPOINT ((1.1 101.1), (2.1 102.1), (3.1 103.1), (4.1 104.1), (5.1 105.1),
(6.1 106.1), (7.1 107.1), (8.1 108.1), (9.1 109.1), (10.1 110.1))
+```
+
+## ST_Union_Aggr
+
+Introduction: Return the polygon union of all polygons in A
+
+Format: `ST_Union_Aggr (A:geometryColumn)`
+
+SQL example:
+
+```sql
+SELECT ST_Union_Aggr(ST_GeomFromText('MULTIPOINT(1.1 101.1,2.1 102.1,3.1
103.1,4.1 104.1,5.1 105.1,6.1 106.1,7.1 107.1,8.1 108.1,9.1 109.1,10.1 110.1)'))
+```
+
+Output:
+
+```
+MULTIPOINT ((1.1 101.1), (2.1 102.1), (3.1 103.1), (4.1 104.1), (5.1 105.1),
(6.1 106.1), (7.1 107.1), (8.1 108.1), (9.1 109.1), (10.1 110.1))
+```
diff --git a/docs/api/snowflake/vector-data/Constructor.md
b/docs/api/snowflake/vector-data/Constructor.md
new file mode 100644
index 000000000..2ffc90290
--- /dev/null
+++ b/docs/api/snowflake/vector-data/Constructor.md
@@ -0,0 +1,440 @@
+## ST_GeomFromGeoHash
+
+Introduction: Create Geometry from geohash string and optional precision
+
+Format: `ST_GeomFromGeoHash(geohash: string, precision: int)`
+
+SQL example:
+
+```sql
+SELECT ST_GeomFromGeoHash('s00twy01mt', 4)
+```
+
+Output:
+
+```
+POLYGON ((0.703125 0.87890625, 0.703125 1.0546875, 1.0546875 1.0546875,
1.0546875 0.87890625, 0.703125 0.87890625))
+```
+
+## ST_GeomFromGeoJSON
+
+Introduction: Construct a Geometry from GeoJson
+
+Format: `ST_GeomFromGeoJSON (GeoJson:string)`
+
+SQL example:
+
+```sql
+SELECT ST_GeomFromGeoJSON('{
+ "type":"Feature",
+ "properties":{
+ "STATEFP":"01",
+ "COUNTYFP":"077",
+ "TRACTCE":"011501",
+ "BLKGRPCE":"5",
+ "AFFGEOID":"1500000US010770115015",
+ "GEOID":"010770115015",
+ "NAME":"5",
+ "LSAD":"BG",
+ "ALAND":6844991,
+ "AWATER":32636
+ },
+ "geometry":{
+ "type":"Polygon",
+ "coordinates":[
+ [
+ [-87.621765, 34.873444],
+ [-87.617535, 34.873369],
+ [-87.62119, 34.85053],
+ [-87.62144, 34.865379],
+ [-87.621765, 34.873444]
+ ]
+ ]
+ }
+}')
+```
+
+Output:
+
+```
+POLYGON ((-87.621765 34.873444, -87.617535 34.873369, -87.62119 34.85053,
-87.62144 34.865379, -87.621765 34.873444))
+```
+
+SQL example:
+
+```sql
+SELECT ST_GeomFromGeoJSON('{
+ "type":"Polygon",
+ "coordinates":[
+ [
+ [-87.621765, 34.873444],
+ [-87.617535, 34.873369],
+ [-87.62119, 34.85053],
+ [-87.62144, 34.865379],
+ [-87.621765, 34.873444]
+ ]
+ ]
+}')
+```
+
+Output:
+
+```
+POLYGON ((-87.621765 34.873444, -87.617535 34.873369, -87.62119 34.85053,
-87.62144 34.865379, -87.621765 34.873444))
+```
+
+## ST_GeomFromGML
+
+Introduction: Construct a Geometry from GML.
+
+Format:
+`ST_GeomFromGML (gml:string)`
+
+SQL example:
+
+```sql
+SELECT ST_GeomFromGML('
+ <gml:LineString srsName="EPSG:4269">
+ <gml:coordinates>
+ -71.16028,42.258729
+ -71.160837,42.259112
+ -71.161143,42.25932
+ </gml:coordinates>
+ </gml:LineString>
+')
+```
+
+Output:
+
+```
+LINESTRING (-71.16028 42.258729, -71.160837 42.259112, -71.161143 42.25932)
+```
+
+## ST_GeomFromKML
+
+Introduction: Construct a Geometry from KML.
+
+Format:
+`ST_GeomFromKML (kml:string)`
+
+SQL example:
+
+```sql
+SELECT ST_GeomFromKML('
+ <LineString>
+ <coordinates>
+ -71.1663,42.2614
+ -71.1667,42.2616
+ </coordinates>
+ </LineString>
+')
+```
+
+Output:
+
+```
+LINESTRING (-71.1663 42.2614, -71.1667 42.2616)
+```
+
+## ST_GeomFromText
+
+Introduction: Construct a Geometry from WKT. If SRID is not set, it defaults
to 0 (unknown). Alias of [ST_GeomFromWKT](#st_geomfromwkt)
+
+Format:
+`ST_GeomFromText (Wkt:string)`
+`ST_GeomFromText (Wkt:string, srid:integer)`
+
+SQL example:
+
+```sql
+SELECT ST_GeomFromText('POINT(40.7128 -74.0060)')
+```
+
+Output:
+
+```
+POINT(40.7128 -74.006)
+```
+
+## ST_GeomFromWKB
+
+Introduction: Construct a Geometry from WKB string or Binary. This function
also supports EWKB format.
+
+Format:
+`ST_GeomFromWKB (Wkb:string)`
+`ST_GeomFromWKB (Wkb:binary)`
+
+SQL example:
+
+```sql
+SELECT ST_GeomFromWKB([01 02 00 00 00 02 00 00 00 00 00 00 00 84 D6 00 C0 00
00 00 00 80 B5 D6 BF 00 00 00 60 E1 EF F7 BF 00 00 00 80 07 5D E5 BF])
+```
+
+Output:
+
+```
+LINESTRING (-2.1047439575195312 -0.354827880859375, -1.49606454372406
-0.6676061153411865)
+```
+
+SQL example:
+
+```sql
+SELECT
ST_asEWKT(ST_GeomFromWKB('01010000a0e6100000000000000000f03f000000000000f03f000000000000f03f'))
+```
+
+Output:
+
+```
+SRID=4326;POINT Z(1 1 1)
+```
+
+## ST_GeomFromWKT
+
+Introduction: Construct a Geometry from WKT. If SRID is not set, it defaults
to 0 (unknown).
+
+Format:
+`ST_GeomFromWKT (Wkt:string)`
+`ST_GeomFromWKT (Wkt:string, srid:integer)`
+
+The optional srid parameter was added in `v1.3.1`
+
+SQL example:
+
+```sql
+SELECT ST_GeomFromWKT('POINT(40.7128 -74.0060)')
+```
+
+Output:
+
+```
+POINT(40.7128 -74.006)
+```
+
+## ST_GeomFromEWKT
+
+Introduction: Construct a Geometry from OGC Extended WKT
+
+Format:
+`ST_GeomFromEWKT (EWkt:string)`
+
+SQL example:
+```sql
+SELECT ST_AsText(ST_GeomFromEWKT('SRID=4269;POINT(40.7128 -74.0060)'))
+```
+
+Output:
+
+```
+POINT(40.7128 -74.006)
+```
+
+## ST_LineFromText
+
+Introduction: Construct a Line from Wkt text
+
+Format:
+`ST_LineFromText (Wkt:string)`
+
+SQL example:
+
+```sql
+SELECT ST_LineFromText('LINESTRING(1 2,3 4)')
+```
+
+Output:
+
+```
+LINESTRING (1 2, 3 4)
+```
+
+## ST_LineStringFromText
+
+Introduction: Construct a LineString from Text, delimited by Delimiter
+
+Format: `ST_LineStringFromText (Text:string, Delimiter:char)`
+
+SQL example:
+
+```sql
+SELECT
ST_LineStringFromText('-74.0428197,40.6867969,-74.0421975,40.6921336,-74.0508020,40.6912794',
',')
+```
+
+Output:
+
+```
+LINESTRING (-74.0428197 40.6867969, -74.0421975 40.6921336, -74.050802
40.6912794)
+```
+
+## ST_MakePoint
+
+Introduction: Creates a 2D, 3D Z or 4D ZM Point geometry. Use ST_MakePointM to
make points with XYM coordinates. Z and M values are optional.
+
+Format: `ST_MakePoint (X:decimal, Y:decimal, Z:decimal, M:decimal)`
+
+Example:
+
+```sql
+SELECT ST_AsText(ST_MakePoint(1.2345, 2.3456));
+```
+
+Output:
+
+```
+POINT (1.2345 2.3456)
+```
+
+Example:
+
+```sql
+SELECT ST_AsText(ST_MakePoint(1.2345, 2.3456, 3.4567));
+```
+
+Output:
+
+```
+POINT Z (1.2345 2.3456 3.4567)
+```
+
+Example:
+
+```sql
+SELECT ST_AsText(ST_MakePoint(1.2345, 2.3456, 3.4567, 4));
+```
+
+Output:
+
+```
+POINT ZM (1.2345 2.3456 3.4567 4)
+```
+
+## ST_MLineFromText
+
+Introduction: Construct a MultiLineString from Wkt. If srid is not set, it
defaults to 0 (unknown).
+
+Format:
+`ST_MLineFromText (Wkt:string)`
+`ST_MLineFromText (Wkt:string, srid:integer)`
+
+SQL example:
+
+```sql
+SELECT ST_MLineFromText('MULTILINESTRING((1 2, 3 4), (4 5, 6 7))')
+```
+
+Output:
+
+```
+MULTILINESTRING ((1 2, 3 4), (4 5, 6 7))
+```
+
+## ST_MPolyFromText
+
+Introduction: Construct a MultiPolygon from Wkt. If srid is not set, it
defaults to 0 (unknown).
+
+Format:
+`ST_MPolyFromText (Wkt:string)`
+`ST_MPolyFromText (Wkt:string, srid:integer)`
+
+SQL example:
+
+```sql
+SELECT ST_MPolyFromText('MULTIPOLYGON(((0 0 1,20 0 1,20 20 1,0 20 1,0 0 1),(5
5 3,5 7 3,7 7 3,7 5 3,5 5 3)))')
+```
+
+Output:
+
+```
+MULTIPOLYGON (((0 0, 20 0, 20 20, 0 20, 0 0), (5 5, 5 7, 7 7, 7 5, 5 5)))
+```
+
+## ST_Point
+
+Introduction: Construct a Point from X and Y
+
+Format: `ST_Point (X:decimal, Y:decimal)`
+
+In `v1.4.0` an optional Z parameter was removed to be more consistent with
other spatial SQL implementations.
+If you are upgrading from an older version of Sedona - please use ST_PointZ to
create 3D points.
+
+SQL example:
+
+```sql
+SELECT ST_Point(double(1.2345), 2.3456)
+```
+
+Output:
+
+```
+POINT (1.2345 2.3456)
+```
+
+## ST_PointZ
+
+Introduction: Construct a Point from X, Y and Z and an optional srid. If srid
is not set, it defaults to 0 (unknown).
+Must use ST_AsEWKT function to print the Z coordinate.
+
+Format: `ST_PointZ (X:decimal, Y:decimal, Z:decimal)`
+
+Format: `ST_PointZ (X:decimal, Y:decimal, Z:decimal, srid:integer)`
+
+```sql
+SELECT ST_AsEWKT(ST_PointZ(1.2345, 2.3456, 3.4567))
+```
+
+Output:
+
+```
+POINT Z(1.2345 2.3456 3.4567)
+```
+
+## ST_PointFromText
+
+Introduction: Construct a Point from Text, delimited by Delimiter
+
+Format: `ST_PointFromText (Text:string, Delimiter:char)`
+
+SQL example:
+
+```sql
+SELECT ST_PointFromText('40.7128,-74.0060', ',')
+```
+
+Output:
+
+```
+POINT (40.7128 -74.006)
+```
+
+## ST_PolygonFromEnvelope
+
+Introduction: Construct a Polygon from MinX, MinY, MaxX, MaxY.
+
+Format: `ST_PolygonFromEnvelope (MinX:decimal, MinY:decimal, MaxX:decimal,
MaxY:decimal)`
+
+```sql
+SELECT
ST_PolygonFromEnvelope(double(1.234),double(2.234),double(3.345),double(3.345))
+```
+
+Output:
+
+```
+POLYGON ((1.234 2.234, 1.234 3.345, 3.345 3.345, 3.345 2.234, 1.234 2.234))
+```
+
+## ST_PolygonFromText
+
+Introduction: Construct a Polygon from Text, delimited by Delimiter. Path must
be closed
+
+Format: `ST_PolygonFromText (Text:string, Delimiter:char)`
+
+SQL example:
+
+```sql
+SELECT
ST_PolygonFromText('-74.0428197,40.6867969,-74.0421975,40.6921336,-74.0508020,40.6912794,-74.0428197,40.6867969',
',')
+```
+
+Output:
+
+```
+POLYGON ((-74.0428197 40.6867969, -74.0421975 40.6921336, -74.050802
40.6912794, -74.0428197 40.6867969))
+```
diff --git a/docs/api/snowflake/vector-data/Function.md
b/docs/api/snowflake/vector-data/Function.md
new file mode 100644
index 000000000..2f34325e0
--- /dev/null
+++ b/docs/api/snowflake/vector-data/Function.md
@@ -0,0 +1,1712 @@
+## ST_3DDistance
+
+Introduction: Return the 3-dimensional minimum cartesian distance between A
and B
+
+Format: `ST_3DDistance (A:geometry, B:geometry)`
+
+
+SQL example:
+```SQL
+SELECT ST_3DDistance(polygondf.countyshape, polygondf.countyshape)
+FROM polygondf
+```
+
+## ST_AddPoint
+
+Introduction: RETURN Linestring with additional point at the given index, if
position is not available the point will be added at the end of line.
+
+Format: `ST_AddPoint(geom: geometry, point: geometry, position: integer)`
+
+Format: `ST_AddPoint(geom: geometry, point: geometry)`
+
+
+
+SQL example:
+```SQL
+SELECT ST_AddPoint(ST_GeomFromText('LINESTRING(0 0, 1 1, 1 0)'),
ST_GeomFromText('Point(21 52)'), 1)
+
+SELECT ST_AddPoint(ST_GeomFromText('Linestring(0 0, 1 1, 1 0)'),
ST_GeomFromText('Point(21 52)'))
+```
+
+Output:
+```
+LINESTRING(0 0, 21 52, 1 1, 1 0)
+LINESTRING(0 0, 1 1, 1 0, 21 52)
+```
+
+## ST_Area
+
+Introduction: Return the area of A
+
+Format: `ST_Area (A:geometry)`
+
+
+
+SQL example:
+```SQL
+SELECT ST_Area(polygondf.countyshape)
+FROM polygondf
+```
+
+## ST_AreaSpheroid
+
+Introduction: Return the geodesic area of A using WGS84 spheroid. Unit is
square meter. Works better for large geometries (country level) compared to
`ST_Area` + `ST_Transform`. It is equivalent to PostGIS `ST_Area(geography,
use_spheroid=true)` function and produces nearly identical results.
+
+Geometry must be in EPSG:4326 (WGS84) projection and must be in ==lat/lon==
order. You can use ==ST_FlipCoordinates== to swap lat and lon.
+
+Format: `ST_AreaSpheroid (A:geometry)`
+
+
+
+SQL example:
+
+```sql
+SELECT ST_AreaSpheroid(ST_GeomFromWKT('Polygon ((35 34, 30 28, 34 25, 35
34))'))
+```
+
+Output: `201824850811.76245`
+
+## ST_AsBinary
+
+Introduction: Return the Well-Known Binary representation of a geometry
+
+Format: `ST_AsBinary (A:geometry)`
+
+
+
+SQL example:
+```SQL
+SELECT ST_AsBinary(polygondf.countyshape)
+FROM polygondf
+```
+
+## ST_AsEWKB
+
+Introduction: Return the Extended Well-Known Binary representation of a
geometry.
+EWKB is an extended version of WKB which includes the SRID of the geometry.
+The format originated in PostGIS but is supported by many GIS tools.
+If the geometry is lacking SRID a WKB format is produced.
+[See ST_SetSRID](#st_setsrid)
+
+Format: `ST_AsEWKB (A:geometry)`
+
+
+
+SQL example:
+```SQL
+SELECT ST_AsEWKB(polygondf.countyshape)
+FROM polygondf
+```
+
+## ST_AsEWKT
+
+Introduction: Return the Extended Well-Known Text representation of a geometry.
+EWKT is an extended version of WKT which includes the SRID of the geometry.
+The format originated in PostGIS but is supported by many GIS tools.
+If the geometry is lacking SRID a WKT format is produced.
+[See ST_SetSRID](#st_setsrid)
+
+Format: `ST_AsEWKT (A:geometry)`
+
+
+
+SQL example:
+```SQL
+SELECT ST_AsEWKT(polygondf.countyshape)
+FROM polygondf
+```
+
+## ST_AsGeoJSON
+
+Introduction: Return the [GeoJSON](https://geojson.org/) string representation
of a geometry
+
+Format: `ST_AsGeoJSON (A:geometry)`
+
+
+
+SQL example:
+```SQL
+SELECT ST_AsGeoJSON(polygondf.countyshape)
+FROM polygondf
+```
+
+## ST_AsGML
+
+Introduction: Return the [GML](https://www.ogc.org/standards/gml) string
representation of a geometry
+
+Format: `ST_AsGML (A:geometry)`
+
+
+
+SQL example:
+```SQL
+SELECT ST_AsGML(polygondf.countyshape)
+FROM polygondf
+```
+
+## ST_AsKML
+
+Introduction: Return the [KML](https://www.ogc.org/standards/kml) string
representation of a geometry
+
+Format: `ST_AsKML (A:geometry)`
+
+
+
+SQL example:
+```SQL
+SELECT ST_AsKML(polygondf.countyshape)
+FROM polygondf
+```
+
+## ST_AsText
+
+Introduction: Return the Well-Known Text string representation of a geometry
+
+Format: `ST_AsText (A:geometry)`
+
+
+
+SQL example:
+```SQL
+SELECT ST_AsText(polygondf.countyshape)
+FROM polygondf
+```
+
+## ST_Azimuth
+
+Introduction: Returns Azimuth for two given points in radians null otherwise.
+
+Format: `ST_Azimuth(pointA: Point, pointB: Point)`
+
+
+
+SQL example:
+```SQL
+SELECT ST_Azimuth(ST_POINT(0.0, 25.0), ST_POINT(0.0, 0.0))
+```
+
+Output: `3.141592653589793`
+
+## ST_Boundary
+
+Introduction: Returns the closure of the combinatorial boundary of this
Geometry.
+
+Format: `ST_Boundary(geom: geometry)`
+
+
+
+SQL example:
+```SQL
+SELECT ST_Boundary(ST_GeomFromText('POLYGON((1 1,0 0, -1 1, 1 1))'))
+```
+
+Output: `LINESTRING (1 1, 0 0, -1 1, 1 1)`
+
+## ST_Buffer
+
+Introduction: Returns a geometry/geography that represents all points whose
distance from this Geometry/geography is less than or equal to distance.
+
+Format: `ST_Buffer (A:geometry, buffer: Double)`
+
+
+
+SQL example:
+```SQL
+SELECT ST_Buffer(polygondf.countyshape, 1)
+FROM polygondf
+```
+
+## ST_BuildArea
+
+Introduction: Returns the areal geometry formed by the constituent linework of
the input geometry.
+
+Format: `ST_BuildArea (A:geometry)`
+
+
+
+Example:
+
+```SQL
+SELECT ST_BuildArea(
+ ST_GeomFromText('MULTILINESTRING((0 0, 20 0, 20 20, 0 20, 0 0),(2 2, 18 2,
18 18, 2 18, 2 2))')
+) AS geom
+```
+
+Result:
+
+```
+
++----------------------------------------------------------------------------+
+|geom |
++----------------------------------------------------------------------------+
+|POLYGON((0 0,0 20,20 20,20 0,0 0),(2 2,18 2,18 18,2 18,2 2)) |
++----------------------------------------------------------------------------+
+```
+
+## ST_Centroid
+
+Introduction: Return the centroid point of A
+
+Format: `ST_Centroid (A:geometry)`
+
+
+
+SQL example:
+```SQL
+SELECT ST_Centroid(polygondf.countyshape)
+FROM polygondf
+```
+
+## ST_Collect
+
+Introduction: Returns MultiGeometry object based on a geometry column.
+
+Format
+
+`ST_Collect(*geom: geometry)`
+
+
+Example:
+
+```SQL
+SELECT ST_Collect(
+ tbl.geom) AS geom
+```
+
+Result:
+
+```
++---------------------------------------------------------------+
+|geom |
++---------------------------------------------------------------+
+|MULTIPOINT ((21.427834 52.042576573), (45.342524 56.342354355))|
++---------------------------------------------------------------+
+```
+
+Example:
+
+```SQL
+SELECT ST_Collect(
+ Array(
+ ST_GeomFromText('POINT(21.427834 52.042576573)'),
+ ST_GeomFromText('POINT(45.342524 56.342354355)')
+ )
+) AS geom
+```
+
+Result:
+
+```
++---------------------------------------------------------------+
+|geom |
++---------------------------------------------------------------+
+|MULTIPOINT ((21.427834 52.042576573), (45.342524 56.342354355))|
++---------------------------------------------------------------+
+```
+
+## ST_CollectionExtract
+
+Introduction: Returns a homogeneous multi-geometry from a given geometry
collection.
+
+The type numbers are:
+1. POINT
+2. LINESTRING
+3. POLYGON
+
+If the type parameter is omitted a multi-geometry of the highest dimension is
returned.
+
+Format: `ST_CollectionExtract (A:geometry)`
+
+Format: `ST_CollectionExtract (A:geometry, type:Int)`
+
+
+
+Example:
+
+```SQL
+WITH test_data as (
+ ST_GeomFromText(
+ 'GEOMETRYCOLLECTION(POINT(40 10), POLYGON((0 0, 0 5, 5 5, 5 0, 0 0)))'
+ ) as geom
+)
+SELECT ST_CollectionExtract(geom) as c1, ST_CollectionExtract(geom, 1) as c2
+FROM test_data
+
+```
+
+Result:
+
+```
++----------------------------------------------------------------------------+
+|c1 |c2 |
++----------------------------------------------------------------------------+
+|MULTIPOLYGON(((0 0, 0 5, 5 5, 5 0, 0 0))) |MULTIPOINT(40 10) |
|
++----------------------------------------------------------------------------+
+```
+
+## ST_ConcaveHull
+
+Introduction: Return the Concave Hull of polgyon A, with alpha set to
pctConvex[0, 1] in the Delaunay Triangulation method, the concave hull will not
contain a hole unless allowHoles is set to true
+
+Format: `ST_ConcaveHull (A:geometry, pctConvex:float)`
+
+Format: `ST_ConcaveHull (A:geometry, pctConvex:float, allowHoles:Boolean)`
+
+SQL example:
+```SQL
+SELECT ST_ConcaveHull(polygondf.countyshape, pctConvex)`
+FROM polygondf
+```
+
+## ST_ConvexHull
+
+Introduction: Return the Convex Hull of polgyon A
+
+Format: `ST_ConvexHull (A:geometry)`
+
+
+
+SQL example:
+```SQL
+SELECT ST_ConvexHull(polygondf.countyshape)
+FROM polygondf
+```
+
+## ST_Difference
+
+Introduction: Return the difference between geometry A and B (return part of
geometry A that does not intersect geometry B)
+
+Format: `ST_Difference (A:geometry, B:geometry)`
+
+
+
+Example:
+
+```SQL
+SELECT ST_Difference(ST_GeomFromWKT('POLYGON ((-3 -3, 3 -3, 3 3, -3 3, -3
-3))'), ST_GeomFromWKT('POLYGON ((0 -4, 4 -4, 4 4, 0 4, 0 -4))'))
+```
+
+Result:
+
+```
+POLYGON ((0 -3, -3 -3, -3 3, 0 3, 0 -3))
+```
+
+## ST_Distance
+
+Introduction: Return the Euclidean distance between A and B
+
+Format: `ST_Distance (A:geometry, B:geometry)`
+
+
+
+SQL example:
+```SQL
+SELECT ST_Distance(polygondf.countyshape, polygondf.countyshape)
+FROM polygondf
+```
+
+## ST_DistanceSphere
+
+Introduction: Return the haversine / great-circle distance of A using a given
earth radius (default radius: 6371008.0). Unit is meter. Compared to
`ST_Distance` + `ST_Transform`, it works better for datasets that cover large
regions such as continents or the entire planet. It is equivalent to PostGIS
`ST_Distance(geography, use_spheroid=false)` and `ST_DistanceSphere` function
and produces nearly identical results. It provides faster but less accurate
result compared to `ST_DistanceSpheroid`.
+
+Geometry must be in EPSG:4326 (WGS84) projection and must be in ==lat/lon==
order. You can use ==ST_FlipCoordinates== to swap lat and lon. For non-point
data, we first take the centroids of both geometries and then compute the
distance.
+
+Format: `ST_DistanceSphere (A:geometry)`
+
+
+
+SQL example 1:
+```sql
+SELECT ST_DistanceSphere(ST_GeomFromWKT('POINT (51.3168 -0.56)'),
ST_GeomFromWKT('POINT (55.9533 -3.1883)'))
+```
+
+Output: `543796.9506134904`
+
+SQL example 2:
+```sql
+SELECT ST_DistanceSphere(ST_GeomFromWKT('POINT (51.3168 -0.56)'),
ST_GeomFromWKT('POINT (55.9533 -3.1883)'), 6378137.0)
+```
+
+Output: `544405.4459192449`
+
+
+## ST_DistanceSpheroid
+
+Introduction: Return the geodesic distance of A using WGS84 spheroid. Unit is
meter. Compared to `ST_Distance` + `ST_Transform`, it works better for datasets
that cover large regions such as continents or the entire planet. It is
equivalent to PostGIS `ST_Distance(geography, use_spheroid=true)` and
`ST_DistanceSpheroid` function and produces nearly identical results. It
provides slower but more accurate result compared to `ST_DistanceSphere`.
+
+Geometry must be in EPSG:4326 (WGS84) projection and must be in ==lat/lon==
order. You can use ==ST_FlipCoordinates== to swap lat and lon. For non-point
data, we first take the centroids of both geometries and then compute the
distance.
+
+Format: `ST_DistanceSpheroid (A:geometry)`
+
+
+
+SQL example:
+```sql
+SELECT ST_DistanceSpheroid(ST_GeomFromWKT('POINT (51.3168 -0.56)'),
ST_GeomFromWKT('POINT (55.9533 -3.1883)'))
+```
+
+Output: `544430.9411996207`
+
+## ST_Dump
+
+Introduction: This is an aggregate function that takes a column of of
geometries as input, and returns a single GeometryCollection of all these
geometries.
+
+Format: `ST_Dump(geom: geometry)`
+
+
+SQL example:
+```SQL
+SELECT ST_Dump(tbl.geom)
+```
+
+Output: `GeometryCollection ( (10 40), (40 30), (20 20), (30 10) )`
+
+## ST_DumpPoints
+
+Introduction: Returns a MultiPoint geometry which consists of individual
points that compose the input line string.
+
+Format: `ST_DumpPoints(geom: geometry)`
+
+
+SQL example:
+```SQL
+SELECT ST_DumpPoints(ST_GeomFromText('LINESTRING (0 0, 1 1, 1 0)'))
+```
+
+Output: `MultiPoint ((0 0), (0 1), (1 1), (1 0), (0 0))`
+
+## ST_EndPoint
+
+Introduction: Returns last point of given linestring.
+
+Format: `ST_EndPoint(geom: geometry)`
+
+
+
+SQL example:
+```SQL
+SELECT ST_EndPoint(ST_GeomFromText('LINESTRING(100 150,50 60, 70 80, 160
170)'))
+```
+
+Output: `POINT(160 170)`
+
+## ST_Envelope
+
+Introduction: Return the envelop boundary of A
+
+Format: `ST_Envelope (A:geometry)`
+
+
+
+SQL example:
+
+```SQL
+SELECT ST_Envelope(polygondf.countyshape)
+FROM polygondf
+```
+
+## ST_ExteriorRing
+
+Introduction: Returns a line string representing the exterior ring of the
POLYGON geometry. Return NULL if the geometry is not a polygon.
+
+Format: `ST_ExteriorRing(geom: geometry)`
+
+
+
+SQL example:
+```SQL
+SELECT ST_ExteriorRing(ST_GeomFromText('POLYGON((0 0 1, 1 1 1, 1 2 1, 1 1 1, 0
0 1))'))
+```
+
+Output: `LINESTRING (0 0, 1 1, 1 2, 1 1, 0 0)`
+
+## ST_FlipCoordinates
+
+Introduction: Returns a version of the given geometry with X and Y axis
flipped.
+
+Format: `ST_FlipCoordinates(A:geometry)`
+
+
+
+SQL example:
+```SQL
+SELECT ST_FlipCoordinates(df.geometry)
+FROM df
+```
+
+Input: `POINT (1 2)`
+
+Output: `POINT (2 1)`
+
+## ST_Force_2D
+
+Introduction: Forces the geometries into a "2-dimensional mode" so that all
output representations will only have the X and Y coordinates
+
+Format: `ST_Force_2D (A:geometry)`
+
+
+
+Example:
+
+```SQL
+SELECT ST_AsText(
+ ST_Force_2D(ST_GeomFromText('POLYGON((0 0 2,0 5 2,5 0 2,0 0 2),(1 1 2,3 1
2,1 3 2,1 1 2))'))
+) AS geom
+```
+
+Result:
+
+```
++---------------------------------------------------------------+
+|geom |
++---------------------------------------------------------------+
+|POLYGON((0 0,0 5,5 0,0 0),(1 1,3 1,1 3,1 1)) |
++---------------------------------------------------------------+
+```
+
+## ST_Force3D
+Introduction: Forces the geometry into a 3-dimensional model so that all
output representations will have X, Y and Z coordinates.
+An optionally given zValue is tacked onto the geometry if the geometry is
2-dimensional. Default value of zValue is 0.0
+If the given geometry is 3-dimensional, no change is performed on it.
+If the given geometry is empty, no change is performed on it.
+
+!!!Note
+ Example output is after calling ST_AsText() on returned geometry, which
adds Z for in the WKT for 3D geometries
+
+Format: `ST_Force3D(geometry, zValue)`
+
+SQL Example:
+
+```sql
+SELECT ST_Force3D(geometry) AS geom
+```
+
+Input: `LINESTRING(0 1, 1 2, 2 1)`
+
+Output: `LINESTRING Z(0 1 0, 1 2 0, 2 1 0)`
+
+Input: `POLYGON((0 0 2,0 5 2,5 0 2,0 0 2),(1 1 2,3 1 2,1 3 2,1 1 2))`
+
+Output: `POLYGON Z((0 0 2,0 5 2,5 0 2,0 0 2),(1 1 2,3 1 2,1 3 2,1 1 2))`
+
+```sql
+SELECT ST_Force3D(geometry, 2.3) AS geom
+```
+
+Input: `LINESTRING(0 1, 1 2, 2 1)`
+
+Output: `LINESTRING Z(0 1 2.3, 1 2 2.3, 2 1 2.3)`
+
+Input: `POLYGON((0 0 2,0 5 2,5 0 2,0 0 2),(1 1 2,3 1 2,1 3 2,1 1 2))`
+
+Output: `POLYGON Z((0 0 2,0 5 2,5 0 2,0 0 2),(1 1 2,3 1 2,1 3 2,1 1 2))`
+
+Input: `LINESTRING EMPTY`
+
+Output: `LINESTRING EMPTY`
+
+## ST_GeoHash
+
+Introduction: Returns GeoHash of the geometry with given precision
+
+Format: `ST_GeoHash(geom: geometry, precision: int)`
+
+
+
+Example:
+
+Query:
+
+```SQL
+SELECT ST_GeoHash(ST_GeomFromText('POINT(21.427834 52.042576573)'), 5) AS
geohash
+```
+
+Result:
+
+```
++-----------------------------+
+|geohash |
++-----------------------------+
+|u3r0p |
++-----------------------------+
+```
+
+## ST_GeometricMedian
+
+Introduction: Computes the approximate geometric median of a MultiPoint
geometry using the Weiszfeld algorithm. The geometric median provides a
centrality measure that is less sensitive to outlier points than the centroid.
+
+The algorithm will iterate until the distance change between successive
iterations is less than the supplied `tolerance` parameter. If this condition
has not been met after `maxIter` iterations, the function will produce an error
and exit, unless `failIfNotConverged` is set to `false`.
+
+If a `tolerance` value is not provided, a default `tolerance` value is `1e-6`.
+
+Format: `ST_GeometricMedian(geom: geometry, tolerance: float, maxIter:
integer, failIfNotConverged: boolean)`
+
+Format: `ST_GeometricMedian(geom: geometry, tolerance: float, maxIter:
integer)`
+
+Format: `ST_GeometricMedian(geom: geometry, tolerance: float)`
+
+Format: `ST_GeometricMedian(geom: geometry)`
+
+Default parameters: `tolerance: 1e-6, maxIter: 1000, failIfNotConverged: false`
+
+Example:
+```sql
+SELECT ST_GeometricMedian(ST_GeomFromWKT('MULTIPOINT((0 0), (1 1), (2 2), (200
200))'))
+```
+
+Output:
+```
+POINT (1.9761550281255005 1.9761550281255005)
+```
+
+## ST_GeometryN
+
+Introduction: Return the 0-based Nth geometry if the geometry is a
GEOMETRYCOLLECTION, (MULTI)POINT, (MULTI)LINESTRING, MULTICURVE or
(MULTI)POLYGON. Otherwise, return null
+
+Format: `ST_GeometryN(geom: geometry, n: Int)`
+
+
+
+SQL example:
+```SQL
+SELECT ST_GeometryN(ST_GeomFromText('MULTIPOINT((1 2), (3 4), (5 6), (8 9))'),
1)
+```
+
+Output: `POINT (3 4)`
+
+## ST_GeometryType
+
+Introduction: Returns the type of the geometry as a string. EG:
'ST_Linestring', 'ST_Polygon' etc.
+
+Format: `ST_GeometryType (A:geometry)`
+
+
+
+SQL example:
+```SQL
+SELECT ST_GeometryType(polygondf.countyshape)
+FROM polygondf
+```
+
+## ST_InteriorRingN
+
+Introduction: Returns the Nth interior linestring ring of the polygon
geometry. Returns NULL if the geometry is not a polygon or the given N is out
of range
+
+Format: `ST_InteriorRingN(geom: geometry, n: Int)`
+
+
+
+SQL example:
+```SQL
+SELECT ST_InteriorRingN(ST_GeomFromText('POLYGON((0 0, 0 5, 5 5, 5 0, 0 0), (1
1, 2 1, 2 2, 1 2, 1 1), (1 3, 2 3, 2 4, 1 4, 1 3), (3 3, 4 3, 4 4, 3 4, 3
3))'), 0)
+```
+
+Output: `LINESTRING (1 1, 2 1, 2 2, 1 2, 1 1)`
+
+## ST_Intersection
+
+Introduction: Return the intersection geometry of A and B
+
+Format: `ST_Intersection (A:geometry, B:geometry)`
+
+
+
+SQL example:
+
+```SQL
+SELECT ST_Intersection(polygondf.countyshape, polygondf.countyshape)
+FROM polygondf
+```
+
+## ST_IsClosed
+
+Introduction: RETURNS true if the LINESTRING start and end point are the same.
+
+Format: `ST_IsClosed(geom: geometry)`
+
+
+
+SQL example:
+```SQL
+SELECT ST_IsClosed(ST_GeomFromText('LINESTRING(0 0, 1 1, 1 0)'))
+```
+
+Output: `false`
+
+## ST_IsEmpty
+
+Introduction: Test if a geometry is empty geometry
+
+Format: `ST_IsEmpty (A:geometry)`
+
+
+
+SQL example:
+
+```SQL
+SELECT ST_IsEmpty(polygondf.countyshape)
+FROM polygondf
+```
+
+## ST_IsRing
+
+Introduction: RETURN true if LINESTRING is ST_IsClosed and ST_IsSimple.
+
+Format: `ST_IsRing(geom: geometry)`
+
+
+
+SQL example:
+```SQL
+SELECT ST_IsRing(ST_GeomFromText('LINESTRING(0 0, 0 1, 1 1, 1 0, 0 0)'))
+```
+
+Output: `true`
+
+## ST_IsSimple
+
+Introduction: Test if geometry's only self-intersections are at boundary
points.
+
+Format: `ST_IsSimple (A:geometry)`
+
+
+
+SQL example:
+
+```SQL
+SELECT ST_IsSimple(polygondf.countyshape)
+FROM polygondf
+```
+
+## ST_IsValid
+
+Introduction: Test if a geometry is well formed. The function can be invoked
with just the geometry or with an additional flag. The flag alters the validity
checking behavior. The flags parameter is a bitfield with the following options:
+
+- 0 (default): Use usual OGC SFS (Simple Features Specification) validity
semantics.
+- 1: "ESRI flag", Accepts certain self-touching rings as valid, which are
considered invalid under OGC standards.
+
+Formats:
+```
+ST_IsValid (A: Geometry)
+```
+```
+ST_IsValid (A: Geometry, flag: Integer)
+```
+
+SQL Example:
+
+```sql
+SELECT ST_IsValid(polygondf.countyshape)
+FROM polygondf
+```
+
+## ST_Length
+
+Introduction: Return the perimeter of A
+
+Format: ST_Length (A:geometry)
+
+
+
+SQL example:
+```SQL
+SELECT ST_Length(polygondf.countyshape)
+FROM polygondf
+```
+
+## ST_LengthSpheroid
+
+Introduction: Return the geodesic perimeter of A using WGS84 spheroid. Unit is
meter. Works better for large geometries (country level) compared to
`ST_Length` + `ST_Transform`. It is equivalent to PostGIS `ST_Length(geography,
use_spheroid=true)` and `ST_LengthSpheroid` function and produces nearly
identical results.
+
+Geometry must be in EPSG:4326 (WGS84) projection and must be in ==lat/lon==
order. You can use ==ST_FlipCoordinates== to swap lat and lon.
+
+Format: `ST_LengthSpheroid (A:geometry)`
+
+
+
+SQL example:
+```sql
+SELECT ST_LengthSpheroid(ST_GeomFromWKT('Polygon ((0 0, 0 90, 0 0))'))
+```
+
+Output: `20037508.342789244`
+
+## ST_LineFromMultiPoint
+
+Introduction: Creates a LineString from a MultiPoint geometry.
+
+Format: `ST_LineFromMultiPoint (A:geometry)`
+
+
+
+Example:
+
+```SQL
+SELECT ST_AsText(
+ ST_LineFromMultiPoint(ST_GeomFromText('MULTIPOINT((10 40), (40 30), (20
20), (30 10))'))
+) AS geom
+```
+
+Result:
+
+```
++---------------------------------------------------------------+
+|geom |
++---------------------------------------------------------------+
+|LINESTRING (10 40, 40 30, 20 20, 30 10) |
++---------------------------------------------------------------+
+```
+
+## ST_LineInterpolatePoint
+
+Introduction: Returns a point interpolated along a line. First argument must
be a LINESTRING. Second argument is a Double between 0 and 1 representing
fraction of total linestring length the point has to be located.
+
+Format: `ST_LineInterpolatePoint (geom: geometry, fraction: Double)`
+
+
+
+SQL example:
+```SQL
+SELECT ST_LineInterpolatePoint(ST_GeomFromWKT('LINESTRING(25 50, 100 125, 150
190)'), 0.2) as Interpolated
+```
+
+Output:
+```
++-----------------------------------------+
+|Interpolated |
++-----------------------------------------+
+|POINT (51.5974135047432 76.5974135047432)|
++-----------------------------------------+
+```
+
+## ST_LineMerge
+
+Introduction: Returns a LineString formed by sewing together the constituent
line work of a MULTILINESTRING.
+
+!!!note
+ Only works for MULTILINESTRING. Using other geometry will return a
GEOMETRYCOLLECTION EMPTY. If the MultiLineString can't be merged, the original
MULTILINESTRING is returned.
+
+Format: `ST_LineMerge (A:geometry)`
+
+
+
+```SQL
+SELECT ST_LineMerge(geometry)
+FROM df
+```
+
+## ST_LineSubstring
+
+Introduction: Return a linestring being a substring of the input one starting
and ending at the given fractions of total 2d length. Second and third
arguments are Double values between 0 and 1. This only works with LINESTRINGs.
+
+Format: `ST_LineSubstring (geom: geometry, startfraction: Double, endfraction:
Double)`
+
+
+
+SQL example:
+```SQL
+SELECT ST_LineSubstring(ST_GeomFromWKT('LINESTRING(25 50, 100 125, 150 190)'),
0.333, 0.666) as Substring
+```
+
+Output:
+```
++------------------------------------------------------------------------------------------------+
+|Substring
|
++------------------------------------------------------------------------------------------------+
+|LINESTRING (69.28469348539744 94.28469348539744, 100 125, 111.70035626068274
140.21046313888758)|
++------------------------------------------------------------------------------------------------+
+```
+
+## ST_MakePolygon
+
+Introduction: Function to convert closed linestring to polygon including
holes. The holes must be a MultiLinestring.
+
+Format: `ST_MakePolygon(geom: geometry, holes: <geometry>)`
+
+
+
+Example:
+
+Query:
+```SQL
+SELECT
+ ST_MakePolygon(
+ ST_GeomFromText('LINESTRING(7 -1, 7 6, 9 6, 9 1, 7 -1)'),
+ ST_GeomFromText('MultiLINESTRING((6 2, 8 2, 8 1, 6 1, 6 2))')
+ ) AS polygon
+```
+
+Result:
+
+```
++----------------------------------------------------------------+
+|polygon |
++----------------------------------------------------------------+
+|POLYGON ((7 -1, 7 6, 9 6, 9 1, 7 -1), (6 2, 8 2, 8 1, 6 1, 6 2))|
++----------------------------------------------------------------+
+
+```
+
+## ST_MakeValid
+
+Introduction: Given an invalid geometry, create a valid representation of the
geometry.
+
+Collapsed geometries are either converted to empty (keepCollaped=true) or a
valid geometry of lower dimension (keepCollapsed=false).
+Default is keepCollapsed=false.
+
+Format: `ST_MakeValid (A:geometry)`
+
+Format: `ST_MakeValid (A:geometry, keepCollapsed:Boolean)`
+
+
+
+SQL example:
+
+```SQL
+WITH linestring AS (
+ SELECT ST_GeomFromWKT('LINESTRING(1 1, 1 1)') AS geom
+) SELECT ST_MakeValid(geom), ST_MakeValid(geom, true) FROM linestring
+```
+
+Result:
+```
++------------------+------------------------+
+|st_makevalid(geom)|st_makevalid(geom, true)|
++------------------+------------------------+
+| LINESTRING EMPTY| POINT (1 1)|
++------------------+------------------------+
+```
+
+!!!note
+ In Sedona up to and including version 1.2 the behaviour of ST_MakeValid
was different.
+ Be sure to check you code when upgrading.
+ The previous implementation only worked for (multi)polygons and had a
different interpretation of the second, boolean, argument.
+ It would also sometimes return multiple geometries for a single geomtry
input.
+
+## ST_MinimumBoundingCircle
+
+Introduction: Returns the smallest circle polygon that contains a geometry.
+
+Format: `ST_MinimumBoundingCircle(geom: geometry, [Optional]
quadrantSegments:int)`
+
+
+
+SQL example:
+```SQL
+SELECT ST_MinimumBoundingCircle(ST_GeomFromText('POLYGON((1 1,0 0, -1 1, 1
1))'))
+```
+
+## ST_MinimumBoundingRadius
+
+Introduction: Returns two columns containing the center point and radius of
the smallest circle that contains a geometry.
+
+Format: `ST_MinimumBoundingRadius(geom: geometry)`
+
+
+SQL example:
+```SQL
+SELECT ST_MinimumBoundingRadius(ST_GeomFromText('POLYGON((1 1,0 0, -1 1, 1
1))'))
+```
+
+## ST_Multi
+
+Introduction: Returns a MultiGeometry object based on the geometry input.
+ST_Multi is basically an alias for ST_Collect with one geometry.
+
+Format
+
+`ST_Multi(geom: geometry)`
+
+
+
+Example:
+
+```SQL
+SELECT ST_Multi(
+ ST_GeomFromText('POINT(1 1)')
+) AS geom
+```
+
+Result:
+
+```
++---------------------------------------------------------------+
+|geom |
++---------------------------------------------------------------+
+|MULTIPOINT (1 1) |
++---------------------------------------------------------------+
+```
+## ST_NDims
+
+Introduction: Returns the coordinate dimension of the geometry.
+
+Format: `ST_NDims(geom: geometry)`
+
+
+
+SQL example with z co-rodinate:
+
+```SQL
+SELECT ST_NDims(ST_GeomFromEWKT('POINT(1 1 2)'))
+```
+
+Output: `3`
+
+SQL example with x,y co-ordinate:
+
+```SQL
+SELECT ST_NDims(ST_GeomFromText('POINT(1 1)'))
+```
+
+Output: `2`
+
+## ST_Normalize
+
+Introduction: Returns the input geometry in its normalized form.
+
+Format
+
+`ST_Normalize(geom: geometry)`
+
+
+
+Example:
+
+```SQL
+SELECT ST_AsEWKT(ST_Normalize(ST_GeomFromWKT('POLYGON((0 1, 1 1, 1 0, 0 0, 0
1))'))) AS geom
+```
+
+Result:
+
+```
++-----------------------------------+
+|geom |
++-----------------------------------+
+|POLYGON ((0 0, 0 1, 1 1, 1 0, 0 0))|
++-----------------------------------+
+```
+
+## ST_NPoints
+
+Introduction: Return points of the geometry
+
+
+
+Format: `ST_NPoints (A:geometry)`
+
+```SQL
+SELECT ST_NPoints(polygondf.countyshape)
+FROM polygondf
+```
+
+## ST_NRings
+
+Introduction: Returns the number of rings in a Polygon or MultiPolygon.
Contrary to ST_NumInteriorRings,
+this function also takes into account the number of exterior rings.
+
+This function returns 0 for an empty Polygon or MultiPolygon.
+If the geometry is not a Polygon or MultiPolygon, an IllegalArgument Exception
is thrown.
+
+Format: `ST_NRings(geom: geometry)`
+
+Examples:
+
+Input: `POLYGON ((1 0, 1 1, 2 1, 2 0, 1 0))`
+
+Output: `1`
+
+Input: `'MULTIPOLYGON (((1 0, 1 6, 6 6, 6 0, 1 0), (2 1, 2 2, 3 2, 3 1, 2 1)),
((10 0, 10 6, 16 6, 16 0, 10 0), (12 1, 12 2, 13 2, 13 1, 12 1)))'`
+
+Output: `4`
+
+Input: `'POLYGON EMPTY'`
+
+Output: `0`
+
+Input: `'LINESTRING (1 0, 1 1, 2 1)'`
+
+Output: `Unsupported geometry type: LineString, only Polygon or MultiPolygon
geometries are supported.`
+
+## ST_NumGeometries
+
+Introduction: Returns the number of Geometries. If geometry is a
GEOMETRYCOLLECTION (or MULTI*) return the number of geometries, for single
geometries will return 1.
+
+Format: `ST_NumGeometries (A:geometry)`
+
+
+
+```SQL
+SELECT ST_NumGeometries(df.geometry)
+FROM df
+```
+
+## ST_NumInteriorRings
+
+Introduction: RETURNS number of interior rings of polygon geometries.
+
+Format: `ST_NumInteriorRings(geom: geometry)`
+
+
+
+SQL example:
+```SQL
+SELECT ST_NumInteriorRings(ST_GeomFromText('POLYGON ((0 0, 0 5, 5 5, 5 0, 0
0), (1 1, 2 1, 2 2, 1 2, 1 1))'))
+```
+
+Output: `1`
+
+## ST_NumPoints
+Introduction: Returns number of points in a LineString
+
+Format: `ST_NumPoints(geom: geometry)`
+
+!!!note
+ If any other geometry is provided as an argument, an
IllegalArgumentException is thrown.
+
+SQL Example:
+
+```
+SELECT ST_NumPoints(ST_GeomFromWKT('MULTIPOINT ((0 0), (1 1), (0 1), (2 2))'))
+```
+
+Output:
+
+```
+IllegalArgumentException: Unsupported geometry type: MultiPoint, only
LineString geometry is supported.
+```
+
+SQL Example:
+```sql
+SELECT ST_NumPoints(ST_GeomFromText('LINESTRING(0 1, 1 0, 2 0)'))
+```
+
+Output: `3`
+
+## ST_PointN
+
+Introduction: Return the Nth point in a single linestring or circular
linestring in the geometry. Negative values are counted backwards from the end
of the LineString, so that -1 is the last point. Returns NULL if there is no
linestring in the geometry.
+
+Format: `ST_PointN(geom: geometry, n: integer)`
+
+
+
+SQL example:
+```SQL
+SELECT ST_PointN(ST_GeomFromText('LINESTRING(0 0, 1 2, 2 4, 3 6)'), 2) AS geom
+```
+
+Result:
+
+```
++---------------------------------------------------------------+
+|geom |
++---------------------------------------------------------------+
+|POINT (1 2) |
++---------------------------------------------------------------+
+```
+
+## ST_PointOnSurface
+
+Introduction: Returns a POINT guaranteed to lie on the surface.
+
+Format: `ST_PointOnSurface(A:geometry)`
+
+
+
+Examples:
+
+```
+SELECT ST_AsText(ST_PointOnSurface(ST_GeomFromText('POINT(0 5)')));
+ st_astext
+------------
+ POINT(0 5)
+
+SELECT ST_AsText(ST_PointOnSurface(ST_GeomFromText('LINESTRING(0 5, 0 10)')));
+ st_astext
+------------
+ POINT(0 5)
+
+SELECT ST_AsText(ST_PointOnSurface(ST_GeomFromText('POLYGON((0 0, 0 5, 5 5, 5
0, 0 0))')));
+ st_astext
+----------------
+ POINT(2.5 2.5)
+
+SELECT ST_AsText(ST_PointOnSurface(ST_GeomFromText('LINESTRING(0 5 1, 0 0 1, 0
10 2)')));
+ st_astext
+----------------
+ POINT Z(0 0 1)
+
+```
+
+## ST_PrecisionReduce
+
+Introduction: Reduce the decimals places in the coordinates of the geometry to
the given number of decimal places. The last decimal place will be rounded.
+
+Format: `ST_PrecisionReduce (A:geometry, B:int)`
+
+
+
+SQL example:
+
+```SQL
+SELECT ST_PrecisionReduce(polygondf.countyshape, 9)
+FROM polygondf
+```
+The new coordinates will only have 9 decimal places.
+
+## ST_RemovePoint
+
+Introduction: RETURN Line with removed point at given index, position can be
omitted and then last one will be removed.
+
+Format: `ST_RemovePoint(geom: geometry, position: integer)`
+
+Format: `ST_RemovePoint(geom: geometry)`
+
+
+
+SQL example:
+```SQL
+SELECT ST_RemovePoint(ST_GeomFromText('LINESTRING(0 0, 1 1, 1 0)'), 1)
+```
+
+Output: `LINESTRING(0 0, 1 0)`
+
+## ST_Reverse
+
+Introduction: Return the geometry with vertex order reversed
+
+Format: `ST_Reverse (A:geometry)`
+
+
+
+Example:
+
+```SQL
+SELECT ST_AsText(
+ ST_Reverse(ST_GeomFromText('LINESTRING(0 0, 1 2, 2 4, 3 6)'))
+) AS geom
+```
+
+Result:
+
+```
++---------------------------------------------------------------+
+|geom |
++---------------------------------------------------------------+
+|LINESTRING (3 6, 2 4, 1 2, 0 0) |
++---------------------------------------------------------------+
+```
+
+## ST_S2CellIDs
+
+Introduction: Cover the geometry with Google S2 Cells, return the
corresponding cell IDs with the given level.
+The level indicates the [size of
cells](https://s2geometry.io/resources/s2cell_statistics.html). With a bigger
level,
+the cells will be smaller, the coverage will be more accurate, but the result
size will be exponentially increasing.
+
+Format: `ST_S2CellIDs(geom: geometry, level: Int)`
+
+
+
+SQL example:
+```SQL
+SELECT ST_S2CellIDs(ST_GeomFromText('LINESTRING(1 3 4, 5 6 7)'), 6)
+```
+
+Output:
+```
++------------------------------------------------------------------------------------------------------------------------------+
+|st_s2cellids(st_geomfromtext(LINESTRING(1 3 4, 5 6 7), 0), 6)
|
++------------------------------------------------------------------------------------------------------------------------------+
+|[1159395429071192064, 1159958379024613376, 1160521328978034688,
1161084278931456000, 1170091478186196992, 1170654428139618304]|
++------------------------------------------------------------------------------------------------------------------------------+
+```
+
+## ST_SetPoint
+
+Introduction: Replace Nth point of linestring with given point. Index is
0-based. Negative index are counted backwards, e.g., -1 is last point.
+
+Format: `ST_SetPoint (linestring: geometry, index: integer, point: geometry)`
+
+
+
+Example:
+
+```SQL
+SELECT ST_SetPoint(ST_GeomFromText('LINESTRING (0 0, 0 1, 1 1)'), 2,
ST_GeomFromText('POINT (1 0)')) AS geom
+```
+
+Result:
+
+```
++--------------------------+
+|geom |
++--------------------------+
+|LINESTRING (0 0, 0 1, 1 0)|
++--------------------------+
+```
+
+## ST_SetSRID
+
+Introduction: Sets the spatial reference system identifier (SRID) of the
geometry.
+
+Format: `ST_SetSRID (A:geometry, srid: Integer)`
+
+
+
+SQL example:
+```SQL
+SELECT ST_SetSRID(polygondf.countyshape, 3021)
+FROM polygondf
+```
+
+## ST_SimplifyPreserveTopology
+
+Introduction: Simplifies a geometry and ensures that the result is a valid
geometry having the same dimension and number of components as the input,
+and with the components having the same topological relationship.
+
+
+
+Format: `ST_SimplifyPreserveTopology (A:geometry, distanceTolerance: Double)`
+
+```SQL
+SELECT ST_SimplifyPreserveTopology(polygondf.countyshape, 10.0)
+FROM polygondf
+```
+
+## ST_Split
+
+Introduction: Split an input geometry by another geometry (called the blade).
+Linear (LineString or MultiLineString) geometry can be split by a Point,
MultiPoint, LineString, MultiLineString, Polygon, or MultiPolygon.
+Polygonal (Polygon or MultiPolygon) geometry can be split by a LineString,
MultiLineString, Polygon, or MultiPolygon.
+In either case, when a polygonal blade is used then the boundary of the blade
is what is actually split by.
+ST_Split will always return either a MultiLineString or MultiPolygon even if
they only contain a single geometry.
+Homogeneous GeometryCollections are treated as a multi-geometry of the type it
contains.
+For example, if a GeometryCollection of only Point geometries is passed as a
blade it is the same as passing a MultiPoint of the same geometries.
+
+Format: `ST_Split (input: geometry, blade: geometry)`
+
+SQL Example:
+```SQL
+SELECT ST_Split(
+ ST_GeomFromWKT('LINESTRING (0 0, 1.5 1.5, 2 2)'),
+ ST_GeomFromWKT('MULTIPOINT (0.5 0.5, 1 1)'))
+```
+
+Output: `MULTILINESTRING ((0 0, 0.5 0.5), (0.5 0.5, 1 1), (1 1, 1.5 1.5, 2 2))`
+
+## ST_SRID
+
+Introduction: Return the spatial reference system identifier (SRID) of the
geometry.
+
+Format: `ST_SRID (A:geometry)`
+
+
+
+SQL example:
+```SQL
+SELECT ST_SRID(polygondf.countyshape)
+FROM polygondf
+```
+
+## ST_StartPoint
+
+Introduction: Returns first point of given linestring.
+
+Format: `ST_StartPoint(geom: geometry)`
+
+
+
+SQL example:
+```SQL
+SELECT ST_StartPoint(ST_GeomFromText('LINESTRING(100 150,50 60, 70 80, 160
170)'))
+```
+
+Output: `POINT(100 150)`
+
+## ST_SubDivide
+
+Introduction: Returns a multi-geometry divided based of given maximum number
of vertices.
+
+Format: `ST_SubDivide(geom: geometry, maxVertices: int)`
+
+
+
+SQL example:
+```SQL
+SELECT
Sedona.ST_AsText(Sedona.ST_SubDivide(Sedona.ST_GeomFromText('LINESTRING(0 0, 85
85, 100 100, 120 120, 21 21, 10 10, 5 5)'), 5));
+
+```
+
+Output:
+```
+MULTILINESTRING ((0 0, 5 5), (5 5, 10 10), (10 10, 21 21), (21 21, 60 60), (60
60, 85 85), (85 85, 100 100), (100 100, 120 120))
+```
+
+## ST_SubDivideExplode
+
+Introduction: It works the same as ST_SubDivide but returns new rows with
geometries instead of a multi-geometry.
+
+Format: `
+SELECT SEDONA.ST_AsText(GEOM)
+FROM table(SEDONA.ST_SubDivideExplode(geom: geometry, maxVertices: int))`
+
+Example:
+
+Query:
+```SQL
+SELECT Sedona.ST_AsText(GEOM)
+FROM table(Sedona.ST_SubDivideExplode(Sedona.ST_GeomFromText('LINESTRING(0 0,
85 85, 100 100, 120 120, 21 21, 10 10, 5 5)'), 5));
+```
+
+Result:
+
+```
++-----------------------------+
+|geom |
++-----------------------------+
+|LINESTRING(0 0, 5 5) |
+|LINESTRING(5 5, 10 10) |
+|LINESTRING(10 10, 21 21) |
+|LINESTRING(21 21, 60 60) |
+|LINESTRING(60 60, 85 85) |
+|LINESTRING(85 85, 100 100) |
+|LINESTRING(100 100, 120 120) |
++-----------------------------+
+```
+
+## ST_SymDifference
+
+Introduction: Return the symmetrical difference between geometry A and B
(return parts of geometries which are in either of the sets, but not in their
intersection)
+
+
+Format: `ST_SymDifference (A:geometry, B:geometry)`
+
+Example:
+
+```SQL
+SELECT ST_SymDifference(ST_GeomFromWKT('POLYGON ((-3 -3, 3 -3, 3 3, -3 3, -3
-3))'), ST_GeomFromWKT('POLYGON ((-2 -3, 4 -3, 4 3, -2 3, -2 -3))'))
+```
+
+Result:
+
+```
+MULTIPOLYGON (((-2 -3, -3 -3, -3 3, -2 3, -2 -3)), ((3 -3, 3 3, 4 3, 4 -3, 3
-3)))
+```
+
+## ST_Transform
+
+Introduction:
+
+Transform the Spatial Reference System / Coordinate Reference System of A,
from SourceCRS to TargetCRS.
+For SourceCRS and TargetCRS, WKT format is also available.
+
+!!!note
+ By default, this function uses lat/lon order. You can use
==ST_FlipCoordinates== to swap X and Y.
+
+!!!note
+ If ==ST_Transform== throws an Exception called "Bursa wolf parameters
required", you need to disable the error notification in ST_Transform. You can
append a boolean value at the end.
+
+Format: `ST_Transform (A:geometry, SourceCRS:string, TargetCRS:string
,[Optional] DisableError)`
+
+
+
+SQL example (simple):
+```SQL
+SELECT ST_Transform(polygondf.countyshape, 'epsg:4326','epsg:3857')
+FROM polygondf
+```
+
+SQL example (with optional parameters):
+```SQL
+SELECT ST_Transform(polygondf.countyshape, 'epsg:4326','epsg:3857', false)
+FROM polygondf
+```
+
+!!!note
+ The detailed EPSG information can be searched on
[EPSG.io](https://epsg.io/).
+
+
+## ST_Translate
+Introduction: Returns the input geometry with its X, Y and Z coordinates (if
present in the geometry) translated by deltaX, deltaY and deltaZ (if specified)
+
+If the geometry is 2D, and a deltaZ parameter is specified, no change is done
to the Z coordinate of the geometry and the resultant geometry is also 2D.
+
+If the geometry is empty, no change is done to it.
+If the given geometry contains sub-geometries (GEOMETRY COLLECTION, MULTI
POLYGON/LINE/POINT), all underlying geometries are individually translated.
+
+Format: `ST_Translate(geometry: geometry, deltaX: deltaX, deltaY: deltaY,
deltaZ: deltaZ)`
+
+Example:
+
+Input: `ST_Translate(GEOMETRYCOLLECTION(MULTIPOLYGON (((1 0, 1 1, 2 1, 2 0, 1
0)), ((1 2, 3 4, 3 5, 1 2))), POINT(1, 1, 1), LINESTRING EMPTY), 2, 2, 3)`
+
+Output: `GEOMETRYCOLLECTION(MULTIPOLYGON (((3 2, 3 3, 4 3, 4 2, 3 2)), ((3 4,
5 6, 5 7, 3 4))), POINT(3, 3, 4), LINESTRING EMPTY)`
+
+Input: `ST_Translate(POINT(1, 3, 2), 1, 2)`
+
+Output: `POINT(2, 5, 2)`
+
+## ST_Union
+
+Introduction: Return the union of geometry A and B
+
+
+Format: `ST_Union (A:geometry, B:geometry)`
+
+
+
+Example:
+
+```SQL
+SELECT ST_Union(ST_GeomFromWKT('POLYGON ((-3 -3, 3 -3, 3 3, -3 3, -3 -3))'),
ST_GeomFromWKT('POLYGON ((1 -2, 5 0, 1 2, 1 -2))'))
+```
+
+Result:
+
+```
+POLYGON ((3 -1, 3 -3, -3 -3, -3 3, 3 3, 3 1, 5 0, 3 -1))
+```
+
+## ST_X
+
+Introduction: Returns X Coordinate of given Point null otherwise.
+
+Format: `ST_X(pointA: Point)`
+
+
+
+SQL example:
+```SQL
+SELECT ST_X(ST_POINT(0.0 25.0))
+```
+
+Output: `0.0`
+
+## ST_XMax
+
+Introduction: Returns the maximum X coordinate of a geometry
+
+Format: `ST_XMax (A:geometry)`
+
+
+
+Example:
+
+```SQL
+SELECT ST_XMax(df.geometry) AS xmax
+FROM df
+```
+
+Input: `POLYGON ((-1 -11, 0 10, 1 11, 2 12, -1 -11))`
+
+Output: `2`
+
+## ST_XMin
+
+Introduction: Returns the minimum X coordinate of a geometry
+
+Format: `ST_XMin (A:geometry)`
+
+
+
+Example:
+
+```SQL
+SELECT ST_XMin(df.geometry) AS xmin
+FROM df
+```
+
+Input: `POLYGON ((-1 -11, 0 10, 1 11, 2 12, -1 -11))`
+
+Output: `-1`
+
+## ST_Y
+
+Introduction: Returns Y Coordinate of given Point, null otherwise.
+
+Format: `ST_Y(pointA: Point)`
+
+
+
+SQL example:
+```SQL
+SELECT ST_Y(ST_POINT(0.0 25.0))
+```
+
+Output: `25.0`
+
+## ST_YMax
+
+Introduction: Return the minimum Y coordinate of A
+
+Format: `ST_YMax (A:geometry)`
+
+
+
+SQL example:
+```SQL
+SELECT ST_YMax(ST_GeomFromText('POLYGON((0 0 1, 1 1 1, 1 2 1, 1 1 1, 0 0 1))'))
+```
+
+Output: 2
+
+## ST_YMin
+
+Introduction: Return the minimum Y coordinate of A
+
+Format: `ST_Y_Min (A:geometry)`
+
+
+
+SQL example:
+```SQL
+SELECT ST_YMin(ST_GeomFromText('POLYGON((0 0 1, 1 1 1, 1 2 1, 1 1 1, 0 0 1))'))
+```
+
+Output : 0
+
+## ST_Z
+
+Introduction: Returns Z Coordinate of given Point, null otherwise.
+
+Format: `ST_Z(pointA: Point)`
+
+
+
+SQL example:
+```SQL
+SELECT ST_Z(ST_POINT(0.0 25.0 11.0))
+```
+
+Output: `11.0`
+
+## ST_ZMax
+
+Introduction: Returns Z maxima of the given geometry or null if there is no Z
coordinate.
+
+Format: `ST_ZMax(geom: geometry)`
+
+
+
+SQL example:
+```SQL
+SELECT ST_ZMax(ST_GeomFromText('POLYGON((0 0 1, 1 1 1, 1 2 1, 1 1 1, 0 0 1))'))
+```
+
+Output: `1.0`
+
+## ST_ZMin
+
+Introduction: Returns Z minima of the given geometry or null if there is no Z
coordinate.
+
+Format: `ST_ZMin(geom: geometry)`
+
+
+
+SQL example:
+```SQL
+SELECT ST_ZMin(ST_GeomFromText('LINESTRING(1 3 4, 5 6 7)'))
+```
+
+Output: `4.0`
diff --git a/docs/api/snowflake/vector-data/Overview.md
b/docs/api/snowflake/vector-data/Overview.md
new file mode 100644
index 000000000..3decc4dcc
--- /dev/null
+++ b/docs/api/snowflake/vector-data/Overview.md
@@ -0,0 +1,15 @@
+SedonaSQL supports SQL/MM Part3 Spatial SQL Standard. It includes four kinds
of SQL operators as follows.
+
+
+* Constructor: Construct a Geometry given an input string or coordinates
+ * Example: ST_GeomFromWKT (string). Create a Geometry from a WKT String.
+ * Documentation: [Here](../Constructor)
+* Function: Execute a function on the given column or columns
+ * Example: ST_Distance (A, B). Given two Geometry A and B, return the
Euclidean distance of A and B.
+ * Documentation: [Here](../Function)
+* Aggregate function: Return the aggregated value on the given column
+ * Example: ST_Envelope_Aggr (Geometry column). Given a Geometry column,
calculate the entire envelope boundary of this column.
+ * Documentation: [Here](../AggregateFunction)
+* Predicate: Execute a logic judgement on the given columns and return true or
false
+ * Example: ST_Contains (A, B). Check if A fully contains B. Return "True" if
yes, else return "False".
+ * Documentation: [Here](../Predicate)
\ No newline at end of file
diff --git a/docs/api/snowflake/vector-data/Predicate.md
b/docs/api/snowflake/vector-data/Predicate.md
new file mode 100644
index 000000000..c3b0f2208
--- /dev/null
+++ b/docs/api/snowflake/vector-data/Predicate.md
@@ -0,0 +1,159 @@
+## ST_Contains
+
+Introduction: Return true if A fully contains B
+
+Format: `ST_Contains (A:geometry, B:geometry)`
+
+SQL example:
+
+```sql
+SELECT *
+FROM pointdf
+WHERE ST_Contains(ST_PolygonFromEnvelope(1.0,100.0,1000.0,1100.0),
pointdf.arealandmark)
+```
+
+## ST_Crosses
+
+Introduction: Return true if A crosses B
+
+Format: `ST_Crosses (A:geometry, B:geometry)`
+
+SQL example:
+
+```sql
+SELECT *
+FROM pointdf
+WHERE ST_Crosses(pointdf.arealandmark,
ST_PolygonFromEnvelope(1.0,100.0,1000.0,1100.0))
+```
+
+## ST_Disjoint
+
+Introduction: Return true if A and B are disjoint
+
+Format: `ST_Disjoint (A:geometry, B:geometry)`
+
+SQL example:
+
+```sql
+SELECT *
+FROM geom
+WHERE ST_Disjoinnt(geom.geom_a, geom.geom_b)
+```
+
+## ST_Equals
+
+Introduction: Return true if A equals to B
+
+Format: `ST_Equals (A:geometry, B:geometry)`
+
+SQL example:
+
+```sql
+SELECT *
+FROM pointdf
+WHERE ST_Equals(pointdf.arealandmark,
ST_PolygonFromEnvelope(1.0,100.0,1000.0,1100.0))
+```
+
+## ST_Intersects
+
+Introduction: Return true if A intersects B
+
+Format: `ST_Intersects (A:geometry, B:geometry)`
+
+SQL example:
+
+```sql
+SELECT *
+FROM pointdf
+WHERE ST_Intersects(ST_PolygonFromEnvelope(1.0,100.0,1000.0,1100.0),
pointdf.arealandmark)
+```
+
+## ST_OrderingEquals
+
+Introduction: Returns true if the geometries are equal and the coordinates are
in the same order
+
+Format: `ST_OrderingEquals(A: geometry, B: geometry)`
+
+SQL example 1:
+
+```sql
+SELECT ST_OrderingEquals(ST_GeomFromWKT('POLYGON((2 0, 0 2, -2 0, 2 0))'),
ST_GeomFromWKT('POLYGON((2 0, 0 2, -2 0, 2 0))'))
+```
+
+Output: `true`
+
+SQL example 2:
+
+```sql
+SELECT ST_OrderingEquals(ST_GeomFromWKT('POLYGON((2 0, 0 2, -2 0, 2 0))'),
ST_GeomFromWKT('POLYGON((0 2, -2 0, 2 0, 0 2))'))
+```
+
+Output: `false`
+
+## ST_Overlaps
+
+Introduction: Return true if A overlaps B
+
+Format: `ST_Overlaps (A:geometry, B:geometry)`
+
+SQL example:
+
+```sql
+SELECT *
+FROM geom
+WHERE ST_Overlaps(geom.geom_a, geom.geom_b)
+```
+
+## ST_Touches
+
+Introduction: Return true if A touches B
+
+Format: `ST_Touches (A:geometry, B:geometry)`
+
+```sql
+SELECT *
+FROM pointdf
+WHERE ST_Touches(pointdf.arealandmark,
ST_PolygonFromEnvelope(1.0,100.0,1000.0,1100.0))
+```
+
+## ST_Within
+
+Introduction: Return true if A is fully contained by B
+
+Format: `ST_Within (A:geometry, B:geometry)`
+
+SQL example:
+
+```sql
+SELECT *
+FROM pointdf
+WHERE ST_Within(pointdf.arealandmark,
ST_PolygonFromEnvelope(1.0,100.0,1000.0,1100.0))
+```
+
+## ST_Covers
+
+Introduction: Return true if A covers B
+
+Format: `ST_Covers (A:geometry, B:geometry)`
+
+SQL example:
+
+```sql
+SELECT *
+FROM pointdf
+WHERE ST_Covers(ST_PolygonFromEnvelope(1.0,100.0,1000.0,1100.0),
pointdf.arealandmark)
+```
+
+## ST_CoveredBy
+
+Introduction: Return true if A is covered by B
+
+Format: `ST_CoveredBy (A:geometry, B:geometry)`
+
+SQL example:
+
+```sql
+SELECT *
+FROM pointdf
+WHERE ST_CoveredBy(pointdf.arealandmark,
ST_PolygonFromEnvelope(1.0,100.0,1000.0,1100.0))
+```
diff --git a/docs/setup/snowflake/install.md b/docs/setup/snowflake/install.md
new file mode 100644
index 000000000..7b80aed75
--- /dev/null
+++ b/docs/setup/snowflake/install.md
@@ -0,0 +1,11 @@
+# SedonaSnow
+
+SedonaSnow is a plugin that brings the open-source Apache Sedona functions to
Snowflake. The plugin doubles the spatial SQL functions supported by Snowflake,
and hence enables snowflake users to do more with their geospatial data.
+
+# Why Integrate Apache Sedona with Snowflake?
+
+Apache Sedona is a powerful open-source library for large-scaling geospatial
data processing and analysis. It has been used in use cases where data
engineers need to process spatial data at scale in their complicated data
stack. On the other hand, Snowflake is a cloud-based data warehousing platform
that allows for seamless data integration and processing.
+
+Many Snowflake users collect and store geospatial data in the platform. To
meet this need, Snowflake released the GEOGRAPHY data type and corresponding
geospatial functions in June 2021. Since then, new features have been added to
fulfill computation demands.
+
+The Wherobots team has observed a significant overlap in user bases between
Snowflake and Sedona. For users who have been utilizing Sedona Spatial SQL
APIs, we aim to enable them to continue using their favorite Sedona-flavored ST
functions through Snowflake SQL.
\ No newline at end of file
diff --git a/docs/setup/snowflake/modules.md b/docs/setup/snowflake/modules.md
new file mode 100644
index 000000000..a25e5767c
--- /dev/null
+++ b/docs/setup/snowflake/modules.md
@@ -0,0 +1,13 @@
+# Sedona modules for Snowflake
+
+| Name | Introduction|
+|---|---|
+|snowflake|Spatial SQL functions for Snowflake|
+|snowflake-tester| Automated tester of Sedona Snowflake functions |
+
+## API availability
+
+| | **Table** |
+|:----------:|:-----------------:|
+| SnowSQL |✅|
+| Snowpark |✅|
\ No newline at end of file
diff --git a/docs/tutorial/snowflake/sql.md b/docs/tutorial/snowflake/sql.md
new file mode 100644
index 000000000..2ed842261
--- /dev/null
+++ b/docs/tutorial/snowflake/sql.md
@@ -0,0 +1,434 @@
+After the installation done, you can start using Sedona functions. Please log
in to Snowflake again using the user that has the privilege to access the
database.
+
+!!!note
+ A good practice is to always keep at least the schema name "SEDONA" to
avoid conflicting with Snowflake's built-in functions.
+
+## Create a sample table
+
+Let's create a `city_tbl` that contains the locations and names of cities.
Each location is a WKT string.
+
+```sql
+CREATE TABLE city_tbl (wkt STRING, city_name STRING);
+INSERT INTO city_tbl(wkt, city_name) VALUES ('POINT (-122.33 47.61)',
'Seattle');
+INSERT INTO city_tbl(wkt, city_name) VALUES ('POINT (-122.42 37.76)', 'San
Francisco');
+```
+
+Then we can show the content of this table:
+
+```sql
+SELECT *
+FROM city_tbl;
+```
+
+Output:
+```
+WKT CITY_NAME
+POINT (-122.33 47.61) Seattle
+POINT (-122.42 37.76) San Francisco
+```
+
+## Create a Geometry column
+
+All geometrical operations in SedonaSQL are on Geometry type objects.
Therefore, before any kind of queries, you need to create a Geometry type
column on the table.
+
+```sql
+CREATE TABLE city_tbl_geom AS
+SELECT Sedona.ST_GeomFromWKT(wkt) AS geom, city_name
+FROM city_tbl
+```
+
+The `geom` column Table `city_tbl_geom ` is now in a `Binary` type and data in
this column is in a format that can be understood by Sedona. The output of this
query will show geometries in WKB binary format like this:
+
+```
+GEOM CITY_NAME
+010100000085eb51b81e955ec0ae47e17a14ce4740 Seattle
+01010000007b14ae47e19a5ec0e17a14ae47e14240 San Francisco
+```
+
+To view the content of this column in a human-readable format, you can use
`ST_AsText`. For example,
+
+```sql
+SELECT Sedona.ST_AsText(geom), city_name
+FROM city_tbl_geom
+```
+
+!!!note
+ SedonaSQL provides lots of functions to create a Geometry column,
please read [SedonaSQL API](../../../api/snowflake/vector-data/Constructor/).
+
+## Check the lon/lat order
+
+In SedonaSnow `v1.4.1` and before, we use lat/lon order in the following
functions:
+
+* ST_Transform
+* ST_DistanceSphere
+* ST_DistanceSpheroid
+
+We use `lon/lat` order in the following functions:
+
+* ST_GeomFromGeoHash
+* ST_GeoHash
+* ST_S2CellIDs
+
+In Sedona `v1.5.0` and above, all functions will be fixed to lon/lat order.
+
+If your original data is in lon/lat order, you need to flip the coordinate
using `ST_FlipCoordinates(geom: Geometry)` if you want to use those functions.
+
+The sample data used above is in lon/lat order, we can flip the coordinates as
follows:
+
+```sql
+CREATE OR REPLACE TABLE city_tbl_geom AS
+SELECT Sedona.ST_FlipCoordinates(geom) AS geom, city_name
+FROM city_tbl_geom
+```
+
+If we show the content of this table, it is now in lat/lon order:
+
+```sql
+SELECT Sedona.ST_AsText(geom), city_name
+FROM city_tbl_geom
+```
+
+Output:
+
+```
+GEOM CITY_NAME
+POINT (47.61 -122.33) Seattle
+POINT (37.76 -122.42) San Francisco
+```
+
+## Save as an ordinary column
+
+To save a table to some permanent storage, you can simply convert each
geometry in the Geometry type column back to a plain String and save it
anywhere you want.
+
+Use the following code to convert the Geometry column in a table back to a WKT
string column:
+
+```sql
+SELECT ST_AsText(geom)
+FROM city_tbl_geom
+```
+
+!!!note
+ SedonaSQL provides lots of functions to save the Geometry column,
please read [SedonaSQL API](../../../api/snowflake/vector-data/Function/).
+
+## Transform the Coordinate Reference System
+
+Sedona doesn't control the coordinate unit (degree-based or meter-based) of
all geometries in a Geometry column. The unit of all related distances in
SedonaSQL is same as the unit of all geometries in a Geometry column.
+
+To convert Coordinate Reference System of the Geometry column created before,
use `ST_Transform (A:geometry, SourceCRS:string, TargetCRS:string`
+
+The first EPSG code EPSG:4326 in `ST_Transform` is the source CRS of the
geometries. It is WGS84, the most common degree-based CRS.
+
+The second EPSG code EPSG:3857 in `ST_Transform` is the target CRS of the
geometries. It is the most common meter-based CRS.
+
+This `ST_Transform` transform the CRS of these geometries from EPSG:4326 to
EPSG:3857. The details CRS information can be found on
[EPSG.io](https://epsg.io/).
+
+!!!note
+ This function follows lat/lon order. If your data is in lon/lat order,
you can use `ST_FlipCoordinates` to swap X and Y.
+
+We can transform our sample data as follows
+
+```sql
+SELECT Sedona.ST_AsText(Sedona.ST_Transform(geom, 'epsg:4326', 'epsg:3857')),
city_name
+FROM city_tbl_geom
+```
+
+The output will be like this:
+
+```
+POINT (-13617713.308741156 6042216.250411431) Seattle
+POINT (-13627732.06291255 4545577.120361927) San Francisco
+```
+
+`ST_Transform` also supports the CRS string in OGC WKT format. For example,
the following query generates the same output but with a OGC WKT CRS string.
+
+```sql
+SELECT Sedona.ST_AsText(Sedona.ST_Transform(geom, 'epsg:4326', 'PROJCS["WGS 84
/ Pseudo-Mercator",
+ GEOGCS["WGS 84",
+ DATUM["WGS_1984",
+ SPHEROID["WGS 84",6378137,298.257223563,
+ AUTHORITY["EPSG","7030"]],
+ AUTHORITY["EPSG","6326"]],
+ PRIMEM["Greenwich",0,
+ AUTHORITY["EPSG","8901"]],
+ UNIT["degree",0.0174532925199433,
+ AUTHORITY["EPSG","9122"]],
+ AUTHORITY["EPSG","4326"]],
+ PROJECTION["Mercator_1SP"],
+ PARAMETER["central_meridian",0],
+ PARAMETER["scale_factor",1],
+ PARAMETER["false_easting",0],
+ PARAMETER["false_northing",0],
+ UNIT["metre",1,
+ AUTHORITY["EPSG","9001"]],
+ AXIS["Easting",EAST],
+ AXIS["Northing",NORTH],
+ EXTENSION["PROJ4","+proj=merc +a=6378137 +b=6378137 +lat_ts=0 +lon_0=0
+x_0=0 +y_0=0 +k=1 +units=m +nadgrids=@null +wktext +no_defs"],
+ AUTHORITY["EPSG","3857"]]')), city_name
+FROM city_tbl_geom
+```
+
+## Range query
+
+Use ==ST_Contains==, ==ST_Intersects==, ==ST_Within== to run a range query
over a single column.
+
+The following example finds all geometries that are within the given polygon:
+
+```sql
+SELECT *
+FROM city_tbl_geom
+WHERE
Sedona.ST_Contains(Sedona.ST_PolygonFromEnvelope(1.0,100.0,1000.0,1100.0), geom)
+```
+
+!!!note
+ Read [SedonaSQL API](../../../api/snowflake/vector-data/Constructor/)
to learn how to create a Geometry type query window.
+
+## KNN query
+
+Use ==ST_Distance==, ==ST_DistanceSphere==, ==ST_DistanceSpheroid== to
calculate the distance and rank the distance.
+
+The following code returns the 5 nearest neighbor of the given point.
+
+```sql
+SELECT geom, ST_Distance(Sedona.ST_Point(1.0, 1.0), geom) AS distance
+FROM city_tbl_geom
+ORDER BY distance DESC
+LIMIT 5
+```
+
+## Range join query
+
+!!!warning
+ Sedona range join in Snowflake does not trigger Sedona's optimized
spatial join algorithm while Sedona Spark does. It uses Snowflake's default
Cartesian join which is very slow. Therefore, it is recommended to use Sedona's
S2-based join or Snowflake's native ST functions to do range join, which will
trigger Snowflake's `GeoJoin` algorithm.
+
+Introduction: Find geometries from A and geometries from B such that each
geometry pair satisfies a certain predicate. Most predicates supported by
SedonaSQL can trigger a range join.
+
+Example:
+
+```sql
+SELECT *
+FROM polygondf, pointdf
+WHERE ST_Contains(polygondf.polygonshape,pointdf.pointshape)
+```
+
+```sql
+SELECT *
+FROM polygondf, pointdf
+WHERE ST_Intersects(polygondf.polygonshape,pointdf.pointshape)
+```
+
+```sql
+SELECT *
+FROM pointdf, polygondf
+WHERE ST_Within(pointdf.pointshape, polygondf.polygonshape)
+```
+
+## Distance join
+
+!!!warning
+ Sedona distance join in Snowflake does not trigger Sedona's optimized
spatial join algorithm while Sedona Spark does. It uses Snowflake's default
Cartesian join which is very slow. Therefore, it is recommended to use Sedona's
S2-based join or Snowflake's native ST functions to do range join, which will
trigger Snowflake's `GeoJoin` algorithm.
+
+Introduction: Find geometries from A and geometries from B such that the
distance of each geometry pair is less or equal than a certain distance. It
supports the planar Euclidean distance calculators `ST_Distance`,
`ST_HausdorffDistance`, `ST_FrechetDistance` and the meter-based geodesic
distance calculators `ST_DistanceSpheroid` and `ST_DistanceSphere`.
+
+Example for planar Euclidean distance:
+
+```sql
+SELECT *
+FROM pointdf1, pointdf2
+WHERE ST_Distance(pointdf1.pointshape1,pointdf2.pointshape2) < 2
+```
+
+```sql
+SELECT *
+FROM pointDf, polygonDF
+WHERE ST_HausdorffDistance(pointDf.pointshape, polygonDf.polygonshape, 0.3) < 2
+```
+
+```sql
+SELECT *
+FROM pointDf, polygonDF
+WHERE ST_FrechetDistance(pointDf.pointshape, polygonDf.polygonshape) < 2
+```
+
+!!!warning
+ If you use planar euclidean distance functions like `ST_Distance`,
`ST_HausdorffDistance` or `ST_FrechetDistance` as the predicate, Sedona doesn't
control the distance's unit (degree or meter). It is same with the geometry. If
your coordinates are in the longitude and latitude system, the unit of
`distance` should be degree instead of meter or mile. To change the geometry's
unit, please either transform the coordinate reference system to a meter-based
system. See [ST_Transform](Function [...]
+
+```sql
+SELECT *
+FROM pointdf1, pointdf2
+WHERE ST_DistanceSpheroid(pointdf1.pointshape1,pointdf2.pointshape2) < 2
+```
+
+## Google S2 based approximate equi-join
+
+You can use Sedona built-in Google S2 functions to perform an approximate
equi-join. This algorithm leverages Snowflake's internal equi-join algorithm
and might be performant given that you can opt to skip the refinement step by
sacrificing query accuracy.
+
+Please use the following steps:
+
+### 1. Generate S2 ids for both tables
+
+Use [ST_S2CellIds](../Function/#st_s2cellids) to generate cell IDs. Each
geometry may produce one or more IDs.
+
+```sql
+SELECT * FROM lefts, TABLE(FLATTEN(ST_S2CellIDs(lefts.geom, 15))) s1
+```
+
+```sql
+SELECT * FROM rights, TABLE(FLATTEN(ST_S2CellIDs(rights.geom, 15))) s2
+```
+
+### 2. Perform equi-join
+
+Join the two tables by their S2 cellId
+
+```sql
+SELECT lcs.id as lcs_id, lcs.geom as lcs_geom, lcs.name as lcs_name, rcs.id as
rcs_id, rcs.geom as rcs_geom, rcs.name as rcs_name
+FROM lcs JOIN rcs ON lcs.cellId = rcs.cellId
+```
+
+### 3. Optional: Refine the result
+
+Due to the nature of S2 Cellid, the equi-join results might have a few
false-positives depending on the S2 level you choose. A smaller level indicates
bigger cells, less exploded rows, but more false positives.
+
+To ensure the correctness, you can use one of the [Spatial
Predicates](../Predicate/) to filter out them. Use this query instead of the
query in Step 2.
+
+```sql
+SELECT lcs.id as lcs_id, lcs.geom as lcs_geom, lcs.name as lcs_name, rcs.id as
rcs_id, rcs.geom as rcs_geom, rcs.name as rcs_name
+FROM lcs, rcs
+WHERE lcs.cellId = rcs.cellId AND ST_Contains(lcs.geom, rcs.geom)
+```
+
+As you see, compared to the query in Step 2, we added one more filter, which
is `ST_Contains`, to remove false positives. You can also use `ST_Intersects`
and so on.
+
+!!!tip
+ You can skip this step if you don't need 100% accuracy and want faster
query speed.
+
+### 4. Optional: De-duplicate
+
+Due to the `Flatten` function used when we generate S2 Cell Ids, the resulting
DataFrame may have several duplicate <lcs_geom, rcs_geom> matches. You can
remove them by performing a GroupBy query.
+
+```sql
+SELECT lcs_id, rcs_id, ANY_VALUE(lcs_geom), ANY_VALUE(lcs_name),
ANY_VALUE(rcs_geom), ANY_VALUE(rcs_name)
+FROM joinresult
+GROUP BY (lcs_id, rcs_id)
+```
+
+The `ANY_VALUE` function is to take the first value from a number of duplicate
values.
+
+If you don't have a unique id for each geometry, you can also group by
geometry itself. See below:
+
+```sql
+SELECT lcs_geom, rcs_geom, ANY_VALUE(lcs_name), ANY_VALUE(rcs_name)
+FROM joinresult
+GROUP BY (lcs_geom, rcs_geom)
+```
+
+!!!note
+ If you are doing point-in-polygon join, this is not a problem and you
can safely discard this issue. This issue only happens when you do
polygon-polygon, polygon-linestring, linestring-linestring join.
+
+### S2 for distance join
+
+This also works for distance join. You first need to use `ST_Buffer(geometry,
distance)` to wrap one of your original geometry column. If your original
geometry column contains points, this `ST_Buffer` will make them become circles
with a radius of `distance`.
+
+Since the coordinates are in the longitude and latitude system, so the unit of
`distance` should be degree instead of meter or mile. You can get an
approximation by performing `METER_DISTANCE/111000.0`, then filter out
false-positives. Note that this might lead to inaccurate results if your data
is close to the poles or antimeridian.
+
+In a nutshell, run this query first on the left table before Step 1. Please
replace `METER_DISTANCE` with a meter distance. In Step 1, generate S2 IDs
based on the `buffered_geom` column. Then run Step 2, 3, 4 on the original
`geom` column.
+
+```sql
+SELECT id, geom, ST_Buffer(geom, METER_DISTANCE/111000.0) as buffered_geom,
name
+FROM lefts
+```
+
+## Functions that are only availble in Sedona
+
+Sedona implements over 200 geospatial vector and raster functions, which are
much more than what Snowflake native functions offer. For example:
+
+* [ST_3DDistance](../../../api/snowflake/vector-data/Function/#st_3ddistance)
+* [ST_Force2D](../../../api/snowflake/vector-data/Function/#st_force_2d)
+* [ST_GeometryN](../../../api/snowflake/vector-data/Function/#st_geometryn)
+* [ST_MakeValid](../../../api/snowflake/vector-data/Function/#st_makevalid)
+* [ST_Multi](../../../api/snowflake/vector-data/Function/#st_multi)
+*
[ST_NumGeometries](../../../api/snowflake/vector-data/Function/#st_numgeometries)
+*
[ST_ReducePrecision](../../../api/snowflake/vector-data/Function/#st_precisionreduce)
+*
[ST_SubdivdeExplode](../../../api/snowflake/vector-data/Function/#st_subdivideexplode)
+
+You can click the links above to learn more about these functions. More
functions can be found in [SedonaSQL
API](../../../api/snowflake/vector-data/Function/).
+
+## Interoperate with Snowflake native functions
+
+Sedona can interoperate with Snowflake native functions seamlessly. There are
two ways to do this:
+
+* Use Sedona functions to create a Geometry column, then use Snowflake native
functions and Sedona functions to query the Geometry column.
+* Use Snowflake native functions to create a Geometry column, then use
Snowflake native functions and Sedona functions to query the Geometry column.
+
+Now we will show you how to do this.
+
+### Geometries created by Sedona Geometry constructors
+
+In this case, Sedona uses EWKB type as the input/output type for geometry. If
you have datasets of built-in Snowflake GEOMETRY/GEOGRAPHY type, you can easily
transform them into EWKB through this function.
+
+#### From Snowflake native functions to Sedona functions
+
+In this example, `SEDONA.ST_X` is a Sedona function, `ST_GeommetryFromWkt` and
`ST_AsEWKB` are Snowflake native functions.
+
+```sql
+SELECT SEDONA.ST_X(ST_AsEWKB(ST_GeommetryFromWkt('POLYGON((0 0, 0 1, 1 1, 1 0,
0 0))'))) FROM {{geometry_table}};
+```
+
+#### From Sedona functions to Snowflake native functions
+
+In this example, `SEDONA.ST_GeomFromText` is a Sedona function, `ST_AREA` and
`to_geometry` are Snowflake native functions.
+
+```sql
+SELECT ST_AREA(to_geometry(SEDONA.ST_GeomFromText('POLYGON((0 0, 0 1, 1 1, 1
0, 0 0))')));
+```
+
+#### Pros:
+Sedona geometry constructors are more powerful than Snowflake native
functions. It has the following advantages:
+
+* Sedona offers more constructors especially for 3D (XYZ) geometries, but
Snowflake native functions don't.
+* WKB serialization is more efficient. If you need to use multiple Sedona
functions, it is more efficient to use this method, which might bring in 2X
performance improvement.
+* SRID information of geometries is preserved. The method below will lose SRID
information.
+
+### Geometries created by Snowflake Geometry constructors
+
+In this case, Sedona uses Snowflake native GEOMETRY/GEOGRAPHY type as the
input/output type for geometry. The serialization format is GeoJSON string.
+
+```sql
+SELECT ST_AREA(SEDONA.ST_Buffer(ST_GeometryFromWkt('POLYGON((0 0, 0 1, 1 1, 1
0, 0 0))'), 1));
+```
+
+In this example, `SEDONA.ST_Buffer` is a Sedona function,
`ST_GeommetryFromWkt` and `ST_AREA` are Snowflake native functions.
+
+As you can see, you can use Sedona functions and Snowflake native functions
together without explicit conversion.
+
+#### Pros:
+
+* You don't need to convert the geometry type, which is more convenient.
+
+
+Note that: Snowflake natively serializes Geometry type data to GeoJSON String
and sends to UDF as input. GeoJSON spec does not include SRID. So the SRID
information will be lost if you mix-match Snowflake functions and Sedona
functions directly without using `WKB`.
+
+In the example below, the SRID=4326 information is lost.
+
+```sql
+SELECT ST_AsEWKT(SEDONA.ST_SetSRID(ST_GeometryFromWKT('POINT(1 2)'), 4326))
+```
+
+Output:
+```
+SRID=0;POINT(1 2)
+```
+
+## Known issues
+
+1. Sedona Snowflake doesn't support `M` dimension due to the limitation of WKB
serialization. Sedona Spark and Sedona Flink support XYZM because it uses our
in-house serialization format. Although Sedona Snowflake has functions related
to `M` dimension, all `M` values will be ignored.
+2. Sedona H3 functions are not supported because Snowflake does not allow
embedded C code in UDF.
+3. All User Defined Table Functions only work with geometries created by
Sedona constructors due to Snowflake current limitation `Data type GEOMETRY is
not supported in non-SQL UDTF return type`. This includes:
+ * ST_MinimumBoundingRadius
+ * ST_Intersection_Aggr
+ * ST_SubDivideExplode
+ * ST_Envelope_Aggr
+ * ST_Union_Aggr
+ * ST_Collect
+ * ST_Dump
+4. Only Sedona ST functions are available in Snowflake. Raster functions (RS
functions) are not available in Snowflake yet.
\ No newline at end of file
diff --git a/mkdocs.yml b/mkdocs.yml
index 766d77c53..52234ddc6 100644
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -11,6 +11,8 @@ nav:
- Sedona with Apache Flink:
- Modules: setup/flink/modules.md
- Language wrappers: setup/flink/platform.md
+ - Sedona with Snowflake:
+ - Modules: setup/snowflake/modules.md
- Maven Central coordinate: setup/maven-coordinates.md
- Install with Apache Spark:
- Install Sedona Scala/Java: setup/install-scala.md
@@ -24,6 +26,8 @@ nav:
- Set up Spark cluster: setup/cluster.md
- Install with Apache Flink:
- Install Sedona Scala/Java: setup/flink/install-scala.md
+ - Install with Snowflake:
+ - Install Sedona SQL: setup/snowflake/install.md
- Release notes: setup/release-notes.md
- Compile the code: setup/compile.md
- Download: download.md
@@ -45,6 +49,8 @@ nav:
- Storing large raster geometries in Parquet files:
tutorial/storing-blobs-in-parquet.md
- Sedona with Apache Flink:
- Spatial SQL app: tutorial/flink/sql.md
+ - Sedona with Snowflake:
+ - Spatial SQL app: tutorial/snowflake/sql.md
- Examples:
- Scala/Java: tutorial/demo.md
- Python: tutorial/jupyter-notebook.md
@@ -84,6 +90,13 @@ nav:
- Function: api/flink/Function.md
- Aggregator: api/flink/Aggregator.md
- Predicate: api/flink/Predicate.md
+ - Sedona with Snowflake:
+ - SQL:
+ - Overview: api/snowflake/vector-data/Overview.md
+ - Constructor: api/snowflake/vector-data/Constructor.md
+ - Function: api/snowflake/vector-data/Function.md
+ - Aggregate Function: api/snowflake/vector-data/AggregateFunction.md
+ - Predicate: api/snowflake/vector-data/Predicate.md
- Community:
- Community: community/contact.md
- Contributor Guide:
