squirreling 0.9.2 → 0.9.4

package/src/expression/spatial.js

@@ -0,0 +1,365 @@
+import { geomToWkt, parseWkt } from './wkt.js'
+import { distSq, pointInPolygon, pointLineRelation, pointToSegmentDistSq, simpleIntersects, simplePairContainment, simplePairRelation } from './spatial.geometry.js'
+import { simpleGeomEqual } from './spatial.equality.js'
+
+/**
+ * @import { SpatialFunc, SqlPrimitive } from '../types.js'
+ * @import { Geometry, Point, SimpleGeometry } from './geometry.js'
+ */
+
+/**
+ * Evaluate a spatial predicate function.
+ *
+ * @param {Object} options
+ * @param {SpatialFunc} options.funcName
+ * @param {SqlPrimitive[]} options.args
+ * @returns {SqlPrimitive}
+ */
+export function evaluateSpatialFunc({ funcName, args }) {
+  // Singleton functions
+  if (funcName === 'ST_GEOMFROMTEXT') {
+    if (args[0] == null) return null
+    return parseWkt(String(args[0]))
+  }
+
+  if (funcName === 'ST_MAKEENVELOPE') {
+    if (args[0] == null || args[1] == null || args[2] == null || args[3] == null) return null
+    const xmin = Number(args[0])
+    const ymin = Number(args[1])
+    const xmax = Number(args[2])
+    const ymax = Number(args[3])
+    return {
+      type: 'Polygon',
+      coordinates: [[[xmin, ymin], [xmax, ymin], [xmax, ymax], [xmin, ymax], [xmin, ymin]]],
+    }
+  }
+
+  const geomA = toGeometry(args[0])
+  if (funcName === 'ST_ASTEXT') {
+    if (geomA == null) return null
+    return geomToWkt(geomA)
+  }
+
+  // Predicate functions (require two geometries)
+  const geomB = toGeometry(args[1])
+  if (geomA == null || geomB == null) return null
+  const a = decompose(geomA)
+  const b = decompose(geomB)
+
+  switch (funcName) {
+  case 'ST_INTERSECTS': return simpleIntersects(a, b)
+  case 'ST_CONTAINS': return stContains(a, b)
+  case 'ST_CONTAINSPROPERLY': return stContainsProperly(a, b)
+  case 'ST_WITHIN': return stContains(b, a) // inverse of contains
+  case 'ST_OVERLAPS': return stOverlaps(a, b)
+  case 'ST_TOUCHES': return stTouches(a, b)
+  case 'ST_EQUALS': return stEquals(a, b)
+  case 'ST_CROSSES': return stCrosses(a, b)
+  case 'ST_COVERS': return stContains(a, b) // TODO: handle boundary
+  case 'ST_COVEREDBY': return stContains(b, a) // inverse of covers
+  case 'ST_DWITHIN': {
+    if (args[2] == null) return null
+    const dist = Number(args[2])
+    return stDWithin(a, b, dist)
+  }
+  default: return null
+  }
+}
+
+/**
+ * Normalize a geometry value. Accepts GeoJSON objects.
+ * Returns null if the value is not a valid geometry.
+ *
+ * @param {SqlPrimitive} val
+ * @returns {Geometry | null}
+ */
+function toGeometry(val) {
+  if (typeof val === 'object' && val != null && 'type' in val) {
+    if (val.type === 'GeometryCollection' && Array.isArray(val.geometries)) {
+      // eslint-disable-next-line no-extra-parens
+      return /** @type {Geometry} */ (val)
+    }
+    const geometryTypes = ['Point', 'MultiPoint', 'LineString', 'MultiLineString', 'Polygon', 'MultiPolygon']
+    if (geometryTypes.includes(val.type) && Array.isArray(val.coordinates)) {
+      // eslint-disable-next-line no-extra-parens
+      return /** @type {Geometry} */ (val)
+    }
+  }
+  return null
+}
+
+// ============================================================================
+// Minimum distance between geometries
+// ============================================================================
+
+/**
+ * Get all line segments from a geometry.
+ *
+ * @param {SimpleGeometry[]} geoms
+ * @returns {{ segments: Array<[number[], number[]]>, points: number[][] }}
+ */
+function getSegments(geoms) {
+  /** @type {Array<[number[], number[]]>} */
+  const segments = []
+  /** @type {number[][]} */
+  const points = []
+
+  /**
+   * @param {number[][]} coords
+   */
+  function addLine(coords) {
+    for (let i = 0; i < coords.length - 1; i++) {
+      segments.push([coords[i], coords[i + 1]])
+    }
+    points.push(...coords)
+  }
+
+  for (const geom of geoms) {
+    if (geom.type === 'Point') points.push(geom.coordinates)
+    else if (geom.type === 'LineString') addLine(geom.coordinates)
+    else if (geom.type === 'Polygon') geom.coordinates.forEach(addLine)
+  }
+
+  return { segments, points }
+}
+
+/**
+ * Test whether two geometries are within a given distance of each other.
+ * Intersecting geometries have distance 0. For non-intersecting geometries,
+ * the minimum distance is always at an endpoint, so point-to-segment suffices.
+ *
+ * @param {SimpleGeometry[]} a
+ * @param {SimpleGeometry[]} b
+ * @param {number} distance
+ * @returns {boolean}
+ */
+function stDWithin(a, b, distance) {
+  if (distance < 0) return false
+  if (simpleIntersects(a, b)) return true
+
+  const distanceSq = distance * distance
+  const { points: ptsA, segments: segsA } = getSegments(a)
+  const { points: ptsB, segments: segsB } = getSegments(b)
+
+  // Point-to-point
+  for (const pa of ptsA) {
+    for (const pb of ptsB) {
+      if (distSq(pa, pb) <= distanceSq) return true
+    }
+  }
+
+  // Point-to-segment
+  for (const pt of ptsA) {
+    for (const [b1, b2] of segsB) {
+      if (pointToSegmentDistSq(pt, b1, b2) <= distanceSq) return true
+    }
+  }
+  for (const pt of ptsB) {
+    for (const [a1, a2] of segsA) {
+      if (pointToSegmentDistSq(pt, a1, a2) <= distanceSq) return true
+    }
+  }
+
+  return false
+}
+
+// ============================================================================
+// Spatial predicate dispatch - decompose to primitive type pairs
+// ============================================================================
+
+/**
+ * Decompose Multi* and GeometryCollection into simple geometries.
+ *
+ * @param {Geometry} geom
+ * @returns {SimpleGeometry[]}
+ */
+function decompose(geom) {
+  switch (geom.type) {
+  case 'MultiPoint':
+    return geom.coordinates.map(c => ({ type: 'Point', coordinates: c }))
+  case 'MultiLineString':
+    return geom.coordinates.map(c => ({ type: 'LineString', coordinates: c }))
+  case 'MultiPolygon':
+    return geom.coordinates.map(c => ({ type: 'Polygon', coordinates: c }))
+  case 'GeometryCollection':
+    return geom.geometries.flatMap(decompose)
+  default:
+    return [geom]
+  }
+}
+
+// ============================================================================
+// ST_Contains
+// ============================================================================
+
+/**
+ * @param {SimpleGeometry[]} a
+ * @param {SimpleGeometry[]} b
+ * @returns {boolean}
+ */
+function stContains(a, b) {
+  // Every part of b must be inside some part of a
+  return b.every(pb => a.some(pa => simplePairContainment(pa, pb) !== 'OUTSIDE'))
+}
+
+// ============================================================================
+// ST_ContainsProperly
+// ============================================================================
+
+/**
+ * @param {SimpleGeometry[]} a
+ * @param {SimpleGeometry[]} b
+ * @returns {boolean}
+ */
+function stContainsProperly(a, b) {
+  // Every part of b must be strictly inside some part of a
+  return b.every(pb => a.some(pa => simplePairContainment(pa, pb) === 'INSIDE'))
+}
+
+// ============================================================================
+// ST_Touches
+// ============================================================================
+
+/**
+ * @param {SimpleGeometry[]} a
+ * @param {SimpleGeometry[]} b
+ * @returns {boolean}
+ */
+function stTouches(a, b) {
+  let intersects = false
+  for (const pa of a) {
+    for (const pb of b) {
+      const rel = simplePairRelation(pa, pb)
+      if (rel === 'INSIDE') return false
+      if (rel === 'BOUNDARY') intersects = true
+    }
+  }
+  return intersects
+}
+
+// ============================================================================
+// ST_Overlaps
+// ============================================================================
+
+/**
+ * @param {SimpleGeometry[]} a
+ * @param {SimpleGeometry[]} b
+ * @returns {boolean}
+ */
+function stOverlaps(a, b) {
+  // Overlaps requires same dimension, and that each geometry has some part
+  // inside the other and some part outside
+  const dimA = geometryDimension(a)
+  const dimB = geometryDimension(b)
+  if (dimA !== dimB) return false
+  if (!simpleIntersects(a, b)) return false
+  if (stEquals(a, b)) return false
+  // Must not be containment
+  if (stContains(a, b) || stContains(b, a)) return false
+  return true
+}
+
+/**
+ * @param {SimpleGeometry[]} parts
+ * @returns {number}
+ */
+function geometryDimension(parts) {
+  let max = 0
+  for (const geom of parts) {
+    switch (geom.type) {
+    case 'Point':
+      break
+    case 'LineString':
+      if (max < 1) max = 1
+      break
+    case 'Polygon':
+      return 2
+    }
+  }
+  return max
+}
+
+// ============================================================================
+// ST_Equals
+// ============================================================================
+
+/**
+ * @param {SimpleGeometry[]} a
+ * @param {SimpleGeometry[]} b
+ * @returns {boolean}
+ */
+function stEquals(a, b) {
+  if (a.length !== b.length) return false
+
+  // For each simple geometry in a, find a matching one in b
+  const used = new Set()
+  for (const pa of a) {
+    let found = false
+    for (let i = 0; i < b.length; i++) {
+      if (used.has(i)) continue
+      if (simpleGeomEqual(pa, b[i])) {
+        used.add(i)
+        found = true
+        break
+      }
+    }
+    if (!found) return false
+  }
+  return true
+}
+
+// ============================================================================
+// ST_Crosses
+// ============================================================================
+
+/**
+ * @param {SimpleGeometry[]} a
+ * @param {SimpleGeometry[]} b
+ * @returns {boolean}
+ */
+function stCrosses(a, b) {
+  // Crosses: interiors intersect, and the intersection has lower dimension
+  // than the maximum of the two geometries' dimensions
+  const dimA = geometryDimension(a)
+  const dimB = geometryDimension(b)
+
+  if (!simpleIntersects(a, b)) return false
+
+  // Point/Point or Polygon/Polygon cannot cross
+  if (dimA === dimB && dimA !== 1) return false
+
+  // Line/Line: they cross if they intersect at a point (not overlap)
+  if (dimA === 1 && dimB === 1) {
+    // They cross if they intersect but neither contains the other
+    // and the intersection is a set of points (not line segments)
+    return !stContains(a, b) && !stContains(b, a) && !stTouches(a, b)
+  }
+
+  // Point/Line, Point/Polygon: point "in interior"
+  if (dimA === 0 && dimB >= 1) {
+    for (const pa of a) {
+      // eslint-disable-next-line no-extra-parens
+      const point = /** @type {Point} */ (pa)
+      for (const pb of b) {
+        if (pb.type === 'LineString') {
+          if (pointLineRelation(point.coordinates, pb.coordinates) === 'INSIDE') return true
+        }
+        if (pb.type === 'Polygon') {
+          if (pointInPolygon(point.coordinates, pb.coordinates) === 'INSIDE') return true
+        }
+      }
+    }
+    return false
+  }
+
+  // Line/Polygon: line crosses polygon if part of line is inside and part is outside
+  if (dimA === 1 && dimB === 2) {
+    return !stContains(b, a)
+  }
+
+  // Symmetric cases
+  if (dimA >= 1 && dimB === 0) return stCrosses(b, a)
+  if (dimA === 2 && dimB === 1) return stCrosses(b, a)
+
+  return false
+}

