squirreling 0.12.18 → 0.12.20

package/README.md

@@ -161,7 +161,7 @@ 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`, `DATE_DIFF`, `DATEDIFF`, `DATE_PART`, `DATE_TRUNC`, `EPOCH`, `EXTRACT`, `INTERVAL`
 - Json: `JSON_VALUE`, `JSON_QUERY`, `JSON_EXTRACT`, `JSON_OBJECT`, `JSON_ARRAY_LENGTH`, `JSON_VALID`, `JSON_TYPE`
-- Array: `ARRAY_LENGTH`, `ARRAY_POSITION`, `ARRAY_CONTAINS`, `ARRAY_SORT`, `CARDINALITY`, `SIZE`
+- Array: `ARRAY_LENGTH`, `ARRAY_POSITION`, `ARRAY_CONTAINS`, `ARRAY_SORT`, `ARRAY_APPEND`, `ARRAY_CONCAT`, `LEN`, `CARDINALITY`, `SIZE`
 - Table functions: `UNNEST`, `EXPLODE`, `JSON_EACH`
 - Regex: `REGEXP_SUBSTR`, `REGEXP_EXTRACT`, `REGEXP_REPLACE`, `REGEXP_MATCHES`
 - 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`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squirreling",
-  "version": "0.12.18",
+  "version": "0.12.20",
   "description": "Squirreling Async SQL Engine",
   "author": "Hyperparam",
   "homepage": "https://hyperparam.app",
@@ -39,11 +39,11 @@
     "test": "vitest run"
   },
   "devDependencies": {
-    "@types/node": "25.6.0",
-    "@vitest/coverage-v8": "4.1.5",
+    "@types/node": "25.8.0",
+    "@vitest/coverage-v8": "4.1.6",
     "eslint": "9.39.4",
     "eslint-plugin-jsdoc": "62.9.0",
     "typescript": "6.0.3",
-    "vitest": "4.1.5"
+    "vitest": "4.1.6"
   }
 }

package/src/ast.d.ts

