squirreling 0.10.0 → 0.10.2

package/src/types.d.ts

@@ -1,3 +1,6 @@
+import type { ExprNode, SelectStatement, SqlPrimitive } from './ast.js'
+
+export * from './ast.js'
 export { ParserState, Token, TokenType } from './parse/types.js'
 export { QueryPlan } from './plan/types.js'
 
@@ -19,6 +22,7 @@ export interface ExecuteSqlOptions {
 export interface PlanSqlOptions {
   query: string | SelectStatement
   functions?: Record<string, UserDefinedFunction>
+  tables?: Record<string, AsyncDataSource>
 }
 
 // executePlan(plan, context)
@@ -73,170 +77,21 @@ export interface ScanOptions {
   signal?: AbortSignal
 }
 
-export type SqlPrimitive =
-  | string
-  | number
-  | bigint
-  | boolean
-  | Date
-  | null
-  | SqlPrimitive[]
-  | Record<string, any>
+export interface FunctionSignature {
+  min: number
+  max?: number
+  signature?: string
+}
 
 export interface UserDefinedFunction {
   apply: (...args: SqlPrimitive[]) => SqlPrimitive | Promise<SqlPrimitive>
-  arguments: {
-    min: number
-    max?: number
-  }
-}
-
-export interface CTEDefinition {
-  name: string
-  query: SelectStatement
-}
-
-export interface WithClause {
-  ctes: CTEDefinition[]
-}
-
-export interface SelectStatement {
-  with?: WithClause
-  distinct: boolean
-  columns: SelectColumn[]
-  from: FromTable | FromSubquery
-  joins: JoinClause[]
-  where?: ExprNode
-  groupBy: ExprNode[]
-  having?: ExprNode
-  orderBy: OrderByItem[]
-  limit?: number
-  offset?: number
-}
-
-export interface FromTable {
-  kind: 'table'
-  table: string
-  alias?: string
-}
-
-export interface FromSubquery {
-  kind: 'subquery'
-  query: SelectStatement
-  alias: string
-}
-
-export type ArithmeticOp = '+' | '-' | '*' | '/' | '%'
-
-export type BinaryOp = 'AND' | 'OR' | 'LIKE' | ComparisonOp | ArithmeticOp
-
-export type ComparisonOp = '=' | '!=' | '<>' | '<' | '>' | '<=' | '>='
-
-export interface ExprNodeBase {
-  positionStart: number
-  positionEnd: number
-}
-
-export interface LiteralNode extends ExprNodeBase {
-  type: 'literal'
-  value: SqlPrimitive
-}
-
-export interface IdentifierNode extends ExprNodeBase {
-  type: 'identifier'
-  name: string
-}
-
-export interface UnaryNode extends ExprNodeBase {
-  type: 'unary'
-  op: 'NOT' | 'IS NULL' | 'IS NOT NULL' | '-'
-  argument: ExprNode
-}
-
-export interface BinaryNode extends ExprNodeBase {
-  type: 'binary'
-  op: BinaryOp
-  left: ExprNode
-  right: ExprNode
-}
-
-export interface FunctionNode extends ExprNodeBase {
-  type: 'function'
-  name: string
-  args: ExprNode[]
-  distinct?: boolean
-  filter?: ExprNode
-}
-
-export interface CastNode extends ExprNodeBase {
-  type: 'cast'
-  expr: ExprNode
-  toType: string
-}
-
-export interface InSubqueryNode extends ExprNodeBase {
-  type: 'in'
-  expr: ExprNode
-  subquery: SelectStatement
+  arguments: FunctionSignature
 }
 
-export interface InValuesNode extends ExprNodeBase {
-  type: 'in valuelist'
-  expr: ExprNode
-  values: ExprNode[]
-}
-
-export interface ExistsNode extends ExprNodeBase {
-  type: 'exists' | 'not exists'
-  subquery: SelectStatement
-}
-
-export interface WhenClause {
-  condition: ExprNode
-  result: ExprNode
-}
-
-export interface CaseNode extends ExprNodeBase {
-  type: 'case'
-  caseExpr?: ExprNode
-  whenClauses: WhenClause[]
-  elseResult?: ExprNode
-}
-
-export interface SubqueryNode extends ExprNodeBase {
-  type: 'subquery'
-  subquery: SelectStatement
-}
-
-export type IntervalUnit = 'DAY' | 'MONTH' | 'YEAR' | 'HOUR' | 'MINUTE' | 'SECOND'
-
-export interface IntervalNode extends ExprNodeBase {
-  type: 'interval'
-  value: number
-  unit: IntervalUnit
-}
-
-export interface StarNode extends ExprNodeBase {
-  type: 'star'
-}
-
-export type ExprNode =
-  | LiteralNode
-  | IdentifierNode
-  | UnaryNode
-  | BinaryNode
-  | FunctionNode
-  | CastNode
-  | InSubqueryNode
-  | InValuesNode
-  | ExistsNode
-  | CaseNode
-  | SubqueryNode
-  | IntervalNode
-  | StarNode
-
 export type AggregateFunc = 'COUNT' | 'SUM' | 'AVG' | 'MIN' | 'MAX' | 'JSON_ARRAYAGG' | 'STDDEV_SAMP' | 'STDDEV_POP'
 
+export type RegExpFunction = 'REGEXP_SUBSTR' | 'REGEXP_REPLACE'
+
 export type MathFunc =
   | 'FLOOR'
   | 'CEIL'
@@ -292,37 +147,3 @@ export type SpatialFunc =
   | 'ST_GEOMFROMTEXT'
   | 'ST_MAKEENVELOPE'
   | 'ST_ASTEXT'
-
-export interface StarColumn {
-  kind: 'star'
-  table?: string
-}
-
-export interface DerivedColumn {
-  kind: 'derived'
-  expr: ExprNode
-  alias?: string
-}
-
-export type SelectColumn = StarColumn | DerivedColumn
-
-export interface OrderByItem {
-  expr: ExprNode
-  direction: 'ASC' | 'DESC'
-  nulls?: 'FIRST' | 'LAST'
-}
-
-export type JoinType = 'INNER' | 'LEFT' | 'RIGHT' | 'FULL' | 'CROSS' | 'POSITIONAL'
-
-export interface JoinClause {
-  joinType: JoinType
-  table: string
-  alias?: string
-  on?: ExprNode
-}
-
-export interface ExecuteContext {
-  tables: Record<string, AsyncDataSource>
-  functions?: Record<string, UserDefinedFunction>
-  signal?: AbortSignal
-}

package/src/validation/aggregates.js

@@ -0,0 +1,67 @@
+import { isAggregateFunc } from './functions.js'
+import { ParseError } from './parseErrors.js'
+
+/**
+ * @import { ExprNode, FunctionNode } from '../types.js'
+ */
+
+/**
+ * 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.funcName.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({
+      ...agg,
+      message: `Aggregate function ${agg.funcName} is not allowed in ${clause} clause${hint}`,
+    })
+  }
+}

package/src/validation/executionErrors.js

@@ -0,0 +1,35 @@
+/**
+ * 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
+   * @param {number} options.positionEnd
+   * @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
+  }
+}
+
+/**
+ * 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
+ * @param {number} options.positionEnd
+ * @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 })
+}

package/src/validation/expressionErrors.js

@@ -0,0 +1,57 @@
+import { ExecutionError } from './executionErrors.js'
+import { FUNCTION_SIGNATURES } from './functions.js'
+
+/**
+ * Error for invalid argument type or value.
+ *
+ * @param {Object} options
+ * @param {string} options.funcName - The function name
+ * @param {string} options.message - Specific error message
+ * @param {number} options.positionStart
+ * @param {number} options.positionEnd
+ * @param {string} [options.hint] - Recovery hint
+ * @param {number} options.rowIndex - 1-based row number where error occurred
+ * @returns {ExecutionError}
+ */
+export function argValueError({ funcName, message, positionStart, positionEnd, hint, rowIndex }) {
+  const funcNameUpper = funcName.toUpperCase()
+  const signature = FUNCTION_SIGNATURES[funcNameUpper]?.signature ?? ''
+  const suffix = hint ? `. ${hint}` : ''
+  return new ExecutionError({ message: `${funcName}(${signature}): ${message}${suffix}`, positionStart, positionEnd, rowIndex })
+}
+
+/**
+ * Error for aggregate function misuse.
+ *
+ * @param {Object} options
+ * @param {string} options.funcName - The aggregate function
+ * @param {number} options.positionStart
+ * @param {number} options.positionEnd
+ * @returns {ExecutionError}
+ */
+export function aggregateError({ funcName, positionStart, positionEnd }) {
+  return new ExecutionError({
+    message: `Aggregate function ${funcName} is not available in this context`,
+    positionStart,
+    positionEnd,
+  })
+}
+
+/**
+ * Error for unsupported CAST type.
+ *
+ * @param {Object} options
+ * @param {string} options.toType - The unsupported target type
+ * @param {number} options.positionStart
+ * @param {number} options.positionEnd
+ * @param {string} [options.fromType] - The source type (undefined means unsupported target type)
+ * @param {number} options.rowIndex - 1-based row number where error occurred
+ * @returns {ExecutionError}
+ */
+export function castError({ toType, positionStart, positionEnd, fromType, rowIndex }) {
+  const message = fromType
+    ? `Cannot CAST ${fromType} to ${toType}`
+    : `Unsupported CAST to type ${toType}`
+
+  return new ExecutionError({ message: `${message}. Supported types: STRING, INT, BIGINT, FLOAT, BOOL`, positionStart, positionEnd, rowIndex })
+}

package/src/validation/functions.js

@@ -0,0 +1,281 @@
+/**
+ * @import { AggregateFunc, BinaryOp, CastType, FunctionSignature, IntervalUnit, MathFunc, RegExpFunction, SpatialFunc, StringFunc, UserDefinedFunction } from '../types.js'
+ */
+import { ParseError } from '../validation/parseErrors.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)
+}
+
+/**
+ * @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 RegExpFunction}
+ */
+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 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 CastType}
+ */
+export function isCastType(name) {
+  return ['TEXT', 'STRING', 'VARCHAR', 'INTEGER', 'INT', 'BIGINT', 'FLOAT', 'REAL', 'DOUBLE', 'BOOLEAN', 'BOOL'].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 signatures: argument counts and human-readable parameter signatures.
+ * @type {Record<string, FunctionSignature>}
+ */
+export const FUNCTION_SIGNATURES = {
+  // String functions
+  UPPER: { min: 1, max: 1, signature: 'string' },
+  LOWER: { min: 1, max: 1, signature: 'string' },
+  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]' },
+  SUBSTR: { min: 2, max: 3, signature: 'string, start[, length]' },
+  CONCAT: { min: 1, signature: 'value1, value2[, ...]' },
+  LEFT: { min: 2, max: 2, signature: 'string, length' },
+  RIGHT: { min: 2, max: 2, signature: 'string, length' },
+  INSTR: { min: 2, max: 2, signature: 'string, substring' },
+  REGEXP_SUBSTR: { min: 2, max: 4, signature: 'string, pattern[, position[, flags]]' },
+  REGEXP_REPLACE: { min: 3, max: 5, signature: 'string, pattern, replacement[, position[, flags]]' },
+
+  // Date/time functions
+  RANDOM: { min: 0, max: 0, signature: '' },
+  RAND: { min: 0, max: 0, signature: '' },
+  CURRENT_DATE: { min: 0, max: 0, signature: '' },
+  CURRENT_TIME: { min: 0, max: 0, signature: '' },
+  CURRENT_TIMESTAMP: { min: 0, max: 0, signature: '' },
+  DATE_TRUNC: { min: 2, max: 2, signature: 'unit, date' },
+  DATE_PART: { min: 2, max: 2, signature: 'field, date' },
+  EXTRACT: { min: 2, max: 2, signature: 'field FROM date' },
+
+  // Math functions
+  FLOOR: { min: 1, max: 1, signature: 'number' },
+  CEIL: { min: 1, max: 1, signature: 'number' },
+  CEILING: { min: 1, max: 1, signature: 'number' },
+  ROUND: { min: 1, max: 2, signature: 'number[, decimals]' },
+  ABS: { min: 1, max: 1, signature: 'number' },
+  SIGN: { min: 1, max: 1, signature: 'number' },
+  MOD: { min: 2, max: 2, signature: 'dividend, divisor' },
+  EXP: { min: 1, max: 1, signature: 'number' },
+  LN: { min: 1, max: 1, signature: 'number' },
+  LOG10: { min: 1, max: 1, signature: 'number' },
+  POWER: { min: 2, max: 2, signature: 'base, exponent' },
+  SQRT: { min: 1, max: 1, signature: 'number' },
+  SIN: { min: 1, max: 1, signature: 'radians' },
+  COS: { min: 1, max: 1, signature: 'radians' },
+  TAN: { min: 1, max: 1, signature: 'radians' },
+  COT: { min: 1, max: 1, signature: 'radians' },
+  ASIN: { min: 1, max: 1, signature: 'number' },
+  ACOS: { min: 1, max: 1, signature: 'number' },
+  ATAN: { min: 1, max: 2, signature: 'number' },
+  ATAN2: { min: 2, max: 2, signature: 'y, x' },
+  DEGREES: { min: 1, max: 1, signature: 'radians' },
+  RADIANS: { min: 1, max: 1, signature: 'degrees' },
+  PI: { min: 0, max: 0, signature: '' },
+
+  // JSON functions
+  JSON_VALUE: { min: 2, max: 2, signature: 'expression, path' },
+  JSON_QUERY: { min: 2, max: 2, signature: 'expression, path' },
+  JSON_OBJECT: { min: 0, signature: 'key1, value1[, ...]' },
+  JSON_ARRAYAGG: { min: 1, max: 1, signature: 'expression' },
+
+  // Array functions
+  ARRAY_LENGTH: { min: 1, max: 1, signature: 'array' },
+  ARRAY_POSITION: { min: 2, max: 2, signature: 'array, element' },
+  ARRAY_SORT: { min: 1, max: 1, signature: 'array' },
+  CARDINALITY: { min: 1, max: 1, signature: 'array' },
+
+  // Conditional functions
+  COALESCE: { min: 1, signature: 'value1, value2[, ...]' },
+  NULLIF: { min: 2, max: 2, signature: 'value1, value2' },
+
+  // Aggregate functions
+  COUNT: { min: 1, max: 1, signature: 'expression' },
+  SUM: { min: 1, max: 1, signature: 'expression' },
+  AVG: { min: 1, max: 1, signature: 'expression' },
+  MIN: { min: 1, max: 1, signature: 'expression' },
+  MAX: { min: 1, max: 1, signature: 'expression' },
+  STDDEV_SAMP: { min: 1, max: 1, signature: 'expression' },
+  STDDEV_POP: { min: 1, max: 1, signature: 'expression' },
+
+  // Spatial functions
+  ST_INTERSECTS: { min: 2, max: 2, signature: 'geometry, geometry' },
+  ST_CONTAINS: { min: 2, max: 2, signature: 'geometry, geometry' },
+  ST_CONTAINSPROPERLY: { min: 2, max: 2, signature: 'geometry, geometry' },
+  ST_WITHIN: { min: 2, max: 2, signature: 'geometry, geometry' },
+  ST_OVERLAPS: { min: 2, max: 2, signature: 'geometry, geometry' },
+  ST_TOUCHES: { min: 2, max: 2, signature: 'geometry, geometry' },
+  ST_EQUALS: { min: 2, max: 2, signature: 'geometry, geometry' },
+  ST_CROSSES: { min: 2, max: 2, signature: 'geometry, geometry' },
+  ST_COVERS: { min: 2, max: 2, signature: 'geometry, geometry' },
+  ST_COVEREDBY: { min: 2, max: 2, signature: 'geometry, geometry' },
+  ST_DWITHIN: { min: 3, max: 3, signature: 'geometry, geometry, distance' },
+  ST_GEOMFROMTEXT: { min: 1, max: 1, signature: 'wkt' },
+  ST_MAKEENVELOPE: { min: 4, max: 4, signature: 'xmin, ymin, xmax, ymax' },
+  ST_ASTEXT: { min: 1, max: 1, signature: 'geometry' },
+}
+
+/**
+ * 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, throwing a ParseError if invalid.
+ * @param {string} funcName - The function name (uppercase)
+ * @param {number} argCount - Number of arguments provided
+ * @param {number} positionStart - Start position in query
+ * @param {number} positionEnd - End position in query
+ * @param {Record<string, UserDefinedFunction>} [functions] - User-defined functions
+ * @throws {ParseError}
+ */
+export function validateFunctionArgCount(funcName, argCount, positionStart, positionEnd, functions) {
+  // Check built-in functions
+  let spec = FUNCTION_SIGNATURES[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
+
+  const { min, max } = spec
+
+  if (argCount < min || max != null && argCount > max) {
+    const expected = formatExpected(min, max)
+    const signature = FUNCTION_SIGNATURES[funcName]?.signature ?? ''
+    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`
+    }
+
+    throw new ParseError({
+      message: `${funcName}(${signature}) function requires ${expectedStr}, got ${argCount}`,
+      positionStart,
+      positionEnd,
+    })
+  }
+}
+
+/**
+ * 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 (FUNCTION_SIGNATURES[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',
+])