package/src/expression/wkt.js

@@ -0,0 +1,222 @@
+/**
+ * @import { Geometry } from './geometry.js'
+ */
+
+/**
+ * Parse a WKT string into a GeoJSON geometry.
+ *
+ * @param {string} wkt
+ * @returns {Geometry | null}
+ */
+export function parseWkt(wkt) {
+  const s = wkt.trim()
+  const upper = s.toUpperCase()
+
+  if (upper.startsWith('POINT')) {
+    const coords = parseWktCoordinate(s.slice(5).trim())
+    if (!coords) return null
+    return { type: 'Point', coordinates: coords }
+  }
+
+  if (upper.startsWith('MULTIPOINT')) {
+    const inner = extractParens(s.slice(10).trim())
+    if (inner == null) return null
+    const coords = parseWktCoordinateList(inner)
+    if (!coords) return null
+    return { type: 'MultiPoint', coordinates: coords }
+  }
+
+  if (upper.startsWith('MULTILINESTRING')) {
+    const inner = extractParens(s.slice(15).trim())
+    if (inner == null) return null
+    const rings = parseWktRingList(inner)
+    if (!rings) return null
+    return { type: 'MultiLineString', coordinates: rings }
+  }
+
+  if (upper.startsWith('MULTIPOLYGON')) {
+    const inner = extractParens(s.slice(12).trim())
+    if (inner == null) return null
+    const polys = parseWktPolygonList(inner)
+    if (!polys) return null
+    return { type: 'MultiPolygon', coordinates: polys }
+  }
+
+  if (upper.startsWith('LINESTRING')) {
+    const inner = extractParens(s.slice(10).trim())
+    if (inner == null) return null
+    const coords = parseWktCoordinateList(inner)
+    if (!coords) return null
+    return { type: 'LineString', coordinates: coords }
+  }
+
+  if (upper.startsWith('POLYGON')) {
+    const inner = extractParens(s.slice(7).trim())
+    if (inner == null) return null
+    const rings = parseWktRingList(inner)
+    if (!rings) return null
+    return { type: 'Polygon', coordinates: rings }
+  }
+
+  return null
+}
+
+/**
+ * Convert a GeoJSON geometry to WKT.
+ *
+ * @param {Geometry} geom
+ * @returns {string}
+ */
+export function geomToWkt(geom) {
+  switch (geom.type) {
+  case 'Point':
+    return `POINT (${coordToWkt(geom.coordinates)})`
+  case 'MultiPoint':
+    return `MULTIPOINT (${geom.coordinates.map(c => `(${coordToWkt(c)})`).join(', ')})`
+  case 'LineString':
+    return `LINESTRING (${coordListToWkt(geom.coordinates)})`
+  case 'MultiLineString':
+    return `MULTILINESTRING (${geom.coordinates.map(l => `(${coordListToWkt(l)})`).join(', ')})`
+  case 'Polygon':
+    return `POLYGON (${geom.coordinates.map(r => `(${coordListToWkt(r)})`).join(', ')})`
+  case 'MultiPolygon':
+    return `MULTIPOLYGON (${geom.coordinates.map(p => `(${p.map(r => `(${coordListToWkt(r)})`).join(', ')})`).join(', ')})`
+  case 'GeometryCollection':
+    return `GEOMETRYCOLLECTION (${(geom.geometries || []).map(g => geomToWkt(g)).join(', ')})`
+  default:
+    return ''
+  }
+}
+
+/**
+ * Extract content inside outer parentheses.
+ *
+ * @param {string} s
+ * @returns {string | null}
+ */
+function extractParens(s) {
+  const trimmed = s.trim()
+  if (!trimmed.startsWith('(') || !trimmed.endsWith(')')) return null
+  return trimmed.slice(1, -1).trim()
+}
+
+/**
+ * Parse a single coordinate like "(1 2)" or "1 2".
+ *
+ * @param {string} s
+ * @returns {number[] | null}
+ */
+function parseWktCoordinate(s) {
+  const inner = s.trim().replace(/^\(/, '').replace(/\)$/, '').trim()
+  const parts = inner.split(/\s+/)
+  if (parts.length < 2) return null
+  const x = Number(parts[0])
+  const y = Number(parts[1])
+  if (!Number.isFinite(x) || !Number.isFinite(y)) return null
+  return [x, y]
+}
+
+/**
+ * Parse a comma-separated list of coordinates like "1 2, 3 4, 5 6".
+ *
+ * @param {string} s
+ * @returns {number[][] | null}
+ */
+function parseWktCoordinateList(s) {
+  const parts = s.split(',')
+  /** @type {number[][]} */
+  const coords = []
+  for (const part of parts) {
+    const trimmed = part.trim().replace(/^\(/, '').replace(/\)$/, '').trim()
+    const nums = trimmed.split(/\s+/)
+    if (nums.length < 2) return null
+    const x = Number(nums[0])
+    const y = Number(nums[1])
+    if (!Number.isFinite(x) || !Number.isFinite(y)) return null
+    coords.push([x, y])
+  }
+  return coords.length ? coords : null
+}
+
+/**
+ * Parse a list of rings like "(1 2, 3 4), (5 6, 7 8)".
+ *
+ * @param {string} s
+ * @returns {number[][][] | null}
+ */
+function parseWktRingList(s) {
+  /** @type {number[][][]} */
+  const rings = []
+  const ringStrs = splitTopLevel(s)
+  for (const ringStr of ringStrs) {
+    const inner = extractParens(ringStr.trim())
+    if (inner == null) return null
+    const coords = parseWktCoordinateList(inner)
+    if (!coords) return null
+    rings.push(coords)
+  }
+  return rings.length ? rings : null
+}
+
+/**
+ * Parse a list of polygons like "((ring1), (ring2)), ((ring3))".
+ *
+ * @param {string} s
+ * @returns {number[][][][] | null}
+ */
+function parseWktPolygonList(s) {
+  /** @type {number[][][][]} */
+  const polys = []
+  const polyStrs = splitTopLevel(s)
+  for (const polyStr of polyStrs) {
+    const inner = extractParens(polyStr.trim())
+    if (inner == null) return null
+    const rings = parseWktRingList(inner)
+    if (!rings) return null
+    polys.push(rings)
+  }
+  return polys.length ? polys : null
+}
+
+/**
+ * Split a string by commas at the top-level (not inside parentheses).
+ *
+ * @param {string} s
+ * @returns {string[]}
+ */
+function splitTopLevel(s) {
+  /** @type {string[]} */
+  const parts = []
+  let depth = 0
+  let start = 0
+  for (let i = 0; i < s.length; i++) {
+    if (s[i] === '(') depth++
+    else if (s[i] === ')') depth--
+    else if (s[i] === ',' && depth === 0) {
+      parts.push(s.slice(start, i))
+      start = i + 1
+    }
+  }
+  parts.push(s.slice(start))
+  return parts
+}
+
+/**
+ * Format a single coordinate to WKT.
+ *
+ * @param {number[]} coord
+ * @returns {string}
+ */
+function coordToWkt(coord) {
+  return `${coord[0]} ${coord[1]}`
+}
+
+/**
+ * Format a coordinate list to WKT.
+ *
+ * @param {number[][]} coords
+ * @returns {string}
+ */
+function coordListToWkt(coords) {
+  return coords.map(coordToWkt).join(', ')
+}

