rawsql-ts 0.1.0-beta.6 → 0.1.0-beta.8

package/dist/tokenReaders/TypeTokenReader.d.ts

@@ -0,0 +1,11 @@
+import { BaseTokenReader } from './BaseTokenReader';
+import { Lexeme } from '../models/Lexeme';
+/**
+ * Reads SQL identifier tokens
+ */
+export declare class TypeTokenReader extends BaseTokenReader {
+    /**
+     * Try to read an identifier token
+     */
+    tryRead(previous: Lexeme | null): Lexeme | null;
+}

package/dist/transformers/CTEBuilder.d.ts

@@ -0,0 +1,52 @@
+import { CommonTable, WithClause } from "../models/Clause";
+/**
+ * CTENameConflictResolver is responsible for resolving name conflicts among Common Table Expressions (CTEs).
+ * It also sorts the tables in the proper order based on dependencies and recursiveness.
+ */
+export declare class CTEBuilder {
+    private sourceCollector;
+    private cteCollector;
+    private formatter;
+    constructor();
+    /**
+     * Resolves name conflicts among CommonTables.
+     * If there are duplicate CTE names, they must have identical definitions.
+     * Also sorts the tables so that:
+     * 1. Recursive CTEs come first (CTEs that reference themselves)
+     * 2. Then remaining tables are sorted so inner (deeper) CTEs come before outer CTEs
+     *
+     * @param commonTables The list of CommonTables to check for name conflicts
+     * @returns An object containing:
+     *          - needRecursive: boolean indicating if any recursive CTEs are present
+     *          - commonTables: A new list of CommonTables with resolved name conflicts and proper order
+     * @throws Error if there are duplicate CTE names with different definitions
+     */
+    build(commonTables: CommonTable[]): WithClause;
+    /**
+     * Resolves duplicate CTE names by checking if they have identical definitions.
+     * If definitions differ, throws an error.
+     *
+     * @param commonTables The list of CTEs to check for duplicates
+     * @returns A list of CTEs with duplicates removed
+     * @throws Error if there are duplicate CTE names with different definitions
+     */
+    private resolveDuplicateNames;
+    /**
+     * Builds a dependency graph of CTEs and identifies recursive CTEs.
+     *
+     * @param tables The list of CTEs to analyze
+     * @returns Object containing the table map, set of recursive CTEs, and dependency map
+     */
+    private buildDependencyGraph;
+    /**
+     * Sorts the CTEs using topological sort, with recursive CTEs coming first.
+     *
+     * @param tables The list of CTEs to sort
+     * @param tableMap Map of table names to their CommonTable objects
+     * @param recursiveCTEs Set of table names that are recursive (self-referential)
+     * @param dependencies Map of table dependencies
+     * @returns Sorted list of CTEs
+     * @throws Error if a circular reference is detected
+     */
+    private sortCommonTables;
+}

package/dist/transformers/CTECollector.d.ts

