squirreling 0.10.0 → 0.10.2

package/src/{parseErrors.js → validation/parseErrors.js}

@@ -1,9 +1,3 @@
-// ============================================================================
-// PARSE ERRORS - Issues during SQL tokenization and parsing
-// ============================================================================
-
-import { FUNCTION_SIGNATURES } from './validationErrors.js'
-
 /**
  * Structured parse error with position range.
  */
@@ -11,8 +5,8 @@ export class ParseError extends Error {
   /**
    * @param {Object} options
    * @param {string} options.message - Human-readable error message
-   * @param {number} options.positionStart - Start position (0-based character offset)
-   * @param {number} options.positionEnd - End position (exclusive, 0-based character offset)
+   * @param {number} options.positionStart
+   * @param {number} options.positionEnd
    */
   constructor({ message, positionStart, positionEnd }) {
     super(message)
@@ -28,8 +22,8 @@ export class ParseError extends Error {
  * @param {Object} options
  * @param {string} options.expected - Description of what was expected
  * @param {string} options.received - What was actually found
- * @param {number} options.positionStart - Start character position in query
- * @param {number} options.positionEnd - End character position in query
+ * @param {number} options.positionStart
+ * @param {number} options.positionEnd
  * @param {string} [options.after] - What token came before (for context)
  * @returns {ParseError}
  */
@@ -43,8 +37,8 @@ export function syntaxError({ expected, received, positionStart, positionEnd, af
  *
  * @param {Object} options
  * @param {'string' | 'identifier'} options.type - Type of unterminated literal
- * @param {number} options.positionStart - Starting position
- * @param {number} options.positionEnd - End position
+ * @param {number} options.positionStart
+ * @param {number} options.positionEnd
  * @returns {ParseError}
  */
 export function unterminatedError({ type, positionStart, positionEnd }) {
@@ -58,8 +52,8 @@ export function unterminatedError({ type, positionStart, positionEnd }) {
  * @param {Object} options
  * @param {string} options.type - Type of invalid literal (e.g., 'number', 'interval value', 'interval unit')
  * @param {string} options.value - The invalid value
- * @param {number} options.positionStart - Start position in query
- * @param {number} options.positionEnd - End position in query
+ * @param {number} options.positionStart
+ * @param {number} options.positionEnd
  * @param {string} [options.validValues] - List of valid values (for enums like interval units)
  * @returns {ParseError}
  */
@@ -73,11 +67,11 @@ export function invalidLiteralError({ type, value, positionStart, positionEnd, v
  *
  * @param {Object} options
  * @param {string} options.char - The unexpected character
- * @param {number} options.positionStart - Position in query
- * @param {boolean} [options.expectsSelect=false] - Whether SELECT was expected (first token)
+ * @param {number} options.positionStart
+ * @param {boolean} options.expectsSelect - Whether SELECT was expected (first token)
  * @returns {ParseError}
  */
-export function unexpectedCharError({ char, positionStart, expectsSelect = false }) {
+export function unexpectedCharError({ char, positionStart, expectsSelect }) {
   const positionEnd = positionStart + 1
   if (expectsSelect) {
     return new ParseError({ message: `Expected SELECT but found "${char}" at position ${positionStart}. Queries must start with SELECT or WITH.`, positionStart, positionEnd })
@@ -90,44 +84,14 @@ export function unexpectedCharError({ char, positionStart, expectsSelect = false
  *
  * @param {Object} options
  * @param {string} options.funcName - The unknown function name
- * @param {number} options.positionStart - Start position in query
- * @param {number} options.positionEnd - End position in query
- * @param {string} [options.validFunctions] - List of valid functions
- * @returns {ParseError}
- */
-export function unknownFunctionError({ funcName, positionStart, positionEnd, validFunctions }) {
-  const supported = validFunctions ||
-    'COUNT, SUM, AVG, MIN, MAX, UPPER, LOWER, CONCAT, LENGTH, SUBSTRING, TRIM, REPLACE, FLOOR, CEIL, ABS, MOD, EXP, LN, LOG10, POWER, SQRT, JSON_OBJECT, JSON_VALUE, JSON_QUERY, JSON_ARRAYAGG'
-
-  return new ParseError({
-    message: `Unknown function "${funcName}" at position ${positionStart}. Supported: ${supported}`,
-    positionStart,
-    positionEnd,
-  })
-}
-
-/**
- * Error for wrong number of function arguments at parse time.
- *
- * @param {Object} options
- * @param {string} options.funcName - The function name
- * @param {number | string} options.expected - Expected count (number or range like "2 to 3")
- * @param {number} options.received - Actual argument count
- * @param {number} options.positionStart - Start position in query
- * @param {number} options.positionEnd - End position in query
+ * @param {number} options.positionStart
+ * @param {number} options.positionEnd
  * @returns {ParseError}
  */
-export function argCountParseError({ funcName, expected, received, positionStart, positionEnd }) {
-  const signature = FUNCTION_SIGNATURES[funcName] ?? ''
-  let expectedStr = `${expected} arguments`
-  if (expected === 0) expectedStr = 'no arguments'
-  if (expected === 1) expectedStr = '1 argument'
-  if (typeof expected === 'string' && expected.endsWith(' 1')) {
-    expectedStr = `${expected} argument`
-  }
-
+export function unknownFunctionError({ funcName, positionStart, positionEnd }) {
+  // TODO: suggest similar function names based on edit distance
   return new ParseError({
-    message: `${funcName}(${signature}) function requires ${expectedStr}, got ${received}`,
+    message: `Unknown function "${funcName}" at position ${positionStart}.`,
     positionStart,
     positionEnd,
   })
@@ -139,12 +103,12 @@ export function argCountParseError({ funcName, expected, received, positionStart
  * @param {Object} options
  * @param {string} options.missing - What is missing (e.g., 'WHEN clause', 'FROM clause', 'ON condition')
  * @param {string} options.context - Where it's missing from (e.g., 'CASE expression', 'SELECT statement', 'JOIN')
- * @param {number} options.positionStart - Start position in query
- * @param {number} options.positionEnd - End position in query
+ * @param {number} options.positionStart
+ * @param {number} options.positionEnd
  * @returns {ParseError}
  */
 export function missingClauseError({ missing, context, positionStart, positionEnd }) {
-  return new ParseError({ message: `${context} requires ${missing}`, positionStart: positionStart ?? 0, positionEnd: positionEnd ?? 0 })
+  return new ParseError({ message: `${context} requires ${missing}`, positionStart, positionEnd })
 }
 
 /**
@@ -152,8 +116,8 @@ export function missingClauseError({ missing, context, positionStart, positionEn
  *
  * @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
+ * @param {number} options.positionStart
+ * @param {number} options.positionEnd
  * @returns {ParseError}
  */
 export function duplicateCTEError({ cteName, positionStart, positionEnd }) {

package/src/validation/planErrors.js

@@ -0,0 +1,42 @@
+import { ExecutionError } from './executionErrors.js'
+
+/**
+ * @param {Object} options
+ * @param {string} options.table - The missing table name
+ * @param {Record<string, any>} options.tables - Available tables object
+ * @param {number} [options.positionStart]
+ * @param {number} [options.positionEnd]
+ * @returns {ExecutionError}
+ */
+export function tableNotFoundError({ table, tables, positionStart, positionEnd }) {
+  const names = tables ? Object.keys(tables) : []
+  const available = names.length
+    ? `. Available tables: ${names.join(', ')}`
+    : ''
+  return new ExecutionError({
+    message: `Table "${table}" not found${available}`,
+    positionStart,
+    positionEnd,
+  })
+}
+
+/**
+ * @param {Object} options
+ * @param {string} options.columnName - The missing column name
+ * @param {string[]} options.availableColumns - List of available column names
+ * @param {number} options.positionStart
+ * @param {number} options.positionEnd
+ * @param {number} [options.rowIndex] - 1-based row number where error occurred
+ * @returns {ExecutionError}
+ */
+export function columnNotFoundError({ columnName, availableColumns, positionStart, positionEnd, rowIndex }) {
+  const available = availableColumns.length > 0
+    ? `. Available columns: ${availableColumns.join(', ')}`
+    : ''
+  return new ExecutionError({
+    message: `Column "${columnName}" not found${available}`,
+    positionStart,
+    positionEnd,
+    rowIndex,
+  })
+}

package/src/executionErrors.js

@@ -1,80 +0,0 @@
-// ============================================================================
-// EXECUTION ERRORS - Issues during query execution
-// ============================================================================
-
-/**
- * Structured execution error with position range and optional row number.
- */
-export class ExecutionError extends Error {
-  /**
-   * @param {Object} options
-   * @param {string} options.message - Human-readable error message
-   * @param {number} options.positionStart - Start position (0-based character offset)
-   * @param {number} options.positionEnd - End position (exclusive, 0-based character offset)
-   * @param {number} [options.rowIndex] - 1-based row number where error occurred
-   */
-  constructor({ message, positionStart, positionEnd, rowIndex }) {
-    const rowSuffix = rowIndex != null ? ` (row ${rowIndex})` : ''
-    super(message + rowSuffix)
-    this.name = 'ExecutionError'
-    this.positionStart = positionStart
-    this.positionEnd = positionEnd
-    this.rowIndex = rowIndex
-  }
-}
-
-/**
- * @param {Object} options
- * @param {string} options.tableName - The missing table name
- * @returns {Error}
- */
-export function tableNotFoundError({ tableName }) {
-  return new Error(`Table "${tableName}" not found. Check spelling or add it to the tables parameter.`)
-}
-
-/**
- * Error for invalid context (e.g., INTERVAL without date arithmetic).
- *
- * @param {Object} options
- * @param {string} options.item - What was used incorrectly
- * @param {string} options.validContext - Where it can be used
- * @param {number} options.positionStart - Start position in query
- * @param {number} options.positionEnd - End position in query
- * @param {number} [options.rowIndex] - 1-based row number where error occurred
- * @returns {ExecutionError}
- */
-export function invalidContextError({ item, validContext, positionStart, positionEnd, rowIndex }) {
-  return new ExecutionError({ message: `${item} can only be used with ${validContext}`, positionStart, positionEnd, rowIndex })
-}
-
-/**
- * @param {Object} options
- * @param {string} options.operation - The unsupported operation
- * @param {string} [options.hint] - How to fix it
- * @returns {Error}
- */
-export function unsupportedOperationError({ operation, hint }) {
-  const suffix = hint ? `. ${hint}` : ''
-  return new Error(`${operation}${suffix}`)
-}
-
-/**
- * @param {Object} options
- * @param {string} options.columnName - The missing column name
- * @param {string[]} options.availableColumns - List of available column names
- * @param {number} options.positionStart - Start position in query
- * @param {number} options.positionEnd - End position in query
- * @param {number} [options.rowIndex] - 1-based row number where error occurred
- * @returns {ExecutionError}
- */
-export function columnNotFoundError({ columnName, availableColumns, positionStart, positionEnd, rowIndex }) {
-  const available = availableColumns.length > 0
-    ? `. Available columns: ${availableColumns.join(', ')}`
-    : ''
-  return new ExecutionError({
-    message: `Column "${columnName}" not found${available}`,
-    positionStart,
-    positionEnd,
-    rowIndex,
-  })
-}

package/src/validation.js

@@ -1,343 +0,0 @@
-import { ParseError } from './parseErrors.js'
-
-/**
- * @import { AggregateFunc, BinaryOp, ExprNode, FunctionNode, IntervalUnit, MathFunc, SpatialFunc, StringFunc, UserDefinedFunction } from './types.js'
- * @param {string} name
- * @returns {name is AggregateFunc}
- */
-export function isAggregateFunc(name) {
-  return ['COUNT', 'SUM', 'AVG', 'MIN', 'MAX', 'JSON_ARRAYAGG', 'STDDEV_SAMP', 'STDDEV_POP'].includes(name)
-}
-
-/**
- * Finds the first aggregate function call in an expression tree.
- * Does not recurse into subqueries (they have their own aggregate scope).
- *
- * @param {ExprNode | undefined} expr
- * @returns {FunctionNode | undefined}
- */
-export function findAggregate(expr) {
-  if (!expr) return undefined
-  if (expr.type === 'function' && isAggregateFunc(expr.name.toUpperCase())) {
-    return expr
-  }
-  if (expr.type === 'binary') {
-    return findAggregate(expr.left) || findAggregate(expr.right)
-  }
-  if (expr.type === 'unary') {
-    return findAggregate(expr.argument)
-  }
-  if (expr.type === 'cast') {
-    return findAggregate(expr.expr)
-  }
-  if (expr.type === 'case') {
-    if (expr.caseExpr) {
-      const found = findAggregate(expr.caseExpr)
-      if (found) return found
-    }
-    for (const when of expr.whenClauses) {
-      const found = findAggregate(when.condition) || findAggregate(when.result)
-      if (found) return found
-    }
-    return findAggregate(expr.elseResult)
-  }
-  if (expr.type === 'in valuelist') {
-    const found = findAggregate(expr.expr)
-    if (found) return found
-    for (const val of expr.values) {
-      const found = findAggregate(val)
-      if (found) return found
-    }
-  }
-  // Subqueries have their own aggregate scope
-  return undefined
-}
-
-/**
- * Throws a ParseError if the expression contains an aggregate function.
- *
- * @param {ExprNode | undefined} expr - The expression to check
- * @param {string} clause - The clause name (e.g., 'WHERE', 'JOIN ON', 'GROUP BY')
- */
-export function expectNoAggregate(expr, clause) {
-  const agg = findAggregate(expr)
-  if (agg) {
-    const hint = clause === 'WHERE' ? '. Use HAVING instead.' : ''
-    throw new ParseError({
-      message: `Aggregate function ${agg.name.toUpperCase()} is not allowed in ${clause} clause${hint}`,
-      positionStart: agg.positionStart,
-      positionEnd: agg.positionEnd,
-    })
-  }
-}
-
-/**
- * @param {string} name
- * @returns {boolean}
- */
-export function isRegexpFunc(name) {
-  return ['REGEXP_SUBSTR', 'REGEXP_REPLACE'].includes(name)
-}
-
-/**
- * @param {string} name
- * @returns {name is SpatialFunc}
- */
-export function isSpatialFunc(name) {
-  return [
-    'ST_INTERSECTS', 'ST_CONTAINS', 'ST_CONTAINSPROPERLY', 'ST_WITHIN',
-    'ST_OVERLAPS', 'ST_TOUCHES', 'ST_EQUALS', 'ST_CROSSES',
-    'ST_COVERS', 'ST_COVEREDBY', 'ST_DWITHIN',
-    'ST_GEOMFROMTEXT', 'ST_MAKEENVELOPE', 'ST_ASTEXT',
-  ].includes(name)
-}
-
-/**
- * @param {string} name
- * @returns {name is MathFunc}
- */
-export function isMathFunc(name) {
-  return [
-    'FLOOR', 'CEIL', 'CEILING', 'ROUND', 'ABS', 'SIGN', 'MOD', 'EXP', 'LN', 'LOG10', 'POWER', 'SQRT',
-    'SIN', 'COS', 'TAN', 'COT', 'ASIN', 'ACOS', 'ATAN', 'ATAN2', 'DEGREES', 'RADIANS', 'PI',
-    'RAND', 'RANDOM',
-  ].includes(name)
-}
-
-/**
- * @param {string} name
- * @returns {name is IntervalUnit}
- */
-export function isIntervalUnit(name) {
-  return ['DAY', 'MONTH', 'YEAR', 'HOUR', 'MINUTE', 'SECOND'].includes(name)
-}
-
-/**
- * @param {string} name
- * @returns {boolean}
- */
-export function isExtractField(name) {
-  return ['YEAR', 'MONTH', 'DAY', 'HOUR', 'MINUTE', 'SECOND', 'DOW', 'EPOCH'].includes(name)
-}
-
-/**
- * @param {string} name
- * @returns {name is StringFunc}
- */
-export function isStringFunc(name) {
-  return [
-    'UPPER', 'LOWER', 'CONCAT', 'LENGTH', 'SUBSTRING', 'SUBSTR', 'TRIM',
-    'REPLACE', 'LEFT', 'RIGHT', 'INSTR',
-  ].includes(name)
-}
-
-/**
- * @param {string} op
- * @returns {op is BinaryOp}
- */
-export function isBinaryOp(op) {
-  return ['AND', 'OR', 'LIKE', '=', '!=', '<>', '<', '>', '<=', '>='].includes(op)
-}
-
-/**
- * Function argument count specifications.
- * min: minimum number of arguments
- * max: maximum number of arguments
- * @type {Record<string, {min: number, max?: number}>}
- */
-export const FUNCTION_ARG_COUNTS = {
-  // String functions
-  UPPER: { min: 1, max: 1 },
-  LOWER: { min: 1, max: 1 },
-  LENGTH: { min: 1, max: 1 },
-  TRIM: { min: 1, max: 1 },
-  REPLACE: { min: 3, max: 3 },
-  SUBSTRING: { min: 2, max: 3 },
-  SUBSTR: { min: 2, max: 3 },
-  CONCAT: { min: 1 },
-  LEFT: { min: 2, max: 2 },
-  RIGHT: { min: 2, max: 2 },
-  INSTR: { min: 2, max: 2 },
-  REGEXP_SUBSTR: { min: 2, max: 4 },
-  REGEXP_REPLACE: { min: 3, max: 5 },
-
-  // Date/time functions
-  RANDOM: { min: 0, max: 0 },
-  RAND: { min: 0, max: 0 },
-  CURRENT_DATE: { min: 0, max: 0 },
-  CURRENT_TIME: { min: 0, max: 0 },
-  CURRENT_TIMESTAMP: { min: 0, max: 0 },
-  DATE_TRUNC: { min: 2, max: 2 },
-  DATE_PART: { min: 2, max: 2 },
-  EXTRACT: { min: 2, max: 2 },
-
-  // Math functions
-  FLOOR: { min: 1, max: 1 },
-  CEIL: { min: 1, max: 1 },
-  CEILING: { min: 1, max: 1 },
-  ROUND: { min: 1, max: 2 },
-  ABS: { min: 1, max: 1 },
-  SIGN: { min: 1, max: 1 },
-  MOD: { min: 2, max: 2 },
-  EXP: { min: 1, max: 1 },
-  LN: { min: 1, max: 1 },
-  LOG10: { min: 1, max: 1 },
-  POWER: { min: 2, max: 2 },
-  SQRT: { min: 1, max: 1 },
-  SIN: { min: 1, max: 1 },
-  COS: { min: 1, max: 1 },
-  TAN: { min: 1, max: 1 },
-  COT: { min: 1, max: 1 },
-  ASIN: { min: 1, max: 1 },
-  ACOS: { min: 1, max: 1 },
-  ATAN: { min: 1, max: 2 },
-  ATAN2: { min: 2, max: 2 },
-  DEGREES: { min: 1, max: 1 },
-  RADIANS: { min: 1, max: 1 },
-  PI: { min: 0, max: 0 },
-
-  // JSON functions
-  JSON_VALUE: { min: 2, max: 2 },
-  JSON_QUERY: { min: 2, max: 2 },
-  JSON_OBJECT: { min: 0 },
-  JSON_ARRAYAGG: { min: 1, max: 1 },
-
-  // Array functions
-  ARRAY_LENGTH: { min: 1, max: 1 },
-  ARRAY_POSITION: { min: 2, max: 2 },
-  ARRAY_SORT: { min: 1, max: 1 },
-  CARDINALITY: { min: 1, max: 1 },
-
-  // Conditional functions
-  COALESCE: { min: 1 },
-  NULLIF: { min: 2, max: 2 },
-
-  // Aggregate functions
-  COUNT: { min: 1, max: 1 },
-  SUM: { min: 1, max: 1 },
-  AVG: { min: 1, max: 1 },
-  MIN: { min: 1, max: 1 },
-  MAX: { min: 1, max: 1 },
-  STDDEV_SAMP: { min: 1, max: 1 },
-  STDDEV_POP: { min: 1, max: 1 },
-
-  // Spatial predicate functions
-  ST_INTERSECTS: { min: 2, max: 2 },
-  ST_CONTAINS: { min: 2, max: 2 },
-  ST_CONTAINSPROPERLY: { min: 2, max: 2 },
-  ST_WITHIN: { min: 2, max: 2 },
-  ST_OVERLAPS: { min: 2, max: 2 },
-  ST_TOUCHES: { min: 2, max: 2 },
-  ST_EQUALS: { min: 2, max: 2 },
-  ST_CROSSES: { min: 2, max: 2 },
-  ST_COVERS: { min: 2, max: 2 },
-  ST_COVEREDBY: { min: 2, max: 2 },
-  ST_DWITHIN: { min: 3, max: 3 },
-  ST_GEOMFROMTEXT: { min: 1, max: 1 },
-  ST_MAKEENVELOPE: { min: 4, max: 4 },
-  ST_ASTEXT: { min: 1, max: 1 },
-}
-
-/**
- * Format expected argument count for error messages.
- * @param {number} min
- * @param {number | undefined} max
- * @returns {string | number}
- */
-function formatExpected(min, max) {
-  if (max == null) return `at least ${min}`
-  if (min === max) return min
-  return `${min} or ${max}`
-}
-
-/**
- * Validates function argument count.
- * @param {string} funcName - The function name (uppercase)
- * @param {number} argCount - Number of arguments provided
- * @param {Record<string, UserDefinedFunction>} [functions] - User-defined functions
- * @returns {{ valid: boolean, expected: string | number }}
- */
-export function validateFunctionArgCount(funcName, argCount, functions) {
-  // Check built-in functions
-  let spec = FUNCTION_ARG_COUNTS[funcName]
-
-  // Check user-defined functions (case-insensitive)
-  if (!spec && functions) {
-    const udfName = Object.keys(functions).find(k => k.toUpperCase() === funcName)
-    if (udfName) {
-      spec = functions[udfName].arguments
-    }
-  }
-
-  if (!spec) return { valid: true, expected: 0 }
-
-  const { min, max } = spec
-
-  if (argCount < min) {
-    return { valid: false, expected: formatExpected(min, max) }
-  }
-  if (max != null && argCount > max) {
-    return { valid: false, expected: formatExpected(min, max) }
-  }
-
-  return { valid: true, expected: formatExpected(min, max) }
-}
-
-/**
- * Checks if a function is known (either built-in or user-defined).
- * @param {string} funcName - The function name (uppercase)
- * @param {Record<string, UserDefinedFunction>} [functions] - User-defined functions
- * @returns {boolean}
- */
-export function isKnownFunction(funcName, functions) {
-  // Check built-in functions
-  if (
-    isAggregateFunc(funcName) ||
-    isMathFunc(funcName) ||
-    isStringFunc(funcName) ||
-    isRegexpFunc(funcName) ||
-    isSpatialFunc(funcName)
-  ) {
-    return true
-  }
-
-  // Date/time, JSON, conditional, and CAST functions
-  if ([
-    'CURRENT_DATE', 'CURRENT_TIME', 'CURRENT_TIMESTAMP', 'DATE_TRUNC', 'DATE_PART', 'EXTRACT',
-    'JSON_VALUE', 'JSON_QUERY', 'JSON_OBJECT',
-    'ARRAY_LENGTH', 'ARRAY_POSITION', 'ARRAY_SORT', 'CARDINALITY',
-    'COALESCE', 'NULLIF', 'CAST',
-  ].includes(funcName)) {
-    return true
-  }
-
-  // Check user-defined functions (case-insensitive)
-  if (functions) {
-    return Object.keys(functions).some(k => k.toUpperCase() === funcName)
-  }
-
-  return false
-}
-
-// Reserved keywords that cannot be used as identifiers in expressions.
-// Non-reserved keywords (e.g. DAY, MONTH, FILTER, ASC) can be used as column alias references.
-export const RESERVED_KEYWORDS = new Set([
-  'SELECT', 'FROM', 'WHERE', 'WITH',
-  'AND', 'OR', 'NOT', 'IS', 'LIKE', 'IN', 'BETWEEN',
-  'TRUE', 'FALSE', 'NULL',
-  'EXISTS', 'CASE', 'WHEN', 'THEN', 'ELSE', 'END', 'INTERVAL',
-  'GROUP', 'BY', 'HAVING', 'ORDER', 'LIMIT', 'OFFSET',
-  'AS', 'ALL', 'DISTINCT',
-  'JOIN', 'INNER', 'LEFT', 'RIGHT', 'FULL', 'OUTER', 'ON',
-])
-
-// Keywords that cannot be used as implicit aliases after a column
-export const RESERVED_AFTER_COLUMN = new Set([
-  'FROM', 'WHERE', 'GROUP', 'HAVING', 'ORDER', 'LIMIT', 'OFFSET',
-])
-
-// 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',
-])