| Title: | Apache SedonaDB Function Definitions and Documentation |
|---|---|
| Description: | Provides function definitions and documentation for use in 'SedonaDB'. |
| Authors: | Dewey Dunnington [aut, cre] |
| Maintainer: | Dewey Dunnington <[email protected]> |
| License: | Apache License (>= 2) |
| Version: | 0.4.1.9000 |
| Built: | 2026-10-15 06:15:00 UTC |
| Source: | https://github.com/apache/sedona-db |
RS_AsGeoTiff encodes a raster as a GeoTIFF (via GDAL) and returns the file
bytes as a binary value — the inverse of reading a GeoTIFF into a raster. The
result is NULL for a NULL raster. A NULL option argument means "not
specified": e.g. a NULL compression writes an uncompressed GeoTIFF rather
than propagating NULL to the result. The two-argument form
RS_AsGeoTiff(raster, tile_size) writes a tiled GeoTIFF with square
tile_size blocks. Compression is selected by name; a JPEG quality factor
and explicit tile dimensions can be supplied via the longer overloads.
rs_as_geo_tiff(...)rs_as_geo_tiff(...)
... |
Supported combinations:
|
(binary)
SedonaDB SQL documentation for RS_ASGEOTIFF
Creates a single-band in-db raster by rasterizing geometry onto the grid
defined by reference_raster. The output pixel type is controlled by
pixel_type. Optional arguments control whether pixels touched by the
geometry are burned, the value burned into covered pixels, the nodata fill
value, and whether the output extent is cropped to the geometry extent or
kept equal to the full reference raster extent. When both geometry and
reference_raster have a CRS and they differ, geometry is reprojected into
the reference raster's CRS before rasterization. An error is returned if
exactly one of them has a CRS.
rs_as_raster( geometry = sd_missing_arg(), reference_raster = sd_missing_arg(), pixel_type = sd_missing_arg(), all_touched = sd_missing_arg(), burn_value = sd_missing_arg(), nodata_value = sd_missing_arg(), use_geometry_extent = sd_missing_arg() )rs_as_raster( geometry = sd_missing_arg(), reference_raster = sd_missing_arg(), pixel_type = sd_missing_arg(), all_touched = sd_missing_arg(), burn_value = sd_missing_arg(), nodata_value = sd_missing_arg(), use_geometry_extent = sd_missing_arg() )
geometry |
(geometry): Input geometry |
reference_raster |
(raster): Input raster |
pixel_type |
(string): Input string |
all_touched |
(boolean): Input boolean |
burn_value |
(double): Input double |
nodata_value |
(double): Input double |
use_geometry_extent |
(boolean): Input boolean |
(raster)
SedonaDB SQL documentation for RS_ASRASTER
A pixel counts as nodata when it equals the band's nodata value; a NaN pixel matches a NaN nodata value. A band without a nodata value is never all nodata, even if every pixel is 0. Only 2-D rasters are supported.
rs_band_is_no_data(rast = sd_missing_arg(), band = sd_missing_arg())rs_band_is_no_data(rast = sd_missing_arg(), band = sd_missing_arg())
rast |
(raster): Input raster |
band |
(integer): Band index (1-based). Defaults to 1 if not specified. |
(boolean)
SedonaDB SQL documentation for RS_BANDISNODATA
Returns the nodata value of the specified band as a double. Returns null if the band has no nodata value defined.
rs_band_no_data_value(rast = sd_missing_arg(), band = sd_missing_arg())rs_band_no_data_value(rast = sd_missing_arg(), band = sd_missing_arg())
rast |
(raster): Input raster |
band |
(int): Band index (1-based). Defaults to 1 if not specified. |
(float64)
SedonaDB SQL documentation for RS_BANDNODATAVALUE
Primarily used with out-db rasters, where only raster path and geo-referencing metadata are stored in the database.
rs_band_path(rast = sd_missing_arg())rs_band_path(rast = sd_missing_arg())
rast |
(raster): Input raster |
(utf8)
SedonaDB SQL documentation for RS_BANDPATH
Returns the pixel data type of the specified band as a string.
rs_band_pixel_type(rast = sd_missing_arg(), band = sd_missing_arg())rs_band_pixel_type(rast = sd_missing_arg(), band = sd_missing_arg())
rast |
(raster): Input raster |
band |
(int): Band index (1-based). Defaults to 1 if not specified. |
(utf8)
SedonaDB SQL documentation for RS_BANDPIXELTYPE
Collapses all bands in a raster into a single band by introducing a new
dimension. The new dimension is prepended to the existing dimensions, with
size equal to the number of bands. Band data is concatenated in band order.
All bands must have identical dimension names, shapes, data types, and nodata
values. If any of these differ, an error is returned — collapsing bands with
different nodata sentinels would silently lose information about which
sentinel applies where. The new dimension name must not already exist on the
input bands. For example, RS_BandToDim(raster_with_y_x, 'y') is rejected
because the output would carry duplicate y dimensions and the round-trip
through RS_DimToBand cannot recover the original layout.
This is the inverse of RS_DimToBand. A round-trip
RS_BandToDim(RS_DimToBand(raster, 'dim'), 'dim') recovers the original data
layout. This is useful for converting GeoTIFF-style multi-band rasters into a
single N-dimensional chunk for export to formats like Zarr.
rs_band_to_dim(rast = sd_missing_arg(), dim_name = sd_missing_arg())rs_band_to_dim(rast = sd_missing_arg(), dim_name = sd_missing_arg())
rast |
(raster): Input raster |
dim_name |
(utf8): Name for the new dimension (e.g., 'time', 'band'). |
(raster)
SedonaDB SQL documentation for RS_BANDTODIM
RS_Clip clips a raster to a geometry, in the spirit of PostGIS ST_Clip.
Pixels of the selected band that fall outside the geometry are set to the
band's nodata value (or no_data_value if given); pixels inside are kept.
When crop is true (the default) the output is cropped to the geometry's
bounding box intersected with the raster extent, snapped to the pixel grid;
unselected pixels within that window remain as nodata padding. Otherwise the
original extent is preserved. The geometry is reprojected into the raster's
CRS when both carry one. If exactly one side has a CRS, the call errors; if
neither does, the geometry is used as-is. A pixel is selected only when its
center falls inside the geometry. A geometry smaller than a pixel, or a thin
sliver, can therefore select no pixels even though it overlaps the raster;
set all_touched to true to keep every pixel the geometry touches instead.
The clip is a 2-D (y, x) operation. For an N-D raster (bands with extra
dimensions such as time), the same mask and crop window are broadcast
across every non-spatial plane, so the non-spatial dimensions are preserved
and only the (y, x) extent changes.
rs_clip( rast = sd_missing_arg(), band = sd_missing_arg(), geom = sd_missing_arg(), all_touched = sd_missing_arg(), no_data_value = sd_missing_arg(), crop = sd_missing_arg(), lenient = sd_missing_arg() )rs_clip( rast = sd_missing_arg(), band = sd_missing_arg(), geom = sd_missing_arg(), all_touched = sd_missing_arg(), no_data_value = sd_missing_arg(), crop = sd_missing_arg(), lenient = sd_missing_arg() )
rast |
(raster): Input raster |
band |
(integer): 1-based index of the band to clip, or 0 to clip every band. A NULL band yields a NULL result. |
geom |
(geometry): Clip geometry. Reprojected into the raster's CRS when both carry one; it is an error for exactly one side to have a CRS. |
all_touched |
(boolean): If true, keep every pixel the geometry touches; otherwise keep only pixels whose center falls inside it. Defaults to false. |
no_data_value |
(double): Value written to pixels outside the geometry. Defaults to the band's own nodata value, or the band data type's minimum if it has none. It is an error if the value does not fit the band's data type. |
crop |
(boolean): Crop the output to the geometry's bounding box. Defaults to true. |
lenient |
(boolean): If true, a geometry that does not intersect the raster yields NULL; if false, it raises an error. Defaults to true. |
(raster)
SedonaDB SQL documentation for RS_CLIP
Returns true if the convex hull of the first argument completely contains
the second argument. Both rasters and geometries are accepted in either
argument position. When two rasters are provided, their convex hulls are
compared. If the arguments have different CRSes, the geometry is transformed
into the raster's CRS before evaluating the predicate. For two rasters, the
second raster's extent is transformed into the first raster's CRS. If the
preferred transformation fails, the extent of both sides are transformed to
WGS 84 as a fallback. If either argument has no CRS set, the comparison is
performed directly without CRS transformation.
rs_contains(...)rs_contains(...)
... |
Supported combinations:
|
(boolean)
SedonaDB SQL documentation for RS_CONTAINS
Returns the convex hull geometry of a raster.
rs_convex_hull(rast = sd_missing_arg())rs_convex_hull(rast = sd_missing_arg())
rast |
(raster): Input raster |
(geometry)
SedonaDB SQL documentation for RS_CONVEXHULL
Returns the CRS string for a raster.
rs_crs(rast = sd_missing_arg())rs_crs(rast = sd_missing_arg())
rast |
(raster): Input raster |
(string)
SedonaDB SQL documentation for RS_CRS
Returns the ordered list of dimension names for a raster band. Standard 2D
rasters have dimensions ["y", "x"]. N-dimensional rasters may include
additional dimensions such as time, pressure, wavelength, etc. The
dimension names correspond to the entries in RS_Shape — the
i-th name matches the i-th size. When the band index is omitted, all bands
must agree on their dimension names; if they disagree, an error is returned
prompting the user to specify a band index.
rs_dim_names(rast = sd_missing_arg(), band = sd_missing_arg())rs_dim_names(rast = sd_missing_arg(), band = sd_missing_arg())
rast |
(raster): Input raster |
band |
(int): Band index (1-based). A null or out-of-range index returns null. |
(list
SedonaDB SQL documentation for RS_DIMNAMES
Returns the size of a named dimension in a raster. For example,
RS_DimSize(raster, 'x') returns the width and RS_DimSize(raster, 'time')
returns the number of time steps. This is equivalent to looking up a specific
entry in RS_Shape by name rather than by position. ###
Heterogeneous rasters Bands within a raster can have different
dimensionality. When the band index is omitted, RS_DimSize considers only
the bands that carry the named dimension ("pass-through"): - If at least one
band carries the dimension and they all agree on its size, that size is
returned. - If the bands that carry the dimension disagree on its size, an
error is returned prompting the user to specify a band index. - If no
band carries the dimension, an error is returned. This usually signals a
typo'd dimension name. When the band index is supplied explicitly, returns
the size of the dimension in that band, or NULL if the band does not carry
it.
rs_dim_size( rast = sd_missing_arg(), dim_name = sd_missing_arg(), band = sd_missing_arg() )rs_dim_size( rast = sd_missing_arg(), dim_name = sd_missing_arg(), band = sd_missing_arg() )
rast |
(raster): Input raster |
dim_name |
(utf8): Name of the dimension to query. |
band |
(int): Band index (1-based). A null or out-of-range index returns null. |
(int64)
SedonaDB SQL documentation for RS_DIMSIZE
Promotes a named non-spatial dimension into separate bands. Each index along
the dimension becomes its own band with that dimension removed. This bridges
the gap between the dimension model (where all indices live in one band) and
the band model (where each index is a separate band accessible by number).
For example, a raster with 1 band of shape [wavelength=200, y=256, x=256]
becomes a raster with 200 bands, each of shape [y=256, x=256]. Standard
band math functions can then operate on individual wavelength bands by index.
Bands that do not contain the named dimension are passed through unchanged.
If no band carries the named dimension, the function errors — that
condition usually signals a typo'd dimension name. The spatial dimensions
(x_dim and y_dim) cannot be promoted. The inverse operation is
RS_BandToDim.
rs_dim_to_band(rast = sd_missing_arg(), dim_name = sd_missing_arg())rs_dim_to_band(rast = sd_missing_arg(), dim_name = sd_missing_arg())
rast |
(raster): Input raster |
dim_name |
(utf8): Name of the dimension to promote (e.g., 'wavelength', 'time'). |
(raster)
SedonaDB SQL documentation for RS_DIMTOBAND
Returns the envelope (bounding box) of a raster as a geometry.
rs_envelope(rast = sd_missing_arg())rs_envelope(rast = sd_missing_arg())
rast |
(raster): Input raster |
(geometry)
SedonaDB SQL documentation for RS_ENVELOPE
Creates a simple example raster for testing and demos.
rs_example()rs_example()
(raster)
SedonaDB SQL documentation for RS_EXAMPLE
RS_FromGDALRaster parses raster file bytes with GDAL and returns an
in-database raster with all band data materialised inline — the inverse of
RS_AsGeoTiff, and the binary counterpart of
RS_FromPath (which references a file on disk as an
out-db raster instead). A NULL input yields a NULL raster. It is
typically applied to a binary column holding encoded rasters — for example
rasters produced by RS_AsGeoTiff, which round-trips back through
RS_FromGDALRaster: sql SELECT RS_Width(RS_FromGDALRaster(RS_AsGeoTiff(RS_Example())));
rs_from_gdal_raster(content = sd_missing_arg())rs_from_gdal_raster(content = sd_missing_arg())
content |
(binary): Raster file bytes in any format GDAL can read (GeoTIFF, PNG, …). A NULL input yields a NULL raster. |
(raster)
SedonaDB SQL documentation for RS_FROMGDALRASTER
Loads raster metadata from the file at path and returns a raster whose
bands reference the source file as out-db bands. This is useful when you want
to work with rasters stored on disk without copying their pixel data into the
raster value itself.
rs_from_path(path = sd_missing_arg())rs_from_path(path = sd_missing_arg())
path |
(string): Input string |
(raster)
SedonaDB SQL documentation for RS_FROMPATH
Returns the georeference metadata of raster as a string in GDAL or ESRI format as commonly seen in a world file. Default is GDAL if not specified. Both formats output six lines: scalex, skewy, skewx, scaley, upperleftx, upperlefty. In GDAL format the upper-left coordinates refer to the corner of the upper-left pixel, while in ESRI format they are shifted to the center of the upper-left pixel.
rs_geo_reference(rast = sd_missing_arg(), format = sd_missing_arg())rs_geo_reference(rast = sd_missing_arg(), format = sd_missing_arg())
rast |
(raster): Input raster |
format |
(utf8): Output format: 'GDAL' (default; alias 'PIXEL') reports the upper-left corner of the upper-left pixel; 'ESRI' (alias 'NODE') shifts the coordinates to the center of the upper-left pixel. The center shift maps through the full affine transform, so it is exact for skewed (rotated) rasters too. |
(utf8)
SedonaDB SQL documentation for RS_GEOREFERENCE
Returns the raster's geotransform decomposed into a struct of six doubles, matching Sedona Spark's RS_GeoTransform: magnitudeI and magnitudeJ (pixel sizes along the transformed i and j axes), thetaI (rotation of the raster in radians, positive clockwise), thetaIJ (angle from the transformed i axis to the transformed j axis in radians, positive counter-clockwise), and offsetX and offsetY (the upper-left corner of the upper-left pixel). For the raw affine coefficients instead of this decomposition, use the individual accessors (RS_ScaleX, RS_SkewX, RS_UpperLeftX, ...) or RS_GeoReference.
rs_geo_transform(rast = sd_missing_arg())rs_geo_transform(rast = sd_missing_arg())
rast |
(raster): Input raster |
(struct)
SedonaDB SQL documentation for RS_GEOTRANSFORM
Returns the height of a raster in pixels.
rs_height(rast = sd_missing_arg())rs_height(rast = sd_missing_arg())
rast |
(raster): Input raster |
(bigint)
SedonaDB SQL documentation for RS_HEIGHT
Returns true if the convex hull of the first argument intersects the second
argument. Both rasters and geometries are accepted in either argument
position. When two rasters are provided, their convex hulls are compared. If
the arguments have different CRSes, the geometry is transformed into the
raster's CRS before evaluating the predicate. For two rasters, the second
raster's extent is transformed into the first raster's CRS. If the preferred
transformation fails, the extent of both sides are transformed to WGS 84 as a
fallback. If either argument has no CRS set, the comparison is performed
directly without CRS transformation. Across CRSes a reprojected raster
footprint is densified with about 10 points per edge before it is
reprojected, so it follows the curve of each edge instead of chording
straight through the four reprojected corners. Same-CRS comparisons are
exact.
rs_intersects(...)rs_intersects(...)
... |
Supported combinations:
|
(boolean)
SedonaDB SQL documentation for RS_INTERSECTS
Returns true when the raster has zero visible volume — some dimension has length 0, so it holds no cells. This is visible-volume emptiness, not byte-emptiness: a lazy raster whose pixels are resolved on demand carries no bytes but is not empty.
rs_is_empty(rast = sd_missing_arg())rs_is_empty(rast = sd_missing_arg())
rast |
(raster): Input raster |
(boolean)
SedonaDB SQL documentation for RS_ISEMPTY
RS_MakeEmptyRaster builds a raster from nothing but a grid definition.
Every band holds width * height zeros of band_data_type (default
float64) and has no nodata value. The grid can be placed three ways: -
From an extent geometry. The raster covers the envelope of extent with
width x height north-up pixels: the upper-left corner is the envelope's
(xmin, ymax), the pixel size is the envelope size divided by the pixel count,
and the raster's CRS is the geometry's. This is the direct way to describe a
grid as "columns, rows, bounding box and CRS"; pair it with
ST_MakeEnvelope, ST_Envelope or
RS_Envelope. The envelope must span a positive width and
height. - From an upper-left corner and a square cell size. No skew and
no CRS (attach one with RS_SetSRID or
RS_SetCRS). - From a full affine transform and SRID.
The six geotransform parameters and an EPSG code, 0 meaning no CRS. The
last two forms take the same arguments as Sedona Spark's
RS_MakeEmptyRaster; the extent form is a SedonaDB extension. Where Sedona
Spark silently falls back to float64 for an unrecognised band_data_type,
SedonaDB raises an error. num_bands may be 0, which yields a raster with
a grid but no bands: a lightweight template that reference-taking functions
can consume without carrying pixel data. The result is an in-database raster,
so each band occupies width * height * bytes-per-pixel in memory (a
float64 band of 1000 x 1000 pixels is 8 MB). A single band is limited to 4
GiB. Null arguments yield a null raster.
rs_make_empty_raster(...)rs_make_empty_raster(...)
... |
Supported combinations:
|
(raster)
SedonaDB SQL documentation for RS_MAKEEMPTYRASTER
RS_MetaData() returns a struct containing: - upperLeftX, upperLeftY:
origin of the raster geotransform - gridWidth, gridHeight: raster
dimensions in pixels - scaleX, scaleY: pixel scale - skewX, skewY:
geotransform skew terms - srid: raster SRID if available, otherwise 0 -
numSampleDimensions: band count - tileWidth, tileHeight: GDAL block
size derived tile dimensions For rasters with no bands, tileWidth and
tileHeight are 0.
rs_meta_data(rast = sd_missing_arg())rs_meta_data(rast = sd_missing_arg())
rast |
(raster): Input raster |
(struct)
SedonaDB SQL documentation for RS_METADATA
RS_MinConvexHull is RS_ConvexHull with the nodata margin trimmed off. The
rectangle is aligned to the raster's grid, so on a rotated or skewed raster
the result follows the grid axes, like RS_ConvexHull. A band without a
nodata value holds data everywhere, so it spans the whole grid. Only 2-D
rasters are supported.
rs_min_convex_hull(rast = sd_missing_arg(), band = sd_missing_arg())rs_min_convex_hull(rast = sd_missing_arg(), band = sd_missing_arg())
rast |
(raster): Input raster |
band |
(integer): Band index (1-based). When omitted, a pixel holds data if any band holds data there. |
(geometry)
SedonaDB SQL documentation for RS_MINCONVEXHULL
Returns the number of bands in the raster.
rs_num_bands(rast = sd_missing_arg())rs_num_bands(rast = sd_missing_arg())
rast |
(raster): Input raster |
(uint32)
SedonaDB SQL documentation for RS_NUMBANDS
Returns the number of dimensions in a raster band. A standard 2D raster has 2
dimensions (y and x). N-dimensional rasters (e.g., from Zarr or NetCDF
sources) may have additional dimensions such as time, pressure, or
wavelength. When the band index is omitted, all bands must agree on the
number of dimensions; if they disagree, an error is returned prompting the
user to specify a band index.
rs_num_dimensions(rast = sd_missing_arg(), band = sd_missing_arg())rs_num_dimensions(rast = sd_missing_arg(), band = sd_missing_arg())
rast |
(raster): Input raster |
band |
(int): Band index (1-based). A null or out-of-range index returns null. |
(int32)
SedonaDB SQL documentation for RS_NUMDIMENSIONS
Returns the centroid of the specified pixel as a Point geometry.
rs_pixel_as_centroid( rast = sd_missing_arg(), colX = sd_missing_arg(), rowY = sd_missing_arg() )rs_pixel_as_centroid( rast = sd_missing_arg(), colX = sd_missing_arg(), rowY = sd_missing_arg() )
rast |
(raster): Input raster |
colX |
(integer): Input integer |
rowY |
(integer): Input integer |
(geometry)
SedonaDB SQL documentation for RS_PIXELASCENTROID
Returns the upper-left corner of the specified pixel as a Point geometry.
rs_pixel_as_point( rast = sd_missing_arg(), colX = sd_missing_arg(), rowY = sd_missing_arg() )rs_pixel_as_point( rast = sd_missing_arg(), colX = sd_missing_arg(), rowY = sd_missing_arg() )
rast |
(raster): Input raster |
colX |
(integer): Input integer |
rowY |
(integer): Input integer |
(geometry)
SedonaDB SQL documentation for RS_PIXELASPOINT
Returns the bounding polygon of the specified pixel.
rs_pixel_as_polygon( rast = sd_missing_arg(), colX = sd_missing_arg(), rowY = sd_missing_arg() )rs_pixel_as_polygon( rast = sd_missing_arg(), colX = sd_missing_arg(), rowY = sd_missing_arg() )
rast |
(raster): Input raster |
colX |
(integer): Input integer |
rowY |
(integer): Input integer |
(geometry)
SedonaDB SQL documentation for RS_PIXELASPOLYGON
Converts the specified raster band into vector polygons, returning one item
per connected region of pixels that shares the same value. Each returned list
item contains: - geom: the polygon geometry encoded as WKB - value: the
pixel value represented by that polygon
rs_polygonize(rast = sd_missing_arg(), band = sd_missing_arg())rs_polygonize(rast = sd_missing_arg(), band = sd_missing_arg())
rast |
(raster): Input raster |
band |
(integer): Input integer |
(list)
SedonaDB SQL documentation for RS_POLYGONIZE
Pixel coordinates are 1-based, as in PostGIS ST_RasterToWorldCoord: (1, 1) is the upper-left pixel, and the result is the world coordinate of that
pixel's upper-left corner. Coordinates outside the grid, including 0,
extrapolate along the geotransform.
rs_raster_to_world_coord( rast = sd_missing_arg(), x = sd_missing_arg(), y = sd_missing_arg() )rs_raster_to_world_coord( rast = sd_missing_arg(), x = sd_missing_arg(), y = sd_missing_arg() )
rast |
(raster): Input raster |
x |
(integer): Input integer |
y |
(integer): Input integer |
(geometry)
SedonaDB SQL documentation for RS_RASTERTOWORLDCOORD
Pixel coordinates are 1-based, as in PostGIS ST_RasterToWorldCoord: (1, 1) is the upper-left pixel, and the result is the world coordinate of that
pixel's upper-left corner. Coordinates outside the grid, including 0,
extrapolate along the geotransform.
rs_raster_to_world_coord_x( rast = sd_missing_arg(), x = sd_missing_arg(), y = sd_missing_arg() )rs_raster_to_world_coord_x( rast = sd_missing_arg(), x = sd_missing_arg(), y = sd_missing_arg() )
rast |
(raster): Input raster |
x |
(integer): Input integer |
y |
(integer): Input integer |
(double)
SedonaDB SQL documentation for RS_RASTERTOWORLDCOORDX
Pixel coordinates are 1-based, as in PostGIS ST_RasterToWorldCoord: (1, 1) is the upper-left pixel, and the result is the world coordinate of that
pixel's upper-left corner. Coordinates outside the grid, including 0,
extrapolate along the geotransform.
rs_raster_to_world_coord_y( rast = sd_missing_arg(), x = sd_missing_arg(), y = sd_missing_arg() )rs_raster_to_world_coord_y( rast = sd_missing_arg(), x = sd_missing_arg(), y = sd_missing_arg() )
rast |
(raster): Input raster |
x |
(integer): Input integer |
y |
(integer): Input integer |
(double)
SedonaDB SQL documentation for RS_RASTERTOWORLDCOORDY
RS_SetBandNoDataValue changes only the declared nodata value, so pixels
that held the old value become ordinary data. RS_ReplaceBandNoDataValue
also rewrites those pixels, so they keep reading as nodata. A pixel reads as
nodata by the same rules sampling uses: exactly for integer bands, and
numerically for float bands, so -0.0 matches a 0.0 nodata and any NaN
matches a NaN nodata. Other bands are unchanged. The band must already have a
nodata value; otherwise there is nothing to replace and the call is an error.
A null raster, band or nodata value gives a null raster. Only 2-D rasters are
supported.
rs_replace_band_no_data_value( rast = sd_missing_arg(), band = sd_missing_arg(), nodata = sd_missing_arg() )rs_replace_band_no_data_value( rast = sd_missing_arg(), band = sd_missing_arg(), nodata = sd_missing_arg() )
rast |
(raster): Input raster |
band |
(int): Band index (1-based). |
nodata |
(float64): The new nodata value. It must fit the band's data type exactly. |
(raster)
SedonaDB SQL documentation for RS_REPLACEBANDNODATAVALUE
RS_ReprojectMatch reprojects raster onto the grid of reference: the
output always has the same CRS, extent, resolution, and dimensions as
reference, in the spirit of rioxarray's reproject_match. The reference
contributes only its grid — its pixel values are never read. The input's band
count and order, per-band data type, and nodata are preserved. Pixel values
are recomputed by GDAL's warp using the chosen algorithm (nearest neighbour
by default). Cells of the reference grid that the reprojected input does not
cover are filled with the input band's nodata value (or zero when a band has
none). Both rasters must agree on whether they carry a CRS: reprojecting
between an unknown CRS and a real one is undefined, so it is an error for
exactly one side to have a CRS. When neither has one, the operation is a
same-space regrid onto the reference grid. Int64 and UInt64 input rasters
are not supported: GDAL's warp routes 64-bit integer pixels through a
floating working type (a double for nearest/interpolation, a 32-bit float for
mode on GDAL < 3.13), so no resampling method can represent them exactly.
Cast to a supported type (for example Int32 or Float64) first. :::
callout-note This reads the entire input raster into memory. :::
rs_reproject_match( raster = sd_missing_arg(), reference = sd_missing_arg(), algorithm = sd_missing_arg() )rs_reproject_match( raster = sd_missing_arg(), reference = sd_missing_arg(), algorithm = sd_missing_arg() )
raster |
(raster): Input raster |
reference |
(raster): Input raster |
algorithm |
(string): Resampling algorithm (case-insensitive): |
(raster)
SedonaDB SQL documentation for RS_REPROJECTMATCH
RS_Resample changes a raster's pixel grid while keeping its band count and
order and per-band nodata. Pixel values are recomputed by GDAL with the
chosen algorithm (nearest neighbour by default). The output stays in the
input's CRS — RS_Resample never reprojects (use
RS_ReprojectMatch for that). RS_Resample has
three positional overloads: - RS_Resample(raster, width_or_scale, height_or_scale, use_scale, algorithm) — when use_scale is false,
width_or_scale/height_or_scale are the output pixel dimensions (a
fractional value is an error) and the world extent is preserved. When
use_scale is true they are the target pixel size (scaleX, scaleY, with
scaleY negative for a north-up raster); the pixel size is kept exact and
the extent grows by up to one pixel so it tiles into whole pixels. Cells
outside the source footprint become nodata. - RS_Resample(raster, width_or_scale, height_or_scale, grid_x, grid_y, use_scale, algorithm) —
additionally snaps the output origin to the grid anchored at (grid_x, grid_y), expanding outward so the original extent stays covered. -
RS_Resample(raster, reference_raster, use_scale, algorithm) — takes the
target dimensions (or pixel size, when use_scale) and the origin grid from
reference_raster, which must share the input's CRS (it is an error
otherwise). algorithm (case-insensitive) is one of NearestNeighbor (the
default), Bilinear, Cubic (alias Bicubic), CubicSpline, Lanczos,
Average, or Mode. Dimensions and pixel size use the rows-then-columns
intuition of the raster (height_or_scale/scaleY for rows,
width_or_scale/scaleX for columns). In the extent-preserving dimension
form, a skewed or rotated raster is re-gridded with its footprint preserved
(both the scale and skew terms of each axis scale by the same factor). A
scale change or origin snap on a skewed raster is not supported and errors.
For an N-D raster (bands with extra dimensions such as time), the resample
is a 2-D (y, x) operation broadcast across every non-spatial plane, so the
non-spatial dimensions are preserved and only the (y, x) extent changes.
::: callout-note Extent-growing scale changes and origin snaps read the
entire raster into memory. :::
rs_resample(...)rs_resample(...)
... |
Supported combinations:
|
(raster)
SedonaDB SQL documentation for RS_RESAMPLE
Returns the raster rotation in radians based on skew parameters.
rs_rotation(rast = sd_missing_arg())rs_rotation(rast = sd_missing_arg())
rast |
(raster): Input raster |
(double)
SedonaDB SQL documentation for RS_ROTATION
Returns the pixel width (scale X) of a raster.
rs_scale_x(rast = sd_missing_arg())rs_scale_x(rast = sd_missing_arg())
rast |
(raster): Input raster |
(double)
SedonaDB SQL documentation for RS_SCALEX
Returns the pixel height (scale Y) of a raster.
rs_scale_y(rast = sd_missing_arg())rs_scale_y(rast = sd_missing_arg())
rast |
(raster): Input raster |
(double)
SedonaDB SQL documentation for RS_SCALEY
Sets the nodata value of the specified band, packing the value into the band's native data type. A null raster or band yields a null raster; a null nodata value instead clears the addressed band's nodata. This is metadata-only: raster cell values are not modified.
rs_set_band_no_data_value(...)rs_set_band_no_data_value(...)
... |
Supported combinations:
|
(raster)
SedonaDB SQL documentation for RS_SETBANDNODATAVALUE
Sets a CRS on a raster. This is metadata-only: raster cell values and geotransform are not transformed. See Coordinate Reference Systems for how SedonaDB represents and compares CRS.
rs_set_crs(rast = sd_missing_arg(), target_crs = sd_missing_arg())rs_set_crs(rast = sd_missing_arg(), target_crs = sd_missing_arg())
rast |
(raster): Input raster |
target_crs |
(string): Input string |
(raster)
SedonaDB SQL documentation for RS_SETCRS
Sets the affine geotransform of a raster from a world-file georeference string of six whitespace-separated numbers in the order scalex, skewy, skewx, scaley, upperleftx, upperlefty — the same order RS_GeoReference emits. The format is 'GDAL' (default) or 'ESRI'; in GDAL the upper-left coordinates refer to the corner of the upper-left pixel, while in ESRI they refer to its center. The transform can also be given as six numeric arguments instead of a string, always as GDAL/corner coordinates. This is metadata-only: raster cell values are not resampled.
rs_set_geo_reference(...)rs_set_geo_reference(...)
... |
Supported combinations:
|
(raster)
SedonaDB SQL documentation for RS_SETGEOREFERENCE
Sets the SRID of a raster. This is metadata-only: raster cell values and geotransform are not transformed. See Coordinate Reference Systems for how SedonaDB represents and compares CRS.
rs_set_srid(rast = sd_missing_arg(), srid = sd_missing_arg())rs_set_srid(rast = sd_missing_arg(), srid = sd_missing_arg())
rast |
(raster): Input raster |
srid |
(integer): Input integer |
(raster)
SedonaDB SQL documentation for RS_SETSRID
col_x and row_y count from 1, as in PostGIS and Sedona Spark: (1, 1) is
the upper-left pixel. The pixel is overwritten even if it holds the band's
nodata value, and the band's nodata value is unchanged. The value is stored
in the band's pixel type: an integer band truncates it toward zero (3.9 is
stored as 3) and a float32 band rounds it to the nearest float32. A value
outside an integer band's range (for a 64-bit integer band, beyond ±2^53, the
largest integers a double holds exactly), NaN, a pixel outside the grid, or a
band the raster does not have is an error. Only 2-D rasters are supported.
rs_set_value(...)rs_set_value(...)
... |
Supported combinations:
|
(raster)
SedonaDB SQL documentation for RS_SETVALUE
Returns the shape of a raster band as a list of dimension sizes. The entries
correspond to the dimension names returned by RS_DimNames.
For a standard 2D raster this returns [height, width]. For an N-dimensional
raster with a time dimension it might return [12, 256, 256] meaning 12 time
steps at 256x256 spatial resolution. When the band index is omitted, all
bands must agree on their shape; if they disagree, an error is returned
prompting the user to specify a band index.
rs_shape(rast = sd_missing_arg(), band = sd_missing_arg())rs_shape(rast = sd_missing_arg(), band = sd_missing_arg())
rast |
(raster): Input raster |
band |
(int): Band index (1-based). A null or out-of-range index returns null. |
(list
SedonaDB SQL documentation for RS_SHAPE
Returns the X skew (rotation) parameter of a raster.
rs_skew_x(rast = sd_missing_arg())rs_skew_x(rast = sd_missing_arg())
rast |
(raster): Input raster |
(double)
SedonaDB SQL documentation for RS_SKEWX
Returns the Y skew (rotation) parameter of a raster.
rs_skew_y(rast = sd_missing_arg())rs_skew_y(rast = sd_missing_arg())
rast |
(raster): Input raster |
(double)
SedonaDB SQL documentation for RS_SKEWY
Extracts a single slice along a named non-spatial dimension, removing that
dimension from every band that carries it in the output raster. For example,
slicing a raster with shape [time=12, y=256, x=256] on 'time' at index 5
produces a 2D raster with shape [y=256, x=256] containing the data at time
step 5. The spatial dimensions (x_dim and y_dim) cannot be sliced. ###
Heterogeneous rasters Bands within a raster can have different
dimensionality. Bands that do not carry the named dimension are emitted
unchanged ("pass-through") rather than producing an error. This matches the
convention used by RS_DimToBand and xarray's ds.isel({dim: i}). For
example, with a raster containing an elevation band ([y, x]) and a
temperature band ([time, y, x]), RS_Slice(raster, 'time', 5) slices the
temperature band and passes the elevation band through unchanged. If no
band carries the named dimension, the function errors — that condition
usually signals a typo'd dimension name. Returns an error if the index is out
of range for any band that does carry the dimension. See also
RS_SliceRange to extract a range of indices while
keeping the dimension.
rs_slice( rast = sd_missing_arg(), dim_name = sd_missing_arg(), index = sd_missing_arg() )rs_slice( rast = sd_missing_arg(), dim_name = sd_missing_arg(), index = sd_missing_arg() )
rast |
(raster): Input raster |
dim_name |
(utf8): Name of the dimension to slice (e.g., 'time'). |
index |
(int): Zero-based index along the dimension. |
(raster)
SedonaDB SQL documentation for RS_SLICE
Narrows a named non-spatial dimension to the half-open range [start, end)
on every band that carries it, keeping the dimension in the output with
reduced size. For example, narrowing a raster with shape [time=12, y=256, x=256] on 'time' with range [2, 7) produces a raster with shape
[time=5, y=256, x=256]. The spatial dimensions (x_dim and y_dim) cannot
be narrowed. ### Heterogeneous rasters Bands within a raster can have
different dimensionality. Bands that do not carry the named dimension are
emitted unchanged ("pass-through") rather than producing an error. This
matches the convention used by RS_Slice, RS_DimToBand, and xarray's
ds.isel. If no band carries the named dimension, the function errors —
that condition usually signals a typo'd dimension name. Returns an error if
start >= end or the range is out of bounds for any band that does carry the
dimension. See also RS_Slice to extract a single index and
remove the dimension entirely.
rs_slice_range( rast = sd_missing_arg(), dim_name = sd_missing_arg(), start = sd_missing_arg(), end = sd_missing_arg() )rs_slice_range( rast = sd_missing_arg(), dim_name = sd_missing_arg(), start = sd_missing_arg(), end = sd_missing_arg() )
rast |
(raster): Input raster |
dim_name |
(utf8): Name of the dimension to narrow (e.g., 'time'). |
start |
(int): Start index (inclusive, zero-based). |
end |
(int): End index (exclusive). |
(raster)
SedonaDB SQL documentation for RS_SLICERANGE
Returns the SRID of a raster.
rs_srid(rast = sd_missing_arg())rs_srid(rast = sd_missing_arg())
rast |
(raster): Input raster |
(integer)
SedonaDB SQL documentation for RS_SRID
Sedona Spark 1.9 calls this function RS_Union. The result holds every band
of the first raster, then every band of the second, and so on. Each band
keeps its own pixel type, nodata value and name, so rasters of different
pixel types can be stacked. Every raster must be on the first raster's grid
(the same width, height, geotransform and CRS); a raster on any other grid is
an error. A band's spatial dimensions take the first raster's names, matched
by role, so a lat/lon raster stacked onto a y/x raster gives y/x
bands; a band with another dimension already named y or x is an error. A
NULL raster gives a NULL result. No pixel is read: bands are carried over as
they are, so stacking rasters that are still out-of-database does not load
them.
rs_stack(rast_a = sd_missing_arg(), rasters = sd_missing_arg())rs_stack(rast_a = sd_missing_arg(), rasters = sd_missing_arg())
rast_a |
(raster): Input raster |
rasters |
(raster): One or more further rasters (any number), on the same grid as the first: the same width, height, geotransform and CRS. |
(raster)
SedonaDB SQL documentation for RS_STACK
Over no pixels (for example, a band that is entirely nodata), count and
sum are 0 and the other statistics are NaN; over one pixel, stddev is 0.
A NaN pixel is left out as nodata when the band's nodata value is NaN.
Otherwise it is data: it makes sum and mean NaN, and stddev too unless
it is the only pixel, while min and max skip it unless every pixel is
NaN. An unknown stat_type, a band the raster does not have, or a 64-bit
integer pixel beyond 2^53 in magnitude (which a double cannot hold exactly)
is an error. Only 2-D rasters are supported.
rs_summary_stats( rast = sd_missing_arg(), stat_type = sd_missing_arg(), band = sd_missing_arg(), exclude_nodata = sd_missing_arg() )rs_summary_stats( rast = sd_missing_arg(), stat_type = sd_missing_arg(), band = sd_missing_arg(), exclude_nodata = sd_missing_arg() )
rast |
(raster): Input raster |
stat_type |
(string): Input string |
band |
(integer): Input integer |
exclude_nodata |
(boolean): Whether to leave pixels holding the band's nodata value out of the statistic. Defaults to true. |
(double)
SedonaDB SQL documentation for RS_SUMMARYSTATS
The fields are the statistics RS_SummaryStats returns one at a time, with
the same values: stddev is the population standard deviation, and over no
pixels (for example, a band that is entirely nodata) count and sum are 0
and the other fields are NaN. Computing them together scans the band three
times, where six RS_SummaryStats calls would scan it more often. A band the
raster does not have, or a 64-bit integer pixel beyond 2^53 in magnitude
(which a double cannot hold exactly), is an error. Only 2-D rasters are
supported.
rs_summary_stats_all( rast = sd_missing_arg(), band = sd_missing_arg(), exclude_nodata = sd_missing_arg() )rs_summary_stats_all( rast = sd_missing_arg(), band = sd_missing_arg(), exclude_nodata = sd_missing_arg() )
rast |
(raster): Input raster |
band |
(integer): Input integer |
exclude_nodata |
(boolean): Whether to leave pixels holding the band's nodata value out of the statistics. Defaults to true. |
(struct)
SedonaDB SQL documentation for RS_SUMMARYSTATSALL
RS_Tile cuts a raster into a grid of width x height tiles, returning a
list with one item per tile that you UNNEST to get one row per tile. When
no band argument is given, every band is included. band_indices selects an
ordered subset of bands. Band indices are 1-based. Each returned list item is
a struct with: - x: the tile's grid column (0-based), counting from the
left - y: the tile's grid row (0-based), counting from the top - tile:
the tile raster, with a geotransform shifted to the tile's own origin The
grid is ceil(width / tile_width) columns by ceil(height / tile_height)
rows. When the raster does not divide evenly, the last column and row of
tiles are partial: with pad_with_no_data = false the smaller edge tile is
emitted as-is, and with pad_with_no_data = true those tiles are padded to
the full tile size with a nodata fill. When the band(s) have no nodata value,
no_data_value supplies one. ::: callout-note RS_Tile copies the
raster: every tile carries its own pixels, so the returned list
materializes a full copy of the raster spread across the tiles and held in
memory as one list value. A small tile size produces many tiles (a 1 x 1
tile size yields one tile per pixel). :::
rs_tile(...)rs_tile(...)
... |
Supported combinations:
|
(list)
SedonaDB SQL documentation for RS_TILE
Returns the upper-left X coordinate of a raster.
rs_upper_left_x(rast = sd_missing_arg())rs_upper_left_x(rast = sd_missing_arg())
rast |
(raster): Input raster |
(double)
SedonaDB SQL documentation for RS_UPPERLEFTX
Returns the upper-left Y coordinate of a raster.
rs_upper_left_y(rast = sd_missing_arg())rs_upper_left_y(rast = sd_missing_arg())
rast |
(raster): Input raster |
(double)
SedonaDB SQL documentation for RS_UPPERLEFTY
RS_Value samples one pixel of a raster. The location is given as a point
geometry — the value of the pixel that contains the point is returned, with
no interpolation. The band defaults to 1 when omitted, but only for a
single-band raster; on a multiband raster the band must be given explicitly.
The pixel can instead be addressed by its grid coordinate. Grid coordinates
are 1-based, as in PostGIS ST_Value: (1, 1) is the upper-left pixel, and
a column or row of 0 is outside the raster. The result is NULL when the
point falls outside the raster, or when the sampled pixel equals the band's
nodata value. Only 2-D rasters are supported.
rs_value(...)rs_value(...)
... |
Supported combinations:
|
(float64)
SedonaDB SQL documentation for RS_VALUE
RS_Values is the plural form of RS_Value: it samples one
pixel per point of a MultiPoint and returns the values as a list of doubles,
in the same order as the input points. A single Point is accepted as well and
produces a one-element list. The band defaults to 1 when omitted, but only
for a single-band raster; on a multiband raster the band is ambiguous and
must be given explicitly. Each list element is NULL when its point falls
outside the raster or the sampled pixel equals the band's nodata value; the
whole result is NULL when the raster, geometry, or band is NULL. An empty
MultiPoint yields an empty list. Only 2-D rasters are supported.
rs_values( rast = sd_missing_arg(), points = sd_missing_arg(), band = sd_missing_arg() )rs_values( rast = sd_missing_arg(), points = sd_missing_arg(), band = sd_missing_arg() )
rast |
(raster): Input raster |
points |
(geometry): Input geometry |
band |
(int): Band index (1-based). When omitted, defaults to band 1, but only for a single-band raster; sampling an unspecified band of a multiband raster is ambiguous and raises an error. |
(list)
SedonaDB SQL documentation for RS_VALUES
Returns the width of a raster in pixels.
rs_width(rast = sd_missing_arg())rs_width(rast = sd_missing_arg())
rast |
(raster): Input raster |
(bigint)
SedonaDB SQL documentation for RS_WIDTH
Returns true if the convex hull of the first argument is completely within
the second argument. This is the inverse of RS_Contains: RS_Within(A, B)
is equivalent to RS_Contains(B, A). Both rasters and geometries are
accepted in either argument position. When two rasters are provided, their
convex hulls are compared. If the arguments have different CRSes, the
geometry is transformed into the raster's CRS before evaluating the
predicate. For two rasters, the second raster's extent is transformed into
the first raster's CRS. If the preferred transformation fails, the extent of
both sides are transformed to WGS 84 as a fallback. If either argument has no
CRS set, the comparison is performed directly without CRS transformation.
rs_within(...)rs_within(...)
... |
Supported combinations:
|
(boolean)
SedonaDB SQL documentation for RS_WITHIN
The result is a 1-based pixel coordinate, as in PostGIS
ST_WorldToRasterCoord: a world coordinate inside the upper-left pixel maps
to (1, 1). A world coordinate outside the raster extrapolates along the
geotransform, so it can map to 0 or a negative coordinate.
rs_world_to_raster_coord(...)rs_world_to_raster_coord(...)
... |
Supported combinations:
|
(geometry)
SedonaDB SQL documentation for RS_WORLDTORASTERCOORD
The result is a 1-based pixel coordinate, as in PostGIS
ST_WorldToRasterCoord: a world coordinate inside the upper-left pixel maps
to (1, 1). A world coordinate outside the raster extrapolates along the
geotransform, so it can map to 0 or a negative coordinate.
rs_world_to_raster_coord_x(...)rs_world_to_raster_coord_x(...)
... |
Supported combinations:
|
(integer)
SedonaDB SQL documentation for RS_WORLDTORASTERCOORDX
The result is a 1-based pixel coordinate, as in PostGIS
ST_WorldToRasterCoord: a world coordinate inside the upper-left pixel maps
to (1, 1). A world coordinate outside the raster extrapolates along the
geotransform, so it can map to 0 or a negative coordinate.
rs_world_to_raster_coord_y(...)rs_world_to_raster_coord_y(...)
... |
Supported combinations:
|
(integer)
SedonaDB SQL documentation for RS_WORLDTORASTERCOORDY
RS_ZonalStats returns one summary statistic of the pixels of a single band
that a region of interest (ROI) geometry covers. A pixel is included when its
center falls inside the roi (or, with all_touched, when the roi touches it
at all). By default the band's nodata pixels are excluded. The statistic is
one of count, sum, mean, median, mode, stddev, variance, min,
or max. count is returned as a whole number; all other statistics are
floating point. Variance and standard deviation are the sample (n-1) values,
and mode breaks ties toward the larger value. When the ROI overlaps the
raster but selects no pixel, count is 0 and every other statistic is NULL.
When the ROI does not intersect the raster at all, the result is NULL under
the default lenient behavior, or an error when lenient is set to false.
The band, all_touched, exclude_no_data, and lenient arguments are
added one at a time by the wider overloads; all_touched defaults to false,
exclude_no_data to true, and lenient to true. The band-less overload does
not default to band 1 on a multiband raster: naming the band is required
there. This function operates on 2-D (y, x) bands; computing a statistic
per non-spatial plane of an N-D band is not supported. Use
RS_ZonalStatsAll to compute every statistic at
once.
rs_zonal_stats(...)rs_zonal_stats(...)
... |
Supported combinations:
|
(double)
SedonaDB SQL documentation for RS_ZONALSTATS
RS_ZonalStatsAll returns every summary statistic of the pixels of a single
band that a roi geometry covers, as a struct with fields count, sum,
mean, median, mode, stddev, variance, min, and max. A pixel is
included when its center falls inside the roi (or, with all_touched, when
the roi touches it at all), and the band's nodata pixels are excluded by
default. count is a whole number (a 64-bit integer); every other field is
floating point. Variance and standard deviation are the sample (n-1) values,
and mode breaks ties toward the larger value. When the roi overlaps the
raster but selects no pixel, count is 0 and every other field is NULL. When
the roi does not intersect the raster at all, the whole struct is NULL under
the default lenient behavior, or the call raises an error when lenient is
set to false. The overloads are the same ladder as RS_ZonalStats without
stat_type. The band, all_touched, exclude_no_data, and lenient
arguments are added one at a time by the wider overloads; all_touched
defaults to false, exclude_no_data to true, and lenient to true. The
band-less overload does not default to band 1 on a multiband raster: naming
the band is required there. This function operates on 2-D (y, x) bands;
computing statistics per non-spatial plane of an N-D band is not supported.
Use RS_ZonalStats to compute a single statistic.
rs_zonal_stats_all( rast = sd_missing_arg(), roi = sd_missing_arg(), band = sd_missing_arg(), all_touched = sd_missing_arg(), exclude_no_data = sd_missing_arg(), lenient = sd_missing_arg() )rs_zonal_stats_all( rast = sd_missing_arg(), roi = sd_missing_arg(), band = sd_missing_arg(), all_touched = sd_missing_arg(), exclude_no_data = sd_missing_arg(), lenient = sd_missing_arg() )
rast |
(raster): Input raster |
roi |
(geometry): Region-of-interest geometry. Reprojected into the raster's CRS when both carry one; it is an error for exactly one side to have a CRS. |
band |
(integer): 1-based band index to compute over. Required for a multiband raster; a single-band raster may omit it via the band-less overload. |
all_touched |
(boolean): If true, include every pixel the roi touches; otherwise only pixels whose center falls inside it. Defaults to false. |
exclude_no_data |
(boolean): If true (the default), skip pixels equal to the band's nodata value. |
lenient |
(boolean): If true (the default), return NULL when the roi does not intersect the raster; if false, raise an error. |
(struct)
SedonaDB SQL documentation for RS_ZONALSTATSALL
Applies an affine transformation to a geometry.
sd_affine(...)sd_affine(...)
... |
Supported combinations:
|
(geometry)
SedonaDB SQL documentation for ST_AFFINE
ST_Analyze_Agg() provides a high-level summary of its input geometries. The
fields of its struct return type are: - count: Number of input geometries -
minx, miny, maxx, maxy: Minimum bounding rectangle (envelope). For
geography, this represents geographical bounds such that minx may be greater
than maxx where this represents more compact bounds (e.g., a small feature
crossing the antimeridian). - mean_size_in_bytes -
mean_points_per_geometry - puntal_count: Number of point or multipoint
geometries - lineal_count: Number of line or multilinestring geometries -
polygonal_count: Number of polygon or multipolygon geometries -
geometrycollection_count: Number of geometrycollection geometries -
mean_envelope_width - mean_envelope_height - mean_envelope_area
sd_analyze_agg(geom = sd_missing_arg())sd_analyze_agg(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(struct)
SedonaDB SQL documentation for ST_ANALYZE_AGG
ST_Area() Returns the area of a polygon or multi-polygon. For geometry,
returns the area in the units of the coordinate reference system (squared);
for geography, returns the area in square meters, calculated on a spherical
Earth model.
sd_area(geom = sd_missing_arg())sd_area(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(double)
SedonaDB SQL documentation for ST_AREA
ST_AsBinary() Returns the Well-Known Binary representation of a geometry or
geography. This function also has the alias ST_AsWKB. ST_AsBinary() may
preserve the underlying Arrow storage type of the input geometry. For
example, when the input geometry is backed by Arrow BinaryView storage, the
WKB output may also use BinaryView storage. If a downstream consumer
requires simpler Arrow storage such as Binary, wrap the result with
sd_simplifystorage().
sd_as_binary(geom = sd_missing_arg())sd_as_binary(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(binary)
SedonaDB SQL documentation for ST_ASBINARY
EWKB extends WKB to include SRID information in the binary header and is useful for PostGIS compatibility. This function preserves item-level CRSes or will repeat a type-level CRS for all elements if present.
sd_as_ewkb(geom = sd_missing_arg())sd_as_ewkb(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(binary)
SedonaDB SQL documentation for ST_ASEWKB
Returns the GeoJSON representation of a geometry.
sd_as_geo_json(geom = sd_missing_arg())sd_as_geo_json(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(string)
SedonaDB SQL documentation for ST_ASGEOJSON
Alias: ST_AsWKT.
sd_as_text(geom = sd_missing_arg())sd_as_text(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(string)
SedonaDB SQL documentation for ST_ASTEXT
Returns the azimuth (angle) from the first point to the second point, measured in radians clockwise from north. Returns NULL if either input is not a point.
sd_azimuth(geom_a = sd_missing_arg(), geom_b = sd_missing_arg())sd_azimuth(geom_a = sd_missing_arg(), geom_b = sd_missing_arg())
geom_a |
(geometry): Input geometry |
geom_b |
(geometry): Input geometry |
(double)
SedonaDB SQL documentation for ST_AZIMUTH
For a polygon, the boundary is the exterior and interior rings; for a linestring it is the endpoints.
sd_boundary(geom = sd_missing_arg())sd_boundary(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(geometry)
SedonaDB SQL documentation for ST_BOUNDARY
For geography, the distance is specified in meters. The buffer is computed on the sphere, producing a result that considers polar regions and the antimeridian. Negative distances are supported for polygon inputs to shrink the polygon.
sd_buffer(...)sd_buffer(...)
... |
Supported combinations:
|
(geometry)
SedonaDB SQL documentation for ST_BUFFER
Treats the input geometry's edges as linework and assembles them into a polygon or multipolygon. Open rings are closed automatically before assembly. Empty input returns an empty polygon, and polygon or multipolygon input is returned unchanged. If no closed ring can be formed, returns NULL.
sd_build_area(geom = sd_missing_arg())sd_build_area(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(geometry)
SedonaDB SQL documentation for ST_BUILDAREA
Returns the 64-bit S2 cell ID at level 30 (the finest resolution) that contains the given point geography. Returns NULL for empty point geometries. This is useful for spatial indexing and efficient spatial queries.
sd_cell_id_from_point(geom = sd_missing_arg())sd_cell_id_from_point(geom = sd_missing_arg())
geom |
(geography): Input geography |
(int64)
SedonaDB SQL documentation for S2_CELLIDFROMPOINT
For geography, the centroid is calculated using spherical geometry.
sd_centroid(geom = sd_missing_arg())sd_centroid(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(geometry)
SedonaDB SQL documentation for ST_CENTROID
Returns the 2-dimensional point on geom1 that is closest to geom2.
sd_closest_point(geom_a = sd_missing_arg(), geom_b = sd_missing_arg())sd_closest_point(geom_a = sd_missing_arg(), geom_b = sd_missing_arg())
geom_a |
(geometry): Input geometry |
geom_b |
(geometry): Input geometry |
(geometry)
SedonaDB SQL documentation for ST_CLOSESTPOINT
An aggregate function that collects multiple geometries or geographies into a single GeometryCollection or the appropriate Multi-type if all inputs share the same geometry type. Collecting geographies returns a geography.
sd_collect_agg(geom = sd_missing_arg())sd_collect_agg(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(geometry)
SedonaDB SQL documentation for ST_COLLECT_AGG
Returns a concave hull enclosing the input geometry. The pct_convex
parameter controls how "tight" the hull is: 1.0 produces the convex hull,
while smaller values produce tighter, more concave shapes.
sd_concave_hull(geom = sd_missing_arg(), pct_convex = sd_missing_arg())sd_concave_hull(geom = sd_missing_arg(), pct_convex = sd_missing_arg())
geom |
(geometry): Input geometry |
pct_convex |
(double): Input double |
(geometry)
SedonaDB SQL documentation for ST_CONCAVEHULL
Returns true if no points of B lie outside A and at least one point of B
lies inside A.
sd_contains(geom_a = sd_missing_arg(), geom_b = sd_missing_arg())sd_contains(geom_a = sd_missing_arg(), geom_b = sd_missing_arg())
geom_a |
(geometry): Input geometry |
geom_b |
(geometry): Input geometry |
(boolean)
SedonaDB SQL documentation for ST_CONTAINS
Returns the smallest convex polygon that encloses all points in the input geometry.
sd_convex_hull(geom = sd_missing_arg())sd_convex_hull(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(geometry)
SedonaDB SQL documentation for ST_CONVEXHULL
An aggregate function that computes the smallest convex polygon enclosing all points across every geometry in a group.
sd_convex_hull_agg(geom = sd_missing_arg())sd_convex_hull_agg(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(geometry)
SedonaDB SQL documentation for ST_CONVEXHULL_AGG
Returns true if no point in geometry A is outside geometry B. Inverse of
ST_Covers: ST_CoveredBy(A, B) is equivalent to ST_Covers(B, A).
sd_covered_by(geom_a = sd_missing_arg(), geom_b = sd_missing_arg())sd_covered_by(geom_a = sd_missing_arg(), geom_b = sd_missing_arg())
geom_a |
(geometry): Input geometry |
geom_b |
(geometry): Input geometry |
(boolean)
SedonaDB SQL documentation for ST_COVEREDBY
Returns an array of 64-bit S2 cell IDs that form a covering of the given geography. A covering is a set of cells that completely contains the geography with minimal overlap. For a point, returns an array with a single cell ID. For empty geometries, returns an empty array. This is useful for spatial indexing and efficient spatial queries. The returned cells may be at different S2 levels depending on the size and shape of the geography.
sd_covering_cell_ids( geom = sd_missing_arg(), min_level = sd_missing_arg(), max_level = sd_missing_arg(), max_cells = sd_missing_arg() )sd_covering_cell_ids( geom = sd_missing_arg(), min_level = sd_missing_arg(), max_level = sd_missing_arg(), max_cells = sd_missing_arg() )
geom |
(geography): Input geography |
min_level |
(int64): Input int64 |
max_level |
(int64): Input int64 |
max_cells |
(int64): Maximum number of cells to return. Must be greater than 0. Defaults to 8. |
(array)
SedonaDB SQL documentation for S2_COVERINGCELLIDS
Returns true if no point in geometry B is outside geometry A. Similar to
ST_Contains but does not require interior intersection.
sd_covers(geom_a = sd_missing_arg(), geom_b = sd_missing_arg())sd_covers(geom_a = sd_missing_arg(), geom_b = sd_missing_arg())
geom_a |
(geometry): Input geometry |
geom_b |
(geometry): Input geometry |
(boolean)
SedonaDB SQL documentation for ST_COVERS
Returns true if the two geometries have some (but not all) interior points
in common and the dimension of the intersection is less than that of either
input.
sd_crosses(geom_a = sd_missing_arg(), geom_b = sd_missing_arg())sd_crosses(geom_a = sd_missing_arg(), geom_b = sd_missing_arg())
geom_a |
(geometry): Input geometry |
geom_b |
(geometry): Input geometry |
(boolean)
SedonaDB SQL documentation for ST_CROSSES
Returns the CRS (Coordinate Reference System) string associated with a
geometry or geography. Whether it was set as an authority code (e.g.
'EPSG:3857'), PROJJSON, or WKT, the CRS is returned in the same form it was
set. See Coordinate Reference Systems for how
SedonaDB represents and compares CRS.
sd_crs(geom = sd_missing_arg())sd_crs(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(string)
SedonaDB SQL documentation for ST_CRS
For geography, the distance is specified in meters and represents the spherical approximation of the geodesic distance between the two geographies.
sd_d_within( geom_a = sd_missing_arg(), geom_b = sd_missing_arg(), distance = sd_missing_arg() )sd_d_within( geom_a = sd_missing_arg(), geom_b = sd_missing_arg(), distance = sd_missing_arg() )
geom_a |
(geometry): Input geometry |
geom_b |
(geometry): Input geometry |
distance |
(double): Input double |
(boolean)
SedonaDB SQL documentation for ST_DWITHIN
Computes a Delaunay triangulation of the vertices of the input geometry. The
result is a GEOMETRYCOLLECTION of POLYGON triangles unless the flags
parameter is set to request MULTILINESTRING output. An optional tolerance
value can be specified to snap nearby vertices together before triangulation.
sd_delaunay_triangles( geom = sd_missing_arg(), tolerance = sd_missing_arg(), flags = sd_missing_arg() )sd_delaunay_triangles( geom = sd_missing_arg(), tolerance = sd_missing_arg(), flags = sd_missing_arg() )
geom |
(geometry): Input geometry |
tolerance |
(float64): Snap-rounding tolerance for vertices. Use 0.0 for exact computation. |
flags |
(integer): Use 0 for polygon triangles or 1 for edge-only MULTILINESTRING output. |
(geometry)
SedonaDB SQL documentation for ST_DELAUNAYTRIANGLES
Returns the part of geometry A that does not intersect with geometry B.
sd_difference(geom_a = sd_missing_arg(), geom_b = sd_missing_arg())sd_difference(geom_a = sd_missing_arg(), geom_b = sd_missing_arg())
geom_a |
(geometry): Input geometry |
geom_b |
(geometry): Input geometry |
(geometry)
SedonaDB SQL documentation for ST_DIFFERENCE
Returns the inherent dimension of the geometry: - 0 for points or multipoints
1 for linestring or multilinestrings - 2 for polygons or multipolygons For geometry collections, returns the largest dimension among the components.
sd_dimension(geom = sd_missing_arg())sd_dimension(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(integer)
SedonaDB SQL documentation for ST_DIMENSION
Returns true if the two geometries do not share any points. This is the
inverse of ST_Intersects.
sd_disjoint(geom_a = sd_missing_arg(), geom_b = sd_missing_arg())sd_disjoint(geom_a = sd_missing_arg(), geom_b = sd_missing_arg())
geom_a |
(geometry): Input geometry |
geom_b |
(geometry): Input geometry |
(boolean)
SedonaDB SQL documentation for ST_DISJOINT
For geometry, returns the 2D Cartesian (planar) distance between two geometries, in the units of the coordinate reference system. For geography, returns the spherical approximation of the geodesic distance between two geographies in meters.
sd_distance(geom_a = sd_missing_arg(), geom_b = sd_missing_arg())sd_distance(geom_a = sd_missing_arg(), geom_b = sd_missing_arg())
geom_a |
(geometry): Input geometry |
geom_b |
(geometry): Input geometry |
(double)
SedonaDB SQL documentation for ST_DISTANCE
If the geometry is simple it returns the geometry itself, if the geometry is collection or multi it returns record for each of collection components.
sd_dump(geom = sd_missing_arg())sd_dump(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(struct)
SedonaDB SQL documentation for ST_DUMP
Returns last point of a linestring.
sd_end_point(geom = sd_missing_arg())sd_end_point(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(geometry)
SedonaDB SQL documentation for ST_ENDPOINT
Returns the minimum axis-aligned bounding box of a geometry. This is usually a polygon but can be a linestring for perfectly vertical or horizontal input and is a point if the input is also a point. For geography, the return value is still a rectangular polygon geometry that represents the latitude and longitude range of the input. For geographies that span the antimeridian, a multipolygon is returned (one on each side of the antimeridian). Because of slight numerical inaccuracy of geographical calculations, the bounds are expanded slightly compared to the corresponding geometry envelope.
sd_envelope(geom = sd_missing_arg())sd_envelope(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(geometry)
SedonaDB SQL documentation for ST_ENVELOPE
An aggregate function that computes the collective bounding box (envelope) of all geometries in a group. Geography input is also accepted; the envelope is always returned as a geometry. For geographies that cross the antimeridian, a multi geometry is returned with one polygon each for the west and east component.
sd_envelope_agg(geom = sd_missing_arg())sd_envelope_agg(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(geometry)
SedonaDB SQL documentation for ST_ENVELOPE_AGG
Returns true if the two geometries are topologically equal (i.e., they
represent the same point set, regardless of vertex order).
sd_equals(geom_a = sd_missing_arg(), geom_b = sd_missing_arg())sd_equals(geom_a = sd_missing_arg(), geom_b = sd_missing_arg())
geom_a |
(geometry): Input geometry |
geom_b |
(geometry): Input geometry |
(boolean)
SedonaDB SQL documentation for ST_EQUALS
Returns the exterior ring (outer boundary) of a polygon as a LINESTRING.
Returns NULL for non-polygon geometry types.
sd_exterior_ring(geom = sd_missing_arg())sd_exterior_ring(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(geometry)
SedonaDB SQL documentation for ST_EXTERIORRING
Returns a new geometry with the X and Y coordinates of each vertex swapped.
sd_flip_coordinates(geom = sd_missing_arg())sd_flip_coordinates(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(geometry)
SedonaDB SQL documentation for ST_FLIPCOORDINATES
Discards any Z and M values present (if any).
sd_force2d(geom = sd_missing_arg())sd_force2d(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(geometry)
SedonaDB SQL documentation for ST_FORCE2D
If the geometry already has Z values they are preserved; otherwise the
optional z argument (default 0) is used. Aliases: ST_Force3DZ.
sd_force3d(geom = sd_missing_arg(), z = sd_missing_arg())sd_force3d(geom = sd_missing_arg(), z = sd_missing_arg())
geom |
(geometry): Input geometry |
z |
(double): Input double |
(geometry)
SedonaDB SQL documentation for ST_FORCE3D
If the geometry already has M values they are preserved; otherwise the
optional m argument (default 0) is used.
sd_force3dm(geom = sd_missing_arg(), m = sd_missing_arg())sd_force3dm(geom = sd_missing_arg(), m = sd_missing_arg())
geom |
(geometry): Input geometry |
m |
(double): Input double |
(geometry)
SedonaDB SQL documentation for ST_FORCE3DM
If the geometry already has Z and M values they are preserved; otherwise
optional z and m arguments (both default 0) are used.
sd_force4d(geom = sd_missing_arg(), z = sd_missing_arg(), m = sd_missing_arg())sd_force4d(geom = sd_missing_arg(), z = sd_missing_arg(), m = sd_missing_arg())
geom |
(geometry): Input geometry |
z |
(double): Input double |
m |
(double): Input double |
(geometry)
SedonaDB SQL documentation for ST_FORCE4D
Encodes the geometry as a base-32 GeoHash string with precision characters.
Non-point geometries are encoded using the center of their bounding box. A
non-positive precision returns an empty string, and precision is capped at 20
characters. A GeoHash is defined against the WGS84 datum, so the argument
must carry either a WGS84 CRS (EPSG:4326 / OGC:CRS84) or no CRS at all;
anything else raises an error. Use ST_Transform() to reproject first. This
includes other geographic CRSes such as NAD83, whose units are degrees but
whose datum differs from WGS84 by enough to shift the result at high
precision. The same rule applies whether the CRS belongs to the column or to
the individual rows; only the timing differs. A column-level CRS is known
while the query is planned, so it is rejected before any row is read. A
row-level CRS is not known until the row is reached, so it is rejected then.
To encode only the WGS84 rows of a mixed column, filter them first — WHERE ST_SRID(geom) = 4326 is applied before the encoding, so the other rows never
reach it. Latitudes outside -90 to 90 return NULL. Longitudes outside -180
to 180 are wrapped back into range when the argument declares a WGS84 CRS, so
a longitude of 181 encodes as -179; without a declared CRS they return NULL
instead, matching Apache Sedona. When precision is omitted, the argument
must be a POINT and is encoded at the maximum precision of 20 characters.
Any other geometry type raises an error, because there is no single obvious
precision for a geometry that covers an area. Geography arguments are bounded
on the sphere and require the s2geography bounder to be registered on the
session.
sd_geo_hash(geom = sd_missing_arg(), precision = sd_missing_arg())sd_geo_hash(geom = sd_missing_arg(), precision = sd_missing_arg())
geom |
(geometry): Input geometry |
precision |
(integer): Number of base-32 characters in the returned GeoHash. |
(string)
SedonaDB SQL documentation for ST_GEOHASH
Constructs a Geography from WKB Binary.
sd_geog_from_wkb(wkb = sd_missing_arg())sd_geog_from_wkb(wkb = sd_missing_arg())
wkb |
(binary): Input binary |
(geography)
SedonaDB SQL documentation for ST_GEOGFROMWKB
Alias: ST_GeogFromText.
sd_geog_from_wkt(wkt = sd_missing_arg(), srid = sd_missing_arg())sd_geog_from_wkt(wkt = sd_missing_arg(), srid = sd_missing_arg())
wkt |
(string): Input string |
srid |
(integer): Input integer |
(geography)
SedonaDB SQL documentation for ST_GEOGFROMWKT
Creates a geography Point from longitude and latitude coordinates.
sd_geog_point(longitude = sd_missing_arg(), latitude = sd_missing_arg())sd_geog_point(longitude = sd_missing_arg(), latitude = sd_missing_arg())
longitude |
(double): Input double |
latitude |
(double): Input double |
(geography)
SedonaDB SQL documentation for ST_GEOGPOINT
Parses a WKT string and returns a geometry. Raises an error if the WKT does not represent a GeometryCollection.
sd_geom_coll_from_text(wkt = sd_missing_arg(), srid = sd_missing_arg())sd_geom_coll_from_text(wkt = sd_missing_arg(), srid = sd_missing_arg())
wkt |
(string): Input string |
srid |
(crs): Input crs |
(geometry)
SedonaDB SQL documentation for ST_GEOMCOLLFROMTEXT
Parses an EWKB binary value and returns a geometry. EWKB extends the WKB format to include SRID information in the binary header and is useful for PostGIS compatibility.
sd_geom_from_ewkb(ewkb = sd_missing_arg())sd_geom_from_ewkb(ewkb = sd_missing_arg())
ewkb |
(binary): Input binary |
(geometry)
SedonaDB SQL documentation for ST_GEOMFROMEWKB
Parses an EWKT string in the format SRID=<srid>;<wkt> and returns a
geometry with the embedded SRID set. EWKT is used by PostGIS and other
systems for human-readable output when an item-level SRID required.
sd_geom_from_ewkt(ewkt = sd_missing_arg())sd_geom_from_ewkt(ewkt = sd_missing_arg())
ewkt |
(string): Input string |
(geometry)
SedonaDB SQL documentation for ST_GEOMFROMEWKT
Parses a WKB binary value and returns a geometry. The input is validated by default. An optional SRID or CRS can be provided as a second argument.
sd_geom_from_wkb(wkb = sd_missing_arg(), srid = sd_missing_arg())sd_geom_from_wkb(wkb = sd_missing_arg(), srid = sd_missing_arg())
wkb |
(binary): Input binary |
srid |
(crs): Input crs |
(geometry)
SedonaDB SQL documentation for ST_GEOMFROMWKB
An optional SRID or CRS can be provided as a second argument to set the
spatial reference. Aliases: ST_GeomFromText, ST_GeometryFromText.
sd_geom_from_wkt(wkt = sd_missing_arg(), srid = sd_missing_arg())sd_geom_from_wkt(wkt = sd_missing_arg(), srid = sd_missing_arg())
wkt |
(string): Input string |
srid |
(crs): Input crs |
(geometry)
SedonaDB SQL documentation for ST_GEOMFROMWKT
Returns NULL if the index is out of range.
sd_geometry_n(geom = sd_missing_arg(), n = sd_missing_arg())sd_geometry_n(geom = sd_missing_arg(), n = sd_missing_arg())
geom |
(geometry): Input geometry |
n |
(integer): Input integer |
(geometry)
SedonaDB SQL documentation for ST_GEOMETRYN
Returns the OGC geometry type name prefixed with ST_. Possible return
values include: 'ST_Point', 'ST_LineString', 'ST_Polygon',
'ST_MultiPoint', 'ST_MultiLineString', 'ST_MultiPolygon', and
'ST_GeometryCollection'.
sd_geometry_type(geom = sd_missing_arg())sd_geometry_type(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(string)
SedonaDB SQL documentation for ST_GEOMETRYTYPE
Returns true if the geometry has a M dimension.
sd_has_m(geom = sd_missing_arg())sd_has_m(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(boolean)
SedonaDB SQL documentation for ST_HASM
Returns true if the geometry has a Z dimension.
sd_has_z(geom = sd_missing_arg())sd_has_z(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(boolean)
SedonaDB SQL documentation for ST_HASZ
The Hausdorff distance is a measure of the similarity between two geometric
shapes. This implementation returns the greatest of all distances from a
point in one geometry to the closest point in the other geometry. Returns
NULL if either geometry is NULL. Returns 0 if either geometry is empty.
sd_hausdorff_distance( geom_a = sd_missing_arg(), geom_b = sd_missing_arg(), densifyFrac = sd_missing_arg() )sd_hausdorff_distance( geom_a = sd_missing_arg(), geom_b = sd_missing_arg(), densifyFrac = sd_missing_arg() )
geom_a |
(geometry): Input geometry |
geom_b |
(geometry): Input geometry |
densifyFrac |
(double): A fraction by which to densify each segment of the geometries before computing the distance. A value of 0.25 will densify the segment by adding vertices every 1/4 of the segment length. Densification can give a more accurate result for geometries with long segments or complex shapes. |
(double)
SedonaDB SQL documentation for ST_HAUSDORFFDISTANCE
Returns the Nth interior LINESTRING ring of a POLYGON. Returns NULL if
the geometry is not a polygon or n is out of range. n is 1-based, as in
PostGIS: 1 returns the first interior ring.
sd_interior_ring_n(geom = sd_missing_arg(), n = sd_missing_arg())sd_interior_ring_n(geom = sd_missing_arg(), n = sd_missing_arg())
geom |
(geometry): Input geometry |
n |
(integer): Input integer |
(geometry)
SedonaDB SQL documentation for ST_INTERIORRINGN
Computes the intersection of two geometries or geographies.
sd_intersection(geom_a = sd_missing_arg(), geom_b = sd_missing_arg())sd_intersection(geom_a = sd_missing_arg(), geom_b = sd_missing_arg())
geom_a |
(geometry): Input geometry |
geom_b |
(geometry): Input geometry |
(geometry)
SedonaDB SQL documentation for ST_INTERSECTION
Returns the cumulative intersection of all geometries in the input.
sd_intersection_agg(geom = sd_missing_arg())sd_intersection_agg(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(geometry)
SedonaDB SQL documentation for ST_INTERSECTION_AGG
Returns true if geomA intersects geomB.
sd_intersects(geom_a = sd_missing_arg(), geom_b = sd_missing_arg())sd_intersects(geom_a = sd_missing_arg(), geom_b = sd_missing_arg())
geom_a |
(geometry): Input geometry |
geom_b |
(geometry): Input geometry |
(boolean)
SedonaDB SQL documentation for ST_INTERSECTS
Returns true if the LineString's start and end points are the same. For
MultiLineStrings, all elements must be closed.
sd_is_closed(geom = sd_missing_arg())sd_is_closed(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(boolean)
SedonaDB SQL documentation for ST_ISCLOSED
Returns TRUE if the geometry type of the input is a geometry collection type. Collection types are the following: - GEOMETRYCOLLECTION - MULTIPOINT - MULTIPOLYGON - MULTILINESTRING
sd_is_collection(geom = sd_missing_arg())sd_is_collection(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(boolean)
SedonaDB SQL documentation for ST_ISCOLLECTION
Returns true if the geometry or geography is empty.
sd_is_empty(geom = sd_missing_arg())sd_is_empty(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(boolean)
SedonaDB SQL documentation for ST_ISEMPTY
Returns true if the linestring is both closed (ST_IsClosed) and simple
(ST_IsSimple). In other words, the input forms a ring with no
self-intersections.
sd_is_ring(geom = sd_missing_arg())sd_is_ring(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(boolean)
SedonaDB SQL documentation for ST_ISRING
Returns true if the geometry has no anomalous geometric points such as
self-intersections or self-tangency.
sd_is_simple(geom = sd_missing_arg())sd_is_simple(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(boolean)
SedonaDB SQL documentation for ST_ISSIMPLE
Returns true if the geometry is well-formed according to OGC rules. Use
ST_IsValidReason to get a diagnostic message for invalid geometries and
ST_MakeValid to attempt to repair them.
sd_is_valid(geom = sd_missing_arg())sd_is_valid(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(boolean)
SedonaDB SQL documentation for ST_ISVALID
Returns a text string explaining why a geometry is invalid, or "Valid Geometry" if the geometry is valid. Useful for debugging geometry
construction.
sd_is_valid_reason(geom = sd_missing_arg())sd_is_valid_reason(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(string)
SedonaDB SQL documentation for ST_ISVALIDREASON
ST_KNN is used in a join condition to find the k nearest neighbors of one
geometry from another set of geometries. The actual k-nearest neighbors logic
is handled by the spatial join execution engine: the function itself is a
stub that simply defines the expected signature.
sd_knn( geomA = sd_missing_arg(), geomB = sd_missing_arg(), k = sd_missing_arg(), use_spheroid = sd_missing_arg() )sd_knn( geomA = sd_missing_arg(), geomB = sd_missing_arg(), k = sd_missing_arg(), use_spheroid = sd_missing_arg() )
geomA |
(geometry): The geometry around which to search. |
geomB |
(geometry): Column containing candidate geometries. |
k |
(integer): The number of nearest neighbours to return. Defaults to 1. |
use_spheroid |
(boolean): true to use spherical distance, false for Euclidean. Defaults to false. |
(boolean)
SedonaDB SQL documentation for ST_KNN
Returns the length of geom. This function only supports LineString, MultiLineString, and GeometryCollections containing linear geometries. Use ST_Perimeter for polygons. For geometry, returns the length in the units of the coordinate reference system; for geography, returns the spherical approximation of the geodesic length in meters.
sd_length(geom = sd_missing_arg())sd_length(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(double)
SedonaDB SQL documentation for ST_LENGTH
Parses a WKT string and returns a geometry. Raises an error if the WKT does
not represent a LineString. Aliases: ST_LineStringFromText.
sd_line_from_text(wkt = sd_missing_arg(), srid = sd_missing_arg())sd_line_from_text(wkt = sd_missing_arg(), srid = sd_missing_arg())
wkt |
(string): Input string |
srid |
(crs): Input crs |
(geometry)
SedonaDB SQL documentation for ST_LINEFROMTEXT
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. For geography, the interpolation is computed using spherical interpolation between vertices.
sd_line_interpolate_point(geom = sd_missing_arg(), fraction = sd_missing_arg())sd_line_interpolate_point(geom = sd_missing_arg(), fraction = sd_missing_arg())
geom |
(geometry): Input geometry |
fraction |
(double): Input double |
(geometry)
SedonaDB SQL documentation for ST_LINEINTERPOLATEPOINT
Returns a double between 0 and 1, representing the location of the closest point on the LineString as a fraction of its total 2D length. The first argument must be a LineString. For geometry, the fraction is computed using 2D Cartesian distance. For geography, the fraction is computed based on spherical interpolation between vertices.
sd_line_locate_point(geom_a = sd_missing_arg(), geom_b = sd_missing_arg())sd_line_locate_point(geom_a = sd_missing_arg(), geom_b = sd_missing_arg())
geom_a |
(geometry): Input geometry |
geom_b |
(geometry): Input geometry |
(double)
SedonaDB SQL documentation for ST_LINELOCATEPOINT
Merges a collection of potentially connected line segments into the fewest possible LineStrings.
sd_line_merge(geom = sd_missing_arg())sd_line_merge(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(geometry)
SedonaDB SQL documentation for ST_LINEMERGE
Parses a WKB binary value and returns a LineString geometry. Returns NULL
if the WKB represents another geometry type. An optional SRID or CRS can be
provided as a second argument. Alias: ST_LineFromWKB.
sd_line_string_from_wkb(wkb = sd_missing_arg(), srid = sd_missing_arg())sd_line_string_from_wkb(wkb = sd_missing_arg(), srid = sd_missing_arg())
wkb |
(binary): Input binary |
srid |
(crs): Input crs |
(geometry)
SedonaDB SQL documentation for ST_LINESTRINGFROMWKB
Returns a linestring being a substring of the input one starting and ending at the given fractions of total 2d length.
sd_line_substring( geom = sd_missing_arg(), start_fraction = sd_missing_arg(), end_fraction = sd_missing_arg() )sd_line_substring( geom = sd_missing_arg(), start_fraction = sd_missing_arg(), end_fraction = sd_missing_arg() )
geom |
(geometry): Input geometry |
start_fraction |
(double): The fraction from which the returned line will start (between 0 and 1) |
end_fraction |
(double): The fraction from which the returned line will end (between 0 and 1) |
(geometry)
SedonaDB SQL documentation for ST_LINESUBSTRING
Extracts the M (measure) coordinate from a Point geometry or geography. Returns NULL if the geometry has no M dimension or for non-point geometries.
sd_m(geom = sd_missing_arg())sd_m(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(double)
SedonaDB SQL documentation for ST_M
Parses a WKT string and returns a geometry. Raises an error if the WKT does not represent a MultiLineString.
sd_m_line_from_text(wkt = sd_missing_arg(), srid = sd_missing_arg())sd_m_line_from_text(wkt = sd_missing_arg(), srid = sd_missing_arg())
wkt |
(string): Input string |
srid |
(crs): Input crs |
(geometry)
SedonaDB SQL documentation for ST_MLINEFROMTEXT
Returns the maximum M (measure) value from a geometry or geography's bounding box.
sd_m_max(geom = sd_missing_arg())sd_m_max(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(double)
SedonaDB SQL documentation for ST_MMAX
Returns the minimum M-coordinate (measure) of a geometry or geography's bounding box.
sd_m_min(geom = sd_missing_arg())sd_m_min(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(double)
SedonaDB SQL documentation for ST_MMIN
Parses a WKT string and returns a geometry. Raises an error if the WKT does not represent a MultiPoint.
sd_m_point_from_text(wkt = sd_missing_arg(), srid = sd_missing_arg())sd_m_point_from_text(wkt = sd_missing_arg(), srid = sd_missing_arg())
wkt |
(string): Input string |
srid |
(crs): Input crs |
(geometry)
SedonaDB SQL documentation for ST_MPOINTFROMTEXT
Parses a WKT string and returns a geometry. Raises an error if the WKT does not represent a MultiPolygon.
sd_m_poly_from_text(wkt = sd_missing_arg(), srid = sd_missing_arg())sd_m_poly_from_text(wkt = sd_missing_arg(), srid = sd_missing_arg())
wkt |
(string): Input string |
srid |
(crs): Input crs |
(geometry)
SedonaDB SQL documentation for ST_MPOLYFROMTEXT
Constructs a rectangular Polygon from minimum X, minimum Y, maximum X, and maximum Y coordinates. An optional SRID or CRS can be provided as a fifth argument.
sd_make_envelope( min_x = sd_missing_arg(), min_y = sd_missing_arg(), max_x = sd_missing_arg(), max_y = sd_missing_arg(), srid = sd_missing_arg() )sd_make_envelope( min_x = sd_missing_arg(), min_y = sd_missing_arg(), max_x = sd_missing_arg(), max_y = sd_missing_arg(), srid = sd_missing_arg() )
min_x |
(double): Input double |
min_y |
(double): Input double |
max_x |
(double): Input double |
max_y |
(double): Input double |
srid |
(crs): Input crs |
(geometry)
SedonaDB SQL documentation for ST_MAKEENVELOPE
Creates a LineString from two or more input Point, MultiPoint, or
LineString geometries or geographies. The function connects the inputs in
the order they are provided to form a single continuous line. Combining
geographies returns a geography.
sd_make_line(geom_a = sd_missing_arg(), geom_b = sd_missing_arg())sd_make_line(geom_a = sd_missing_arg(), geom_b = sd_missing_arg())
geom_a |
(geometry): Input geometry |
geom_b |
(geometry): Input geometry |
(geometry)
SedonaDB SQL documentation for ST_MAKELINE
Collapsed geometries are either converted to empty (keepCollapsed=false) or a valid geometry of lower dimension (keepCollapsed=true). Default is keepCollapsed=false.
sd_make_valid(geom = sd_missing_arg(), keepCollapsed = sd_missing_arg())sd_make_valid(geom = sd_missing_arg(), keepCollapsed = sd_missing_arg())
geom |
(geometry): Input geometry |
keepCollapsed |
(boolean): Input boolean |
(geometry)
SedonaDB SQL documentation for ST_MAKEVALID
For geometry, returns the 2D Cartesian maximum distance between any pair of vertices across the two geometries, in the units of the coordinate reference system. For geography, returns the maximum distance in meters calculated using a spherical approximation.
sd_max_distance(geom_a = sd_missing_arg(), geom_b = sd_missing_arg())sd_max_distance(geom_a = sd_missing_arg(), geom_b = sd_missing_arg())
geom_a |
(geometry): Input geometry |
geom_b |
(geometry): Input geometry |
(double)
SedonaDB SQL documentation for ST_MAXDISTANCE
The minimum clearance is a metric that quantifies a geometry's tolerance to changes in coordinate precision or vertex positions. It represents the maximum distance by which vertices can be adjusted without introducing invalidity to the geometry's structure. A larger minimum clearance value indicates greater robustness against such perturbations. For a geometry with a minimum clearance of x, the following conditions hold: - No two distinct vertices are separated by a distance less than x. - No vertex lies within a distance x from any line segment it is not an endpoint of. For geometries with no definable minimum clearance, such as single Point geometries or MultiPoint geometries where all points occupy the same location, the function returns Double.MAX_VALUE.
sd_minimum_clearance(geom = sd_missing_arg())sd_minimum_clearance(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(double)
SedonaDB SQL documentation for ST_MINIMUMCLEARANCE
This function returns a two-point LineString geometry representing the minimum clearance distance of the input geometry. If the input geometry does not have a defined minimum clearance, such as for single Points or coincident MultiPoints, an empty LineString geometry is returned instead.
sd_minimum_clearance_line(geom = sd_missing_arg())sd_minimum_clearance_line(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(geometry)
SedonaDB SQL documentation for ST_MINIMUMCLEARANCELINE
Missing argument sentinel
sd_missing_arg()sd_missing_arg()
An object of class 'sd_missing_arg'
Returns the total number of coordinate points in the geometry, counting all
vertices across all components. Aliases: ST_NumPoints.
sd_n_points(geom = sd_missing_arg())sd_n_points(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(integer)
SedonaDB SQL documentation for ST_NPOINTS
Returns the total number of rings (exterior and interior) in a polygon or multipolygon. For a simple polygon, this is 1 plus the number of holes. For a multipolygon, it is the sum of all rings in all polygons. Returns 0 for non-polygon geometry types.
sd_n_rings(geom = sd_missing_arg())sd_n_rings(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(integer)
SedonaDB SQL documentation for ST_NRINGS
Returns the geometry or geography in its canonical form.
sd_normalize(geom = sd_missing_arg())sd_normalize(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(geometry)
SedonaDB SQL documentation for ST_NORMALIZE
Returns the number of Geometries. If geometry is a GEOMETRYCOLLECTION (or MULTI*) return the number of geometries, for single geometries will return 1.
sd_num_geometries(geom = sd_missing_arg())sd_num_geometries(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(integer)
SedonaDB SQL documentation for ST_NUMGEOMETRIES
Returns the number of interior rings (holes) in a polygon. For a polygon
without holes, returns 0. For multipolygons, returns the number of interior
rings in the first polygon. Returns NULL for non-polygon geometry types.
Aliases: ST_NumInteriorRing.
sd_num_interior_rings(geom = sd_missing_arg())sd_num_interior_rings(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(integer)
SedonaDB SQL documentation for ST_NUMINTERIORRINGS
Returns the total number of coordinate points in a linestring geometry.
Returns NULL for other geometry types. Use ST_NPoints() to calculate the
number of vertices for all geometry types.
sd_num_points(geom = sd_missing_arg())sd_num_points(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(integer)
SedonaDB SQL documentation for ST_NUMPOINTS
Returns true if the two geometries share space and have the same dimension,
but are not completely contained by each other.
sd_overlaps(geom_a = sd_missing_arg(), geom_b = sd_missing_arg())sd_overlaps(geom_a = sd_missing_arg(), geom_b = sd_missing_arg())
geom_a |
(geometry): Input geometry |
geom_b |
(geometry): Input geometry |
(boolean)
SedonaDB SQL documentation for ST_OVERLAPS
This function calculates the perimeter of a given geometry or geography. It supports Polygon, MultiPolygon, and GeometryCollection geometries (as long as the GeometryCollection contains polygonal geometries). For other types, it returns 0. To measure lines, use ST_Length. For geography, returns the spherical approximation of the geodesic perimeter in meters.
sd_perimeter(geom = sd_missing_arg())sd_perimeter(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(double)
SedonaDB SQL documentation for ST_PERIMETER
Constructs a Point geometry from X and Y coordinates. An optional SRID or CRS can be provided as a third argument.
sd_point(x = sd_missing_arg(), y = sd_missing_arg(), srid = sd_missing_arg())sd_point(x = sd_missing_arg(), y = sd_missing_arg(), srid = sd_missing_arg())
x |
(double): Input double |
y |
(double): Input double |
srid |
(crs): Input crs |
(geometry)
SedonaDB SQL documentation for ST_POINT
Parses a WKT string and returns a geometry. Raises an error if the WKT does not represent a Point.
sd_point_from_text(wkt = sd_missing_arg(), srid = sd_missing_arg())sd_point_from_text(wkt = sd_missing_arg(), srid = sd_missing_arg())
wkt |
(string): Input string |
srid |
(crs): Input crs |
(geometry)
SedonaDB SQL documentation for ST_POINTFROMTEXT
Parses a WKB binary value and returns a Point geometry. Returns NULL if the
WKB represents another geometry type. An optional SRID or CRS can be provided
as a second argument.
sd_point_from_wkb(wkb = sd_missing_arg(), srid = sd_missing_arg())sd_point_from_wkb(wkb = sd_missing_arg(), srid = sd_missing_arg())
wkb |
(binary): Input binary |
srid |
(crs): Input crs |
(geometry)
SedonaDB SQL documentation for ST_POINTFROMWKB
Constructs a Point with an M (measure) coordinate from X, Y, and M values.
sd_point_m(x = sd_missing_arg(), y = sd_missing_arg(), m = sd_missing_arg())sd_point_m(x = sd_missing_arg(), y = sd_missing_arg(), m = sd_missing_arg())
x |
(double): Input double |
y |
(double): Input double |
m |
(double): Input double |
(geometry)
SedonaDB SQL documentation for ST_POINTM
Return the Nth point in a single linestring. Negative values are counted backwards from the end of the LineString such that -1 is the last point. Returns NULL if there is no linestring in the geometry.
sd_point_n(geom = sd_missing_arg(), n = sd_missing_arg())sd_point_n(geom = sd_missing_arg(), n = sd_missing_arg())
geom |
(geometry): Input geometry |
n |
(integer): Input integer |
(geometry)
SedonaDB SQL documentation for ST_POINTN
Unlike ST_Centroid which does not necessarily intersect a geometry or geography, ST_PointOnSurface makes an attempt to find an interior point close to the middle (using deterministic heuristics).
sd_point_on_surface(geom = sd_missing_arg())sd_point_on_surface(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(geometry)
SedonaDB SQL documentation for ST_POINTONSURFACE
Constructs a Point with a Z coordinate from X, Y, and Z values.
sd_point_z(x = sd_missing_arg(), y = sd_missing_arg(), z = sd_missing_arg())sd_point_z(x = sd_missing_arg(), y = sd_missing_arg(), z = sd_missing_arg())
x |
(double): Input double |
y |
(double): Input double |
z |
(double): Input double |
(geometry)
SedonaDB SQL documentation for ST_POINTZ
Constructs a Point with X, Y, Z and M coordinates.
sd_point_zm( x = sd_missing_arg(), y = sd_missing_arg(), z = sd_missing_arg(), m = sd_missing_arg() )sd_point_zm( x = sd_missing_arg(), y = sd_missing_arg(), z = sd_missing_arg(), m = sd_missing_arg() )
x |
(double): Input double |
y |
(double): Input double |
z |
(double): Input double |
m |
(double): Input double |
(geometry)
SedonaDB SQL documentation for ST_POINTZM
Returns a MultiPoint geometry consisting of all the coordinates of the input geometry. It preserves duplicate points as well as M and Z coordinates.
sd_points(geom = sd_missing_arg())sd_points(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(geometry)
SedonaDB SQL documentation for ST_POINTS
Parses a WKT string and returns a geometry. Raises an error if the WKT does not represent a Polygon.
sd_polygon_from_text(wkt = sd_missing_arg(), srid = sd_missing_arg())sd_polygon_from_text(wkt = sd_missing_arg(), srid = sd_missing_arg())
wkt |
(string): Input string |
srid |
(crs): Input crs |
(geometry)
SedonaDB SQL documentation for ST_POLYGONFROMTEXT
Builds a polygonal geometry from linear components in the input geometry. Handles GeometryCollection and multi-geometries by extracting linear components. Typically used with collections of complete, simple linework that forms polygon boundaries. Unlike many geometry constructors, this doesn't require explicit closure of rings—any closed rings in the input will become polygon boundaries.
sd_polygonize(geom = sd_missing_arg())sd_polygonize(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(geometry)
SedonaDB SQL documentation for ST_POLYGONIZE
Creates polygons from a set of geometries that contain linework representing the edges of a polygon.
sd_polygonize_agg(geom = sd_missing_arg())sd_polygonize_agg(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(geometry)
SedonaDB SQL documentation for ST_POLYGONIZE_AGG
Rebuilds a new geometry after specifying all vertices to the specified size. Z and M values are preserved but not affected by the grid snapping. The implementation is similar to a unary union and is designed to output valid geometry (e.g., by avoiding creating new crossing edges when snapping vertices).
sd_reduce_precision(geom = sd_missing_arg(), grid_size = sd_missing_arg())sd_reduce_precision(geom = sd_missing_arg(), grid_size = sd_missing_arg())
geom |
(geometry): Input geometry |
grid_size |
(double): Input double |
(geometry)
SedonaDB SQL documentation for ST_REDUCEPRECISION
When called with two geometry arguments, returns the DE-9IM (Dimensionally
Extended 9-Intersection Model) intersection matrix as a 9-character string
describing the spatial relationship between two geometries. When called with
a third string argument, returns true if the two geometries satisfy the
given DE-9IM intersection matrix pattern, false otherwise. The pattern can
use wildcards (*) and T (any non-empty intersection) in addition to exact
dimension values (0, 1, 2, F).
sd_relate( geom_a = sd_missing_arg(), geom_b = sd_missing_arg(), intersectionMatrixPattern = sd_missing_arg() )sd_relate( geom_a = sd_missing_arg(), geom_b = sd_missing_arg(), intersectionMatrixPattern = sd_missing_arg() )
geom_a |
(geometry): Input geometry |
geom_b |
(geometry): Input geometry |
intersectionMatrixPattern |
(string): A 9-character DE-9IM pattern string. Each character can be 0-2, T, F, or * (wildcard). |
(string)
SedonaDB SQL documentation for ST_RELATE
Returns the geometry or geography with vertex order reversed.
sd_reverse(geom = sd_missing_arg())sd_reverse(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(geometry)
SedonaDB SQL documentation for ST_REVERSE
Rotates a geometry counter-clockwise around the Z axis by an angle in radians.
sd_rotate(geom = sd_missing_arg(), rot = sd_missing_arg())sd_rotate(geom = sd_missing_arg(), rot = sd_missing_arg())
geom |
(geometry): Input geometry |
rot |
(double): Input double |
(geometry)
SedonaDB SQL documentation for ST_ROTATE
Rotates a geometry around the X axis by an angle in radians.
sd_rotate_x(geom = sd_missing_arg(), rot = sd_missing_arg())sd_rotate_x(geom = sd_missing_arg(), rot = sd_missing_arg())
geom |
(geometry): Input geometry |
rot |
(double): Input double |
(geometry)
SedonaDB SQL documentation for ST_ROTATEX
Rotates a geometry around the Y axis by an angle in radians.
sd_rotate_y(geom = sd_missing_arg(), rot = sd_missing_arg())sd_rotate_y(geom = sd_missing_arg(), rot = sd_missing_arg())
geom |
(geometry): Input geometry |
rot |
(double): Input double |
(geometry)
SedonaDB SQL documentation for ST_ROTATEY
Scales a geometry by multiplying each coordinate by the corresponding scale
factor. A 3D variant accepts scaleZ.
sd_scale( geom = sd_missing_arg(), scaleX = sd_missing_arg(), scaleY = sd_missing_arg(), scaleZ = sd_missing_arg() )sd_scale( geom = sd_missing_arg(), scaleX = sd_missing_arg(), scaleY = sd_missing_arg(), scaleZ = sd_missing_arg() )
geom |
(geometry): Input geometry |
scaleX |
(double): Input double |
scaleY |
(double): Input double |
scaleZ |
(double): Input double |
(geometry)
SedonaDB SQL documentation for ST_SCALE
Densifies a geometry or geography by adding intermediate points along line
segments that exceed the specified maximum segment length. For geometry, uses
planar distance; for geography, uses the spherical approximation of the
geodesic distance in meters and points are added along the great circle arc.
In both cases, points are added so that each resulting segment is no longer
than max_segment_length.
sd_segmentize(geom = sd_missing_arg(), max_segment_length = sd_missing_arg())sd_segmentize(geom = sd_missing_arg(), max_segment_length = sd_missing_arg())
geom |
(geometry): Input geometry |
max_segment_length |
(double): Input double |
(geometry)
SedonaDB SQL documentation for ST_SEGMENTIZE
Sets a CRS to a geometry/geography. This is metadata-only - no coordinates
are transformed. See Coordinate Reference Systems
for how SedonaDB represents and compares CRS. This is different from
ST_Transform which actually transforms coordinates. target_crs accepts an
authority code (e.g. 'EPSG:4326'), PROJJSON, or WKT. It is stored as given
and read back unchanged by ST_CRS.
sd_set_crs(geom = sd_missing_arg(), target_crs = sd_missing_arg())sd_set_crs(geom = sd_missing_arg(), target_crs = sd_missing_arg())
geom |
(geometry): Input geometry |
target_crs |
(string): Input string |
(geometry)
SedonaDB SQL documentation for ST_SETCRS
Sets the SRID (spatial reference system identifier) of the geometry. This is metadata only - no coordinate transformation occurs. Use ST_Transform to actually reproject coordinates. See Coordinate Reference Systems for how SedonaDB represents and compares CRS.
sd_set_srid(geom = sd_missing_arg(), srid = sd_missing_arg())sd_set_srid(geom = sd_missing_arg(), srid = sd_missing_arg())
geom |
(geometry): Input geometry |
srid |
(integer): Input integer |
(geometry)
SedonaDB SQL documentation for ST_SETSRID
Simplifies a geometry or geography using the Douglas-Peucker algorithm. The
tolerance parameter controls the degree of simplification: higher values
produce simpler geometries. For geography, the tolerance is specified in
meters and a different algorithm is used. This function may produce invalid
geometries; use ST_SimplifyPreserveTopology when validity must be
maintained.
sd_simplify(geom = sd_missing_arg(), tolerance = sd_missing_arg())sd_simplify(geom = sd_missing_arg(), tolerance = sd_missing_arg())
geom |
(geometry): Input geometry |
tolerance |
(double): Input double |
(geometry)
SedonaDB SQL documentation for ST_SIMPLIFY
Simplifies a geometry, ensuring 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.
sd_simplify_preserve_topology( geom = sd_missing_arg(), tolerance = sd_missing_arg() )sd_simplify_preserve_topology( geom = sd_missing_arg(), tolerance = sd_missing_arg() )
geom |
(geometry): Input geometry |
tolerance |
(double): Input double |
(geometry)
SedonaDB SQL documentation for ST_SIMPLIFYPRESERVETOPOLOGY
Snaps input geometry to reference geometry within tolerance. Result geometry aligns to the reference geometry where within tolerance distance.
sd_snap( geom_a = sd_missing_arg(), geom_b = sd_missing_arg(), tolerance = sd_missing_arg() )sd_snap( geom_a = sd_missing_arg(), geom_b = sd_missing_arg(), tolerance = sd_missing_arg() )
geom_a |
(geometry): Input geometry |
geom_b |
(geometry): Input geometry |
tolerance |
(double): Input double |
(geometry)
SedonaDB SQL documentation for ST_SNAP
Returns the SRID (spatial reference identifier) of a geometry.
sd_srid(geom = sd_missing_arg())sd_srid(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(integer)
SedonaDB SQL documentation for ST_SRID
Returns the start point of a linestring geometry.
sd_start_point(geom = sd_missing_arg())sd_start_point(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(geometry)
SedonaDB SQL documentation for ST_STARTPOINT
Returns the parts of geometries or geographies A and B that do not overlap.
sd_sym_difference(geom_a = sd_missing_arg(), geom_b = sd_missing_arg())sd_sym_difference(geom_a = sd_missing_arg(), geom_b = sd_missing_arg())
geom_a |
(geometry): Input geometry |
geom_b |
(geometry): Input geometry |
(geometry)
SedonaDB SQL documentation for ST_SYMDIFFERENCE
Converts a geometry to a geography while tessellating edges using spherical (geodesic) interpolation. The tolerance parameter specifies the maximum deviation in meters between the original edge and the tessellated approximation. This is useful when converting planar geometries to geographies where edges need to follow geodesic paths on the sphere.
sd_tessellate_geog(geom = sd_missing_arg(), tolerance = sd_missing_arg())sd_tessellate_geog(geom = sd_missing_arg(), tolerance = sd_missing_arg())
geom |
(geometry): Input geometry |
tolerance |
(double): Input double |
(geography)
SedonaDB SQL documentation for ST_TESSELLATEGEOG
Converts a geography to a geometry while tessellating edges using spherical (geodesic) interpolation. The tolerance parameter specifies the maximum deviation in meters between the original spherical edge and the tessellated planar approximation. This is useful when converting geographies to geometries while preserving the shape of geodesic edges as approximated line segments. When an edge crosses the antimeridian, the returned coordinates are "wrapped" such that the returned longitude is either greater than 180 or less than -180. This helps produce valid geometry in more cases (e.g., linestring or polygon crossing the antimeridian); however, it does not produce valid geometry in the case of a polygon ring that spans the full longitude range (e.g., Antarctica).
sd_tessellate_geom(geom = sd_missing_arg(), tolerance = sd_missing_arg())sd_tessellate_geom(geom = sd_missing_arg(), tolerance = sd_missing_arg())
geom |
(geography): Input geography |
tolerance |
(double): Input double |
(geometry)
SedonaDB SQL documentation for ST_TESSELLATEGEOM
Converts a geometry to a geography by changing the edge interpretation from planar to spherical. This is a metadata-only operation that does not modify the underlying coordinate data. If the input is already a geography, it is returned unchanged.
sd_to_geography(geom = sd_missing_arg())sd_to_geography(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(geography)
SedonaDB SQL documentation for ST_TOGEOGRAPHY
Converts a geography to a geometry by changing the edge interpretation from spherical to planar. This is a metadata-only operation that does not modify the underlying coordinate data. If the input is already a geometry, it is returned unchanged.
sd_to_geometry(geom = sd_missing_arg())sd_to_geometry(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(geometry)
SedonaDB SQL documentation for ST_TOGEOMETRY
Returns true if the two geometries have at least one boundary point in
common but no interior points in common.
sd_touches(geom_a = sd_missing_arg(), geom_b = sd_missing_arg())sd_touches(geom_a = sd_missing_arg(), geom_b = sd_missing_arg())
geom_a |
(geometry): Input geometry |
geom_b |
(geometry): Input geometry |
(boolean)
SedonaDB SQL documentation for ST_TOUCHES
Transforms the coordinate reference system of a geometry between EPSG reference systems. If provided with 2 arguments, target_crs can be specified as an EPSG code (e.g., 'EPSG:4326') or as a PROJ string. See Coordinate Reference Systems for how SedonaDB represents and compares CRS. When 3 arguments are provided, a source_crs can be used to specify the source CRS in case the input geometry doesn't have an SRID defined. The source_crs takes precedence over the geometry's SRID. Geography input is also accepted; because geography is always defined on a geographic (longitude/latitude) CRS, the target_crs must be geographic as well.
sd_transform(...)sd_transform(...)
... |
Supported combinations:
|
(geometry)
SedonaDB SQL documentation for ST_TRANSFORM
Translates (shifts) a geometry by the given deltaX and deltaY offsets. A 3D
variant accepts deltaZ.
sd_translate( geom = sd_missing_arg(), deltaX = sd_missing_arg(), deltaY = sd_missing_arg(), deltaZ = sd_missing_arg() )sd_translate( geom = sd_missing_arg(), deltaX = sd_missing_arg(), deltaY = sd_missing_arg(), deltaZ = sd_missing_arg() )
geom |
(geometry): Input geometry |
deltaX |
(double): Input double |
deltaY |
(double): Input double |
deltaZ |
(double): Input double |
(geometry)
SedonaDB SQL documentation for ST_TRANSLATE
Returns a single geometry which is the union of all components of the input geometry. Useful for computing the union of a set of geometries stored in a single geometry (e.g., a GEOMETRYCOLLECTION or MULTI* geometry).
sd_unary_union(geom = sd_missing_arg())sd_unary_union(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(geometry)
SedonaDB SQL documentation for ST_UNARYUNION
Returns a geometry or geography that represents the point set union of two geometries or geographies.
sd_union(geom_a = sd_missing_arg(), geom_b = sd_missing_arg())sd_union(geom_a = sd_missing_arg(), geom_b = sd_missing_arg())
geom_a |
(geometry): Input geometry |
geom_b |
(geometry): Input geometry |
(geometry)
SedonaDB SQL documentation for ST_UNION
Returns a geometry that represents the point set union of all geometries.
sd_union_agg(geom = sd_missing_arg())sd_union_agg(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(geometry)
SedonaDB SQL documentation for ST_UNION_AGG
Returns true if geometry A is completely inside geometry B. This is the
inverse of ST_Contains: ST_Within(A, B) is equivalent to ST_Contains(B, A).
sd_within(geom_a = sd_missing_arg(), geom_b = sd_missing_arg())sd_within(geom_a = sd_missing_arg(), geom_b = sd_missing_arg())
geom_a |
(geometry): Input geometry |
geom_b |
(geometry): Input geometry |
(boolean)
SedonaDB SQL documentation for ST_WITHIN
Returns NULL for non-point geometries or NULL input.
sd_x(geom = sd_missing_arg())sd_x(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(double)
SedonaDB SQL documentation for ST_X
Returns the maximum X coordinate (longitude for geography) of a geometry or geography's bounding box.
sd_x_max(geom = sd_missing_arg())sd_x_max(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(double)
SedonaDB SQL documentation for ST_XMAX
Returns the minimum X coordinate (longitude for geography) of a geometry or geography's bounding box.
sd_x_min(geom = sd_missing_arg())sd_x_min(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(double)
SedonaDB SQL documentation for ST_XMIN
Returns NULL for non-point geometries or NULL input.
sd_y(geom = sd_missing_arg())sd_y(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(double)
SedonaDB SQL documentation for ST_Y
For geography, the maximum latitude is computed considering spherical geometry (e.g., the maximum latitude of a linestring that crosses the North Pole is 90).
sd_y_max(geom = sd_missing_arg())sd_y_max(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(double)
SedonaDB SQL documentation for ST_YMAX
For geography, the minimum latitude is computed considering spherical geometry (e.g., the minimum latitude of a linestring that crosses the South Pole is -90).
sd_y_min(geom = sd_missing_arg())sd_y_min(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(double)
SedonaDB SQL documentation for ST_YMIN
Returns NULL if the geometry has no Z dimension or for non-point geometries.
sd_z(geom = sd_missing_arg())sd_z(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(double)
SedonaDB SQL documentation for ST_Z
Returns the maximum Z coordinate of a geometry or geography's bounding box.
sd_z_max(geom = sd_missing_arg())sd_z_max(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(double)
SedonaDB SQL documentation for ST_ZMAX
Returns the minimum Z coordinate of a geometry or geography's bounding box.
sd_z_min(geom = sd_missing_arg())sd_z_min(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(double)
SedonaDB SQL documentation for ST_ZMIN
Returns a code indicating the coordinate dimension: - 0 = 2D (XY) - 1 = 3D with M coordinate (XYM) - 2 = 3D with Z coordinate (XYZ) - 3 = 4D (XYZM)
sd_zmflag(geom = sd_missing_arg())sd_zmflag(geom = sd_missing_arg())
geom |
(geometry): Input geometry |
(integer)
SedonaDB SQL documentation for ST_ZMFLAG