@@ -0,0 +1,81 @@
+import { CommonTable } from "../models/Clause";
+import { SelectQuery } from "../models/SelectQuery";
+import { SqlComponent, SqlComponentVisitor } from "../models/SqlComponent";
+/**
+ * A visitor that collects all CommonTable instances from a SQL query structure.
+ * This includes tables from:
+ * - WITH clauses
+ * - Subqueries
+ * - Inline queries
+ * - UNION queries
+ * - Value components that may contain queries
+ */
+export declare class CTECollector implements SqlComponentVisitor<void> {
+    private handlers;
+    private commonTables;
+    private visitedNodes;
+    private isRootVisit;
+    constructor();
+    /**
+     * Get all collected CommonTables
+     */
+    getCommonTables(): CommonTable[];
+    /**
+     * Reset the collection of CommonTables
+     */
+    private reset;
+    collect(query: SelectQuery): CommonTable[];
+    /**
+     * Main entry point for the visitor pattern.
+     * Implements the shallow visit pattern to distinguish between root and recursive visits.
+     */
+    visit(arg: SqlComponent): void;
+    /**
+     * Internal visit method used for all nodes.
+     * This separates the visit flag management from the actual node visitation logic.
+     */
+    private visitNode;
+    private visitSimpleSelectQuery;
+    private visitBinarySelectQuery;
+    private visitValuesQuery;
+    private visitWithClause;
+    private visitCommonTable;
+    private visitSelectClause;
+    private visitSelectItem;
+    private visitFromClause;
+    private visitSourceExpression;
+    private visitTableSource;
+    private visitParenSource;
+    private visitSubQuerySource;
+    private visitInlineQuery;
+    private visitJoinClause;
+    private visitJoinOnClause;
+    private visitJoinUsingClause;
+    private visitWhereClause;
+    private visitGroupByClause;
+    private visitHavingClause;
+    private visitOrderByClause;
+    private visitWindowFrameClause;
+    private visitLimitClause;
+    private visitForClause;
+    private visitOrderByItem;
+    private visitParenExpression;
+    private visitBinaryExpression;
+    private visitUnaryExpression;
+    private visitCaseExpression;
+    private visitSwitchCaseArgument;
+    private visitCaseKeyValuePair;
+    private visitBetweenExpression;
+    private visitFunctionCall;
+    private visitArrayExpression;
+    private visitTupleExpression;
+    private visitCastExpression;
+    private visitTypeValue;
+    private visitWindowFrameExpression;
+    private visitWindowFrameSpec;
+    private visitIdentifierString;
+    private visitRawString;
+    private visitColumnReference;
+    private visitParameterExpression;
+    private visitLiteralValue;
+}

package/dist/transformers/CTEDisabler.d.ts

