squirreling 0.9.3 → 0.9.5

package/README.md

@@ -147,7 +147,7 @@ Squirreling mostly follows the SQL standard. The following features are supporte
 - String: `CONCAT`, `SUBSTRING`, `REPLACE`, `LENGTH`, `UPPER`, `LOWER`, `TRIM`, `LEFT`, `RIGHT`, `INSTR`
 - Math: `ABS`, `SIGN`, `CEIL`, `FLOOR`, `ROUND`, `MOD`, `RAND`, `RANDOM`, `LN`, `LOG10`, `EXP`, `POWER`, `SQRT`
 - Trig: `SIN`, `COS`, `TAN`, `COT`, `ASIN`, `ACOS`, `ATAN`, `ATAN2`, `DEGREES`, `RADIANS`, `PI`
-- Date: `CURRENT_DATE`, `CURRENT_TIME`, `CURRENT_TIMESTAMP`, `INTERVAL`
+- Date: `CURRENT_DATE`, `CURRENT_TIME`, `CURRENT_TIMESTAMP`, `DATE_PART`, `DATE_TRUNC`, `EXTRACT`, `INTERVAL`
 - Json: `JSON_VALUE`, `JSON_QUERY`, `JSON_OBJECT`
 - Array: `ARRAY_LENGTH`, `ARRAY_POSITION`, `ARRAY_SORT`, `CARDINALITY`
 - Regex: `REGEXP_SUBSTR`, `REGEXP_REPLACE`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squirreling",
-  "version": "0.9.3",
+  "version": "0.9.5",
   "description": "Squirreling Async SQL Engine",
   "author": "Hyperparam",
   "homepage": "https://hyperparam.app",
@@ -37,7 +37,7 @@
     "test": "vitest run"
   },
   "devDependencies": {
-    "@types/node": "25.3.0",
+    "@types/node": "25.3.3",
     "@vitest/coverage-v8": "4.0.18",
     "eslint": "9.39.2",
     "eslint-plugin-jsdoc": "62.7.1",

package/src/expression/date.js

@@ -40,6 +40,66 @@ export function applyIntervalToDate(dateVal, value, unit, op) {
   }
 }
 
