squirreling 0.4.7 → 0.5.0

package/README.md

@@ -76,5 +76,6 @@ console.log(allUsers)
 - `GROUP BY` and `HAVING` clauses
 - Aggregate functions: `COUNT`, `SUM`, `AVG`, `MIN`, `MAX`, `JSON_ARRAYAGG`
 - String functions: `CONCAT`, `SUBSTRING`, `LENGTH`, `UPPER`, `LOWER`
+- Date functions: `CURRENT_DATE`, `CURRENT_TIME`, `CURRENT_TIMESTAMP`, `INTERVAL`
 - Json functions: `JSON_VALUE`, `JSON_QUERY`, `JSON_OBJECT`
 - Basic expressions and arithmetic operations

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squirreling",
-  "version": "0.4.7",
+  "version": "0.5.0",
   "description": "Squirreling SQL Engine",
   "author": "Hyperparam",
   "homepage": "https://hyperparam.app",
@@ -37,10 +37,10 @@
     "test": "vitest run"
   },
   "devDependencies": {
-    "@types/node": "24.10.1",
+    "@types/node": "24.10.2",
     "@vitest/coverage-v8": "4.0.15",
     "eslint": "9.39.1",
-    "eslint-plugin-jsdoc": "61.4.1",
+    "eslint-plugin-jsdoc": "61.5.0",
     "typescript": "5.9.3",
     "vitest": "4.0.15"
   }

package/src/execute/aggregates.js

@@ -1,3 +1,5 @@
+import { unknownFunctionError } from '../parseErrors.js'
+import { aggregateError } from '../validationErrors.js'
 import { evaluateExpr } from './expression.js'
 import { defaultDerivedAlias, stringify } from './utils.js'
 
