squirreling 0.12.27 → 0.14.0

package/README.md

@@ -146,7 +146,8 @@ Squirreling mostly follows the SQL standard. The following features are supporte
 - `JOIN` operations: `INNER JOIN`, `LEFT JOIN`, `RIGHT JOIN`, `FULL JOIN`, `CROSS JOIN`, `POSITIONAL JOIN`, `LATERAL VIEW [OUTER] EXPLODE(...)`, with `ON` or `USING (col, ...)` conditions
 - `GROUP BY` and `HAVING` clauses
 - Set operations: `UNION`, `UNION ALL`, `INTERSECT`, `INTERSECT ALL`, `EXCEPT`, `EXCEPT ALL`
-- Expressions: `CASE`, `CAST`, `BETWEEN`, `IN`, `LIKE`, `IS NULL`, `IS NOT NULL`
+- Expressions: `CASE`, `CAST`, `BETWEEN`, `IN`, `LIKE`, `IS NULL`, `IS NOT NULL`, string concatenation `||`
+- Subscript access: zero-based array indexing `col[0]`, struct field access `col['field']`, and chains like `col[0].field`
 
 ### Quoting
 
@@ -158,7 +159,7 @@ Squirreling mostly follows the SQL standard. The following features are supporte
 
 - Aggregate: `COUNT`, `COUNTIF`, `SUM`, `AVG`, `MIN`, `MAX`, `MEDIAN`, `PERCENTILE_CONT`, `APPROX_QUANTILE`, `STDDEV_POP`, `STDDEV_SAMP`, `ARRAY_AGG`, `JSON_ARRAYAGG`, `STRING_AGG`
 - Window: `ROW_NUMBER`, `LAG`, `LEAD`
