squirreling 0.9.2 → 0.9.4

package/README.md

@@ -149,6 +149,8 @@ Squirreling mostly follows the SQL standard. The following features are supporte
 - Trig: `SIN`, `COS`, `TAN`, `COT`, `ASIN`, `ACOS`, `ATAN`, `ATAN2`, `DEGREES`, `RADIANS`, `PI`
 - Date: `CURRENT_DATE`, `CURRENT_TIME`, `CURRENT_TIMESTAMP`, `INTERVAL`
 - Json: `JSON_VALUE`, `JSON_QUERY`, `JSON_OBJECT`
+- Array: `ARRAY_LENGTH`, `ARRAY_POSITION`, `ARRAY_SORT`, `CARDINALITY`
 - Regex: `REGEXP_SUBSTR`, `REGEXP_REPLACE`
+- Spatial: `ST_GeomFromText`, `ST_MakeEnvelope`, `ST_AsText`, `ST_Intersects`, `ST_Contains`, `ST_ContainsProperly`, `ST_Within`, `ST_Overlaps`, `ST_Touches`, `ST_Equals`, `ST_Crosses`, `ST_Covers`, `ST_CoveredBy`, `ST_DWithin`
 - Conditional: `COALESCE`, `NULLIF`
 - User-defined functions (UDFs)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squirreling",
-  "version": "0.9.2",
+  "version": "0.9.4",
   "description": "Squirreling Async SQL Engine",
   "author": "Hyperparam",
   "homepage": "https://hyperparam.app",
@@ -37,10 +37,10 @@
     "test": "vitest run"
   },
   "devDependencies": {
-    "@types/node": "25.3.0",
+    "@types/node": "25.3.2",
     "@vitest/coverage-v8": "4.0.18",
     "eslint": "9.39.2",
-    "eslint-plugin-jsdoc": "62.6.1",
+    "eslint-plugin-jsdoc": "62.7.1",
     "typescript": "5.9.3",
     "vitest": "4.0.18"
   }

package/src/backend/dataSource.js

@@ -1,5 +1,5 @@
 /**
- * @import { AsyncCells, AsyncDataSource, AsyncRow, ScanOptions, ScanResults, SqlPrimitive } from '../types.js'
+ * @import { AsyncCells, AsyncDataSource, AsyncRow, SqlPrimitive } from '../types.js'
  */
 
 /**
@@ -8,7 +8,7 @@
  * @param {Record<string, SqlPrimitive>} obj - the plain object
  * @returns {AsyncRow} a row accessor interface
  */