@@ -20,7 +22,7 @@ export async function evaluateAggregate({ col, rows, tables }) {
       const seen = new Set()
       for (const row of rows) {
         const v = await evaluateExpr({ node: arg.expr, row, tables })
-        if (v !== null && v !== undefined) {
+        if (v != null) {
           seen.add(v)
         }
       }
@@ -29,7 +31,7 @@ export async function evaluateAggregate({ col, rows, tables }) {
     let count = 0
     for (const row of rows) {
       const v = await evaluateExpr({ node: arg.expr, row, tables })
-      if (v !== null && v !== undefined) {
+      if (v != null) {
         count += 1
       }
     }
@@ -38,7 +40,7 @@ export async function evaluateAggregate({ col, rows, tables }) {
 
   if (func === 'SUM' || func === 'AVG' || func === 'MIN' || func === 'MAX') {
     if (arg.kind === 'star') {
-      throw new Error(func + '(*) is not supported, use a column name')
+      throw aggregateError({ funcName: func, issue: '(*) is not supported, use a column name' })
     }
     let sum = 0
     let count = 0
@@ -72,7 +74,7 @@ export async function evaluateAggregate({ col, rows, tables }) {
 
   if (func === 'JSON_ARRAYAGG') {
     if (arg.kind === 'star') {
-      throw new Error('JSON_ARRAYAGG(*) is not supported, use a column name or expression')
+      throw aggregateError({ funcName: 'JSON_ARRAYAGG', issue: '(*) is not supported, use a column name or expression' })
     }
     /** @type {SqlPrimitive[]} */
     const values = []
@@ -95,7 +97,12 @@ export async function evaluateAggregate({ col, rows, tables }) {
     return values
   }
 
-  throw new Error('Unsupported aggregate function ' + func)
+  throw unknownFunctionError({
+    funcName: func,
+    positionStart: 0,
+    positionEnd: 0,
+    validFunctions: 'COUNT, SUM, AVG, MIN, MAX, JSON_ARRAYAGG',
+  })
 }
 
 /**

package/src/execute/date.js

@@ -0,0 +1,57 @@
+/**
+ * @import { SqlPrimitive, IntervalUnit } from '../types.js'
+ */
+
+/**
+ * @param {SqlPrimitive} val
+ * @returns {Date | null}
+ */
+function toDate(val) {
+  if (val instanceof Date) return val
+  const dateOrTime = /^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2})?/
+  if (typeof val === 'string' && dateOrTime.test(val)) {
+    const date = new Date(val)
+    if (!isNaN(date.getTime())) {
+      return date
+    }
+  }
+  return null
+}
+
+/**
+ * Apply an interval to a date
+ * @param {SqlPrimitive} dateVal
+ * @param {number} value
+ * @param {IntervalUnit} unit
+ * @param {'+' | '-'} op
+ * @returns {string | null}
+ */
+export function applyIntervalToDate(dateVal, value, unit, op) {
+  const date = toDate(dateVal)
+  if (date == null) return null
+
+  const multiplier = op === '+' ? 1 : -1
+  const adjusted = value * multiplier
+
+  if (unit === 'SECOND') {
+    date.setUTCSeconds(date.getUTCSeconds() + adjusted)
+  } else if (unit === 'MINUTE') {
+    date.setUTCMinutes(date.getUTCMinutes() + adjusted)
+  } else if (unit === 'HOUR') {
+    date.setUTCHours(date.getUTCHours() + adjusted)
+  } else if (unit === 'DAY') {
+    date.setUTCDate(date.getUTCDate() + adjusted)
+  } else if (unit === 'MONTH') {
+    date.setUTCMonth(date.getUTCMonth() + adjusted)
+  } else if (unit === 'YEAR') {
+    date.setUTCFullYear(date.getUTCFullYear() + adjusted)
+  }
+
+  // Return in same format as input
+  if (dateVal instanceof Date) return date.toISOString()
+  if (String(dateVal).includes('T')) {
+    return date.toISOString()
+  } else {
+    return date.toISOString().split('T')[0]
+  }
+}

package/src/execute/execute.js

@@ -1,3 +1,5 @@
+import { missingClauseError } from '../parseErrors.js'
+import { tableNotFoundError, unsupportedOperationError } from '../executionErrors.js'
 import { generatorSource, memorySource } from '../backend/dataSource.js'
 import { parseSql } from '../parse/parse.js'
 import { defaultAggregateAlias, evaluateAggregate } from './aggregates.js'
@@ -22,7 +24,10 @@ export async function* executeSql({ tables, query }) {
 
   // Check for unsupported operations
   if (!select.from) {
-    throw new Error('FROM clause is required')
+    throw missingClauseError({
+      missing: 'FROM clause',
+      context: 'SELECT statement',
+    })
   }
 
   // Normalize tables: convert arrays to AsyncDataSource
@@ -57,7 +62,7 @@ export async function* executeSelect(select, tables) {
     fromTableName = select.from.alias ?? select.from.table
     dataSource = tables[select.from.table]
     if (dataSource === undefined) {
-      throw new Error(`Table "${select.from.table}" not found`)
+      throw tableNotFoundError({ tableName: select.from.table })
     }
   } else {
     // Nested subquery - recursively resolve
@@ -232,6 +237,7 @@ async function* evaluateSelectAst(select, dataSource, tables) {
 async function* evaluateStreaming(select, dataSource, tables) {
   let rowsYielded = 0
   let rowsSkipped = 0
+  let rowIndex = 0
   const offset = select.offset ?? 0
   const limit = select.limit ?? Infinity
   if (limit <= 0) return
@@ -250,9 +256,10 @@ async function* evaluateStreaming(select, dataSource, tables) {
   }
 
   for await (const row of dataSource.getRows(hints)) {
+    rowIndex++
     // WHERE filter
     if (select.where) {
-      const pass = await evaluateExpr({ node: select.where, row, tables })
+      const pass = await evaluateExpr({ node: select.where, row, tables, rowIndex })
       if (!pass) continue
     }
 
@@ -265,6 +272,7 @@ async function* evaluateStreaming(select, dataSource, tables) {
     // SELECT projection
     /** @type {AsyncRow} */
     const outRow = {}
+    const currentRowIndex = rowIndex
     for (const col of select.columns) {
       if (col.kind === 'star') {
         for (const [key, cell] of Object.entries(row)) {
@@ -272,7 +280,7 @@ async function* evaluateStreaming(select, dataSource, tables) {
         }
       } else if (col.kind === 'derived') {
         const alias = col.alias ?? defaultDerivedAlias(col.expr)
-        outRow[alias] = () => evaluateExpr({ node: col.expr, row, tables })
+        outRow[alias] = () => evaluateExpr({ node: col.expr, row, tables, rowIndex: currentRowIndex })
       } else if (col.kind === 'aggregate') {
         throw new Error(
           'Aggregate functions require GROUP BY or will act on the whole dataset; add GROUP BY or remove aggregates'
@@ -330,9 +338,11 @@ async function* evaluateBuffered(select, dataSource, tables, hasAggregate, useGr
   /** @type {AsyncRow[]} */
   const filtered = []
 
-  for (const row of working) {
+  for (let i = 0; i < working.length; i++) {
+    const row = working[i]
+    const rowIndex = i + 1 // 1-based
     if (select.where) {
-      const passes = await evaluateExpr({ node: select.where, row, tables })
+      const passes = await evaluateExpr({ node: select.where, row, tables, rowIndex })
 
       if (!passes) {
         continue
@@ -375,7 +385,10 @@ async function* evaluateBuffered(select, dataSource, tables, hasAggregate, useGr
 
     const hasStar = select.columns.some(col => col.kind === 'star')
     if (hasStar && hasAggregate) {
-      throw new Error('SELECT * with aggregate functions is not supported in this implementation')
+      throw unsupportedOperationError({
+        operation: 'SELECT * with aggregate functions is not supported',
+        hint: 'Replace * with specific column names when using aggregate functions.',
+      })
     }
 
     for (const group of groups) {