squirreling 0.12.21 → 0.12.23

package/README.md

@@ -141,7 +141,7 @@ Squirreling mostly follows the SQL standard. The following features are supporte
 - `SELECT` statements with `DISTINCT`, `WHERE`, `ORDER BY`, `LIMIT`, `OFFSET`
 - `WITH` clause for Common Table Expressions (CTEs)
 - Subqueries in `SELECT`, `FROM`, `WHERE`, and correlated subqueries
-- `JOIN` operations: `INNER JOIN`, `LEFT JOIN`, `RIGHT JOIN`, `FULL JOIN`, `CROSS JOIN`, `POSITIONAL JOIN`, `LATERAL VIEW [OUTER] EXPLODE(...)`
+- `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`
@@ -160,7 +160,7 @@ Squirreling mostly follows the SQL standard. The following features are supporte
 - 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`
-- Json: `JSON_VALUE`, `JSON_QUERY`, `JSON_EXTRACT`, `JSON_OBJECT`, `JSON_ARRAY_LENGTH`, `JSON_VALID`, `JSON_TYPE`
+- Json: `JSON_VALUE`, `JSON_QUERY`, `JSON_EXTRACT`, `JSON_OBJECT`, `JSON_ARRAY_LENGTH`, `JSON_VALID`, `JSON_TYPE`, `JSON_KEYS`
 - 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`

package/package.json

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

package/src/ast.d.ts

@@ -210,6 +210,7 @@ export interface JoinClause extends AstBase {
   table: string
   alias?: string
   on?: ExprNode
+  using?: string[]
   fromFunction?: FromFunction
 }
 

package/src/execute/aggregates.js

@@ -3,6 +3,7 @@ import { evaluateExpr } from '../expression/evaluate.js'
 import { executePlan, selectColumnNames } from './execute.js'
 import { sortEntriesByTerms } from './sort.js'
 import { keyify } from './utils.js'
+import { yieldToEventLoop } from './yield.js'
 
 /**
  * @import { AsyncCells, AsyncDataSource, AsyncRow, DerivedColumn, ExecuteContext, QueryResults, SelectColumn, SqlPrimitive } from '../types.js'
@@ -89,29 +90,45 @@ export function executeHashAggregate(plan, context) {
       let collectCount = 0
       for await (const row of child.rows()) {
         if (++collectCount % YIELD_INTERVAL === 0) {
-          await new Promise(resolve => setTimeout(resolve, 0))
+          await yieldToEventLoop()
           if (context.signal?.aborted) return
         }
         allRows.push(row)
       }
 
-      // Group rows by GROUP BY keys
+      // Group rows by GROUP BY keys.
+      // Each chunk dispatches all per-row key evaluations in parallel so
+      // async cells (e.g. lazy parquet decode) overlap; the await is at the
+      // chunk boundary. Synchronous cells stay cheap because we skip the
+      // inner Promise.all wrapper when there's a single GROUP BY expression.
       /** @type {Map<any, AsyncRow[]>} */
       const groups = new Map()