@@ -0,0 +1,77 @@
+import { ForClause, FromClause, GroupByClause, HavingClause, JoinClause, JoinOnClause, JoinUsingClause, LimitClause, OrderByClause, OrderByItem, ParenSource, SelectClause, SelectItem, SourceExpression, SubQuerySource, TableSource, WhereClause, WindowFrameClause } from "../models/Clause";
+import { BinarySelectQuery, SimpleSelectQuery, SelectQuery, ValuesQuery } from "../models/SelectQuery";
+import { SqlComponent, SqlComponentVisitor } from "../models/SqlComponent";
+import { ArrayExpression, BetweenExpression, BinaryExpression, CaseExpression, CaseKeyValuePair, CastExpression, ColumnReference, FunctionCall, InlineQuery, ParenExpression, ParameterExpression, SwitchCaseArgument, TupleExpression, UnaryExpression, ValueComponent, WindowFrameExpression, IdentifierString, RawString, WindowFrameSpec, TypeValue } from "../models/ValueComponent";
+/**
+ * A visitor that disables all WITH clauses in a SQL query structure.
+ * This processes and removes WITH clauses from:
+ * - Simple SELECT queries
+ * - Binary queries (UNION, EXCEPT, etc.)
+ * - Subqueries
+ * - Inline queries
+ *
+ * It maintains the CTE queries themselves but restructures the query to not use
+ * the WITH clause syntactical construct.
+ */
+export declare class CTEDisabler implements SqlComponentVisitor<SqlComponent> {
+    private handlers;
+    private visitedNodes;
+    private isRootVisit;
+    constructor();
+    /**
+     * Reset the visited nodes tracking
+     */
+    private reset;
+    execute(arg: SqlComponent): SelectQuery;
+    /**
+     * Main entry point for the visitor pattern.
+     * Implements the shallow visit pattern to distinguish between root and recursive visits.
+     */
+    visit(arg: SqlComponent): SqlComponent;
+    /**
+     * Internal visit method used for all nodes.
+     * This separates the visit flag management from the actual node visitation logic.
+     */
+    private visitNode;
+    visitSimpleSelectQuery(arg: SimpleSelectQuery): SqlComponent;
+    visitBinarySelectQuery(query: BinarySelectQuery): SqlComponent;
+    visitValuesQuery(query: ValuesQuery): SqlComponent;
+    visitSelectClause(clause: SelectClause): SqlComponent;
+    visitFromClause(clause: FromClause): SqlComponent;
+    visitSubQuerySource(subQuery: SubQuerySource): SqlComponent;
+    visitInlineQuery(inlineQuery: InlineQuery): SqlComponent;
+    visitJoinClause(joinClause: JoinClause): SqlComponent;
+    visitJoinOnClause(joinOn: JoinOnClause): SqlComponent;
+    visitJoinUsingClause(joinUsing: JoinUsingClause): SqlComponent;
+    visitWhereClause(whereClause: WhereClause): SqlComponent;
+    visitGroupByClause(clause: GroupByClause): SqlComponent;
+    visitHavingClause(clause: HavingClause): SqlComponent;
+    visitOrderByClause(clause: OrderByClause): SqlComponent;
+    visitWindowFrameClause(clause: WindowFrameClause): SqlComponent;
+    visitLimitClause(clause: LimitClause): SqlComponent;
+    visitForClause(clause: ForClause): SqlComponent;
+    visitParenExpression(expr: ParenExpression): SqlComponent;
+    visitBinaryExpression(expr: BinaryExpression): SqlComponent;
+    visitUnaryExpression(expr: UnaryExpression): SqlComponent;
+    visitCaseExpression(expr: CaseExpression): SqlComponent;
+    visitSwitchCaseArgument(switchCase: SwitchCaseArgument): SqlComponent;
+    visitCaseKeyValuePair(pair: CaseKeyValuePair): SqlComponent;
+    visitBetweenExpression(expr: BetweenExpression): SqlComponent;
+    visitFunctionCall(func: FunctionCall): SqlComponent;
+    visitArrayExpression(expr: ArrayExpression): SqlComponent;
+    visitTupleExpression(expr: TupleExpression): SqlComponent;
+    visitCastExpression(expr: CastExpression): SqlComponent;
+    visitTypeValue(typeValue: TypeValue): SqlComponent;
+    visitSelectItem(item: SelectItem): SqlComponent;
+    visitIdentifierString(ident: IdentifierString): SqlComponent;
+    visitRawString(raw: RawString): SqlComponent;
+    visitColumnReference(column: ColumnReference): SqlComponent;
+    visitSourceExpression(source: SourceExpression): SqlComponent;
+    visitTableSource(source: TableSource): SqlComponent;
+    visitParenSource(source: ParenSource): SqlComponent;
+    visitParameterExpression(param: ParameterExpression): SqlComponent;
+    visitWindowFrameExpression(expr: WindowFrameExpression): SqlComponent;
+    visitWindowFrameSpec(spec: WindowFrameSpec): SqlComponent;
+    visitLiteralValue(value: ValueComponent): SqlComponent;
+    visitOrderByItem(item: OrderByItem): SqlComponent;
+}

package/dist/transformers/CTEInjector.d.ts

