squirreling 0.7.1 → 0.7.3

package/README.md

@@ -10,7 +10,7 @@
 ![coverage](https://img.shields.io/badge/Coverage-95-darkred)
 [![dependencies](https://img.shields.io/badge/Dependencies-0-blueviolet)](https://www.npmjs.com/package/squirreling?activeTab=dependencies)
 
-Squirreling is a streaming async SQL engine for JavaScript. It is designed to provide efficient streaming of results from pluggable backends for highly efficient retrieval of data for browser applications.
+Squirreling is a streaming async SQL engine built for the web. It is designed to query over various data sources and provide efficient streaming of results. 100% JavaScript with zero dependencies.
 
 ## Features
 
@@ -78,8 +78,9 @@ console.log(`Collected rows:`, rows)
 ## Supported SQL Features
 
 - `SELECT` statements with `WHERE`, `ORDER BY`, `LIMIT`, `OFFSET`
+- `WITH` clause for Common Table Expressions (CTEs)
 - Subqueries in `SELECT`, `FROM`, and `WHERE` clauses
-- `JOIN` operations: `INNER JOIN`, `LEFT JOIN`, `RIGHT JOIN`, `FULL JOIN`
+- `JOIN` operations: `INNER JOIN`, `LEFT JOIN`, `RIGHT JOIN`, `FULL JOIN`, `POSITIONAL JOIN`
 - `GROUP BY` and `HAVING` clauses
 
 ### Functions

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squirreling",
-  "version": "0.7.1",
+  "version": "0.7.3",
   "description": "Squirreling SQL Engine",
   "author": "Hyperparam",
   "homepage": "https://hyperparam.app",
@@ -37,7 +37,7 @@
     "test": "vitest run"
   },
   "devDependencies": {
-    "@types/node": "24.10.4",
+    "@types/node": "25.0.3",
     "@vitest/coverage-v8": "4.0.16",
     "eslint": "9.39.2",
     "eslint-plugin-jsdoc": "61.5.0",

package/src/execute/execute.js

@@ -1,15 +1,16 @@
 import { missingClauseError } from '../parseErrors.js'
-import { tableNotFoundError, unsupportedOperationError } from '../executionErrors.js'
+import { unsupportedOperationError } from '../executionErrors.js'
 import { generatorSource, memorySource } from '../backend/dataSource.js'
 import { parseSql } from '../parse/parse.js'
 import { containsAggregate, extractColumns } from './columns.js'
 import { evaluateExpr } from './expression.js'
 import { evaluateHavingExpr } from './having.js'
 import { executeJoins } from './join.js'
+import { resolveTableSource } from './tableSource.js'
 import { compareForTerm, defaultDerivedAlias, stringify } from './utils.js'
 
 /**
- * @import { AsyncCells, AsyncDataSource, AsyncRow, ExecuteSqlOptions, OrderByItem, QueryHints, SelectStatement, SqlPrimitive, UserDefinedFunction } from '../types.js'
+ * @import { AsyncCells, AsyncDataSource, AsyncRow, CTEDefinition, ExecuteSqlOptions, OrderByItem, QueryHints, SelectStatement, SqlPrimitive, UserDefinedFunction, WithClause } from '../types.js'
  */
 
 /**
@@ -40,7 +41,7 @@ export async function* executeSql({ tables, query, functions, signal }) {
     }
   }
 
-  yield* executeSelect({ select, tables: normalizedTables, functions, signal })
+  yield* executeSelect({ select, tables: normalizedTables, withClause: select.with, functions, signal })
 }
 
 /**
@@ -49,32 +50,45 @@ export async function* executeSql({ tables, query, functions, signal }) {
  * @param {Object} options
  * @param {SelectStatement} options.select
  * @param {Record<string, AsyncDataSource>} options.tables
+ * @param {WithClause} [options.withClause] - WITH clause containing CTE definitions
  * @param {Record<string, UserDefinedFunction>} [options.functions]
  * @param {AbortSignal} [options.signal]
  * @yields {AsyncRow}
  */
-export async function* executeSelect({ select, tables, functions, signal }) {
+export async function* executeSelect({ select, tables, withClause, functions, signal }) {
   /** @type {AsyncDataSource} */
   let dataSource
   /** @type {string} */
   let leftTable
 
   if (select.from.kind === 'table') {
-    // Use alias for column prefixing, but look up the actual table name
-    leftTable = select.from.alias ?? select.from.table
-    dataSource = tables[select.from.table]
-    if (dataSource === undefined) {
-      throw tableNotFoundError({ tableName: select.from.table })
-    }
+    const tableName = select.from.table
+    leftTable = select.from.alias ?? tableName
+    dataSource = resolveTableSource(tableName, tables, withClause, executeSelect, functions, signal)
   } else {
     // Nested subquery - recursively resolve
     leftTable = select.from.alias
-    dataSource = generatorSource(executeSelect({ select: select.from.query, tables, functions, signal }))
+    dataSource = generatorSource(executeSelect({
+      select: select.from.query,
+      tables,
+      withClause,
+      functions,
+      signal,
+    }))
   }
 
   // Execute JOINs if present
   if (select.joins.length) {
-    dataSource = await executeJoins({ leftSource: dataSource, joins: select.joins, leftTable, tables, functions })
+    dataSource = await executeJoins({
+      leftSource: dataSource,
+      joins: select.joins,
+      leftTable,
+      tables,
+      withClause,
+      functions,
+      executeSelectFn: executeSelect,
+      signal,
+    })
   }
 
   yield* evaluateSelectAst({ select, dataSource, tables, functions, signal })

package/src/execute/join.js

@@ -1,10 +1,10 @@
 import { missingClauseError } from '../parseErrors.js'
-import { tableNotFoundError } from '../executionErrors.js'
 import { evaluateExpr } from './expression.js'
+import { resolveTableSource } from './tableSource.js'
 import { stringify } from './utils.js'
 
 /**
- * @import { AsyncRow, AsyncDataSource, JoinClause, ExprNode, AsyncCells, UserDefinedFunction } from '../types.js'
+ * @import { AsyncRow, AsyncDataSource, JoinClause, ExprNode, AsyncCells, UserDefinedFunction, WithClause } from '../types.js'
  */
 
 /**
@@ -15,19 +15,19 @@ import { stringify } from './utils.js'
  * @param {JoinClause[]} options.joins - array of join clauses to execute
  * @param {string} options.leftTable - name of the left table (for column prefixing)
  * @param {Record<string, AsyncDataSource>} options.tables - all available tables
+ * @param {WithClause} [options.withClause] - WITH clause containing CTE definitions
  * @param {Record<string, UserDefinedFunction>} [options.functions]
+ * @param {Function} [options.executeSelectFn] - function to execute SELECT for CTEs (passed to avoid circular dep)
+ * @param {AbortSignal} [options.signal]
  * @returns {Promise<AsyncDataSource>} data source yielding joined rows
  */
-export async function executeJoins({ leftSource, joins, leftTable, tables, functions }) {
+export async function executeJoins({ leftSource, joins, leftTable, tables, withClause, functions, executeSelectFn, signal }) {
   let currentLeftTable = leftTable
 
   // Single join optimization: stream left rows without buffering
   if (joins.length === 1) {
     const join = joins[0]
-    const rightSource = tables[join.table]
-    if (rightSource === undefined) {
-      throw tableNotFoundError({ tableName: join.table })
-    }
+    const rightSource = resolveTableSource(join.table, tables, withClause, executeSelectFn, functions, signal)
 
     // Buffer right rows for hash index (required for hash join)
     /** @type {AsyncRow[]} */
@@ -43,16 +43,26 @@ export async function executeJoins({ leftSource, joins, leftTable, tables, funct
     return {
       async *scan(options) {
         const { signal } = options
-        yield* hashJoin({
-          leftRows: leftSource.scan(options), // Stream directly, not buffered
-          rightRows,
-          join,
-          leftTable: currentLeftTable,
-          rightTable,
-          tables,
-          functions,
-          signal,
-        })
+        if (join.joinType === 'POSITIONAL') {
+          yield* positionalJoin({
+            leftRows: leftSource.scan(options),
+            rightRows,
+            leftTable: currentLeftTable,
+            rightTable,
+            signal,
+          })
+        } else {
+          yield* hashJoin({
+            leftRows: leftSource.scan(options), // Stream directly, not buffered
+            rightRows,
+            join,
+            leftTable: currentLeftTable,
+            rightTable,
+            tables,
+            functions,
+            signal,
+          })
+        }
       },
     }
   }
@@ -67,10 +77,7 @@ export async function executeJoins({ leftSource, joins, leftTable, tables, funct
   // Process all but the last join, buffering intermediate results
   for (let i = 0; i < joins.length - 1; i++) {
     const join = joins[i]
-    const rightSource = tables[join.table]
-    if (rightSource === undefined) {
-      throw tableNotFoundError({ tableName: join.table })
-    }
+    const rightSource = resolveTableSource(join.table, tables, withClause, executeSelectFn, functions, signal)
 
     /** @type {AsyncRow[]} */
     const rightRows = []
@@ -84,15 +91,22 @@ export async function executeJoins({ leftSource, joins, leftTable, tables, funct
     // Collect intermediate results into array for next join
     /** @type {AsyncRow[]} */
     const newLeftRows = []
-    const joined = hashJoin({
-      leftRows,
-      rightRows,
-      join,
-      leftTable: currentLeftTable,
-      rightTable,
-      tables,
-      functions,
-    })
+    const joined = join.joinType === 'POSITIONAL'
+      ? positionalJoin({
+        leftRows,
+        rightRows,
+        leftTable: currentLeftTable,
+        rightTable,
+      })
+      : hashJoin({
+        leftRows,
+        rightRows,
+        join,
+        leftTable: currentLeftTable,
+        rightTable,
+        tables,
+        functions,
+      })
     for await (const row of joined) {
       newLeftRows.push(row)
     }
@@ -104,10 +118,7 @@ export async function executeJoins({ leftSource, joins, leftTable, tables, funct
 
   // Final join: stream the results
   const join = joins[joins.length - 1]
-  const rightSource = tables[join.table]
-  if (rightSource === undefined) {
-    throw tableNotFoundError({ tableName: join.table })
-  }
+  const rightSource = resolveTableSource(join.table, tables, withClause, executeSelectFn, functions, signal)
 
   /** @type {AsyncRow[]} */
   const rightRows = []
@@ -121,16 +132,26 @@ export async function executeJoins({ leftSource, joins, leftTable, tables, funct
   return {
     async *scan(options) {
       const { signal } = options
-      yield* hashJoin({
-        leftRows,
-        rightRows,
-        join,
-        leftTable: currentLeftTable,
-        rightTable,
-        tables,
-        functions,
-        signal,
-      })
+      if (join.joinType === 'POSITIONAL') {
+        yield* positionalJoin({
+          leftRows,
+          rightRows,
+          leftTable: currentLeftTable,
+          rightTable,
+          signal,
+        })
+      } else {
+        yield* hashJoin({
+          leftRows,
+          rightRows,
+          join,
+          leftTable: currentLeftTable,
+          rightTable,
+          tables,
+          functions,
+          signal,
+        })
+      }
     },
   }
 }
@@ -230,6 +251,48 @@ function mergeRows(leftRow, rightRow, leftTable, rightTable) {
   return { columns, cells }
 }
 
+/**
+ * Performs a positional join between left and right row sets.
+ * Matches rows by their index position (row 0 with row 0, row 1 with row 1, etc.).
+ * When tables have different lengths, the shorter table is padded with NULLs.
+ *
+ * @param {Object} params
+ * @param {AsyncIterable<AsyncRow>|AsyncRow[]} params.leftRows - rows from left table
+ * @param {AsyncRow[]} params.rightRows - rows from right table (must be buffered)
+ * @param {string} params.leftTable - name of left table (for column prefixing)
+ * @param {string} params.rightTable - name of right table (for column prefixing, may be alias)
+ * @param {AbortSignal} [params.signal] - abort signal for cancellation
+ * @yields {AsyncRow} joined rows
+ */
+async function* positionalJoin({ leftRows, rightRows, leftTable, rightTable, signal }) {
+  // Buffer left rows if streaming
+  /** @type {AsyncRow[]} */
+  const leftArr = []
+  for await (const row of leftRows) {
+    if (signal?.aborted) return
+    leftArr.push(row)
+  }
+
+  const maxLen = Math.max(leftArr.length, rightRows.length)
+
+  // Get column info for NULL row creation
+  const leftCols = leftArr[0]?.columns ?? []
+  const rightCols = rightRows[0]?.columns ?? []
+  const leftPrefixedCols = leftCols.flatMap(col =>
+    col.includes('.') ? [col] : [`${leftTable}.${col}`, col]
+  )
+  const rightPrefixedCols = rightCols.flatMap(col =>
+    col.includes('.') ? [col] : [`${rightTable}.${col}`, col]
+  )
+
+  for (let i = 0; i < maxLen; i++) {
+    if (signal?.aborted) return
+    const leftRow = leftArr[i] ?? createNullRow(leftPrefixedCols)
+    const rightRow = rightRows[i] ?? createNullRow(rightPrefixedCols)
+    yield mergeRows(leftRow, rightRow, leftTable, rightTable)
+  }
+}
+
 /**
  * Performs a hash join between left and right row sets (streaming).
  * Yields rows as they are found instead of buffering all results.

package/src/execute/tableSource.js

@@ -0,0 +1,63 @@
+import { tableNotFoundError } from '../executionErrors.js'
+import { generatorSource } from '../backend/dataSource.js'
+
+/**
+ * @import { AsyncDataSource, CTEDefinition, UserDefinedFunction, WithClause } from '../types.js'
+ */
+
+/**
+ * Gets CTEs defined before the target CTE (excluding the target itself).
+ * Enforces SQL scoping rules: each CTE can only reference CTEs defined before it.
+ *
+ * @param {CTEDefinition[]} allCtes - all CTE definitions in order
+ * @param {string} targetCteName - the CTE name (case-insensitive)
+ * @returns {WithClause} CTEs available to the target
+ */
+export function getCtesDefinedBefore(allCtes, targetCteName) {
+  const available = []
+  for (const cte of allCtes) {
+    if (cte.name.toLowerCase() === targetCteName) break
+    available.push(cte)
+  }
+  return { ctes: available }
+}
+
+/**
+ * Resolves a table name to an AsyncDataSource, checking CTEs first
+ *
+ * @param {string} tableName - the table name to resolve
+ * @param {Record<string, AsyncDataSource>} tables - regular tables
+ * @param {import('../types.js').WithClause} [withClause] - WITH clause containing CTE definitions
+ * @param {Function} [executeSelectFn] - function to execute SELECT for CTEs
+ * @param {Record<string, UserDefinedFunction>} [functions]
+ * @param {AbortSignal} [signal]
+ * @returns {AsyncDataSource}
+ */
+export function resolveTableSource(tableName, tables, withClause, executeSelectFn, functions, signal) {
+  // Check CTEs first (case-insensitive) - only build map when CTE is actually found
+  if (withClause && executeSelectFn) {
+    const lowerName = tableName.toLowerCase()
+    const cte = withClause.ctes.find(c => c.name.toLowerCase() === lowerName)
+
+    if (cte) {
+      // CTE reference: wrap in generatorSource, re-execute each time (streaming)
+      // Pass only CTEs defined before this one to prevent self-reference
+      const availableCtes = getCtesDefinedBefore(withClause.ctes, lowerName)
+
+      return generatorSource(executeSelectFn({
+        select: cte.query,
+        tables,
+        withClause: availableCtes,
+        functions,
+        signal,
+      }))
+    }
+  }
+
+  // Regular table lookup
+  const tableSource = tables[tableName]
+  if (tableSource === undefined) {
+    throw tableNotFoundError({ tableName })
+  }
+  return tableSource
+}

package/src/index.d.ts

@@ -1,5 +1,5 @@
-import type { AsyncDataSource, AsyncRow, ExecuteSqlOptions, ParseSqlOptions, SelectStatement, SqlPrimitive } from './types.js'
-export type { AsyncDataSource, AsyncRow, ParseSqlOptions, SqlPrimitive } from './types.js'
+import type { AsyncDataSource, AsyncRow, ExecuteSqlOptions, ParseSqlOptions, SelectStatement, SqlPrimitive, Token } from './types.js'
+export type { AsyncCells, AsyncDataSource, AsyncRow, ExprNode, ParseSqlOptions, SelectStatement, SqlPrimitive, Token, UserDefinedFunction } from './types.js'
 
 /**
  * Executes a SQL SELECT query against an array of data rows
@@ -23,6 +23,14 @@ export function executeSql(options: ExecuteSqlOptions): AsyncGenerator<AsyncRow>
  */
 export function parseSql(options: ParseSqlOptions): SelectStatement
 
+/**
+ * Tokenizes a SQL query string into an array of tokens
+ *
+ * @param sql - SQL query string to tokenize
+ * @returns array of tokens
+ */
+export function tokenizeSql(sql: string): Token[]
+
 /**
  * Collects all results from an async generator into an array
  *

package/src/index.js

@@ -1,5 +1,6 @@
 export { executeSql } from './execute/execute.js'
 export { parseSql } from './parse/parse.js'
+export { tokenizeSql } from './parse/tokenize.js'
 export { collect } from './execute/utils.js'
 export { cachedDataSource } from './backend/dataSource.js'
 export { ParseError } from './parseErrors.js'

package/src/parse/joins.js

@@ -40,6 +40,9 @@ export function parseJoins(state) {
           // FULL OUTER JOIN
         }
         joinType = 'FULL'
+      } else if (tok.value === 'POSITIONAL') {
+        consume(state)
+        joinType = 'POSITIONAL'
       } else if (tok.value === 'JOIN') {
         // Just JOIN (defaults to INNER)
         consume(state)
@@ -61,9 +64,13 @@ export function parseJoins(state) {
     const tableName = expectIdentifier(state).value
     const tableAlias = parseTableAlias(state)
 
-    // Parse ON condition
-    expect(state, 'keyword', 'ON')
-    const condition = parseExpression(state)
+    // Parse ON condition (not for POSITIONAL joins)
+    /** @type {import('../types.js').ExprNode | undefined} */
+    let condition
+    if (joinType !== 'POSITIONAL') {
+      expect(state, 'keyword', 'ON')
+      condition = parseExpression(state)
+    }
 
     joins.push({
       joinType,

package/src/parse/parse.js

@@ -1,23 +1,87 @@
-import { tokenize } from './tokenize.js'
 import { parseExpression } from './expression.js'
-import { RESERVED_AFTER_COLUMN, RESERVED_AFTER_TABLE, isKnownFunction } from '../validation.js'
+import { tokenizeSql } from './tokenize.js'
 import { consume, current, expect, expectIdentifier, match, parseError, peekToken } from './state.js'
 import { parseJoins } from './joins.js'
+import { duplicateCTEError } from '../parseErrors.js'
+import { RESERVED_AFTER_COLUMN, RESERVED_AFTER_TABLE, isKnownFunction } from '../validation.js'
 
 /**
- * @import { ExprNode, FromSubquery, FromTable, OrderByItem, ParseSqlOptions, ParserState, SelectStatement, SelectColumn } from '../types.js'
+ * @import { CTEDefinition, ExprNode, FromSubquery, FromTable, OrderByItem, ParseSqlOptions, ParserState, SelectStatement, SelectColumn, WithClause } from '../types.js'
  */
 
+/**
+ * Parses a WITH clause containing one or more CTEs
+ * @param {ParserState} state
+ * @returns {WithClause}
+ */
+function parseWithClause(state) {
+  /** @type {CTEDefinition[]} */
+  const ctes = []
+  /** @type {Set<string>} */
+  const seenNames = new Set()
+
+  while (true) {
+    // Parse CTE name
+    const nameTok = expectIdentifier(state)
+    const name = nameTok.value
+    const nameLower = name.toLowerCase()
+
+    // Check for duplicate CTE names
+    if (seenNames.has(nameLower)) {
+      throw duplicateCTEError({
+        cteName: name,
+        positionStart: nameTok.positionStart,
+        positionEnd: nameTok.positionEnd,
+      })
+    }
+    seenNames.add(nameLower)
+
+    // Expect AS keyword
+    expect(state, 'keyword', 'AS')
+
+    // Expect opening parenthesis
+    expect(state, 'paren', '(')
+
+    // Parse the CTE's SELECT statement
+    const query = parseSelectInternal(state)
+
+    // Expect closing parenthesis
+    expect(state, 'paren', ')')
+
+    ctes.push({ name, query })
+
+    // Check for comma (more CTEs) or end of WITH clause
+    if (!match(state, 'comma')) {
+      break
+    }
+  }
+
+  return { ctes }
+}
+
 /**
  * @param {ParseSqlOptions} options
  * @returns {SelectStatement}
  */
 export function parseSql({ query, functions }) {
-  const tokens = tokenize(query)
+  const tokens = tokenizeSql(query)
   /** @type {ParserState} */
   const state = { tokens, pos: 0, functions }
+
+  // Check for WITH clause
+  /** @type {WithClause | undefined} */
+  let withClause
+  if (match(state, 'keyword', 'WITH')) {
+    withClause = parseWithClause(state)
+  }
+
   const select = parseSelectInternal(state)
 
+  // Attach WITH clause to the select statement
+  if (withClause) {
+    select.with = withClause
+  }
+
   const tok = current(state)
   if (tok.type !== 'eof') {
     throw parseError(state, 'end of query')

package/src/parse/tokenize.js

@@ -9,6 +9,7 @@ import {
  */
 
 const KEYWORDS = new Set([
+  'WITH',
   'SELECT',
   'FROM',
   'WHERE',
@@ -46,6 +47,7 @@ const KEYWORDS = new Set([
   'RIGHT',
   'FULL',
   'OUTER',
+  'POSITIONAL',
   'ON',
   'INTERVAL',
   'DAY',
@@ -60,7 +62,7 @@ const KEYWORDS = new Set([
  * @param {string} sql
  * @returns {Token[]}
  */
-export function tokenize(sql) {
+export function tokenizeSql(sql) {
   /** @type {Token[]} */
   const tokens = []
   const { length } = sql

package/src/parseErrors.js

@@ -79,7 +79,7 @@ export function invalidLiteralError({ type, value, positionStart, positionEnd, v
 export function unexpectedCharError({ char, positionStart, expectsSelect = false }) {
   const positionEnd = positionStart + 1
   if (expectsSelect) {
-    return new ParseError({ message: `Expected SELECT but found "${char}" at position ${positionStart}. Queries must start with SELECT.`, positionStart, positionEnd })
+    return new ParseError({ message: `Expected SELECT but found "${char}" at position ${positionStart}. Queries must start with SELECT or WITH.`, positionStart, positionEnd })
   }
   return new ParseError({ message: `Unexpected character "${char}" at position ${positionStart}`, positionStart, positionEnd })
 }
@@ -145,3 +145,20 @@ export function argCountParseError({ funcName, expected, received, positionStart
 export function missingClauseError({ missing, context, positionStart, positionEnd }) {
   return new ParseError({ message: `${context} requires ${missing}`, positionStart: positionStart ?? 0, positionEnd: positionEnd ?? 0 })
 }
+
+/**
+ * Error for duplicate CTE names in WITH clause.
+ *
+ * @param {Object} options
+ * @param {string} options.cteName - The duplicate CTE name
+ * @param {number} options.positionStart - Start position in query
+ * @param {number} options.positionEnd - End position in query
+ * @returns {ParseError}
+ */
+export function duplicateCTEError({ cteName, positionStart, positionEnd }) {
+  return new ParseError({
+    message: `CTE "${cteName}" is defined more than once at position ${positionStart}`,
+    positionStart,
+    positionEnd,
+  })
+}

package/src/types.d.ts

@@ -67,7 +67,17 @@ export interface UserDefinedFunction {
   }
 }
 
+export interface CTEDefinition {
+  name: string
+  query: SelectStatement
+}
+
+export interface WithClause {
+  ctes: CTEDefinition[]
+}
+
 export interface SelectStatement {
+  with?: WithClause
   distinct: boolean
   columns: SelectColumn[]
   from: FromTable | FromSubquery
@@ -255,7 +265,7 @@ export interface OrderByItem {
   nulls?: 'FIRST' | 'LAST'
 }
 
-export type JoinType = 'INNER' | 'LEFT' | 'RIGHT' | 'FULL' | 'CROSS'
+export type JoinType = 'INNER' | 'LEFT' | 'RIGHT' | 'FULL' | 'CROSS' | 'POSITIONAL'
 
 export interface JoinClause {
   joinType: JoinType

package/src/validation.js

@@ -211,5 +211,5 @@ 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',
+  'LEFT', 'RIGHT', 'FULL', 'CROSS', 'ON', 'POSITIONAL',
 ])