package/src/types.d.ts

@@ -276,6 +276,22 @@ export type StringFunc =
   | 'RIGHT'
   | 'INSTR'
 
+export type SpatialFunc =
+  | 'ST_INTERSECTS'
+  | 'ST_CONTAINS'
+  | 'ST_CONTAINSPROPERLY'
+  | 'ST_WITHIN'
+  | 'ST_OVERLAPS'
+  | 'ST_TOUCHES'
+  | 'ST_EQUALS'
+  | 'ST_CROSSES'
+  | 'ST_COVERS'
+  | 'ST_COVEREDBY'
+  | 'ST_DWITHIN'
+  | 'ST_GEOMFROMTEXT'
+  | 'ST_MAKEENVELOPE'
+  | 'ST_ASTEXT'
+
 export interface StarColumn {
   kind: 'star'
   table?: string

package/src/validation.js

@@ -1,7 +1,7 @@
 import { ParseError } from './parseErrors.js'
 
 /**
- * @import { AggregateFunc, BinaryOp, ExprNode, FunctionNode, IntervalUnit, MathFunc, StringFunc, UserDefinedFunction } from './types.js'
+ * @import { AggregateFunc, BinaryOp, ExprNode, FunctionNode, IntervalUnit, MathFunc, SpatialFunc, StringFunc, UserDefinedFunction } from './types.js'
  * @param {string} name
  * @returns {name is AggregateFunc}
  */
@@ -79,6 +79,19 @@ export function isRegexpFunc(name) {
   return ['REGEXP_SUBSTR', 'REGEXP_REPLACE'].includes(name)
 }
 
+/**
+ * @param {string} name
+ * @returns {name is SpatialFunc}
+ */
+export function isSpatialFunc(name) {
+  return [
+    'ST_INTERSECTS', 'ST_CONTAINS', 'ST_CONTAINSPROPERLY', 'ST_WITHIN',
+    'ST_OVERLAPS', 'ST_TOUCHES', 'ST_EQUALS', 'ST_CROSSES',
+    'ST_COVERS', 'ST_COVEREDBY', 'ST_DWITHIN',
+    'ST_GEOMFROMTEXT', 'ST_MAKEENVELOPE', 'ST_ASTEXT',
+  ].includes(name)
+}
+
 /**
  * @param {string} name
  * @returns {name is MathFunc}
@@ -178,6 +191,12 @@ export const FUNCTION_ARG_COUNTS = {
   JSON_OBJECT: { min: 0 },
   JSON_ARRAYAGG: { min: 1, max: 1 },
 
+  // Array functions
+  ARRAY_LENGTH: { min: 1, max: 1 },
+  ARRAY_POSITION: { min: 2, max: 2 },
+  ARRAY_SORT: { min: 1, max: 1 },
+  CARDINALITY: { min: 1, max: 1 },
+
   // Conditional functions
   COALESCE: { min: 1 },
   NULLIF: { min: 2, max: 2 },
@@ -190,6 +209,22 @@ export const FUNCTION_ARG_COUNTS = {
   MAX: { min: 1, max: 1 },
   STDDEV_SAMP: { min: 1, max: 1 },
   STDDEV_POP: { min: 1, max: 1 },
+
+  // Spatial predicate functions
+  ST_INTERSECTS: { min: 2, max: 2 },
+  ST_CONTAINS: { min: 2, max: 2 },
+  ST_CONTAINSPROPERLY: { min: 2, max: 2 },
+  ST_WITHIN: { min: 2, max: 2 },
+  ST_OVERLAPS: { min: 2, max: 2 },
+  ST_TOUCHES: { min: 2, max: 2 },
+  ST_EQUALS: { min: 2, max: 2 },
+  ST_CROSSES: { min: 2, max: 2 },
+  ST_COVERS: { min: 2, max: 2 },
+  ST_COVEREDBY: { min: 2, max: 2 },
+  ST_DWITHIN: { min: 3, max: 3 },
+  ST_GEOMFROMTEXT: { min: 1, max: 1 },
+  ST_MAKEENVELOPE: { min: 4, max: 4 },
+  ST_ASTEXT: { min: 1, max: 1 },
 }
 
 /**
@@ -249,7 +284,8 @@ export function isKnownFunction(funcName, functions) {
     isAggregateFunc(funcName) ||
     isMathFunc(funcName) ||
     isStringFunc(funcName) ||
-    isRegexpFunc(funcName)
+    isRegexpFunc(funcName) ||
+    isSpatialFunc(funcName)
   ) {
     return true
   }
@@ -258,6 +294,7 @@ export function isKnownFunction(funcName, functions) {
   if ([
     'CURRENT_DATE', 'CURRENT_TIME', 'CURRENT_TIMESTAMP',
     'JSON_VALUE', 'JSON_QUERY', 'JSON_OBJECT',
+    'ARRAY_LENGTH', 'ARRAY_POSITION', 'ARRAY_SORT', 'CARDINALITY',
     'COALESCE', 'NULLIF', 'CAST',
   ].includes(funcName)) {
     return true

package/src/validationErrors.js

@@ -68,6 +68,22 @@ export const FUNCTION_SIGNATURES = {
   MAX: 'expression',
   STDDEV_SAMP: 'expression',
   STDDEV_POP: 'expression',
+
+  // Spatial predicate functions
+  ST_INTERSECTS: 'geometry, geometry',
+  ST_CONTAINS: 'geometry, geometry',
+  ST_CONTAINSPROPERLY: 'geometry, geometry',
+  ST_WITHIN: 'geometry, geometry',
+  ST_OVERLAPS: 'geometry, geometry',
+  ST_TOUCHES: 'geometry, geometry',
+  ST_EQUALS: 'geometry, geometry',
+  ST_CROSSES: 'geometry, geometry',
+  ST_COVERS: 'geometry, geometry',
+  ST_COVEREDBY: 'geometry, geometry',
+  ST_DWITHIN: 'geometry, geometry, distance',
+  ST_GEOMFROMTEXT: 'wkt',
+  ST_MAKEENVELOPE: 'xmin, ymin, xmax, ymax',
+  ST_ASTEXT: 'geometry',
 }
 
 /**