@@ -0,0 +1,40 @@
+import { CommonTable } from "../models/Clause";
+import { SelectQuery } from "../models/SelectQuery";
+/**
+ * CTEInjector accepts a SelectQuery object and an array of CommonTables,
+ * and inserts Common Table Expressions into the query.
+ * For BinarySelectQuery, CTEs are inserted into the left query.
+ *
+ * Uses CTENameConflictResolver to resolve naming conflicts between CTEs.
+ */
+export declare class CTEInjector {
+    private nameConflictResolver;
+    private cteCollector;
+    constructor();
+    /**
+     * Inserts Common Table Expressions into a SelectQuery object.
+     *
+     * @param query The query to inject CTEs into
+     * @param commonTables Array of CommonTables to be inserted
+     * @returns A new query with the injected CTEs
+     */
+    inject(query: SelectQuery, commonTables: CommonTable[]): SelectQuery;
+    /**
+     * Inserts Common Table Expressions into a SimpleSelectQuery.
+     *
+     * @param query The SimpleSelectQuery to inject CTEs into
+     * @param commonTables Array of CommonTables to be inserted
+     * @param needRecursive Boolean indicating if recursive WITH clause is needed
+     * @returns A new SimpleSelectQuery with the injected CTEs
+     */
+    private injectIntoSimpleQuery;
+    /**
+     * Inserts Common Table Expressions into the left query of a BinarySelectQuery.
+     *
+     * @param query The BinarySelectQuery to inject CTEs into
+     * @param commonTables Array of CommonTables to be inserted
+     * @param needRecursive Boolean indicating if recursive WITH clause is needed
+     * @returns A new BinarySelectQuery with the injected CTEs
+     */
+    private injectIntoBinaryQuery;
+}

package/dist/transformers/CTENormalizer.d.ts

@@ -0,0 +1,25 @@
+import { SelectQuery } from "../models/SelectQuery";
+/**
+ * CTENormalizer is responsible for normalizing Common Table Expressions (CTEs) within SQL queries.
+ * It collects all CTEs from various parts of the query and consolidates them into a single WITH clause
+ * at the root level of the query.
+ *
+ * This implementation uses:
+ * 1. CommonTableCollector - to gather all CTEs from the query structure
+ * 2. WithClauseDisabler - to remove all original WITH clauses from the query
+ * 3. CTENameConflictResolver - to resolve name conflicts among CTEs and sort them properly
+ */
+export declare class CTENormalizer {
+    private cteCollector;
+    private cteDisabler;
+    private injector;
+    constructor();
+    /**
+     * Normalizes a SQL query by consolidating all CTEs into a single WITH clause
+     * at the root level of the query.
+     *
+     * @param query The query to normalize
+     * @returns A new normalized query with all CTEs at the root level
+     */
+    normalize(query: SelectQuery): SelectQuery;
+}

package/dist/transformers/Formatter.d.ts

@@ -0,0 +1,67 @@
+import { SqlComponent, SqlComponentVisitor } from "../models/SqlComponent";
+interface FormatterConfig {
+    identifierEscape: {
+        start: string;
+        end: string;
+    };
+    parameterSymbol: string;
+}
+export declare class Formatter implements SqlComponentVisitor<string> {
+    private handlers;
+    private config;
+    constructor();
+    execute(arg: SqlComponent, config?: FormatterConfig | null): string;
+    visit(arg: SqlComponent): string;
+    private visitBinarySelectQuery;
+    private visitWindowFrameBoundaryValue;
+    private visitWindowFrameBoundStatic;
+    private visitWindowFrameExpression;
+    private visitWindowFrameSpec;
+    private visitJoinUsingClause;
+    private visitJoinOnClause;
+    private visitTypeValue;
+    private visitStringSpecifierExpression;
+    private visitWithClause;
+    private visitCommonTable;
+    private visitDistinctOn;
+    private visitDistinct;
+    private visitHavingClause;
+    private visitGroupByClause;
+    private visitFromClause;
+    private visitJoinClause;
+    private visitSourceAliasExpression;
+    private visitSourceExpression;
+    private visitSubQuerySource;
+    private visitFunctionSource;
+    private visitTableSource;
+    private visitValueList;
+    private visitSwitchCaseArgument;
+    private visitColumnReference;
+    private visitFunctionCall;
+    private visitUnaryExpression;
+    private visitBinaryExpression;
+    private visitLiteralExpression;
+    private visitParameterExpression;
+    private visitSelectExpression;
+    private visitSelectClause;
+    private visitSelectQuery;
+    private visitArrayExpression;
+    private visitCaseExpression;
+    private visitCastExpression;
+    private visitBracketExpression;
+    private visitBetweenExpression;
+    private visitPartitionByClause;
+    private visitOrderByClause;
+    private visitOrderByItem;
+    private visitWindowFrameClause;
+    private visitLimitClause;
+    private visitFetchSpecification;
+    private visitForClause;
+    private visitWhereClause;
+    private visitInlineQuery;
+    private visitRawString;
+    private visitIdentifierString;
+    private visitValuesQuery;
+    private visitTupleExpression;
+}
+export {};