+/**
+ * Truncate a date to the given precision
+ * @param {SqlPrimitive} precision - the unit to truncate to (year, month, day, hour, minute, second)
+ * @param {SqlPrimitive} dateVal - the date value to truncate
+ * @returns {Date | string | null}
+ */
+export function dateTrunc(precision, dateVal) {
+  if (precision == null || dateVal == null) return null
+  const date = toDate(dateVal)
+  if (date == null) return null
+
+  const unit = String(precision).toUpperCase()
+  if (unit === 'YEAR') {
+    date.setUTCMonth(0, 1)
+    date.setUTCHours(0, 0, 0, 0)
+  } else if (unit === 'MONTH') {
+    date.setUTCDate(1)
+    date.setUTCHours(0, 0, 0, 0)
+  } else if (unit === 'DAY') {
+    date.setUTCHours(0, 0, 0, 0)
+  } else if (unit === 'HOUR') {
+    date.setUTCMinutes(0, 0, 0)
+  } else if (unit === 'MINUTE') {
+    date.setUTCSeconds(0, 0)
+  } else if (unit === 'SECOND') {
+    date.setUTCMilliseconds(0)
+  }
+
+  // Return in same format as input
+  if (dateVal instanceof Date) return date
+  if (String(dateVal).includes('T')) {
+    return date.toISOString()
+  } else {
+    return date.toISOString().split('T')[0]
+  }
+}
+
+/**
+ * Extract a field from a date value
+ * @param {SqlPrimitive} field - the field to extract (YEAR, MONTH, DAY, HOUR, MINUTE, SECOND, DOW, EPOCH)
+ * @param {SqlPrimitive} dateVal - the date value to extract from
+ * @returns {number | null}
+ */
+export function extractField(field, dateVal) {
+  if (field == null || dateVal == null) return null
+  const date = toDate(dateVal)
+  if (date == null) return null
+
+  const unit = String(field).toUpperCase()
+  if (unit === 'YEAR') return date.getUTCFullYear()
+  if (unit === 'MONTH') return date.getUTCMonth() + 1
+  if (unit === 'DAY') return date.getUTCDate()
+  if (unit === 'HOUR') return date.getUTCHours()
+  if (unit === 'MINUTE') return date.getUTCMinutes()
+  if (unit === 'SECOND') return date.getUTCSeconds()
+  if (unit === 'DOW') return date.getUTCDay()
+  if (unit === 'EPOCH') return date.getTime() / 1000
+  return null
+}
+
 /**
  * @param {SqlPrimitive} val
  * @returns {Date | null}

package/src/expression/evaluate.js

@@ -6,10 +6,10 @@ import { isAggregateFunc, isMathFunc, isRegexpFunc, isSpatialFunc, isStringFunc
 import { aggregateError, argValueError, castError } from '../validationErrors.js'
 import { derivedAlias } from './alias.js'
 import { applyBinaryOp } from './binary.js'
-import { applyIntervalToDate } from './date.js'
+import { applyIntervalToDate, dateTrunc, extractField } from './date.js'
 import { evaluateMathFunc } from './math.js'
 import { evaluateRegexpFunc } from './regexp.js'
-import { evaluateSpatialFunc } from './spatial.js'
+import { evaluateSpatialFunc } from '../spatial/spatial.js'
 import { evaluateStringFunc } from './strings.js'
 
 /**
@@ -271,6 +271,14 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
       return val1 == val2 ? null : val1
     }
 
+    if (funcName === 'DATE_TRUNC') {
+      return dateTrunc(args[0], args[1])
+    }
+
+    if (funcName === 'EXTRACT' || funcName === 'DATE_PART') {
+      return extractField(args[0], args[1])
+    }
+
     if (funcName === 'CURRENT_DATE') {
       return new Date().toISOString().split('T')[0]
     }

package/src/parse/expression.js

@@ -4,7 +4,7 @@ import {
   syntaxError,
   unknownFunctionError,
 } from '../parseErrors.js'
-import { isIntervalUnit, isKnownFunction } from '../validation.js'
+import { RESERVED_KEYWORDS, isExtractField, isIntervalUnit, isKnownFunction } from '../validation.js'
 import { parseComparison } from './comparison.js'
 import { parseFunctionCall } from './functions.js'
 import { parseSelectInternal } from './parse.js'
@@ -70,6 +70,36 @@ export function parsePrimary(state) {
       }
     }
 
+    // EXTRACT(field FROM expr)
+    if (tok.value === 'EXTRACT' && next.type === 'paren' && next.value === '(') {
+      consume(state) // EXTRACT
+      consume(state) // '('
+      const fieldTok = current(state)
+      const isValidType = fieldTok.type === 'keyword' || fieldTok.type === 'identifier'
+      if (!isValidType || !isExtractField(fieldTok.value)) {
+        throw syntaxError({
+          expected: 'extract field (YEAR, MONTH, DAY, HOUR, MINUTE, SECOND, DOW, EPOCH)',
+          received: `"${fieldTok.value}"`,
+          positionStart: fieldTok.positionStart,
+          positionEnd: fieldTok.positionEnd,
+        })
+      }
+      consume(state) // field
+      expect(state, 'keyword', 'FROM')
+      const expr = parseExpression(state)
+      expect(state, 'paren', ')')
+      return {
+        type: 'function',
+        name: 'EXTRACT',
+        args: [
+          { type: 'literal', value: fieldTok.value, positionStart: fieldTok.positionStart, positionEnd: fieldTok.positionEnd },
+          expr,
+        ],
+        positionStart,
+        positionEnd: state.lastPos,
+      }
+    }
+
     // function call
     if (next.type === 'paren' && next.value === '(') {
       const funcName = tok.value
@@ -220,6 +250,17 @@ export function parsePrimary(state) {
     if (tok.value === 'INTERVAL') {
       return parseInterval(state)
     }
+
+    // Non-reserved keywords can be used as identifiers (e.g. column aliases)
+    if (!RESERVED_KEYWORDS.has(tok.value)) {
+      consume(state)
+      return {
+        type: 'identifier',
+        name: tok.originalValue ?? tok.value,
+        positionStart,
+        positionEnd: state.lastPos,
+      }
+    }
   }
 
   if (tok.type === 'operator' && tok.value === '-') {

package/src/spatial/bbox.js

@@ -0,0 +1,53 @@
+/**
+ * @import { BBox, SimpleGeometry } from './geometry.js'
+ */
+
+export const EPSILON = 1e-10
+export const EPSILON_SQ = EPSILON * EPSILON
+
+/** @type {WeakMap<SimpleGeometry, BBox>} */
+const bboxCache = new WeakMap()
+
+/**
+ * Test whether two bounding boxes overlap.
+ *
+ * @param {SimpleGeometry} a
+ * @param {SimpleGeometry} b
+ * @returns {boolean}
+ */
+export function bboxOverlap(a, b) {
+  const aBox = bbox(a)
+  const bBox = bbox(b)
+  return aBox.minX <= bBox.maxX && aBox.maxX >= bBox.minX && aBox.minY <= bBox.maxY && aBox.maxY >= bBox.minY
+}
+
+/**
+ * Compute the axis-aligned bounding box of a simple geometry.
+ * Results are cached per geometry object.
+ *
+ * @param {SimpleGeometry} geom
+ * @returns {BBox}
+ */
+function bbox(geom) {
+  let b = bboxCache.get(geom)
+  if (b) return b
+  if (geom.type === 'Point') {
+    const [x, y] = geom.coordinates
+    b = { minX: x, minY: y, maxX: x, maxY: y }
+  } else {
+    /** @type {number[][]} */
+    const points = geom.type === 'LineString'
+      ? geom.coordinates
+      : geom.coordinates[0] // outer ring
+    let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity
+    for (const p of points) {
+      if (p[0] < minX) minX = p[0]
+      if (p[1] < minY) minY = p[1]
+      if (p[0] > maxX) maxX = p[0]
+      if (p[1] > maxY) maxY = p[1]
+    }
+    b = { minX, minY, maxX, maxY }
+  }
+  bboxCache.set(geom, b)
+  return b
+}

package/src/spatial/equality.js

@@ -0,0 +1,98 @@
+/**
+ * @import { SimpleGeometry } from './geometry.js'
+ */
+
+import { EPSILON, EPSILON_SQ, distSq } from './primitives.js'
+
+/**
+ * @param {SimpleGeometry} a
+ * @param {SimpleGeometry} b
+ * @returns {boolean}
+ */
+export function geometryEqual(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}
+ */
+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}
+ */
+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}
+ */
+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
+}

package/src/spatial/geometry.d.ts

@@ -0,0 +1,78 @@
+/**
+ * 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
+
+export interface BBox {
+  minX: number
+  minY: number
+  maxX: number
+  maxY: number
+}
+
+/**
+ * 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[]
+}