-- String: `CONCAT`, `SUBSTRING`, `REPLACE`, `LENGTH`, `UPPER`, `LOWER`, `TRIM`, `LEFT`, `RIGHT`, `INSTR`, `POSITION`, `STRPOS`
+- String: `CONCAT`, `SUBSTRING`, `REPLACE`, `LENGTH`, `OCTET_LENGTH`, `UPPER`, `LOWER`, `TRIM`, `LEFT`, `RIGHT`, `INSTR`, `POSITION`, `STRPOS`, `SPLIT_PART`, `STRING_SPLIT`
 - 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`, `DATE_DIFF`, `DATEDIFF`, `DATE_PART`, `DATE_TRUNC`, `EPOCH`, `EXTRACT`, `INTERVAL`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squirreling",
-  "version": "0.12.27",
+  "version": "0.14.0",
   "description": "Squirreling Async SQL Engine",
   "author": "Hyperparam",
   "homepage": "https://hyperparam.app",
@@ -40,10 +40,10 @@
   },
   "devDependencies": {
     "@types/node": "26.1.0",
-    "@vitest/coverage-v8": "4.1.9",
+    "@vitest/coverage-v8": "4.1.10",
     "eslint": "9.39.4",
-    "eslint-plugin-jsdoc": "63.0.10",
+    "eslint-plugin-jsdoc": "63.0.12",
     "typescript": "6.0.3",
-    "vitest": "4.1.9"
+    "vitest": "4.1.10"
   }
 }

package/src/ast.d.ts

@@ -70,7 +70,7 @@ export interface FromFunction extends AstBase {
 
 export type ArithmeticOp = '+' | '-' | '*' | '/' | '%'
 
-export type BinaryOp = 'AND' | 'OR' | 'LIKE' | ComparisonOp | ArithmeticOp
+export type BinaryOp = 'AND' | 'OR' | 'LIKE' | '||' | ComparisonOp | ArithmeticOp
 
 export type ComparisonOp = '=' | '==' | '!=' | '<>' | '<' | '>' | '<=' | '>='
 
@@ -114,7 +114,7 @@ export interface WindowFunctionNode extends AstBase {
   orderBy: OrderByItem[]
 }
 
-export type CastType = 'TEXT' | 'STRING' | 'VARCHAR' | 'INTEGER' | 'INT' | 'BIGINT' | 'FLOAT' | 'REAL' | 'DOUBLE' | 'BOOLEAN' | 'BOOL'
+export type CastType = 'TEXT' | 'STRING' | 'VARCHAR' | 'INTEGER' | 'INT' | 'BIGINT' | 'FLOAT' | 'REAL' | 'DOUBLE' | 'BOOLEAN' | 'BOOL' | 'TIMESTAMP'
 
 export interface CastNode extends AstBase {
   type: 'cast'
@@ -168,6 +168,12 @@ export interface StarNode extends AstBase {
   type: 'star'
 }
 
+export interface SubscriptNode extends AstBase {
+  type: 'subscript'
+  expr: ExprNode
+  index: ExprNode
+}
+
 export type ExprNode =
   | LiteralNode
   | IdentifierNode
@@ -183,6 +189,7 @@ export type ExprNode =
   | SubqueryNode
   | IntervalNode
   | StarNode
+  | SubscriptNode
 
 export interface StarColumn extends AstBase {
   type: 'star'

package/src/execute/aggregates.js

@@ -101,7 +101,7 @@ export function executeHashAggregate(plan, context) {
       for await (const row of child.rows()) {
         if (++collectCount % YIELD_INTERVAL === 0) {
           await yieldToEventLoop()
-          if (context.signal?.aborted) return
+          context.signal?.throwIfAborted()
         }
         allRows.push(row)
       }
@@ -121,7 +121,7 @@ export function executeHashAggregate(plan, context) {
       for (let chunkStart = 0; chunkStart < allRows.length; chunkStart += YIELD_INTERVAL) {
         if (chunkStart > 0) {
           await yieldToEventLoop()
-          if (context.signal?.aborted) return
+          context.signal?.throwIfAborted()
         }
         const chunkEnd = Math.min(chunkStart + YIELD_INTERVAL, allRows.length)
         const chunkLen = chunkEnd - chunkStart
@@ -227,7 +227,7 @@ export function executeScalarAggregate(plan, context) {
       for await (const row of child.rows()) {
         if (++collectCount % YIELD_INTERVAL === 0) {
           await yieldToEventLoop()
-          if (context.signal?.aborted) return
+          context.signal?.throwIfAborted()
         }
         group.push(row)
       }

package/src/execute/execute.js

@@ -174,7 +174,7 @@ function executeUnnest(plan, context) {
       const value = await evaluateExpr({ node: plan.args[0], row, rowIndex: 1, context })
       if (!Array.isArray(value)) return
       for (const element of value) {
-        if (context.signal?.aborted) return
+        context.signal?.throwIfAborted()
         yield {
           columns,
           cells: { [columnName]: () => Promise.resolve(element) },
@@ -209,7 +209,7 @@ function executeJsonEach(plan, context) {
       }
       if (Array.isArray(parsed)) {
         for (let i = 0; i < parsed.length; i++) {
-          if (context.signal?.aborted) return
+          context.signal?.throwIfAborted()
           const k = i
           const v = parsed[i]
           yield {
@@ -224,7 +224,7 @@ function executeJsonEach(plan, context) {
       }
       if (typeof parsed === 'object' && parsed !== null) {
         for (const [k, v] of Object.entries(parsed)) {
-          if (context.signal?.aborted) return
+          context.signal?.throwIfAborted()
           yield {
             columns,
             cells: {
@@ -294,7 +294,7 @@ function executeScan(plan, context) {
       async *rows() {
         const columns = [column]
         for await (const chunk of chunks) {
-          if (signal?.aborted) return
+          signal?.throwIfAborted()
           for (let i = 0; i < chunk.length; i++) {
             const value = chunk[i]
             yield {
@@ -303,6 +303,9 @@ function executeScan(plan, context) {
             }
           }
         }
+        // A data source may end its stream cooperatively on abort; surface
+        // the abort so a truncated scan is not mistaken for a complete one
+        signal?.throwIfAborted()
       },
     }
   }
@@ -335,6 +338,10 @@ function executeScan(plan, context) {
       }
 
       yield* result
+
+      // A data source may end its stream cooperatively on abort; surface
+      // the abort so a truncated scan is not mistaken for a complete one
+      signal?.throwIfAborted()
     },
   }
 }
@@ -420,10 +427,10 @@ async function* filterRows(rows, condition, context, limit) {
   let buffer = []
 
   for await (const row of rows) {
-    if (context.signal?.aborted) return
+    context.signal?.throwIfAborted()
     if (++innerCount % YIELD_INTERVAL === 0) {
       await yieldToEventLoop()
-      if (context.signal?.aborted) return
+      context.signal?.throwIfAborted()
     }
     rowIndex++
     buffer.push({ row, rowIndex })
@@ -466,10 +473,10 @@ async function* limitRows(rows, limit = Infinity, offset = 0, signal) {
   let yielded = 0
   let innerCount = 0
   for await (const row of rows) {
-    if (signal?.aborted) return
+    signal?.throwIfAborted()
     if (++innerCount % YIELD_INTERVAL === 0) {
       await yieldToEventLoop()
-      if (signal?.aborted) return
+      signal?.throwIfAborted()
     }
     if (skipped < offset) {
       skipped++
@@ -521,10 +528,10 @@ function executeProject(plan, context) {
       let innerCount = 0
 
       for await (const row of child.rows()) {
-        if (context.signal?.aborted) return
+        context.signal?.throwIfAborted()
         if (++innerCount % YIELD_INTERVAL === 0) {
           await yieldToEventLoop()
-          if (context.signal?.aborted) return
+          context.signal?.throwIfAborted()
         }
         rowIndex++
         const currentRowIndex = rowIndex
@@ -614,10 +621,10 @@ function executeDistinct(plan, context) {
       let innerCount = 0
 
       for await (const row of child.rows()) {
-        if (signal?.aborted) return
+        signal?.throwIfAborted()
         if (++innerCount % YIELD_INTERVAL === 0) {
           await yieldToEventLoop()
-          if (signal?.aborted) return
+          signal?.throwIfAborted()
         }
         buffer.push(row)
 
@@ -701,10 +708,10 @@ function executeSetOperation(plan, context) {
           const seen = new Set()
           let count = 0
           for await (const row of left.rows()) {
-            if (signal?.aborted) return
+            signal?.throwIfAborted()
             if (++count % YIELD_INTERVAL === 0) {
               await yieldToEventLoop()
-              if (signal?.aborted) return
+              signal?.throwIfAborted()
             }
             const key = await stableRowKey(row)
             if (!seen.has(key)) {
@@ -713,10 +720,10 @@ function executeSetOperation(plan, context) {
             }
           }
           for await (const row of right.rows()) {
-            if (signal?.aborted) return
+            signal?.throwIfAborted()
             if (++count % YIELD_INTERVAL === 0) {
               await yieldToEventLoop()
-              if (signal?.aborted) return
+              signal?.throwIfAborted()
             }
             const key = await stableRowKey(row)
             if (!seen.has(key)) {
@@ -739,10 +746,10 @@ function executeSetOperation(plan, context) {
         const rightKeys = new Map()
         let tick = 0
         for await (const row of right.rows()) {
-          if (signal?.aborted) return
+          signal?.throwIfAborted()
           if (++tick % YIELD_INTERVAL === 0) {
             await yieldToEventLoop()
-            if (signal?.aborted) return
+            signal?.throwIfAborted()
           }
           const key = await stableRowKey(row)
           rightKeys.set(key, (rightKeys.get(key) ?? 0) + 1)
@@ -751,10 +758,10 @@ function executeSetOperation(plan, context) {
         if (plan.all) {
           // INTERSECT ALL: yield each left row that matches, consuming right counts
           for await (const row of left.rows()) {
-            if (signal?.aborted) return
+            signal?.throwIfAborted()
             if (++tick % YIELD_INTERVAL === 0) {
               await yieldToEventLoop()
-              if (signal?.aborted) return
+              signal?.throwIfAborted()
             }
             const key = await stableRowKey(row)
             const count = rightKeys.get(key)
@@ -767,10 +774,10 @@ function executeSetOperation(plan, context) {
           // INTERSECT: yield deduplicated rows present in both
           const seen = new Set()
           for await (const row of left.rows()) {
-            if (signal?.aborted) return
+            signal?.throwIfAborted()
             if (++tick % YIELD_INTERVAL === 0) {
               await yieldToEventLoop()
-              if (signal?.aborted) return
+              signal?.throwIfAborted()
             }
             const key = await stableRowKey(row)
             if (rightKeys.has(key) && !seen.has(key)) {
@@ -794,10 +801,10 @@ function executeSetOperation(plan, context) {
         const rightKeys = new Map()
         let tick = 0
         for await (const row of right.rows()) {
-          if (signal?.aborted) return
+          signal?.throwIfAborted()
           if (++tick % YIELD_INTERVAL === 0) {
             await yieldToEventLoop()
-            if (signal?.aborted) return
+            signal?.throwIfAborted()
           }
           const key = await stableRowKey(row)
           rightKeys.set(key, (rightKeys.get(key) ?? 0) + 1)
@@ -806,10 +813,10 @@ function executeSetOperation(plan, context) {
         if (plan.all) {
           // EXCEPT ALL: yield left rows, consuming right counts
           for await (const row of left.rows()) {
-            if (signal?.aborted) return
+            signal?.throwIfAborted()
             if (++tick % YIELD_INTERVAL === 0) {
               await yieldToEventLoop()
-              if (signal?.aborted) return
+              signal?.throwIfAborted()
             }
             const key = await stableRowKey(row)
             const count = rightKeys.get(key)
@@ -823,10 +830,10 @@ function executeSetOperation(plan, context) {
           // EXCEPT: yield deduplicated left rows not in right
           const seen = new Set()
           for await (const row of left.rows()) {
-            if (signal?.aborted) return
+            signal?.throwIfAborted()
             if (++tick % YIELD_INTERVAL === 0) {
               await yieldToEventLoop()
-              if (signal?.aborted) return
+              signal?.throwIfAborted()
             }
             const key = await stableRowKey(row)
             if (!rightKeys.has(key) && !seen.has(key)) {

package/src/execute/join.js

@@ -56,7 +56,7 @@ export function executeNestedLoopJoin(plan, context) {
       /** @type {AsyncRow[]} */
       const innerRows = []
       for await (const row of inner.rows()) {
-        if (context.signal?.aborted) return
+        context.signal?.throwIfAborted()
         innerRows.push(row)
       }
 
@@ -69,7 +69,7 @@ export function executeNestedLoopJoin(plan, context) {
 
       let innerCount = 0
       for await (const outerRow of outer.rows()) {
-        if (context.signal?.aborted) return
+        context.signal?.throwIfAborted()
 
         if (!outerCols) {
           outerCols = outerRow.columns
@@ -80,7 +80,7 @@ export function executeNestedLoopJoin(plan, context) {
         for (const innerRow of innerRows) {
           if (++innerCount % YIELD_INTERVAL === 0) {
             await yieldToEventLoop()
-            if (context.signal?.aborted) return
+            context.signal?.throwIfAborted()
           }
           const tempMerged = merge(outerRow, innerRow)
           const matches = await evaluateExpr({
@@ -101,7 +101,7 @@ export function executeNestedLoopJoin(plan, context) {
         }
       }
 
-      if (context.signal?.aborted) return
+      context.signal?.throwIfAborted()
 
       // Unmatched inner rows for outer joins on the buffered side
       if (matchedInnerRows) {
@@ -134,7 +134,7 @@ function executeLateralJoin(plan, context) {
       const rightTable = plan.rightAlias
 
       for await (const leftRow of left.rows()) {
-        if (context.signal?.aborted) return
+        context.signal?.throwIfAborted()
 
         // When nested inside a correlated subquery, preserve the enclosing
         // outer row so UNNEST args can reference its columns (e.g. o.arr).
@@ -146,7 +146,7 @@ function executeLateralJoin(plan, context) {
 
         let hasMatch = false
         for await (const rightRow of right.rows()) {
-          if (context.signal?.aborted) return
+          context.signal?.throwIfAborted()
           const merged = mergeRows(leftRow, rightRow, leftTable, rightTable)
           const matches = plan.condition === undefined
             ? true
@@ -199,10 +199,10 @@ export function executePositionalJoin(plan, context) {
       while (true) {
         const [leftResult, rightResult] = await Promise.all([leftRows.next(), rightRows.next()])
         if (leftResult.done && rightResult.done) return
-        if (signal?.aborted) return
+        signal?.throwIfAborted()
         if (++tick % YIELD_INTERVAL === 0) {
           await yieldToEventLoop()
-          if (signal?.aborted) return
+          signal?.throwIfAborted()
         }
         if (!leftResult.done && !leftCols.length) leftCols = leftResult.value.columns
         if (!rightResult.done && !rightCols.length) rightCols = rightResult.value.columns
@@ -266,10 +266,10 @@ export function executeHashJoin(plan, context) {
       let buildCols = []
       let innerCount = 0
       for await (const buildRow of build.rows()) {
-        if (context.signal?.aborted) return
+        context.signal?.throwIfAborted()
         if (++innerCount % YIELD_INTERVAL === 0) {
           await yieldToEventLoop()
-          if (context.signal?.aborted) return
+          context.signal?.throwIfAborted()
         }
         if (!buildCols.length) {
           buildCols = buildRow.columns
@@ -297,7 +297,7 @@ export function executeHashJoin(plan, context) {
 
       // Probe phase: stream the other side
       for await (const probeRow of probe.rows()) {
-        if (context.signal?.aborted) return
+        context.signal?.throwIfAborted()
 
         if (!probeCols) {
           probeCols = probeRow.columns
@@ -314,7 +314,7 @@ export function executeHashJoin(plan, context) {
             for (const buildRow of candidates) {
               if (++innerCount % YIELD_INTERVAL === 0) {
                 await yieldToEventLoop()
-                if (context.signal?.aborted) return
+                context.signal?.throwIfAborted()
               }
               const merged = merge(probeRow, buildRow)
               if (residual) {
@@ -333,7 +333,7 @@ export function executeHashJoin(plan, context) {
         }
       }
 
-      if (context.signal?.aborted) return
+      context.signal?.throwIfAborted()
 
       // Unmatched build rows for outer joins on the build side
       if (buildRows && matchedBuildRows) {

package/src/execute/sort.js

@@ -146,7 +146,7 @@ export function executeSort(plan, context) {
       /** @type {SortEntry[]} */
       let entries = []
       for await (const row of child.rows()) {
-        if (context.signal?.aborted) return
+        context.signal?.throwIfAborted()
         entries.push({ row })
         if (entries.length >= bufferLimit) {
           // Sort keys are cached on the rows, so survivors of one truncation

package/src/execute/streamingAggregate.js

@@ -161,6 +161,8 @@ export function planStreamingAggregates({ columns, having, orderBy, groupBy }, c
     case 'in valuelist':
       // values after the first are skipped once an earlier value matches
       return walk(node.expr, lazy) && node.values.every((v, i) => walk(v, lazy || i > 0))
+    case 'subscript':
+      return walk(node.expr, lazy) && walk(node.index, lazy)
     case 'function': {
       const funcName = node.funcName.toUpperCase()
       if (!isAggregateFunc(funcName)) {
@@ -257,6 +259,8 @@ function isScalarExpr(node) {
       (!node.elseResult || isScalarExpr(node.elseResult))
   case 'in valuelist':
     return isScalarExpr(node.expr) && node.values.every(v => isScalarExpr(v))
+  case 'subscript':
+    return isScalarExpr(node.expr) && isScalarExpr(node.index)
   case 'function':
     return !isAggregateFunc(node.funcName.toUpperCase()) && node.args.every(arg => isScalarExpr(arg))
   default:
@@ -316,6 +320,11 @@ function substituteValues(node, values) {
     const valueNodes = node.values.map(v => substituteValues(v, values))
     return { ...node, expr, values: valueNodes }
   }
+  case 'subscript': {
+    const expr = substituteValues(node.expr, values)
+    const index = substituteValues(node.index, values)
+    return expr === node.expr && index === node.index ? node : { ...node, expr, index }
+  }
   case 'function': {
     const args = node.args.map(arg => substituteValues(arg, values))
     return args.every((arg, i) => arg === node.args[i]) ? node : { ...node, args }
@@ -409,8 +418,8 @@ async function accumulateChunk({ chunk, groupBy, specs, groups, needsRow, contex
 
 /**
  * Consumes the child rows into per-group accumulators, holding at most one
- * chunk of rows at a time. Returns undefined when aborted mid-collection so
- * callers end the row stream silently, matching the buffered path.
+ * chunk of rows at a time. Throws when aborted so partial accumulators are
+ * never finalized into results.
  *
  * @param {object} options
  * @param {QueryResults} options.child
@@ -418,7 +427,7 @@ async function accumulateChunk({ chunk, groupBy, specs, groups, needsRow, contex
  * @param {StreamingAggSpec[]} options.specs
  * @param {boolean} options.needsRow
  * @param {ExecuteContext} options.context
- * @returns {Promise<Map<unknown, StreamingGroup> | undefined>}
+ * @returns {Promise<Map<unknown, StreamingGroup>>}
  */
 async function accumulateGroups({ child, groupBy, specs, needsRow, context }) {
   /** @type {Map<unknown, StreamingGroup>} */
@@ -431,14 +440,11 @@ async function accumulateGroups({ child, groupBy, specs, needsRow, context }) {
       await accumulateChunk({ chunk, groupBy, specs, groups, needsRow, context })
       chunk = []
       await yieldToEventLoop()
-      if (context.signal?.aborted) return
+      context.signal?.throwIfAborted()
     }
   }
   if (chunk.length) {
     await accumulateChunk({ chunk, groupBy, specs, groups, needsRow, context })
-    // An abort during the final partial chunk ends the stream silently,
-    // consistent with the full-chunk check above
-    if (context.signal?.aborted) return
   }
   context.signal?.throwIfAborted()
   return groups
@@ -531,7 +537,6 @@ export function streamingHashAggregateRows({ plan, streaming, child, context })
   const { specs, keyRefs, needsRow } = streaming
   return async function* () {
     const groups = await accumulateGroups({ child, groupBy: plan.groupBy, specs, needsRow, context })
-    if (!groups) return
     const { orderBy, having } = plan
 
     // Without ORDER BY, groups finalize and yield one at a time so output
@@ -585,7 +590,6 @@ export function streamingScalarAggregateRows({ plan, streaming, child, context }
   const { specs, keyRefs, needsRow } = streaming
   return async function* () {
     const groups = await accumulateGroups({ child, groupBy: [], specs, needsRow, context })
-    if (!groups) return
     /** @type {StreamingGroup} */
     const group = groups.get(true) ?? { firstRow: undefined, keyValues: [], accumulators: specs.map(spec => newAccumulator(spec.funcName, spec.node.distinct)) }
 

package/src/execute/window.js

@@ -42,7 +42,7 @@ export function executeWindow(plan, context) {
         for await (const row of child.rows()) {
           if (++i % YIELD_INTERVAL === 0) {
             await yieldToEventLoop()
-            if (context.signal?.aborted) return
+            context.signal?.throwIfAborted()
           }
           const cells = { ...row.cells }
           for (const w of plan.windows) {
@@ -69,7 +69,7 @@ export function executeWindow(plan, context) {
       for await (const row of child.rows()) {
         if (++collectCount % YIELD_INTERVAL === 0) {
           await yieldToEventLoop()
-          if (context.signal?.aborted) return
+          context.signal?.throwIfAborted()
         }
         rows.push(row)
       }
@@ -81,14 +81,14 @@ export function executeWindow(plan, context) {
 
       for (let w = 0; w < plan.windows.length; w++) {
         await computeWindow(plan.windows[w], rows, windowValues[w], context)
-        if (context.signal?.aborted) return
+        context.signal?.throwIfAborted()
       }
 
       let emitCount = 0
       for (let i = 0; i < rows.length; i++) {
         if (++emitCount % YIELD_INTERVAL === 0) {
           await yieldToEventLoop()
-          if (context.signal?.aborted) return
+          context.signal?.throwIfAborted()
         }
         const row = rows[i]
         const cells = { ...row.cells }
@@ -122,7 +122,7 @@ async function computeWindow(spec, rows, output, context) {
   for (let chunkStart = 0; chunkStart < rows.length; chunkStart += YIELD_INTERVAL) {
     if (chunkStart > 0) {
       await yieldToEventLoop()
-      if (context.signal?.aborted) return
+      context.signal?.throwIfAborted()
     }
     const chunkEnd = Math.min(chunkStart + YIELD_INTERVAL, rows.length)
     const chunkKeys = await Promise.all(
@@ -142,7 +142,7 @@ async function computeWindow(spec, rows, output, context) {
   }
 
   for (const bucket of partitions.values()) {
-    if (context.signal?.aborted) return
+    context.signal?.throwIfAborted()
 
     // Order within the partition. Empty ORDER BY → input order.
     /** @type {number[]} */
@@ -153,7 +153,7 @@ async function computeWindow(spec, rows, output, context) {
       for (let chunkStart = 0; chunkStart < bucket.length; chunkStart += YIELD_INTERVAL) {
         if (chunkStart > 0) {
           await yieldToEventLoop()
-          if (context.signal?.aborted) return
+          context.signal?.throwIfAborted()
         }
         const chunkEnd = Math.min(chunkStart + YIELD_INTERVAL, bucket.length)
         const chunkValues = await Promise.all(
@@ -205,7 +205,7 @@ async function applyWindowFunction(spec, ordered, rows, output, context) {
     for (let k = 0; k < ordered.length; k++) {
       if (++tick % YIELD_INTERVAL === 0) {
         await yieldToEventLoop()
-        if (context.signal?.aborted) return
+        context.signal?.throwIfAborted()
       }
       const idx = ordered[k]
       const row = rows[idx]

package/src/expression/alias.js

@@ -37,5 +37,12 @@ export function derivedAlias(expr) {
   if (expr.type === 'interval') {
     return `interval_${expr.value}_${expr.unit.toLowerCase()}`
   }
+  if (expr.type === 'subscript') {
+    // string subscript is struct field access, alias to the field name
+    if (expr.index.type === 'literal' && typeof expr.index.value === 'string') {
+      return expr.index.value
+    }
+    return `${derivedAlias(expr.expr)}[${derivedAlias(expr.index)}]`
+  }
   return 'expr'
 }

package/src/expression/binary.js

@@ -23,6 +23,12 @@ export function applyBinaryOp(op, a, b) {
     if (op === '%') return numB === 0 ? null : numA % numB
   }
 
+  // String concatenation returns null if either operand is null
+  if (op === '||') {
+    if (a == null || b == null) return null
+    return String(a) + String(b)
+  }
+
   // Comparison and logical operators
   if (a == null || b == null) {
     return false

package/src/expression/date.js

@@ -130,7 +130,7 @@ export function dateDiff(unit, startVal, endVal) {
  * @param {SqlPrimitive} val
  * @returns {Date | null}
  */
-function toDate(val) {
+export 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)) {

package/src/expression/evaluate.js

@@ -7,7 +7,7 @@ import { UnknownFunctionError } from '../validation/parseErrors.js'
 import { ColumnNotFoundError } from '../validation/tables.js'
 import { derivedAlias } from './alias.js'
 import { applyBinaryOp } from './binary.js'
-import { applyIntervalToDate, dateDiff, dateTrunc, extractField } from './date.js'
+import { applyIntervalToDate, dateDiff, dateTrunc, extractField, toDate } from './date.js'
 import { evaluateMathFunc } from './math.js'
 import { evaluateRegexpFunc } from './regexp.js'
 import { evaluateSpatialFunc } from '../spatial/spatial.js'
@@ -130,6 +130,23 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
     })
   }
 
+  // Subscript access: array indexing (arr[0]) or struct field access (obj['key'])
+  if (node.type === 'subscript') {
+    const value = await evaluateExpr({ node: node.expr, row, rowIndex, rows, context })
+    if (value == null) return null
+    const index = await evaluateExpr({ node: node.index, row, rowIndex, rows, context })
+    if (index == null) return null
+    if (typeof index === 'number' || typeof index === 'bigint') {
+      if (!Array.isArray(value)) return null
+      return value[Number(index)] ?? null
+    }
+    const key = String(index)
+    if (isPlainObject(value) && Object.prototype.hasOwnProperty.call(value, key)) {
+      return value[key]
+    }
+    return null
+  }
+
   // Scalar subquery - returns a single value
   if (node.type === 'subquery') {
     const outerScope = context.scope
@@ -710,6 +727,14 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
     if (toType === 'BOOLEAN' || toType === 'BOOL') {
       return Boolean(val)
     }
+    if (toType === 'TIMESTAMP') {
+      if (typeof val === 'number' || typeof val === 'bigint') {
+        const date = new Date(Number(val))
+        if (isNaN(date.getTime())) return null
+        return date
+      }
+      return toDate(val)
+    }
   }
 
   // IN and NOT IN with value lists

package/src/expression/strings.js

@@ -4,6 +4,8 @@ import { ArgValueError } from '../validation/executionErrors.js'
  * @import { FunctionNode, SqlPrimitive, StringFunc } from '../types.js'
  */
 
+const textEncoder = new TextEncoder()
+
 /**
  * Evaluate a string function
  *
@@ -43,6 +45,16 @@ export function evaluateStringFunc({ funcName, node, args, rowIndex }) {
     })
   }
 
+  if (funcName === 'OCTET_LENGTH') {
+    if (typeof val === 'string') return textEncoder.encode(val).length
+    throw new ArgValueError({
+      ...node,
+      message: `expected string, got ${typeof val === 'object' ? val instanceof Date ? 'date' : 'object' : typeof val}`,
+      hint: 'Use CAST to convert to a string first.',
+      rowIndex,
+    })
+  }
+
   if (typeof val === 'object' && !(val instanceof Date)) {
     throw new ArgValueError({
       ...node,
@@ -131,6 +143,32 @@ export function evaluateStringFunc({ funcName, node, args, rowIndex }) {
     return str.substring(str.length - len)
   }
 
+  if (funcName === 'SPLIT_PART') {
+    const delimiter = args[1]
+    if (delimiter == null) return null
+    const index = Number(args[2])
+    if (!Number.isInteger(index) || index === 0) {
+      throw new ArgValueError({
+        ...node,
+        message: `index must be a non-zero integer, got ${args[2]}`,
+        hint: 'Field indexes are 1-based.',
+        rowIndex,
+      })
+    }
+    const delim = String(delimiter)
+    const parts = delim === '' ? [str] : str.split(delim)
+    // Negative index counts from the end
+    const partIdx = index < 0 ? parts.length + index : index - 1
+    return parts[partIdx] ?? ''
+  }
+
+  if (funcName === 'STRING_SPLIT') {
+    const delimiter = args[1]
+    if (delimiter == null) return null
+    const delim = String(delimiter)
+    return delim === '' ? [str] : str.split(delim)
+  }
+
   if (funcName === 'INSTR' || funcName === 'POSITION' || funcName === 'STRPOS') {
     const search = args[1]
     if (search == null) return null

package/src/index.d.ts

@@ -28,7 +28,7 @@ export type {
  * @param options.tables - source data as a list of objects or an AsyncDataSource
  * @param options.query - SQL query string
  * @param options.functions - user-defined functions available in the SQL context
- * @param options.signal - AbortSignal to cancel the query
+ * @param options.signal - AbortSignal to cancel the query; an aborted query rejects with the signal's reason
  * @returns async generator yielding rows matching the query
  */
 export function executeSql(options: ExecuteSqlOptions): QueryResults

package/src/parse/expression.js

@@ -9,7 +9,7 @@ import { consume, current, expect, match } from './state.js'
  */
 
 // Precedence (lowest to highest):
-// OR, AND, NOT, Comparison, Additive, Multiplicative, Primary
+// OR, AND, NOT, Comparison, Concat, Additive, Multiplicative, Primary
 
 /**
  * @param {ParserState} state
@@ -88,7 +88,7 @@ function parseNot(state) {
  * @returns {ExprNode}
  */
 function parseComparison(state) {
-  const left = parseAdditive(state)
+  const left = parseConcat(state)
   const { positionStart } = left
 
   // IS [NOT] NULL
@@ -108,7 +108,7 @@ function parseComparison(state) {
   if (match(state, 'keyword', 'NOT')) {
     // NOT LIKE
     if (match(state, 'keyword', 'LIKE')) {
-      const right = parseAdditive(state)
+      const right = parseConcat(state)
       return {
         type: 'unary',
         op: 'NOT',
@@ -127,9 +127,9 @@ function parseComparison(state) {
 
     // NOT BETWEEN - convert to range comparison
     if (match(state, 'keyword', 'BETWEEN')) {
-      const lower = parseAdditive(state)
+      const lower = parseConcat(state)
       expect(state, 'keyword', 'AND')
-      const upper = parseAdditive(state)
+      const upper = parseConcat(state)
       // NOT BETWEEN -> expr < lower OR expr > upper
       return {
         type: 'binary',
@@ -163,7 +163,7 @@ function parseComparison(state) {
 
   // LIKE
   if (match(state, 'keyword', 'LIKE')) {
-    const right = parseAdditive(state)
+    const right = parseConcat(state)
     return {
       type: 'binary',
       op: 'LIKE',
@@ -176,9 +176,9 @@ function parseComparison(state) {
 
   // BETWEEN - convert to range comparison
   if (match(state, 'keyword', 'BETWEEN')) {
-    const lower = parseAdditive(state)
+    const lower = parseConcat(state)
     expect(state, 'keyword', 'AND')
-    const upper = parseAdditive(state)
+    const upper = parseConcat(state)
     // BETWEEN -> expr >= lower AND expr <= upper
     return {
       type: 'binary',
@@ -198,7 +198,7 @@ function parseComparison(state) {
   const opTok = current(state)
   if (opTok.type === 'operator' && isBinaryOp(opTok.value)) {
     consume(state)
-    const right = parseAdditive(state)
+    const right = parseConcat(state)
     return {
       type: 'binary',
       op: opTok.value,
@@ -212,6 +212,33 @@ function parseComparison(state) {
   return left
 }
 
+/**
+ * @param {ParserState} state
+ * @returns {ExprNode}
+ */
+export function parseConcat(state) {
+  let left = parseAdditive(state)
+  while (true) {
+    const tok = current(state)
+    if (tok.type === 'operator' && tok.value === '||') {
+      consume(state)
+      const right = parseAdditive(state)
+      // Recursive left-associative binary operator
+      left = {
+        type: 'binary',
+        op: '||',
+        left,
+        right,
+        positionStart: left.positionStart,
+        positionEnd: right.positionEnd,
+      }
+    } else {
+      break
+    }
+  }
+  return left
+}
+
 /**
  * @param {ParserState} state
  * @returns {ExprNode}

package/src/parse/extractTables.js

@@ -110,6 +110,10 @@ function walkExpr(expr, cteScope, refs) {
     walkExpr(expr.expr, cteScope, refs)
     for (const v of expr.values) walkExpr(v, cteScope, refs)
     return
+  case 'subscript':
+    walkExpr(expr.expr, cteScope, refs)
+    walkExpr(expr.index, cteScope, refs)
+    return
   case 'exists':
   case 'not exists':
     walkStatement(expr.subquery, cteScope, refs)

package/src/parse/functions.js

@@ -1,6 +1,6 @@
 import { isAggregateFunc, isKnownFunction, isWindowFunc, niladicFuncs, validateFunctionArgs } from '../validation/functions.js'
 import { ParseError, UnknownFunctionError } from '../validation/parseErrors.js'
-import { parseExpression } from './expression.js'
+import { parseConcat, parseExpression } from './expression.js'
 import { consume, current, expect, match } from './state.js'
 
 /**
@@ -60,6 +60,17 @@ export function parseFunctionCall(state, positionStart) {
         positionStart: next.positionStart,
         positionEnd: state.lastPos,
       })
+    } else if (funcNameUpper === 'POSITION' && !args.length) {
+      // ANSI syntax: POSITION(needle IN haystack), stored as (haystack, needle).
+      // The needle is parsed below comparison precedence so IN is not consumed
+      // as the set-membership operator.
+      const needle = parseConcat(state)
+      if (match(state, 'keyword', 'IN')) {
+        const haystack = parseExpression(state)
+        args.push(haystack, needle)
+        break
+      }
+      args.push(needle)
     } else {
       args.push(parseExpression(state))
     }

package/src/parse/parse.js

@@ -48,6 +48,14 @@ export function parseSql({ query, functions }) {
 export function parseStatement(state) {
   const positionStart = state.lastPos
   if (match(state, 'keyword', 'WITH')) {
+    const recursiveTok = current(state)
+    if (recursiveTok.type === 'identifier' && recursiveTok.value.toUpperCase() === 'RECURSIVE') {
+      throw new ParseError({
+        message: `WITH RECURSIVE is not supported at position ${recursiveTok.positionStart}`,
+        ...recursiveTok,
+      })
+    }
+
     /** @type {CTEDefinition[]} */
     const ctes = []
     /** @type {Set<string>} */

package/src/parse/primary.js

@@ -11,12 +11,65 @@ import { consume, current, expect, match, parseError, peekToken } from './state.
  */
 
 /**
- * Parse a primary expression, which is the innermost order of operations.
+ * Parse a primary expression, which is the innermost order of operations,
+ * followed by any postfix subscript operators.
  *
  * @param {ParserState} state
  * @returns {ExprNode}
  */
 export function parsePrimary(state) {
+  return parsePostfix(state, parsePrimaryBase(state))
+}
+
+/**
+ * Parses postfix subscript operators after a primary expression: bracket
+ * indexing (`expr[0]`, `expr['key']`) and struct field access on a subscript
+ * result (`expr[0].field`).
+ *
+ * @param {ParserState} state
+ * @param {ExprNode} expr
+ * @returns {ExprNode}
+ */
+function parsePostfix(state, expr) {
+  while (true) {
+    if (match(state, 'bracket', '[')) {
+      const index = parseExpression(state)
+      expect(state, 'bracket', ']')
+      expr = {
+        type: 'subscript',
+        expr,
+        index,
+        positionStart: expr.positionStart,
+        positionEnd: state.lastPos,
+      }
+    } else if (expr.type === 'subscript' && current(state).type === 'dot') {
+      consume(state)
+      const fieldTok = expect(state, 'identifier')
+      expr = {
+        type: 'subscript',
+        expr,
+        index: {
+          type: 'literal',
+          value: fieldTok.value,
+          positionStart: fieldTok.positionStart,
+          positionEnd: fieldTok.positionEnd,
+        },
+        positionStart: expr.positionStart,
+        positionEnd: state.lastPos,
+      }
+    } else {
+      return expr
+    }
+  }
+}
+
+/**
+ * Parse a primary expression without postfix operators.
+ *
+ * @param {ParserState} state
+ * @returns {ExprNode}
+ */
+function parsePrimaryBase(state) {
   const tok = current(state)
   const { positionStart } = tok
 
@@ -82,7 +135,7 @@ export function parsePrimary(state) {
       const toType = typeTok.value.toUpperCase()
       if (!isCastType(toType)) {
         throw new SyntaxError({
-          expected: 'cast type (STRING, INT, BIGINT, FLOAT, BOOL)',
+          expected: 'cast type (STRING, INT, BIGINT, FLOAT, BOOL, TIMESTAMP)',
           after: 'AS',
           ...typeTok,
         })
@@ -97,6 +150,24 @@ export function parsePrimary(state) {
       }
     }
 
+    // TIMESTAMP '2026-01-01 00:00:00' typed literal
+    if (funcNameUpper === 'TIMESTAMP' && next.type === 'string') {
+      consume(state) // TIMESTAMP
+      const strTok = consume(state) // string literal
+      return {
+        type: 'cast',
+        expr: {
+          type: 'literal',
+          value: strTok.value,
+          positionStart: strTok.positionStart,
+          positionEnd: strTok.positionEnd,
+        },
+        toType: 'TIMESTAMP',
+        positionStart,
+        positionEnd: state.lastPos,
+      }
+    }
+
     // EXTRACT(field FROM expr)
     if (funcNameUpper === 'EXTRACT' && next.type === 'paren' && next.value === '(') {
       consume(state) // EXTRACT
@@ -157,16 +228,21 @@ export function parsePrimary(state) {
     if (match(state, 'dot')) {
       prefix = name
       name = expect(state, 'identifier').value
-    } else if (match(state, 'bracket', '[')) {
-      // table['column'] string subscript is equivalent to dot access
-      const fieldTok = current(state)
-      if (fieldTok.type !== 'string') {
-        throw parseError(state, 'string literal')
+    } else {
+      // table['column'] string subscript is equivalent to dot access; other
+      // subscripts (numeric, expression) are left for the postfix parser
+      const open = current(state)
+      const fieldTok = peekToken(state, 1)
+      const close = peekToken(state, 2)
+      if (open.type === 'bracket' && open.value === '[' &&
+          fieldTok.type === 'string' &&
+          close.type === 'bracket' && close.value === ']') {
+        consume(state) // '['
+        consume(state) // string
+        consume(state) // ']'
+        prefix = name
+        name = fieldTok.value
       }
-      consume(state)
-      expect(state, 'bracket', ']')
-      prefix = name
-      name = fieldTok.value
     }
 
     return {

package/src/parse/tokenize.js

@@ -172,6 +172,18 @@ export function tokenizeSql(query) {
       continue
     }
 
+    // string concatenation operator
+    if (ch === '|' && next === '|') {
+      i += 2
+      tokens.push({
+        type: 'operator',
+        value: '||',
+        positionStart,
+        positionEnd: i,
+      })
+      continue
+    }
+
     // operators
     if ('<>!=+-*/%'.includes(ch)) {
       let op = nextChar()

package/src/plan/columns.js

@@ -255,6 +255,9 @@ export function collectColumnsFromExpr(expr, columns, aliases) {
     }
   } else if (expr.type === 'in') {
     collectColumnsFromExpr(expr.expr, columns, aliases)
+  } else if (expr.type === 'subscript') {
+    collectColumnsFromExpr(expr.expr, columns, aliases)
+    collectColumnsFromExpr(expr.index, columns, aliases)
   } else if (expr.type === 'case') {
     if (expr.caseExpr) {
       collectColumnsFromExpr(expr.caseExpr, columns, aliases)

package/src/plan/plan.js

@@ -637,6 +637,9 @@ function resolveAliases(node, aliases) {
     const values = node.values.map(v => resolveAliases(v, aliases))
     return { ...node, expr, values }
   }
+  if (node.type === 'subscript') {
+    return { ...node, expr: resolveAliases(node.expr, aliases), index: resolveAliases(node.index, aliases) }
+  }
   if (node.type === 'case') {
     const caseExpr = resolveAliases(node.caseExpr, aliases)
     const whenClauses = node.whenClauses.map(w => {
@@ -697,6 +700,13 @@ function normalizeIdentifiers(node, sourceColumns) {
       values: node.values.map(v => normalizeIdentifiers(v, sourceColumns)),
     }
   }
+  if (node.type === 'subscript') {
+    return {
+      ...node,
+      expr: normalizeIdentifiers(node.expr, sourceColumns),
+      index: normalizeIdentifiers(node.index, sourceColumns),
+    }
+  }
   if (node.type === 'case') {
     return {
       ...node,
@@ -872,6 +882,9 @@ function validateLateralSubqueries({ expr, ctePlans, cteColumns, tables, outerSc
     for (const val of expr.values) {
       validateLateralSubqueries({ expr: val, ctePlans, cteColumns, tables, outerScope })
     }
+  } else if (expr.type === 'subscript') {
+    validateLateralSubqueries({ expr: expr.expr, ctePlans, cteColumns, tables, outerScope })
+    validateLateralSubqueries({ expr: expr.index, ctePlans, cteColumns, tables, outerScope })
   } else if (expr.type === 'case') {
     validateLateralSubqueries({ expr: expr.caseExpr, ctePlans, cteColumns, tables, outerScope })
     for (const w of expr.whenClauses) {
@@ -930,6 +943,13 @@ function collectWindows(expr, windows) {
       values: expr.values.map(v => collectWindows(v, windows)),
     }
   }
+  if (expr.type === 'subscript') {
+    return {
+      ...expr,
+      expr: collectWindows(expr.expr, windows),
+      index: collectWindows(expr.index, windows),
+    }
+  }
   if (expr.type === 'case') {
     return {
       ...expr,
@@ -979,6 +999,7 @@ function findWindow(expr) {
     return undefined
   }
   if (expr.type === 'cast') return findWindow(expr.expr)
+  if (expr.type === 'subscript') return findWindow(expr.expr) || findWindow(expr.index)
   if (expr.type === 'in valuelist') {
     const found = findWindow(expr.expr)
     if (found) return found

package/src/types.d.ts

@@ -166,6 +166,7 @@ export type StringFunc =
   | 'LOWER'
   | 'CONCAT'
   | 'LENGTH'
+  | 'OCTET_LENGTH'
   | 'SUBSTRING'
   | 'SUBSTR'
   | 'TRIM'
@@ -175,6 +176,8 @@ export type StringFunc =
   | 'INSTR'
   | 'POSITION'
   | 'STRPOS'
+  | 'SPLIT_PART'
+  | 'STRING_SPLIT'
 
 export type SpatialFunc =
   | 'ST_INTERSECTS'

package/src/validation/aggregates.js

@@ -31,6 +31,9 @@ export function findAggregate(expr) {
   if (expr.type === 'cast') {
     return findAggregate(expr.expr)
   }
+  if (expr.type === 'subscript') {
+    return findAggregate(expr.expr) || findAggregate(expr.index)
+  }
   if (expr.type === 'case') {
     if (expr.caseExpr) {
       const found = findAggregate(expr.caseExpr)

package/src/validation/functions.js

@@ -86,7 +86,7 @@ export function isExtractField(name) {
  * @returns {name is CastType}
  */
 export function isCastType(name) {
-  return ['TEXT', 'STRING', 'VARCHAR', 'INTEGER', 'INT', 'BIGINT', 'FLOAT', 'REAL', 'DOUBLE', 'BOOLEAN', 'BOOL'].includes(name)
+  return ['TEXT', 'STRING', 'VARCHAR', 'INTEGER', 'INT', 'BIGINT', 'FLOAT', 'REAL', 'DOUBLE', 'BOOLEAN', 'BOOL', 'TIMESTAMP'].includes(name)
 }
 
 /**
@@ -95,8 +95,8 @@ export function isCastType(name) {
  */
 export function isStringFunc(name) {
   return [
-    'UPPER', 'LOWER', 'CONCAT', 'LENGTH', 'SUBSTRING', 'SUBSTR', 'TRIM',
-    'REPLACE', 'LEFT', 'RIGHT', 'INSTR', 'POSITION', 'STRPOS',
+    'UPPER', 'LOWER', 'CONCAT', 'LENGTH', 'OCTET_LENGTH', 'SUBSTRING', 'SUBSTR', 'TRIM',
+    'REPLACE', 'LEFT', 'RIGHT', 'INSTR', 'POSITION', 'STRPOS', 'SPLIT_PART', 'STRING_SPLIT',
   ].includes(name)
 }
 
@@ -117,6 +117,7 @@ export const FUNCTION_SIGNATURES = {
   UPPER: { min: 1, max: 1, signature: 'string' },
   LOWER: { min: 1, max: 1, signature: 'string' },
   LENGTH: { min: 1, max: 1, signature: 'string' },
+  OCTET_LENGTH: { min: 1, max: 1, signature: 'string' },
   TRIM: { min: 1, max: 1, signature: 'string' },
   REPLACE: { min: 3, max: 3, signature: 'string, search, replacement' },
   SUBSTRING: { min: 2, max: 3, signature: 'string, start[, length]' },
@@ -127,6 +128,8 @@ export const FUNCTION_SIGNATURES = {
   INSTR: { min: 2, max: 2, signature: 'string, substring' },
   POSITION: { min: 2, max: 2, signature: 'string, substring' },
   STRPOS: { min: 2, max: 2, signature: 'string, substring' },
+  SPLIT_PART: { min: 3, max: 3, signature: 'string, delimiter, index' },
+  STRING_SPLIT: { min: 2, max: 2, signature: 'string, delimiter' },
   REGEXP_SUBSTR: { min: 2, max: 4, signature: 'string, pattern[, position[, occurrence]]' },
   REGEXP_EXTRACT: { min: 2, max: 4, signature: 'string, pattern[, position[, occurrence]]' },
   REGEXP_REPLACE: { min: 3, max: 5, signature: 'string, pattern, replacement[, position[, occurrence]]' },

package/src/validation/tables.js

@@ -90,6 +90,9 @@ export function validateNoIdentifiers(expr, context, outerScope) {
   } else if (expr.type === 'in') {
     // LHS is in our scope; subquery is self-contained and planned separately.
     validateNoIdentifiers(expr.expr, context, outerScope)
+  } else if (expr.type === 'subscript') {
+    validateNoIdentifiers(expr.expr, context, outerScope)
+    validateNoIdentifiers(expr.index, context, outerScope)
   } else if (expr.type === 'case') {
     validateNoIdentifiers(expr.caseExpr, context, outerScope)
     for (const w of expr.whenClauses) {
@@ -144,6 +147,9 @@ export function validateTableRefs(expr, tables, scopeColumns) {
     for (const val of expr.values) {
       validateTableRefs(val, tables, scopeColumns)
     }
+  } else if (expr.type === 'subscript') {
+    validateTableRefs(expr.expr, tables, scopeColumns)
+    validateTableRefs(expr.index, tables, scopeColumns)
   } else if (expr.type === 'case') {
     validateTableRefs(expr.caseExpr, tables, scopeColumns)
     for (const w of expr.whenClauses) {