package/dist/transformers/QueryNormalizer.d.ts

@@ -0,0 +1,37 @@
+import { SelectQuery, SimpleSelectQuery } from "../models/SelectQuery";
+/**
+ * Normalizes SELECT queries by converting different query types to a standard SimpleSelectQuery format.
+ * - Simple SELECT queries are returned as-is
+ * - Binary queries (UNION, etc.) are wrapped in a subquery: SELECT * FROM (original) AS bq
+ * - VALUES queries are given sequentially numbered columns: SELECT * FROM (original) AS vq(column1, column2, ...)
+ */
+export declare class QueryNormalizer {
+    /**
+     * Normalizes a SELECT query to a standard form
+     *
+     * @param query The query to normalize
+     * @returns A normalized SimpleSelectQuery
+     */
+    normalize(query: SelectQuery): SimpleSelectQuery;
+    /**
+     * Converts a binary query (UNION, EXCEPT, etc.) to a simple query
+     * by wrapping it in a SELECT * FROM (original) AS bq
+     *
+     * @param query The binary query to normalize
+     * @returns A normalized SimpleSelectQuery
+     */
+    private normalizeBinaryQuery;
+    /**
+     * Converts a VALUES query to a simple query with sequentially numbered columns
+     *
+     * @param query The VALUES query to normalize
+     * @returns A normalized SimpleSelectQuery
+     */
+    private normalizeValuesQuery;
+    /**
+     * Creates a SELECT clause with a single * (all columns) item
+     *
+     * @returns A SELECT clause with *
+     */
+    private createSelectAllClause;
+}

package/dist/transformers/SelectValueCollector.d.ts

@@ -0,0 +1,62 @@
+import { CommonTable } from "../models/Clause";
+import { SqlComponent, SqlComponentVisitor } from "../models/SqlComponent";
+import { ValueComponent } from "../models/ValueComponent";
+/**
+ * Type definition for a function that resolves column names from a table name
+ */
+export type TableColumnResolver = (tableName: string) => string[];
+/**
+ * A visitor that collects all SelectItem instances from a SQL query structure.
+ * This visitor scans through select clauses and collects all the SelectItem objects.
+ * It can also resolve wildcard selectors (table.* or *) using a provided table column resolver.
+ */
+export declare class SelectValueCollector implements SqlComponentVisitor<void> {
+    private handlers;
+    private selectValues;
+    private visitedNodes;
+    private isRootVisit;
+    private tableColumnResolver?;
+    private commonTableCollector;
+    private commonTables;
+    initialCommonTables: CommonTable[] | null;
+    constructor(tableColumnResolver?: TableColumnResolver, initialCommonTables?: CommonTable[] | null);
+    /**
+     * Get all collected SelectItems as an array of objects with name and value properties
+     * @returns An array of objects with name (string) and value (ValueComponent) properties
+     */
+    getValues(): {
+        name: string;
+        value: ValueComponent;
+    }[];
+    /**
+     * Reset the collection of SelectItems
+     */
+    private reset;
+    collect(arg: SqlComponent): {
+        name: string;
+        value: ValueComponent;
+    }[];
+    /**
+     * Main entry point for the visitor pattern.
+     * Implements the shallow visit pattern to distinguish between root and recursive visits.
+     */
+    visit(arg: SqlComponent): void;
+    /**
+     * Internal visit method used for all nodes.
+     * This separates the visit flag management from the actual node visitation logic.
+     */
+    private visitNode;
+    /**
+     * Process a SimpleSelectQuery to collect data and store the current context
+     */
+    private visitSimpleSelectQuery;
+    private processFromClause;
+    private processJoinClause;
+    private processSourceExpression;
+    private visitSelectClause;
+    private processSelectItem;
+    private processValueComponent;
+    private visitSourceExpression;
+    private visitFromClause;
+    private addSelectValueAsUnique;
+}

