squirreling 0.12.10 → 0.12.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squirreling",
-  "version": "0.12.10",
+  "version": "0.12.11",
   "description": "Squirreling Async SQL Engine",
   "author": "Hyperparam",
   "homepage": "https://hyperparam.app",

package/src/expression/evaluate.js

@@ -47,6 +47,17 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
           return value[node.name]
         }
       }
+      // Struct dot access where the prefix is itself a column name (bare or
+      // table-qualified), e.g. `item.name` reading field `name` from a struct
+      // column `item` (often introduced via UNNEST AS tc(item)).
+      const suffix = '.' + node.prefix
+      const baseColumns = row.columns.filter(col => col === node.prefix || col.endsWith(suffix))
+      if (baseColumns.length === 1) {
+        const value = await row.cells[baseColumns[0]]()
+        if (isPlainObject(value) && Object.prototype.hasOwnProperty.call(value, node.name)) {
+          return value[node.name]
+        }
+      }
       // Check outer row for correlated subquery references
       if (context.outerRow && context.outerAliases?.has(node.prefix) && node.name in context.outerRow.cells) {
         return context.outerRow.cells[node.name]()

package/src/expression/strings.js

@@ -32,6 +32,25 @@ export function evaluateStringFunc({ funcName, node, args, rowIndex }) {
   // String first arg
   const [val] = args
   if (val == null) return null
+
+  if (funcName === 'LENGTH') {
+    if (typeof val === 'string' || Array.isArray(val)) return val.length
+    throw new ArgValueError({
+      ...node,
+      message: `expected string or array, 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,
+      message: `does not support ${Array.isArray(val) ? 'array' : 'object'} arguments`,
+      hint: 'Use CAST to convert to a string first.',
+      rowIndex,
+    })
+  }
   const str = String(val)
 
   if (funcName === 'UPPER') {
@@ -42,10 +61,6 @@ export function evaluateStringFunc({ funcName, node, args, rowIndex }) {
     return str.toLowerCase()
   }
 
-  if (funcName === 'LENGTH') {
-    return str.length
-  }
-
   if (funcName === 'SUBSTRING' || funcName === 'SUBSTR') {
     const start = Number(args[1])
     if (!Number.isInteger(start) || start < 1) {

package/src/plan/columns.js

@@ -400,3 +400,24 @@ export function inferSelectSourceColumns({ select, cteColumns, tables }) {
 function lookupTableColumns(table, cteColumns, tables) {
   return cteColumns?.get(table.toLowerCase()) ?? tables?.[table]?.columns ?? []
 }
+
+/**
+ * Collects bare column names exposed by a SELECT's FROM and joins. Used by
+ * validation to recognize struct-field dot access (e.g. `item.name` on a
+ * struct-valued column `item`) instead of rejecting the prefix as an unknown
+ * table.
+ *
+ * @param {object} options
+ * @param {SelectStatement} options.select
+ * @param {Map<string, string[]>} [options.cteColumns]
+ * @param {Record<string, AsyncDataSource>} [options.tables]
+ * @returns {Set<string>}
+ */
+export function collectScopeColumns({ select, cteColumns, tables }) {
+  const result = new Set()
+  for (const col of inferSelectSourceColumns({ select, cteColumns, tables })) {
+    const dot = col.indexOf('.')
+    result.add(dot >= 0 ? col.slice(dot + 1) : col)
+  }
+  return result
+}

package/src/plan/plan.js

@@ -4,7 +4,7 @@ import { findAggregate } from '../validation/aggregates.js'
 import { ParseError } from '../validation/parseErrors.js'
 import { ColumnNotFoundError, TableNotFoundError } from '../validation/tables.js'
 import { validateNoIdentifiers, validateScan, validateTableRefs } from '../validation/tables.js'
-import { extractColumns, fromAlias, inferSelectSourceColumns, inferStatementColumns, tableFunctionColumnNames } from './columns.js'
+import { collectScopeColumns, extractColumns, fromAlias, inferSelectSourceColumns, inferStatementColumns, tableFunctionColumnNames } from './columns.js'
 
 /**
  * @import { AsyncDataSource, ExprNode, DerivedColumn, IdentifierNode, JoinClause, OrderByItem, PlanSqlOptions, ScanOptions, SelectColumn, SelectStatement, SetOperationStatement, Statement, WindowFunctionNode } from '../types.js'
@@ -159,11 +159,15 @@ function planSelect({ select, ctePlans, cteColumns, tables, parentColumns, outer
   // 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]))
+  // 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.
+  const scopeColumns = collectScopeColumns({ select, cteColumns, tables })
   /** @type {Map<string, ExprNode>} */
   const aliases = new Map()
   const columns = select.columns.map(col => {
     if (col.type === 'derived') {
-      validateTableRefs(col.expr, scopeTables)
+      validateTableRefs(col.expr, scopeTables, scopeColumns)
       const expr = resolveAliases(col.expr, aliases)
       if (col.alias) {
         aliases.set(col.alias, expr)
@@ -180,16 +184,16 @@ function planSelect({ select, ctePlans, cteColumns, tables, parentColumns, outer
   const orderBy = resolveOrderByAliases(select.orderBy, aliases)
 
   // Validate qualified references in other clauses
-  validateTableRefs(select.where, scopeTables)
-  validateTableRefs(select.having, scopeTables)
+  validateTableRefs(select.where, scopeTables, scopeColumns)
+  validateTableRefs(select.having, scopeTables, scopeColumns)
   for (const expr of select.groupBy) {
-    validateTableRefs(expr, scopeTables)
+    validateTableRefs(expr, scopeTables, scopeColumns)
   }
   for (const term of select.orderBy) {
-    validateTableRefs(term.expr, scopeTables)
+    validateTableRefs(term.expr, scopeTables, scopeColumns)
   }
   for (const join of select.joins) {
-    validateTableRefs(join.on, scopeTables)
+    validateTableRefs(join.on, scopeTables, scopeColumns)
   }
 
   // Determine scan hints for direct table scans (WHERE and LIMIT/OFFSET are

package/src/validation/tables.js

@@ -95,13 +95,18 @@ export function validateNoIdentifiers(expr, context) {
 
 /**
  * Validates that qualified identifiers reference known table aliases.
+ * A `prefix` may also be a bare column name in scope, in which case the
+ * identifier is struct-field access (e.g. `item.name` reads field `name`
+ * from a struct-valued column `item`).
  *
  * @param {ExprNode} expr
  * @param {Record<string, any>} tables
+ * @param {Set<string>} [scopeColumns] - bare column names in scope, used to
+ *   recognize struct-field dot access on a column rather than a table
  */
-export function validateTableRefs(expr, tables) {
+export function validateTableRefs(expr, tables, scopeColumns) {
   if (!expr) return
-  if (expr.type === 'identifier' && expr.prefix && !(expr.prefix in tables)) {
+  if (expr.type === 'identifier' && expr.prefix && !(expr.prefix in tables) && !scopeColumns?.has(expr.prefix)) {
     throw new TableNotFoundError({
       table: expr.prefix,
       qualified: expr.prefix + '.' + expr.name,
@@ -111,32 +116,32 @@ export function validateTableRefs(expr, tables) {
     })
   }
   if (expr.type === 'binary') {
-    validateTableRefs(expr.left, tables)
-    validateTableRefs(expr.right, tables)
+    validateTableRefs(expr.left, tables, scopeColumns)
+    validateTableRefs(expr.right, tables, scopeColumns)
   } else if (expr.type === 'unary') {
-    validateTableRefs(expr.argument, tables)
+    validateTableRefs(expr.argument, tables, scopeColumns)
   } else if (expr.type === 'function') {
     for (const arg of expr.args) {
-      validateTableRefs(arg, tables)
+      validateTableRefs(arg, tables, scopeColumns)
     }
   } else if (expr.type === 'window') {
-    for (const arg of expr.args) validateTableRefs(arg, tables)
-    for (const p of expr.partitionBy) validateTableRefs(p, tables)
-    for (const o of expr.orderBy) validateTableRefs(o.expr, tables)
+    for (const arg of expr.args) validateTableRefs(arg, tables, scopeColumns)
+    for (const p of expr.partitionBy) validateTableRefs(p, tables, scopeColumns)
+    for (const o of expr.orderBy) validateTableRefs(o.expr, tables, scopeColumns)
   } else if (expr.type === 'cast') {
-    validateTableRefs(expr.expr, tables)
+    validateTableRefs(expr.expr, tables, scopeColumns)
   } else if (expr.type === 'in valuelist') {
-    validateTableRefs(expr.expr, tables)
+    validateTableRefs(expr.expr, tables, scopeColumns)
     for (const val of expr.values) {
-      validateTableRefs(val, tables)
+      validateTableRefs(val, tables, scopeColumns)
     }
   } else if (expr.type === 'case') {
-    validateTableRefs(expr.caseExpr, tables)
+    validateTableRefs(expr.caseExpr, tables, scopeColumns)
     for (const w of expr.whenClauses) {
-      validateTableRefs(w.condition, tables)
-      validateTableRefs(w.result, tables)
+      validateTableRefs(w.condition, tables, scopeColumns)
+      validateTableRefs(w.result, tables, scopeColumns)
     }
-    validateTableRefs(expr.elseResult, tables)
+    validateTableRefs(expr.elseResult, tables, scopeColumns)
   }
 }