+      const { groupBy } = plan
+      const singleKey = groupBy.length === 1
+      const singleExpr = singleKey ? groupBy[0] : null
 
       for (let chunkStart = 0; chunkStart < allRows.length; chunkStart += YIELD_INTERVAL) {
         if (chunkStart > 0) {
-          await new Promise(resolve => setTimeout(resolve, 0))
+          await yieldToEventLoop()
           if (context.signal?.aborted) return
         }
         const chunkEnd = Math.min(chunkStart + YIELD_INTERVAL, allRows.length)
-        const chunkKeys = await Promise.all(
-          allRows.slice(chunkStart, chunkEnd).map(row =>
-            Promise.all(plan.groupBy.map(expr => evaluateExpr({ node: expr, row, context })))
-          )
-        )
-        for (let j = 0; j < chunkKeys.length; j++) {
-          const key = keyify(...chunkKeys[j])
+        const chunkLen = chunkEnd - chunkStart
+        /** @type {Promise<any>[]} */
+        const pending = new Array(chunkLen)
+        if (singleKey) {
+          for (let j = 0; j < chunkLen; j++) {
+            pending[j] = evaluateExpr({ node: singleExpr, row: allRows[chunkStart + j], context })
+          }
+        } else {
+          for (let j = 0; j < chunkLen; j++) {
+            const row = allRows[chunkStart + j]
+            pending[j] = Promise.all(groupBy.map(expr => evaluateExpr({ node: expr, row, context })))
+          }
+        }
+        const chunkKeys = await Promise.all(pending)
+        for (let j = 0; j < chunkLen; j++) {
+          const key = singleKey ? keyify(chunkKeys[j]) : keyify(...chunkKeys[j])
           const row = allRows[chunkStart + j]
           let group = groups.get(key)
           if (!group) {
@@ -189,7 +206,7 @@ export function executeScalarAggregate(plan, context) {
       let collectCount = 0
       for await (const row of child.rows()) {
         if (++collectCount % YIELD_INTERVAL === 0) {
-          await new Promise(resolve => setTimeout(resolve, 0))
+          await yieldToEventLoop()
           if (context.signal?.aborted) return
         }
         group.push(row)

package/src/execute/execute.js

@@ -10,6 +10,7 @@ import { executeHashJoin, executeNestedLoopJoin, executePositionalJoin } from '.
 import { executeSort } from './sort.js'
 import { addBounds, minBounds, stableRowKey } from './utils.js'
 import { executeWindow } from './window.js'
+import { yieldToEventLoop } from './yield.js'
 
 /**
  * @import { AsyncCells, AsyncDataSource, AsyncRow, DerivedColumn, ExecuteContext, ExecuteSqlOptions, ExprNode, IdentifierNode, QueryResults, SelectColumn, SqlPrimitive, Statement } from '../types.js'
@@ -417,7 +418,7 @@ async function* filterRows(rows, condition, context, limit) {
   for await (const row of rows) {
     if (context.signal?.aborted) return
     if (++innerCount % YIELD_INTERVAL === 0) {
-      await new Promise(resolve => setTimeout(resolve, 0))
+      await yieldToEventLoop()
       if (context.signal?.aborted) return
     }
     rowIndex++
@@ -463,7 +464,7 @@ async function* limitRows(rows, limit = Infinity, offset = 0, signal) {
   for await (const row of rows) {
     if (signal?.aborted) return
     if (++innerCount % YIELD_INTERVAL === 0) {
-      await new Promise(resolve => setTimeout(resolve, 0))
+      await yieldToEventLoop()
       if (signal?.aborted) return
     }
     if (skipped < offset) {
@@ -518,7 +519,7 @@ function executeProject(plan, context) {
       for await (const row of child.rows()) {
         if (context.signal?.aborted) return
         if (++innerCount % YIELD_INTERVAL === 0) {
-          await new Promise(resolve => setTimeout(resolve, 0))
+          await yieldToEventLoop()
           if (context.signal?.aborted) return
         }
         rowIndex++
@@ -611,7 +612,7 @@ function executeDistinct(plan, context) {
       for await (const row of child.rows()) {
         if (signal?.aborted) return
         if (++innerCount % YIELD_INTERVAL === 0) {
-          await new Promise(resolve => setTimeout(resolve, 0))
+          await yieldToEventLoop()
           if (signal?.aborted) return
         }
         buffer.push(row)
@@ -698,7 +699,7 @@ function executeSetOperation(plan, context) {
           for await (const row of left.rows()) {
             if (signal?.aborted) return
             if (++count % YIELD_INTERVAL === 0) {
-              await new Promise(resolve => setTimeout(resolve, 0))
+              await yieldToEventLoop()
               if (signal?.aborted) return
             }
             const key = await stableRowKey(row)
@@ -710,7 +711,7 @@ function executeSetOperation(plan, context) {
           for await (const row of right.rows()) {
             if (signal?.aborted) return
             if (++count % YIELD_INTERVAL === 0) {
-              await new Promise(resolve => setTimeout(resolve, 0))
+              await yieldToEventLoop()
               if (signal?.aborted) return
             }
             const key = await stableRowKey(row)
@@ -736,7 +737,7 @@ function executeSetOperation(plan, context) {
         for await (const row of right.rows()) {
           if (signal?.aborted) return
           if (++tick % YIELD_INTERVAL === 0) {
-            await new Promise(resolve => setTimeout(resolve, 0))
+            await yieldToEventLoop()
             if (signal?.aborted) return
           }
           const key = await stableRowKey(row)
@@ -748,7 +749,7 @@ function executeSetOperation(plan, context) {
           for await (const row of left.rows()) {
             if (signal?.aborted) return
             if (++tick % YIELD_INTERVAL === 0) {
-              await new Promise(resolve => setTimeout(resolve, 0))
+              await yieldToEventLoop()
               if (signal?.aborted) return
             }
             const key = await stableRowKey(row)
@@ -764,7 +765,7 @@ function executeSetOperation(plan, context) {
           for await (const row of left.rows()) {
             if (signal?.aborted) return
             if (++tick % YIELD_INTERVAL === 0) {
-              await new Promise(resolve => setTimeout(resolve, 0))
+              await yieldToEventLoop()
               if (signal?.aborted) return
             }
             const key = await stableRowKey(row)
@@ -791,7 +792,7 @@ function executeSetOperation(plan, context) {
         for await (const row of right.rows()) {
           if (signal?.aborted) return
           if (++tick % YIELD_INTERVAL === 0) {
-            await new Promise(resolve => setTimeout(resolve, 0))
+            await yieldToEventLoop()
             if (signal?.aborted) return
           }
           const key = await stableRowKey(row)
@@ -803,7 +804,7 @@ function executeSetOperation(plan, context) {
           for await (const row of left.rows()) {
             if (signal?.aborted) return
             if (++tick % YIELD_INTERVAL === 0) {
-              await new Promise(resolve => setTimeout(resolve, 0))
+              await yieldToEventLoop()
               if (signal?.aborted) return
             }
             const key = await stableRowKey(row)
@@ -820,7 +821,7 @@ function executeSetOperation(plan, context) {
           for await (const row of left.rows()) {
             if (signal?.aborted) return
             if (++tick % YIELD_INTERVAL === 0) {
-              await new Promise(resolve => setTimeout(resolve, 0))
+              await yieldToEventLoop()
               if (signal?.aborted) return
             }
             const key = await stableRowKey(row)

package/src/execute/join.js

@@ -1,6 +1,7 @@
 import { evaluateExpr } from '../expression/evaluate.js'
 import { keyify, maxBounds } from './utils.js'
 import { executePlan } from './execute.js'
+import { yieldToEventLoop } from './yield.js'
 
 /**
  * @import { AsyncCells, AsyncRow, ExecuteContext, QueryResults } from '../types.js'
@@ -56,7 +57,7 @@ export function executeNestedLoopJoin(plan, context) {
 
         for (const rightRow of rightRows) {
           if (++innerCount % YIELD_INTERVAL === 0) {
-            await new Promise(resolve => setTimeout(resolve, 0))
+            await yieldToEventLoop()
             if (context.signal?.aborted) return
           }
           const tempMerged = mergeRows(leftRow, rightRow, leftTable, rightTable)
@@ -263,7 +264,7 @@ export function executeHashJoin(plan, context) {
           if (candidates?.length) {
             for (const rightRow of candidates) {
               if (++innerCount % YIELD_INTERVAL === 0) {
-                await new Promise(resolve => setTimeout(resolve, 0))
+                await yieldToEventLoop()
                 if (context.signal?.aborted) return
               }
               const merged = mergeRows(leftRow, rightRow, leftTable, rightTable)

package/src/execute/window.js

@@ -1,6 +1,7 @@
 import { evaluateExpr } from '../expression/evaluate.js'
 import { executePlan } from './execute.js'
 import { compareForTerm, keyify } from './utils.js'
+import { yieldToEventLoop } from './yield.js'
 
 /**
  * @import { AsyncRow, ExecuteContext, QueryResults, SqlPrimitive } from '../types.js'
@@ -40,7 +41,7 @@ export function executeWindow(plan, context) {
         let i = 0
         for await (const row of child.rows()) {
           if (++i % YIELD_INTERVAL === 0) {
-            await new Promise(resolve => setTimeout(resolve, 0))
+            await yieldToEventLoop()
             if (context.signal?.aborted) return
           }
           const cells = { ...row.cells }
@@ -67,7 +68,7 @@ export function executeWindow(plan, context) {
       let collectCount = 0
       for await (const row of child.rows()) {
         if (++collectCount % YIELD_INTERVAL === 0) {
-          await new Promise(resolve => setTimeout(resolve, 0))
+          await yieldToEventLoop()
           if (context.signal?.aborted) return
         }
         rows.push(row)
@@ -86,7 +87,7 @@ export function executeWindow(plan, context) {
       let emitCount = 0
       for (let i = 0; i < rows.length; i++) {
         if (++emitCount % YIELD_INTERVAL === 0) {
-          await new Promise(resolve => setTimeout(resolve, 0))
+          await yieldToEventLoop()
           if (context.signal?.aborted) return
         }
         const row = rows[i]
@@ -120,7 +121,7 @@ async function computeWindow(spec, rows, output, context) {
   const partitions = new Map()
   for (let chunkStart = 0; chunkStart < rows.length; chunkStart += YIELD_INTERVAL) {
     if (chunkStart > 0) {
-      await new Promise(resolve => setTimeout(resolve, 0))
+      await yieldToEventLoop()
       if (context.signal?.aborted) return
     }
     const chunkEnd = Math.min(chunkStart + YIELD_INTERVAL, rows.length)
@@ -151,7 +152,7 @@ async function computeWindow(spec, rows, output, context) {
       const entries = new Array(bucket.length)
       for (let chunkStart = 0; chunkStart < bucket.length; chunkStart += YIELD_INTERVAL) {
         if (chunkStart > 0) {
-          await new Promise(resolve => setTimeout(resolve, 0))
+          await yieldToEventLoop()
           if (context.signal?.aborted) return
         }
         const chunkEnd = Math.min(chunkStart + YIELD_INTERVAL, bucket.length)
@@ -203,7 +204,7 @@ async function applyWindowFunction(spec, ordered, rows, output, context) {
     let tick = 0
     for (let k = 0; k < ordered.length; k++) {
       if (++tick % YIELD_INTERVAL === 0) {
-        await new Promise(resolve => setTimeout(resolve, 0))
+        await yieldToEventLoop()
         if (context.signal?.aborted) return
       }
       const idx = ordered[k]

package/src/execute/yield.js

@@ -0,0 +1,30 @@
+// Yield to the event loop so that timer-based aborts can fire.
+//
+// In Node, setTimeout(fn, 0) is clamped to a 1ms minimum, so a tight loop
+// that yields every few thousand iterations can spend hundreds of ms in
+// scheduling overhead alone. setImmediate (Node) and MessageChannel
+// (browsers) provide the same macrotask boundary at a fraction of the cost.
+//
+// We need a macrotask boundary (not just a microtask) because the abort
+// timer itself is a macrotask; microtasks alone cannot let it fire.
+
+/** @type {() => Promise<void>} */
+export const yieldToEventLoop = (() => {
+  if (typeof setImmediate === 'function') {
+    return () => new Promise(resolve => setImmediate(resolve))
+  }
+  if (typeof MessageChannel !== 'undefined') {
+    const channel = new MessageChannel()
+    /** @type {Array<() => void>} */
+    const queue = []
+    channel.port1.onmessage = () => {
+      const resolve = queue.shift()
+      if (resolve) resolve()
+    }
+    return () => new Promise(resolve => {
+      queue.push(resolve)
+      channel.port2.postMessage(0)
+    })
+  }
+  return () => new Promise(resolve => setTimeout(resolve, 0))
+})()

package/src/expression/evaluate.js

@@ -1,5 +1,6 @@
 import { executeStatement } from '../execute/execute.js'
 import { isPlainObject, keyify, sqlEquals, stringify } from '../execute/utils.js'
+import { yieldToEventLoop } from '../execute/yield.js'
 import { ArgValueError, ExecutionError } from '../validation/executionErrors.js'
 import { isAggregateFunc, isMathFunc, isRegexpFunc, isSpatialFunc, isStringFunc } from '../validation/functions.js'
 import { UnknownFunctionError } from '../validation/parseErrors.js'
@@ -31,16 +32,21 @@ const YIELD_INTERVAL = 4000
 async function evaluateAll(node, rows, context) {
   /** @type {SqlPrimitive[]} */
   const results = new Array(rows.length)
+  /** @type {Promise<SqlPrimitive>[]} */
+  const pending = new Array(Math.min(YIELD_INTERVAL, rows.length))
   for (let i = 0; i < rows.length; i += YIELD_INTERVAL) {
     if (i > 0) {
-      await new Promise(resolve => setTimeout(resolve, 0))
+      await yieldToEventLoop()
       context.signal?.throwIfAborted()
     }
     const end = Math.min(i + YIELD_INTERVAL, rows.length)
-    const chunk = await Promise.all(rows.slice(i, end).map(row =>
-      evaluateExpr({ node, row, context })
-    ))
-    for (let j = 0; j < chunk.length; j++) results[i + j] = chunk[j]
+    const chunkLen = end - i
+    pending.length = chunkLen
+    for (let j = 0; j < chunkLen; j++) {
+      pending[j] = evaluateExpr({ node, row: rows[i + j], context })
+    }
+    const chunk = await Promise.all(pending)
+    for (let j = 0; j < chunkLen; j++) results[i + j] = chunk[j]
   }
   return results
 }
@@ -326,7 +332,7 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
         return values[lower] + (values[upper] - values[lower]) * (pos - lower)
       }
 
-      if (funcName === 'JSON_ARRAYAGG' || funcName === 'ARRAY_AGG') {
+      if (funcName === 'JSON_ARRAYAGG' || funcName === 'ARRAY_AGG' || funcName === 'LIST') {
         const allValues = await evaluateAll(argNode, filteredRows, context)
         if (node.distinct) {
           /** @type {SqlPrimitive[]} */
@@ -510,6 +516,25 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
       return typeof value
     }
 
+    if (funcName === 'JSON_KEYS') {
+      let value = args[0]
+      if (value == null) return null
+      if (typeof value === 'string') {
+        try {
+          value = JSON.parse(value)
+        } catch {
+          throw new ArgValueError({
+            ...node,
+            message: 'invalid JSON string',
+            hint: 'Argument must be valid JSON.',
+            rowIndex,
+          })
+        }
+      }
+      if (typeof value !== 'object' || value === null || Array.isArray(value) || value instanceof Date) return null
+      return Object.keys(value)
+    }
+
     if (funcName === 'JSON_ARRAY_LENGTH') {
       let arr = args[0]
       if (arr == null) return null
@@ -703,7 +728,7 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
     let innerCount = 0
     for await (const resRow of subResult.rows()) {
       if (++innerCount % YIELD_INTERVAL === 0) {
-        await new Promise(resolve => setTimeout(resolve, 0))
+        await yieldToEventLoop()
         context.signal?.throwIfAborted()
       }
       const value = await resRow.cells[resRow.columns[0]]()

package/src/parse/joins.js

@@ -222,13 +222,26 @@ export function parseJoins(state) {
     const tableTok = expect(state, 'identifier')
     const tableAlias = parseTableAlias(state)
 
-    // Parse ON condition (not for POSITIONAL joins)
+    // Parse ON condition or USING column list (not for POSITIONAL joins)
     /** @type {ExprNode | undefined} */
     let condition
+    /** @type {string[] | undefined} */
+    let using
     if (joinType !== 'POSITIONAL') {
-      expect(state, 'keyword', 'ON')
-      condition = parseExpression(state)
-      expectNoAggregate(condition, 'JOIN ON')
+      if (match(state, 'keyword', 'USING')) {
+        expect(state, 'paren', '(')
+        using = []
+        while (true) {
+          const colTok = expect(state, 'identifier')
+          using.push(colTok.value)
+          if (!match(state, 'comma')) break
+        }
+        expect(state, 'paren', ')')
+      } else {
+        expect(state, 'keyword', 'ON')
+        condition = parseExpression(state)
+        expectNoAggregate(condition, 'JOIN ON')
+      }
     }
 
     joins.push({
@@ -236,6 +249,7 @@ export function parseJoins(state) {
       table: tableTok.value,
       alias: tableAlias,
       on: condition,
+      using,
       positionStart: tok.positionStart,
       positionEnd: tableTok.positionEnd,
     })

package/src/plan/columns.js

@@ -153,6 +153,13 @@ export function extractColumns({ select, parentColumns }) {
   if (sourceAlias !== undefined) visibleLateralAliases.push(sourceAlias)
   for (const join of select.joins) {
     collectColumnsFromExpr(join.on, identifiers)
+    // USING columns are equi-join keys on both sides; keep them in every
+    // table's needed set so projection pushdown can't prune the join key.
+    if (join.using) {
+      for (const col of join.using) {
+        for (const [, set] of perTable) set?.add(col)
+      }
+    }
     const joinAlias = join.alias ?? join.table
     if (join.fromFunction) {
       /** @type {IdentifierNode[]} */

package/src/plan/plan.js

@@ -463,7 +463,10 @@ function planJoin({ left, joins, leftTable, ctePlans, cteColumns, perTableColumn
     if (join.joinType === 'POSITIONAL') {
       plan = { type: 'PositionalJoin', leftAlias: currentLeftTable, rightAlias: rightTable, left: plan, right: rightScan }
     } else {
-      const keys = join.on && extractEquiKeys({ condition: join.on, leftTable: currentLeftTable, rightTable })
+      // `USING (cols)` desugars to an equi-condition `left.col = right.col` per
+      // column, which routes through the hash-join path like any other ON.
+      const condition = join.on ?? (join.using && buildUsingCondition(join.using, join))
+      const keys = condition && extractEquiKeys({ condition, leftTable: currentLeftTable, rightTable })
       if (keys) {
         /** @type {HashJoinNode} */
         const hashJoin = {
@@ -484,7 +487,7 @@ function planJoin({ left, joins, leftTable, ctePlans, cteColumns, perTableColumn
           joinType: join.joinType,
           leftAlias: currentLeftTable,
           rightAlias: rightTable,
-          condition: join.on,
+          condition,
           left: plan,
           right: rightScan,
         }
@@ -623,6 +626,37 @@ function normalizeIdentifiers(node, sourceColumns) {
   return node
 }
 
+/**
+ * Builds the join condition for a `JOIN ... USING (cols)` clause: an AND of
+ * `col = col` equalities using unprefixed identifiers. The hash-join path
+ * evaluates the left key against the left row and the right key against the
+ * right row, so each unqualified name resolves unambiguously on its own side.
+ *
+ * @param {string[]} using - shared column names from the USING clause
+ * @param {{ positionStart: number, positionEnd: number }} pos - position info for the synthesized exprs
+ * @returns {ExprNode | undefined}
+ */
+function buildUsingCondition(using, pos) {
+  const { positionStart, positionEnd } = pos
+  /** @type {ExprNode | undefined} */
+  let condition
+  for (const col of using) {
+    /** @type {ExprNode} */
+    const eq = {
+      type: 'binary',
+      op: '=',
+      left: { type: 'identifier', name: col, positionStart, positionEnd },
+      right: { type: 'identifier', name: col, positionStart, positionEnd },
+      positionStart,
+      positionEnd,
+    }
+    condition = condition === undefined
+      ? eq
+      : { type: 'binary', op: 'AND', left: condition, right: eq, positionStart, positionEnd }
+  }
+  return condition
+}
+
 /**
  * Splits a join ON expression into equi-key pairs and a residual predicate so
  * the planner can route AND-of-equis (with optional range/inequality

package/src/types.d.ts

@@ -129,7 +129,7 @@ export interface UserDefinedFunction {
   arguments: FunctionSignature
 }
 
-export type AggregateFunc = 'COUNT' | 'COUNTIF' | 'SUM' | 'AVG' | 'MIN' | 'MAX' | 'ARRAY_AGG' | 'JSON_ARRAYAGG' | 'STDDEV_SAMP' | 'STDDEV_POP' | 'MEDIAN' | 'PERCENTILE_CONT' | 'APPROX_QUANTILE' | 'STRING_AGG'
+export type AggregateFunc = 'COUNT' | 'COUNTIF' | 'SUM' | 'AVG' | 'MIN' | 'MAX' | 'ARRAY_AGG' | 'LIST' | 'JSON_ARRAYAGG' | 'STDDEV_SAMP' | 'STDDEV_POP' | 'MEDIAN' | 'PERCENTILE_CONT' | 'APPROX_QUANTILE' | 'STRING_AGG'
 
 export type RegExpFunction = 'REGEXP_SUBSTR' | 'REGEXP_EXTRACT' | 'REGEXP_REPLACE' | 'REGEXP_MATCHES'
 

package/src/validation/functions.js

@@ -11,7 +11,7 @@ export const niladicFuncs = ['CURRENT_DATE', 'CURRENT_TIME', 'CURRENT_TIMESTAMP'
  * @returns {name is AggregateFunc}
  */
 export function isAggregateFunc(name) {
-  return ['COUNT', 'COUNTIF', 'SUM', 'AVG', 'MIN', 'MAX', 'ARRAY_AGG', 'JSON_ARRAYAGG', 'STDDEV_SAMP', 'STDDEV_POP', 'MEDIAN', 'PERCENTILE_CONT', 'APPROX_QUANTILE', 'STRING_AGG'].includes(name)
+  return ['COUNT', 'COUNTIF', 'SUM', 'AVG', 'MIN', 'MAX', 'ARRAY_AGG', 'LIST', 'JSON_ARRAYAGG', 'STDDEV_SAMP', 'STDDEV_POP', 'MEDIAN', 'PERCENTILE_CONT', 'APPROX_QUANTILE', 'STRING_AGG'].includes(name)
 }
 
 /**
@@ -179,8 +179,10 @@ export const FUNCTION_SIGNATURES = {
   JSON_ARRAY_LENGTH: { min: 1, max: 1, signature: 'array' },
   JSON_VALID: { min: 1, max: 1, signature: 'value' },
   JSON_TYPE: { min: 1, max: 1, signature: 'value' },
+  JSON_KEYS: { min: 1, max: 1, signature: 'value' },
   JSON_ARRAYAGG: { min: 1, max: 1, signature: 'expression' },
   ARRAY_AGG: { min: 1, max: 1, signature: 'expression' },
+  LIST: { min: 1, max: 1, signature: 'expression' },
 
   // Array functions
   ARRAY_LENGTH: { min: 1, max: 2, signature: 'array[, dimension]' },

package/src/validation/keywords.js

@@ -3,7 +3,7 @@ export const KEYWORDS = new Set([
   'HAVING', 'ORDER', 'ASC', 'DESC', 'NULLS', 'LIMIT', 'OFFSET', 'AS', 'ALL',
   'DISTINCT', 'TRUE', 'FALSE', 'NULL', 'LIKE', 'IN', 'EXISTS', 'BETWEEN',
   'CASE', 'WHEN', 'THEN', 'ELSE', 'END', 'JOIN', 'INNER', 'LEFT', 'RIGHT',
-  'FULL', 'OUTER', 'CROSS', 'POSITIONAL', 'LATERAL', 'VIEW', 'ON', 'INTERVAL', 'DAY', 'MONTH', 'YEAR',
+  'FULL', 'OUTER', 'CROSS', 'POSITIONAL', 'LATERAL', 'VIEW', 'ON', 'USING', 'INTERVAL', 'DAY', 'MONTH', 'YEAR',
   'HOUR', 'MINUTE', 'SECOND', 'FILTER', 'WITHIN',
   'UNION', 'INTERSECT', 'EXCEPT',
 ])
@@ -17,7 +17,7 @@ export const RESERVED_KEYWORDS = new Set([
   'EXISTS', 'CASE', 'WHEN', 'THEN', 'ELSE', 'END', 'INTERVAL',
   'GROUP', 'BY', 'HAVING', 'ORDER', 'LIMIT', 'OFFSET',
   'AS', 'ALL', 'DISTINCT',
-  'JOIN', 'INNER', 'LEFT', 'RIGHT', 'FULL', 'OUTER', 'ON',
+  'JOIN', 'INNER', 'LEFT', 'RIGHT', 'FULL', 'OUTER', 'ON', 'USING',
   'UNION', 'INTERSECT', 'EXCEPT',
 ])
 
@@ -30,6 +30,6 @@ export const RESERVED_AFTER_COLUMN = new Set([
 // Keywords that cannot be used as table aliases
 export const RESERVED_AFTER_TABLE = new Set([
   'WHERE', 'GROUP', 'HAVING', 'ORDER', 'LIMIT', 'OFFSET', 'JOIN', 'INNER',
-  'LEFT', 'RIGHT', 'FULL', 'CROSS', 'ON', 'POSITIONAL', 'LATERAL',
+  'LEFT', 'RIGHT', 'FULL', 'CROSS', 'ON', 'USING', 'POSITIONAL', 'LATERAL',
   'UNION', 'INTERSECT', 'EXCEPT',
 ])