package/dist/transformers/SelectableColumnCollector.d.ts

@@ -0,0 +1,70 @@
+import { SqlComponent, SqlComponentVisitor } from "../models/SqlComponent";
+import { ValueComponent } from "../models/ValueComponent";
+import { TableColumnResolver } from "./SelectValueCollector";
+/**
+ * A visitor that collects all ColumnReference instances from a SQL query structure.
+ * This visitor scans through all clauses and collects all unique ColumnReference objects.
+ * It does not scan Common Table Expressions (CTEs) or subqueries.
+ *
+ * Important: Only collects column references to tables defined in the root FROM/JOIN clauses,
+ * as these are the only columns that can be directly referenced in the query.
+ */
+export declare class SelectableColumnCollector implements SqlComponentVisitor<void> {
+    private handlers;
+    private selectValues;
+    private visitedNodes;
+    private formatter;
+    private isRootVisit;
+    private tableColumnResolver?;
+    private commonTableCollector;
+    private selectValueCollector;
+    private commonTables;
+    constructor(tableColumnResolver?: TableColumnResolver);
+    getValues(): {
+        name: string;
+        value: ValueComponent;
+    }[];
+    collect(arg: SqlComponent): {
+        name: string;
+        value: ValueComponent;
+    }[];
+    /**
+     * Reset the collection of ColumnReferences
+     */
+    private reset;
+    private addSelectValueAsUnique;
+    /**
+     * Main entry point for the visitor pattern.
+     * Implements the shallow visit pattern to distinguish between root and recursive visits.
+     */
+    visit(arg: SqlComponent): void;
+    /**
+     * Internal visit method used for all nodes.
+     * This separates the visit flag management from the actual node visitation logic.
+     */
+    private visitNode;
+    /**
+      * Process a SimpleSelectQuery to collect ColumnReferences from all its clauses
+      */
+    private visitSimpleSelectQuery;
+    private visitSelectClause;
+    private visitFromClause;
+    private visitWhereClause;
+    private visitGroupByClause;
+    private visitHavingClause;
+    private visitOrderByClause;
+    private visitWindowFrameClause;
+    private visitLimitClause;
+    private visitJoinOnClause;
+    private visitJoinUsingClause;
+    private visitColumnReference;
+    private visitBinaryExpression;
+    private visitUnaryExpression;
+    private visitFunctionCall;
+    private visitParenExpression;
+    private visitCaseExpression;
+    private visitCastExpression;
+    private visitBetweenExpression;
+    private visitArrayExpression;
+    private visitValueList;
+}

package/dist/transformers/TableSourceCollector.d.ts