-function asyncRow(obj) {
+export function asyncRow(obj) {
   /** @type {AsyncCells} */
   const cells = {}
   for (const [key, value] of Object.entries(obj)) {

package/src/expression/evaluate.js

@@ -2,13 +2,14 @@ import { executeSelect } from '../execute/execute.js'
 import { stringify } from '../execute/utils.js'
 import { columnNotFoundError, invalidContextError } from '../executionErrors.js'
 import { unknownFunctionError } from '../parseErrors.js'
-import { isAggregateFunc, isMathFunc, isRegexpFunc, isStringFunc } from '../validation.js'
+import { isAggregateFunc, isMathFunc, isRegexpFunc, isSpatialFunc, isStringFunc } from '../validation.js'
 import { aggregateError, argValueError, castError } from '../validationErrors.js'
 import { derivedAlias } from './alias.js'
 import { applyBinaryOp } from './binary.js'
 import { applyIntervalToDate } from './date.js'
 import { evaluateMathFunc } from './math.js'
 import { evaluateRegexpFunc } from './regexp.js'
+import { evaluateSpatialFunc } from './spatial.js'
 import { evaluateStringFunc } from './strings.js'
 
 /**
@@ -250,6 +251,10 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
       return evaluateMathFunc({ funcName, args })
     }
 
+    if (isSpatialFunc(funcName)) {
+      return evaluateSpatialFunc({ funcName, args })
+    }
+
     if (funcName === 'COALESCE') {
       // Short-circuit: evaluate args one at a time, return first non-null
       for (const arg of node.args) {
@@ -308,6 +313,32 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
       return result
     }
 
+    if (funcName === 'ARRAY_LENGTH' || funcName === 'CARDINALITY') {
+      const arr = args[0]
+      if (!Array.isArray(arr)) return null
+      return arr.length
+    }
+
+    if (funcName === 'ARRAY_POSITION') {
+      const [arr, target] = args
+      if (!Array.isArray(arr)) return null
+      const index = arr.indexOf(target)
+      return index === -1 ? null : index + 1
+    }
+
+    if (funcName === 'ARRAY_SORT') {
+      const arr = args[0]
+      if (!Array.isArray(arr)) return null
+      return [...arr].sort((a, b) => {
+        if (a == null && b == null) return 0
+        if (a == null) return 1
+        if (b == null) return -1
+        if (a < b) return -1
+        if (a > b) return 1
+        return 0
+      })
+    }
+
     if (funcName === 'JSON_VALUE' || funcName === 'JSON_QUERY') {
       let jsonArg = args[0]
       const pathArg = args[1]

package/src/expression/geometry.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Geometry types based on the GeoJSON specification (RFC 7946)
+ */
+export type Geometry =
+  | Point
+  | MultiPoint
+  | LineString
+  | MultiLineString
+  | Polygon
+  | MultiPolygon
+  | GeometryCollection
+
+/**
+ * Simple geometries that are not collections.
+ */
+export type SimpleGeometry = Point | LineString | Polygon
+
+/**
+ * Boundary relationship between two geometries.
+ */
+export type Relation = 'OUTSIDE' | 'BOUNDARY' | 'INSIDE'
+
+/**
+ * Position is an array of at least two numbers.
+ * The order should be [longitude, latitude] with optional properties (eg- altitude).
+ */
+export type Position = number[]
+
+export interface Point {
+  type: 'Point'
+  coordinates: Position
+}
+
+export interface MultiPoint {
+  type: 'MultiPoint'
+  coordinates: Position[]
+}
+
+export interface LineString {
+  type: 'LineString'
+  coordinates: Position[]
+}
+
+/**
+ * Each element is one LineString.
+ */
+export interface MultiLineString {
+  type: 'MultiLineString'
+  coordinates: Position[][]
+}
+
+/**
+ * Each element is a linear ring.
+ */
+export interface Polygon {
+  type: 'Polygon'
+  coordinates: Position[][]
+}
+
+/**
+ * Each element is one Polygon.
+ */
+export interface MultiPolygon {
+  type: 'MultiPolygon'
+  coordinates: Position[][][]
+}
+
+export interface GeometryCollection {
+  type: 'GeometryCollection'
+  geometries: Geometry[]
+}

package/src/expression/spatial.equality.js

@@ -0,0 +1,98 @@
+/**
+ * @import { SimpleGeometry } from './geometry.js'
+ */
+
+import { EPSILON, EPSILON_SQ, distSq } from './spatial.geometry.js'
+
+/**
+ * @param {SimpleGeometry} a
+ * @param {SimpleGeometry} b
+ * @returns {boolean}
+ */
+export function simpleGeomEqual(a, b) {
+  if (a.type === 'Point' && b.type === 'Point') {
+    return distSq(a.coordinates, b.coordinates) < EPSILON_SQ
+  } else if (a.type === 'LineString' && b.type === 'LineString') {
+    return lineEqual(a.coordinates, b.coordinates)
+  } else if (a.type === 'Polygon' && b.type === 'Polygon') {
+    return polygonEqual(a.coordinates, b.coordinates)
+  }
+  return false
+}
+
+/**
+ * @param {number[][]} a
+ * @param {number[][]} b
+ * @returns {boolean}
+ */
+export function lineEqual(a, b) {
+  if (a.length !== b.length) return false
+  // Forward
+  let forward = true
+  for (let i = 0; i < a.length; i++) {
+    if (Math.abs(a[i][0] - b[i][0]) > EPSILON || Math.abs(a[i][1] - b[i][1]) > EPSILON) {
+      forward = false
+      break
+    }
+  }
+  if (forward) return true
+  // Reverse
+  for (let i = 0; i < a.length; i++) {
+    if (Math.abs(a[i][0] - b[a.length - 1 - i][0]) > EPSILON || Math.abs(a[i][1] - b[a.length - 1 - i][1]) > EPSILON) {
+      return false
+    }
+  }
+  return true
+}
+
+/**
+ * @param {number[][][]} a
+ * @param {number[][][]} b
+ * @returns {boolean}
+ */
+export function polygonEqual(a, b) {
+  if (a.length !== b.length) return false
+  for (let i = 0; i < a.length; i++) {
+    if (!ringsEqual(a[i], b[i])) return false
+  }
+  return true
+}
+
+/**
+ * Test if two rings are equal (same vertices, possibly different starting point).
+ *
+ * @param {number[][]} ring1
+ * @param {number[][]} ring2
+ * @returns {boolean}
+ */
+export function ringsEqual(ring1, ring2) {
+  if (ring1.length !== ring2.length) return false
+  // Try every rotation
+  const n = ring1.length - 1 // closed ring, last = first
+  for (let offset = 0; offset < n; offset++) {
+    let match = true
+    for (let i = 0; i < n; i++) {
+      const j = (i + offset) % n
+      if (Math.abs(ring1[i][0] - ring2[j][0]) > EPSILON ||
+          Math.abs(ring1[i][1] - ring2[j][1]) > EPSILON) {
+        match = false
+        break
+      }
+    }
+    if (match) return true
+  }
+  // Try reverse direction
+  for (let offset = 0; offset < n; offset++) {
+    let match = true
+    for (let i = 0; i < n; i++) {
+      const j = (n - i + offset) % n
+      if (Math.abs(ring1[i][0] - ring2[j][0]) > EPSILON ||
+          Math.abs(ring1[i][1] - ring2[j][1]) > EPSILON) {
+        match = false
+        break
+      }
+    }
+    if (match) return true
+  }
+  return false
+}