@@ -12,7 +12,7 @@ export interface SelectStatement extends AstBase {
   type: 'select'
   distinct: boolean
   columns: SelectColumn[]
-  from: FromTable | FromSubquery | FromFunction
+  from?: FromTable | FromSubquery | FromFunction
   joins: JoinClause[]
   where?: ExprNode
   groupBy: ExprNode[]

package/src/execute/execute.js

@@ -83,6 +83,8 @@ export function executeStatement({ query, context, outerScope }) {
 export function executePlan({ plan, context }) {
   if (plan.type === 'Scan') {
     return executeScan(plan, context)
+  } else if (plan.type === 'SingleRow') {
+    return executeSingleRow()
   } else if (plan.type === 'Count') {
     return executeCount(plan, context)
   } else if (plan.type === 'Filter') {
@@ -117,6 +119,23 @@ export function executePlan({ plan, context }) {
   return { columns: [], async *rows() {} }
 }
 
+/**
+ * Yields exactly one empty row. Used for FROM-less SELECT like `SELECT 1`,
+ * where the projection produces the output from constant expressions.
+ *
+ * @returns {QueryResults}
+ */
+function executeSingleRow() {
+  return {
+    columns: [],
+    numRows: 1,
+    maxRows: 1,
+    async *rows() {
+      yield { columns: [], cells: {} }
+    },
+  }
+}
+
 /**
  * Executes a table-valued function (e.g. UNNEST, JSON_EACH).
  * Evaluates the argument once against the outer row (for lateral joins) or an

package/src/execute/utils.js

@@ -27,7 +27,11 @@ export function compareForTerm(a, b, term) {
   if (a == b) return 0
 
   let cmp
-  if (primitiveTypes.has(typeof a) && primitiveTypes.has(typeof b)) {
+  if (a instanceof Date && b instanceof Date) {
+    const at = a.getTime()
+    const bt = b.getTime()
+    cmp = at < bt ? -1 : at > bt ? 1 : 0
+  } else if (primitiveTypes.has(typeof a) && primitiveTypes.has(typeof b)) {
     cmp = a < b ? -1 : 1
   } else {
     const aa = String(a)
@@ -121,6 +125,19 @@ export function maxBounds(a, b) {
   return a ?? b
 }
 
+/**
+ * SQL equality for primitives. Two Date instances for the same instant compare
+ * equal (JS `==` would compare by identity).
+ *
+ * @param {SqlPrimitive} a
+ * @param {SqlPrimitive} b
+ * @returns {boolean}
+ */
+export function sqlEquals(a, b) {
+  if (a instanceof Date && b instanceof Date) return a.getTime() === b.getTime()
+  return a == b
+}
+
 /**
  * Returns true for plain object SqlPrimitive values, excluding null, arrays, and Dates.
  *

package/src/expression/binary.js

@@ -29,6 +29,18 @@ export function applyBinaryOp(op, a, b) {
   }
   if (op === 'AND') return Boolean(a) && Boolean(b)
   if (op === 'OR') return Boolean(a) || Boolean(b)
+  // Compare Date values by their time so distinct instances for the same
+  // instant are equal, matching SQL TIMESTAMP semantics rather than JS identity.
+  if (a instanceof Date && b instanceof Date) {
+    const at = a.getTime()
+    const bt = b.getTime()
+    if (op === '!=' || op === '<>') return at !== bt
+    if (op === '=' || op === '==') return at === bt
+    if (op === '<') return at < bt
+    if (op === '<=') return at <= bt
+    if (op === '>') return at > bt
+    if (op === '>=') return at >= bt
+  }
   if (op === '!=' || op === '<>') return a != b
   if (op === '=' || op === '==') return a == b
   if (op === '<') return a < b

package/src/expression/evaluate.js

@@ -1,5 +1,5 @@
 import { executeStatement } from '../execute/execute.js'
-import { isPlainObject, keyify, stringify } from '../execute/utils.js'
+import { isPlainObject, keyify, sqlEquals, stringify } from '../execute/utils.js'
 import { ArgValueError, ExecutionError } from '../validation/executionErrors.js'
 import { isAggregateFunc, isMathFunc, isRegexpFunc, isSpatialFunc, isStringFunc } from '../validation/functions.js'
 import { UnknownFunctionError } from '../validation/parseErrors.js'
@@ -516,7 +516,7 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
       return arr.length
     }
 
-    if (funcName === 'ARRAY_LENGTH' || funcName === 'CARDINALITY' || funcName === 'SIZE') {
+    if (funcName === 'ARRAY_LENGTH' || funcName === 'LIST_LENGTH' || funcName === 'LEN' || funcName === 'CARDINALITY' || funcName === 'SIZE') {
       const arr = args[0]
       if (!Array.isArray(arr)) return null
       if (funcName === 'ARRAY_LENGTH' && args.length === 2) {
@@ -539,19 +539,31 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
       return arr.length
     }
 
-    if (funcName === 'ARRAY_POSITION') {
+    if (funcName === 'ARRAY_POSITION' || funcName === 'LIST_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_CONTAINS') {
+    if (funcName === 'ARRAY_CONTAINS' || funcName === 'LIST_CONTAINS') {
       const [arr, target] = args
       if (!Array.isArray(arr)) return null
       return arr.includes(target)
     }
 
+    if (funcName === 'ARRAY_APPEND' || funcName === 'LIST_APPEND') {
+      const [arr, element] = args
+      if (!Array.isArray(arr)) return null
+      return [...arr, element]
+    }
+
+    if (funcName === 'ARRAY_CONCAT' || funcName === 'LIST_CONCAT') {
+      const [a, b] = args
+      if (!Array.isArray(a) || !Array.isArray(b)) return null
+      return [...a, ...b]
+    }
+
     if (funcName === 'ARRAY_SORT') {
       const arr = args[0]
       if (!Array.isArray(arr)) return null
@@ -667,7 +679,7 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
     const exprVal = await evaluateExpr({ node: node.expr, row, rowIndex, rows, context })
     for (const valueNode of node.values) {
       const val = await evaluateExpr({ node: valueNode, row, rowIndex, rows, context })
-      if (exprVal == val) return true
+      if (sqlEquals(exprVal, val)) return true
     }
     return false
   }
@@ -677,7 +689,7 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
     const subResult = executeStatement({ query: node.subquery, context })
     for await (const resRow of subResult.rows()) {
       const value = await resRow.cells[resRow.columns[0]]()
-      if (exprVal == value) return true
+      if (sqlEquals(exprVal, value)) return true
     }
     return false
   }
@@ -703,7 +715,7 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
     for (const whenClause of node.whenClauses) {
       const whenValue = await evaluateExpr({ node: whenClause.condition, row, rowIndex, rows, context })
       // compare caseValue with condition or evaluate as boolean
-      if (caseValue !== undefined ? caseValue == whenValue : whenValue) {
+      if (caseValue !== undefined ? sqlEquals(caseValue, whenValue) : whenValue) {
         return evaluateExpr({ node: whenClause.result, row, rowIndex, rows, context })
       }
     }

package/src/parse/extractTables.js

@@ -7,7 +7,7 @@
  * parsed statement, including those inside subqueries (IN, EXISTS, derived
  * tables, scalar subqueries) and the branches of compound (UNION /
  * INTERSECT / EXCEPT) queries. CTE names defined by an enclosing WITH are
- * skipped, including across sibling CTEs and nested WITHs — the result is
+ * skipped, including across sibling CTEs and nested WITHs. The result is
  * the set of names a caller would need to provide as `tables` to
  * `executeSql`.
  *
@@ -47,7 +47,9 @@ function walkStatement(stmt, cteScope, refs) {
     return
   }
   // select
-  if (stmt.from.type === 'table') {
+  if (!stmt.from) {
+    // FROM-less SELECT (e.g. `SELECT 1`), no source tables
+  } else if (stmt.from.type === 'table') {
     if (!cteScope.has(stmt.from.table.toLowerCase())) refs.add(stmt.from.table)
   } else if (stmt.from.type === 'subquery') {
     walkStatement(stmt.from.query, cteScope, refs)

package/src/parse/joins.js

@@ -6,7 +6,7 @@ import { isTableFunctionStart, parseFromFunction, parseTableAlias, tableFunction
 import { consume, current, expect, match } from './state.js'
 
 /**
- * @import { ExprNode, JoinClause, JoinType, ParserState } from '../types.js'
+ * @import { ExprNode, FromFunction, JoinClause, JoinType, ParserState } from '../types.js'
  */
 
 /**
@@ -80,7 +80,7 @@ export function parseJoins(state) {
         })
       }
 
-      /** @type {import('../ast.js').FromFunction} */
+      /** @type {FromFunction} */
       const fromFunction = {
         type: 'function',
         funcName,

package/src/parse/parse.js

@@ -12,6 +12,13 @@ import { tokenizeSql } from './tokenize.js'
  * @import { CTEDefinition, ExprNode, FromFunction, FromSubquery, FromTable, OrderByItem, ParseSqlOptions, ParserState, SelectColumn, SelectStatement, SetOperationStatement, SetOperator, Statement } from '../types.js'
  */
 
+// Keywords that may legitimately follow the SELECT column list in place of FROM.
+// Anything else is a hint that the user forgot the FROM keyword.
+const CONTINUATION_KEYWORDS = new Set([
+  'WHERE', 'GROUP', 'HAVING', 'ORDER', 'LIMIT', 'OFFSET',
+  'UNION', 'INTERSECT', 'EXCEPT',
+])
+
 /**
  * @param {ParseSqlOptions} options
  * @returns {Statement}
@@ -176,20 +183,38 @@ function parseSelect(state) {
   let distinct = false
 
   // Support duckdb-style shorthand "FROM table"
+  let hasFrom = true
   if (match(state, 'keyword', 'FROM')) {
     columns = [{ type: 'star', positionStart, positionEnd: positionStart }]
   } else {
     expect(state, 'keyword', 'SELECT')
     distinct = match(state, 'keyword', 'DISTINCT')
     columns = parseSelectList(state)
-    expect(state, 'keyword', 'FROM')
+    hasFrom = !!match(state, 'keyword', 'FROM')
+    // After the column list, if FROM is missing and the next token isn't a
+    // valid continuation (clause keyword, set operator, terminator), the user
+    // likely forgot a FROM keyword. Report that rather than letting parsing
+    // throw a less-specific end-of-query error.
+    if (!hasFrom) {
+      const tok = current(state)
+      const isContinuation = tok.type === 'eof' ||
+        tok.type === 'semicolon' ||
+        tok.type === 'paren' && tok.value === ')' ||
+        tok.type === 'keyword' && CONTINUATION_KEYWORDS.has(tok.value)
+      if (!isContinuation) {
+        throw parseError(state, 'FROM')
+      }
+    }
   }
 
   // Check if it's a subquery, table function, or table name
-  /** @type {FromTable | FromSubquery | FromFunction} */
+  /** @type {FromTable | FromSubquery | FromFunction | undefined} */
   let from
   const fromTok = current(state)
-  if (fromTok.type === 'paren' && fromTok.value === '(') {
+  if (!hasFrom) {
+    // No FROM clause: constant SELECT like "SELECT 1"
+    from = undefined
+  } else if (fromTok.type === 'paren' && fromTok.value === '(') {
     // Subquery: SELECT * FROM (SELECT ...) AS alias
     expect(state, 'paren', '(')
     const query = parseStatement(state)

package/src/parse/tokenize.js

@@ -2,7 +2,7 @@ import { KEYWORDS } from '../validation/keywords.js'
 import { InvalidLiteralError, ParseError, UnexpectedCharError } from '../validation/parseErrors.js'
 
 /**
- * @import { Token } from '../types.d.ts'
+ * @import { Token } from '../types.js'
  */
 
 const NUMBER_REGEX = /^-?(?:\d+n|(?:\d+\.?\d*|\d*\.\d+)(?:[eE][+-]?\d+)?)/

package/src/plan/columns.js

@@ -6,10 +6,11 @@ import { derivedAlias } from '../expression/alias.js'
  */
 
 /**
- * @param {FromTable | FromSubquery | FromFunction} from
- * @returns {string}
+ * @param {FromTable | FromSubquery | FromFunction | undefined} from
+ * @returns {string | undefined}
  */
 export function fromAlias(from) {
+  if (!from) return undefined
   if (from.alias) return from.alias
   if (from.type === 'table') return from.table
   if (from.type === 'function') return from.funcName.toLowerCase()
@@ -31,7 +32,9 @@ export function fromAlias(from) {
 export function statementScope(stmt) {
   if (stmt.type === 'with') return statementScope(stmt.query)
   if (stmt.type === 'compound') return undefined
-  return [fromAlias(stmt.from), ...stmt.joins.map(j => j.alias ?? j.table)]
+  const alias = fromAlias(stmt.from)
+  const joins = stmt.joins.map(j => j.alias ?? j.table)
+  return alias === undefined ? joins : [alias, ...joins]
 }
 
 /**
@@ -64,7 +67,10 @@ export function extractColumns({ select, parentColumns }) {
   const result = new Map()
 
   // Build alias list from FROM + JOINs
-  const aliases = [fromAlias(select.from)]
+  /** @type {string[]} */
+  const aliases = []
+  const sourceAlias = fromAlias(select.from)
+  if (sourceAlias !== undefined) aliases.push(sourceAlias)
   for (const join of select.joins) {
     aliases.push(join.alias ?? join.table)
   }
@@ -142,7 +148,9 @@ export function extractColumns({ select, parentColumns }) {
     collectColumnsFromExpr(expr, identifiers, selectAliases)
   }
   collectColumnsFromExpr(select.having, identifiers, selectAliases)
-  const visibleLateralAliases = [fromAlias(select.from)]
+  /** @type {string[]} */
+  const visibleLateralAliases = []
+  if (sourceAlias !== undefined) visibleLateralAliases.push(sourceAlias)
   for (const join of select.joins) {
     collectColumnsFromExpr(join.on, identifiers)
     const joinAlias = join.alias ?? join.table
@@ -298,7 +306,7 @@ function collectColumnsFromStatement(stmt, columns) {
     if (col.type === 'derived') collectColumnsFromExpr(col.expr, columns)
   }
   collectColumnsFromExpr(stmt.where, columns)
-  if (stmt.from?.type === 'subquery') {
+  if (stmt.from && stmt.from.type === 'subquery') {
     collectColumnsFromStatement(stmt.from.query, columns)
   }
   for (const join of stmt.joins) {
@@ -384,6 +392,7 @@ export function inferStatementColumns({ stmt, cteColumns, tables }) {
  * @returns {string[]}
  */
 export function inferSelectSourceColumns({ select, cteColumns, tables }) {
+  if (!select.from) return []
   if (select.from.type === 'subquery') {
     return inferStatementColumns({ stmt: select.from.query, cteColumns, tables })
   }

package/src/plan/plan.js

@@ -7,8 +7,8 @@ import { validateNoIdentifiers, validateScan, validateTableRefs } from '../valid
 import { collectScopeColumns, extractColumns, fromAlias, inferSelectSourceColumns, inferStatementColumns, statementScope, tableFunctionColumnNames } from './columns.js'
 
 /**
- * @import { AsyncDataSource, ExprNode, DerivedColumn, IdentifierNode, JoinClause, OrderByItem, PlanSqlOptions, ScanOptions, SelectColumn, SelectStatement, SetOperationStatement, Statement, WindowFunctionNode } from '../types.js'
- * @import { QueryPlan, WindowSpec } from './types.d.ts'
+ * @import { AsyncDataSource, DerivedColumn, ExprNode, FromFunction, IdentifierNode, JoinClause, OrderByItem, PlanSqlOptions, ScanOptions, SelectColumn, SelectStatement, SetOperationStatement, Statement, WindowFunctionNode } from '../types.js'
+ * @import { HashJoinNode, QueryPlan, TableFunctionNode, WindowSpec } from './types.js'
  */
 
 /**
@@ -153,12 +153,17 @@ function planSelect({ select, ctePlans, cteColumns, tables, parentColumns, outer
   const bufferingWindows = windows.some(w => w.partitionBy.length > 0 || w.orderBy.length > 0)
   const needsBuffering = useGrouping || select.orderBy.length > 0 || bufferingWindows
 
-  // Source alias for FROM clause
+  // Source alias for FROM clause (undefined for FROM-less SELECT)
   const sourceAlias = fromAlias(select.from)
 
   // Resolve aliases (and validate qualified references)
   // Include outerScope aliases so correlated references pass validation
-  const scopeTables = Object.fromEntries([sourceAlias, ...select.joins.map(j => j.alias ?? j.table), ...outerScope ?? []].map(a => [a, true]))
+  const scopeAliases = [
+    ...sourceAlias !== undefined ? [sourceAlias] : [],
+    ...select.joins.map(j => j.alias ?? j.table),
+    ...outerScope ?? [],
+  ]
+  const scopeTables = Object.fromEntries(scopeAliases.map(a => [a, true]))
   // Bare column names in scope, so the validator can recognize struct-field
   // dot access on a column (e.g. `item.name` where `item` is an unnested
   // struct column) rather than rejecting `item` as an unknown table.
@@ -201,10 +206,10 @@ function planSelect({ select, ctePlans, cteColumns, tables, parentColumns, outer
   /** @type {ScanOptions} */
   const hints = {}
   const perTableColumns = extractColumns({ select: originalSelect, parentColumns })
-  hints.columns = perTableColumns.get(sourceAlias)
+  if (sourceAlias !== undefined) hints.columns = perTableColumns.get(sourceAlias)
   // Empty columns array means no columns were referenced, but a FROM subquery
   // still needs its own columns (e.g. for DISTINCT). Treat empty as unrestricted.
-  if (hints.columns?.length === 0 && select.from.type === 'subquery') {
+  if (hints.columns?.length === 0 && select.from?.type === 'subquery') {
     hints.columns = undefined
   }
   if (!select.joins.length) {
@@ -334,6 +339,9 @@ function planSelect({ select, ctePlans, cteColumns, tables, parentColumns, outer
  * @returns {QueryPlan}
  */
 function planFrom({ select, ctePlans, cteColumns, hints, tables, outerScope }) {
+  if (!select.from) {
+    return { type: 'SingleRow' }
+  }
   if (select.from.type === 'table') {
     const ctePlan = ctePlans?.get(select.from.table.toLowerCase())
     if (ctePlan) {
@@ -378,8 +386,8 @@ function planFrom({ select, ctePlans, cteColumns, hints, tables, outerScope }) {
 /**
  * Builds a TableFunction plan node for a FromFunction AST.
  *
- * @param {import('../types.js').FromFunction} from
- * @returns {import('./types.d.ts').TableFunctionNode}
+ * @param {FromFunction} from
+ * @returns {TableFunctionNode}
  */
 function planTableFunction(from) {
   return {
@@ -457,7 +465,7 @@ function planJoin({ left, joins, leftTable, ctePlans, cteColumns, perTableColumn
     } else {
       const keys = join.on && extractEquiKeys({ condition: join.on, leftTable: currentLeftTable, rightTable })
       if (keys) {
-        /** @type {import('./types.d.ts').HashJoinNode} */
+        /** @type {HashJoinNode} */
         const hashJoin = {
           type: 'HashJoin',
           joinType: join.joinType,

package/src/plan/types.d.ts

@@ -2,6 +2,7 @@ import { DerivedColumn, ExprNode, JoinType, OrderByItem, ScanOptions, SelectColu
 
 export type QueryPlan =
   | ScanNode
+  | SingleRowNode
   | CountNode
   | FilterNode
   | ProjectNode
@@ -25,6 +26,11 @@ export interface ScanNode {
   hints: ScanOptions
 }
 
+// Source for FROM-less SELECT like `SELECT 1`. Yields exactly one empty row.
+export interface SingleRowNode {
+  type: 'SingleRow'
+}
+
 // Count node for COUNT(*) optimization
 export interface CountNode {
   type: 'Count'

package/src/validation/functions.js

@@ -184,9 +184,17 @@ export const FUNCTION_SIGNATURES = {
 
   // Array functions
   ARRAY_LENGTH: { min: 1, max: 2, signature: 'array[, dimension]' },
+  LIST_LENGTH: { min: 1, max: 1, signature: 'array' },
+  LEN: { min: 1, max: 1, signature: 'array' },
   ARRAY_POSITION: { min: 2, max: 2, signature: 'array, element' },
+  LIST_POSITION: { min: 2, max: 2, signature: 'array, element' },
   ARRAY_CONTAINS: { min: 2, max: 2, signature: 'array, element' },
+  LIST_CONTAINS: { min: 2, max: 2, signature: 'array, element' },
   ARRAY_SORT: { min: 1, max: 1, signature: 'array' },
+  ARRAY_APPEND: { min: 2, max: 2, signature: 'array, element' },
+  LIST_APPEND: { min: 2, max: 2, signature: 'array, element' },
+  ARRAY_CONCAT: { min: 2, max: 2, signature: 'array1, array2' },
+  LIST_CONCAT: { min: 2, max: 2, signature: 'array1, array2' },
   CARDINALITY: { min: 1, max: 1, signature: 'array' },
   SIZE: { min: 1, max: 1, signature: 'array' },