@@ -0,0 +1,92 @@
+import { TableSource } from "../models/Clause";
+import { SqlComponent, SqlComponentVisitor } from "../models/SqlComponent";
+/**
+ * A visitor that collects all table source names from a SQL query structure.
+ *
+ * When selectableOnly is true (default behavior):
+ * - Includes only table sources from FROM and JOIN clauses
+ * - Excludes inline queries, subqueries, and CTEs
+ *
+ * When selectableOnly is false:
+ * - Scans all parts of the query including WITH clauses, subqueries, etc.
+ * - Collects all table sources from the entire query
+ * - Excludes tables that are managed by CTEs
+ *
+ * For UNION-like queries, it scans both the left and right parts.
+ */
+export declare class TableSourceCollector implements SqlComponentVisitor<void> {
+    private handlers;
+    private tableSources;
+    private visitedNodes;
+    private tableNameMap;
+    private selectableOnly;
+    private cteNames;
+    private isRootVisit;
+    constructor(selectableOnly?: boolean);
+    /**
+     * Gets all collected table sources
+     */
+    getTableSources(): TableSource[];
+    /**
+     * Reset the collection of table sources
+     */
+    private reset;
+    /**
+     * Gets a unique identifier for a table source
+     */
+    private getTableIdentifier;
+    collect(query: SqlComponent): TableSource[];
+    /**
+     * Main entry point for the visitor pattern.
+     * Implements the shallow visit pattern to distinguish between root and recursive visits.
+     */
+    visit(arg: SqlComponent): void;
+    /**
+     * Internal visit method used for all nodes.
+     * This separates the visit flag management from the actual node visitation logic.
+     */
+    private visitNode;
+    /**
+     * Collects all CTE names to exclude them from real table sources
+     */
+    private collectCTEs;
+    private visitSimpleSelectQuery;
+    private visitBinarySelectQuery;
+    private visitValuesQuery;
+    private visitWithClause;
+    private visitCommonTable;
+    private visitFromClause;
+    private visitSourceExpression;
+    private visitTableSource;
+    /**
+     * Checks if a table name is a CTE name
+     */
+    private isCTETable;
+    private visitParenSource;
+    private visitSubQuerySource;
+    private visitInlineQuery;
+    private visitJoinClause;
+    private visitJoinOnClause;
+    private visitJoinUsingClause;
+    private visitWhereClause;
+    private visitGroupByClause;
+    private visitHavingClause;
+    private visitOrderByClause;
+    private visitWindowFrameClause;
+    private visitLimitClause;
+    private visitForClause;
+    private visitOrderByItem;
+    private visitSelectClause;
+    private visitSelectItem;
+    private visitParenExpression;
+    private visitBinaryExpression;
+    private visitUnaryExpression;
+    private visitCaseExpression;
+    private visitSwitchCaseArgument;
+    private visitCaseKeyValuePair;
+    private visitBetweenExpression;
+    private visitFunctionCall;
+    private visitArrayExpression;
+    private visitTupleExpression;
+    private visitCastExpression;
+}

package/dist/transformers/UpstreamSelectQueryFinder.d.ts

@@ -0,0 +1,27 @@
+import { SelectQuery } from "../models/SelectQuery";
+/**
+ * UpstreamSelectQueryFinder searches upstream queries for the specified columns.
+ * If a query (including its upstream CTEs or subqueries) contains all columns,
+ * it returns the highest such SelectQuery. Otherwise, it searches downstream.
+ * For UNION queries, it checks each branch independently.
+ */
+export declare class UpstreamSelectQueryFinder {
+    private tableColumnResolver?;
+    private columnCollector;
+    constructor(tableColumnResolver?: (tableName: string) => string[]);
+    /**
+     * Finds the highest SelectQuery containing all specified columns.
+     * @param query The root SelectQuery to search.
+     * @param columnNames Array of column names to check for.
+     * @returns An array of SelectQuery objects, or an empty array if not found.
+     */
+    find(query: SelectQuery, columnNames: string[]): SelectQuery[];
+    private handleTableSource;
+    private handleSubQuerySource;
+    /**
+     * Processes all source branches in a FROM clause and checks if all upstream queries contain the specified columns.
+     * Returns a flat array of SelectQuery if all branches are valid, otherwise null.
+     */
+    private processFromClauseBranches;
+    private findUpstream;
+}

package/dist/utils/charLookupTable.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Fast character classification utilities for SQL tokenization
+ */
+export declare class CharLookupTable {
+    static isWhitespace(char: string): boolean;
+    static isDigit(char: string): boolean;
+    static isHexChar(char: string): boolean;
+    static isOperatorSymbol(char: string): boolean;
+    static isDelimiter(char: string): boolean;
+    static isNamedParameterPrefix(char: string): boolean;
+}