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

package/dist/models/ValuesQuery.d.ts

@@ -0,0 +1,10 @@
+import { SqlComponent } from "./SqlComponent";
+import { TupleExpression } from "./ValueComponent";
+/**
+ * Represents a VALUES query in SQL.
+ */
+export declare class ValuesQuery extends SqlComponent {
+    static kind: symbol;
+    tuples: TupleExpression[];
+    constructor(tuples: TupleExpression[]);
+}

package/dist/parsers/CommandExpressionParser.d.ts

@@ -0,0 +1,15 @@
+import { Lexeme } from "../models/Lexeme";
+import { ValueComponent } from "../models/ValueComponent";
+export declare class CommandExpressionParser {
+    static parse(lexemes: Lexeme[], index: number): {
+        value: ValueComponent;
+        newIndex: number;
+    };
+    private static parseModifierUnaryExpression;
+    private static parseCaseExpression;
+    private static parseCaseWhenExpression;
+    private static parseSwitchCaseArgument;
+    private static isCommandWithValue;
+    private static parseCaseConditionValuePair;
+    private static parseArrayExpression;
+}

package/dist/parsers/CommonTableParser.d.ts

@@ -0,0 +1,9 @@
+import { CommonTable } from "../models/Clause";
+import { Lexeme } from "../models/Lexeme";
+export declare class CommonTableParser {
+    static parseFromText(query: string): CommonTable;
+    static parse(lexemes: Lexeme[], index: number): {
+        value: CommonTable;
+        newIndex: number;
+    };
+}

package/dist/parsers/ForClauseParser.d.ts

@@ -0,0 +1,9 @@
+import { ForClause } from "../models/Clause";
+import { Lexeme } from "../models/Lexeme";
+export declare class ForClauseParser {
+    static parseFromText(query: string): ForClause;
+    static parse(lexemes: Lexeme[], index: number): {
+        value: ForClause;
+        newIndex: number;
+    };
+}

package/dist/parsers/FromClauseParser.d.ts

@@ -0,0 +1,9 @@
+import { FromClause } from "../models/Clause";
+import { Lexeme } from "../models/Lexeme";
+export declare class FromClauseParser {
+    static parseFromText(query: string): FromClause;
+    static parse(lexemes: Lexeme[], index: number): {
+        value: FromClause;
+        newIndex: number;
+    };
+}

package/dist/parsers/FunctionExpressionParser.d.ts

@@ -0,0 +1,22 @@
+import { Lexeme } from "../models/Lexeme";
+import { ValueComponent, TypeValue } from "../models/ValueComponent";
+export declare class FunctionExpressionParser {
+    static parse(lexemes: Lexeme[], index: number): {
+        value: ValueComponent;
+        newIndex: number;
+    };
+    static tryParseBinaryExpression(lexemes: Lexeme[], index: number, left: ValueComponent, allowAndOperator?: boolean): {
+        value: ValueComponent;
+        newIndex: number;
+    } | null;
+    static parseBetweenExpression(lexemes: Lexeme[], index: number, value: ValueComponent, negated: boolean): {
+        value: ValueComponent;
+        newIndex: number;
+    };
+    private static parseFunctionCall;
+    private static parseKeywordFunction;
+    static parseTypeValue(lexemes: Lexeme[], index: number): {
+        value: TypeValue;
+        newIndex: number;
+    };
+}

package/dist/parsers/GroupByParser.d.ts

@@ -0,0 +1,10 @@
+import { GroupByClause } from "../models/Clause";
+import { Lexeme } from "../models/Lexeme";
+export declare class GroupByClauseParser {
+    static parseFromText(query: string): GroupByClause;
+    static parse(lexemes: Lexeme[], index: number): {
+        value: GroupByClause;
+        newIndex: number;
+    };
+    private static parseItem;
+}

package/dist/parsers/HavingParser.d.ts

@@ -0,0 +1,9 @@
+import { HavingClause } from "../models/Clause";
+import { Lexeme } from "../models/Lexeme";
+export declare class HavingClauseParser {
+    static parseFromText(query: string): HavingClause;
+    static parse(lexemes: Lexeme[], index: number): {
+        value: HavingClause;
+        newIndex: number;
+    };
+}

package/dist/parsers/IdentifierParser.d.ts

@@ -0,0 +1,8 @@
+import { Lexeme } from "../models/Lexeme";
+import { ValueComponent } from "../models/ValueComponent";
+export declare class IdentifierParser {
+    static parse(lexemes: Lexeme[], index: number): {
+        value: ValueComponent;
+        newIndex: number;
+    };
+}

package/dist/parsers/JoinClauseParser.d.ts

@@ -0,0 +1,14 @@
+import { JoinClause } from "../models/Clause";
+import { Lexeme } from "../models/Lexeme";
+export declare class JoinClauseParser {
+    static tryParse(lexemes: Lexeme[], index: number): {
+        value: JoinClause[];
+        newIndex: number;
+    } | null;
+    private static isJoinKeyword;
+    private static parseLateral;
+    private static isJoinCommand;
+    private static parseJoinClause;
+    private static tryParseJoinOn;
+    private static tryParseJoinUsing;
+}

package/dist/parsers/KeywordParser.d.ts

@@ -0,0 +1,17 @@
+import { KeywordTrie } from "../models/KeywordTrie";
+export declare enum KeywordMatchResult {
+    NotAKeyword = 0,// "Not recognized as a keyword"
+    PartialOnly = 1,// "Partial match (this will not be the end)"
+    PartialOrFinal = 2,// "Partial or complete match (it can stop here)"
+    Final = 3
+}
+export declare class KeywordParser {
+    private trie;
+    constructor(trie: KeywordTrie);
+    private isEndOfInput;
+    private canParse;
+    parse(input: string, position: number): {
+        keyword: string;
+        newPosition: number;
+    } | null;
+}

package/dist/parsers/LimitClauseParser.d.ts

@@ -0,0 +1,9 @@
+import { LimitClause as LimitClause } from "../models/Clause";
+import { Lexeme } from "../models/Lexeme";
+export declare class LimitClauseParser {
+    static parseFromText(query: string): LimitClause;
+    static parse(lexemes: Lexeme[], index: number): {
+        value: LimitClause;
+        newIndex: number;
+    };
+}

package/dist/parsers/LiteralParser.d.ts

@@ -0,0 +1,8 @@
+import { Lexeme } from "../models/Lexeme";
+import { ValueComponent } from "../models/ValueComponent";
+export declare class LiteralParser {
+    static parse(lexemes: Lexeme[], index: number): {
+        value: ValueComponent;
+        newIndex: number;
+    };
+}

package/dist/parsers/OrderByClauseParser.d.ts

@@ -0,0 +1,10 @@
+import { OrderByClause } from "../models/Clause";
+import { Lexeme } from "../models/Lexeme";
+export declare class OrderByClauseParser {
+    static parseFromText(query: string): OrderByClause;
+    static parse(lexemes: Lexeme[], index: number): {
+        value: OrderByClause;
+        newIndex: number;
+    };
+    private static parseItem;
+}

package/dist/parsers/OverExpressionParser.d.ts

@@ -0,0 +1,9 @@
+import { Lexeme } from "../models/Lexeme";
+import { OverExpression } from "../models/ValueComponent";
+export declare class OverExpressionParser {
+    static parseFromText(query: string): OverExpression;
+    static parse(lexemes: Lexeme[], index: number): {
+        value: OverExpression;
+        newIndex: number;
+    };
+}

package/dist/parsers/ParameterExpressionParser.d.ts

@@ -0,0 +1,8 @@
+import { Lexeme } from "../models/Lexeme";
+import { ValueComponent } from "../models/ValueComponent";
+export declare class ParameterExpressionParser {
+    static parse(lexemes: Lexeme[], index: number): {
+        value: ValueComponent;
+        newIndex: number;
+    };
+}

package/dist/parsers/ParenExpressionParser.d.ts

@@ -0,0 +1,8 @@
+import { Lexeme } from "../models/Lexeme";
+import { ValueComponent } from "../models/ValueComponent";
+export declare class ParenExpressionParser {
+    static parse(lexemes: Lexeme[], index: number): {
+        value: ValueComponent;
+        newIndex: number;
+    };
+}

package/dist/parsers/PartitionByParser.d.ts

@@ -0,0 +1,9 @@
+import { PartitionByClause } from "../models/Clause";
+import { Lexeme } from "../models/Lexeme";
+export declare class PartitionByParser {
+    static parseFromText(query: string): PartitionByClause;
+    static parse(lexemes: Lexeme[], index: number): {
+        value: PartitionByClause;
+        newIndex: number;
+    };
+}

package/dist/parsers/SelectClauseParser.d.ts

@@ -0,0 +1,10 @@
+import { SelectClause } from "../models/Clause";
+import { Lexeme } from "../models/Lexeme";
+export declare class SelectClauseParser {
+    static parseFromText(query: string): SelectClause;
+    static parse(lexemes: Lexeme[], index: number): {
+        value: SelectClause;
+        newIndex: number;
+    };
+    private static parseItem;
+}

package/dist/parsers/SelectQueryParser.d.ts

@@ -0,0 +1,13 @@
+import { Lexeme } from "../models/Lexeme";
+import { SelectQuery } from "../models/SelectQuery";
+export declare class SelectQueryParser {
+    static parseFromText(query: string): SelectQuery;
+    private static unionCommandSet;
+    private static selectCommandSet;
+    static parse(lexemes: Lexeme[], index: number): {
+        value: SelectQuery;
+        newIndex: number;
+    };
+    private static parseSimpleSelectQuery;
+    private static parseValuesQuery;
+}

package/dist/parsers/SourceAliasExpressionParser.d.ts

@@ -0,0 +1,8 @@
+import { SourceAliasExpression } from "../models/Clause";
+import { Lexeme } from "../models/Lexeme";
+export declare class SourceAliasExpressionParser {
+    static parse(lexemes: Lexeme[], index: number): {
+        value: SourceAliasExpression;
+        newIndex: number;
+    };
+}

package/dist/parsers/SourceExpressionParser.d.ts

@@ -0,0 +1,8 @@
+import { SourceExpression } from "../models/Clause";
+import { Lexeme } from "../models/Lexeme";
+export declare class SourceExpressionParser {
+    static parse(lexemes: Lexeme[], index: number): {
+        value: SourceExpression;
+        newIndex: number;
+    };
+}

package/dist/parsers/SourceParser.d.ts

@@ -0,0 +1,13 @@
+import { SourceComponent } from "../models/Clause";
+import { Lexeme } from "../models/Lexeme";
+export declare class SourceParser {
+    static parseFromText(query: string): SourceComponent;
+    static parse(lexemes: Lexeme[], index: number): {
+        value: SourceComponent;
+        newIndex: number;
+    };
+    private static parseTableSource;
+    private static parseFunctionSource;
+    private static parseParenSource;
+    private static parseSubQuerySource;
+}

package/dist/parsers/SqlTokenizer.d.ts

@@ -0,0 +1,64 @@
+import { Lexeme } from '../models/Lexeme';
+/**
+ * Class responsible for tokenizing SQL input.
+ */
+export declare class SqlTokenizer {
+    /**
+     * The input SQL string to be tokenized.
+     */
+    private input;
+    /**
+     * Current position within the input string.
+     */
+    private position;
+    /**
+     * Manager responsible for handling token readers.
+     */
+    private readerManager;
+    /**
+     * Initializes a new instance of the SqlTokenizer.
+     */
+    constructor(input: string);
+    /**
+     * Checks if the end of input is reached.
+     *
+     * @param shift - The shift to consider beyond the current position.
+     * @returns True if the end of input is reached; otherwise, false.
+     */
+    private isEndOfInput;
+    /**
+     * Checks if more input can be read.
+     *
+     * @param shift - The shift to consider beyond the current position.
+     * @returns True if more input can be read; otherwise, false.
+     */
+    private canRead;
+    /**
+     * Reads the lexemes from the input string.
+     *
+     * @returns An array of lexemes extracted from the input string.
+     * @throws Error if an unexpected character is encountered.
+     */
+    readLexmes(): Lexeme[];
+    /**
+     * Adds pending comments to the last token.
+     */
+    private addPendingCommentsToLastToken;
+    /**
+     * Adds comments to the token.
+     */
+    private addCommentsToToken;
+    /**
+     * Skips whitespace characters and SQL comments in the input.
+     *
+     * @remarks This method updates the position pointer.
+     */
+    private readComment;
+    /**
+     * Gets debug information for error reporting.
+     *
+     * @param errPosition - The position where the error occurred.
+     * @returns A string containing the debug position information.
+     */
+    private getDebugPositionInfo;
+}

package/dist/parsers/StringSpecifierExpressionParser.d.ts

@@ -0,0 +1,8 @@
+import { Lexeme } from "../models/Lexeme";
+import { ValueComponent } from "../models/ValueComponent";
+export declare class StringSpecifierExpressionParser {
+    static parse(lexemes: Lexeme[], index: number): {
+        value: ValueComponent;
+        newIndex: number;
+    };
+}

package/dist/parsers/UnaryExpressionParser.d.ts

@@ -0,0 +1,8 @@
+import { Lexeme } from "../models/Lexeme";
+import { ValueComponent } from "../models/ValueComponent";
+export declare class UnaryExpressionParser {
+    static parse(lexemes: Lexeme[], index: number): {
+        value: ValueComponent;
+        newIndex: number;
+    };
+}

package/dist/parsers/ValueParser.d.ts

@@ -0,0 +1,14 @@
+import { Lexeme, TokenType } from "../models/Lexeme";
+import { ValueComponent } from "../models/ValueComponent";
+export declare class ValueParser {
+    static parseFromText(query: string): ValueComponent;
+    static parse(lexemes: Lexeme[], index: number, allowAndOperator?: boolean): {
+        value: ValueComponent;
+        newIndex: number;
+    };
+    private static parseItem;
+    static parseArgument(openToken: TokenType, closeToken: TokenType, lexemes: Lexeme[], index: number): {
+        value: ValueComponent;
+        newIndex: number;
+    };
+}

package/dist/parsers/ValuesQueryParser.d.ts

@@ -0,0 +1,10 @@
+import { Lexeme } from "../models/Lexeme";
+import { ValuesQuery } from "../models/SelectQuery";
+export declare class ValuesQueryParser {
+    static parseFromText(query: string): ValuesQuery;
+    static parse(lexemes: Lexeme[], index: number): {
+        value: ValuesQuery;
+        newIndex: number;
+    };
+    private static parseTuple;
+}

package/dist/parsers/WhereClauseParser.d.ts

@@ -0,0 +1,9 @@
+import { WhereClause } from "../models/Clause";
+import { Lexeme } from "../models/Lexeme";
+export declare class WhereClauseParser {
+    static parseFromText(query: string): WhereClause;
+    static parse(lexemes: Lexeme[], index: number): {
+        value: WhereClause;
+        newIndex: number;
+    };
+}

package/dist/parsers/WindowClauseParser.d.ts

@@ -0,0 +1,9 @@
+import { WindowFrameClause } from "../models/Clause";
+import { Lexeme } from "../models/Lexeme";
+export declare class WindowClauseParser {
+    static parseFromText(query: string): WindowFrameClause;
+    static parse(lexemes: Lexeme[], index: number): {
+        value: WindowFrameClause;
+        newIndex: number;
+    };
+}

package/dist/parsers/WindowExpressionParser.d.ts

@@ -0,0 +1,12 @@
+import { Lexeme } from "../models/Lexeme";
+import { WindowFrameExpression } from "../models/ValueComponent";
+export declare class WindowExpressionParser {
+    static parseFromText(query: string): WindowFrameExpression;
+    static parse(lexemes: Lexeme[], index: number): {
+        value: WindowFrameExpression;
+        newIndex: number;
+    };
+    private static isFrameTypeKeyword;
+    private static parseFrameSpec;
+    private static parseFrameBoundary;
+}

package/dist/parsers/WithClauseParser.d.ts

@@ -0,0 +1,9 @@
+import { WithClause } from "../models/Clause";
+import { Lexeme } from "../models/Lexeme";
+export declare class WithClauseParser {
+    static parseFromText(query: string): WithClause;
+    static parse(lexemes: Lexeme[], index: number): {
+        value: WithClause;
+        newIndex: number;
+    };
+}

package/dist/tokenReaders/BaseTokenReader.d.ts

@@ -0,0 +1,43 @@
+import { Lexeme, TokenType } from '../models/Lexeme';
+/**
+ * Base class for token readers
+ */
+export declare abstract class BaseTokenReader {
+    protected input: string;
+    protected position: number;
+    constructor(input: string, position?: number);
+    /**
+     * Get the current position in the input
+     */
+    getPosition(): number;
+    /**
+     * Set the position in the input
+     */
+    setPosition(position: number): void;
+    /**
+     * Check if we've reached the end of input
+     */
+    protected isEndOfInput(shift?: number): boolean;
+    /**
+     * Check if we can read more characters
+     */
+    protected canRead(shift?: number): boolean;
+    /**
+     * Read an expected character
+     */
+    protected read(expectChar: string): string;
+    /**
+     * Create a lexeme with the specified type and value
+     */
+    protected createLexeme(type: TokenType, value: string, maybeType?: boolean | null, comments?: string[] | null): Lexeme;
+    /**
+     * Get debug info for error reporting
+     */
+    protected getDebugPositionInfo(errPosition: number): string;
+    /**
+     * Try to read a token from the current position
+     * @param previous The previous token, if available
+     * @returns The read token or null if no token could be read
+     */
+    abstract tryRead(previous: Lexeme | null): Lexeme | null;
+}

package/dist/tokenReaders/CommandTokenReader.d.ts

@@ -0,0 +1,7 @@
+import { BaseTokenReader } from "./BaseTokenReader";
+import { Lexeme } from '../models/Lexeme';
+import { KeywordParser } from "../parsers/KeywordParser";
+export declare const joinkeywordParser: KeywordParser;
+export declare class CommandTokenReader extends BaseTokenReader {
+    tryRead(previous: Lexeme | null): Lexeme | null;
+}

package/dist/tokenReaders/FunctionTokenReader.d.ts

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

package/dist/tokenReaders/IdentifierTokenReader.d.ts

@@ -0,0 +1,15 @@
+import { BaseTokenReader } from './BaseTokenReader';
+import { Lexeme } from '../models/Lexeme';
+/**
+ * Reads SQL identifier tokens
+ */
+export declare class IdentifierTokenReader extends BaseTokenReader {
+    /**
+     * Try to read an identifier token
+     */
+    tryRead(previous: Lexeme | null): Lexeme | null;
+    /**
+     * Read an escaped identifier (surrounded by delimiters)
+     */
+    private readEscapedIdentifier;
+}

package/dist/tokenReaders/LiteralTokenReader.d.ts

@@ -0,0 +1,23 @@
+import { BaseTokenReader } from './BaseTokenReader';
+import { Lexeme } from '../models/Lexeme';
+import { KeywordParser } from '../parsers/KeywordParser';
+export declare const literalKeywordParser: KeywordParser;
+export declare class LiteralTokenReader extends BaseTokenReader {
+    /**
+     * Try to read a literal token
+     */
+    tryRead(previous: Lexeme | null): Lexeme | null;
+    private tryReadKeyword;
+    /**
+     * Check if the current context allows for a signed number
+     */
+    private isValidNumericPrefix;
+    /**
+     * Read a numeric value
+     */
+    private readDigit;
+    /**
+     * Read a string literal
+     */
+    private readSingleQuotedString;
+}

package/dist/tokenReaders/OperatorTokenReader.d.ts

@@ -0,0 +1,5 @@
+import { BaseTokenReader } from './BaseTokenReader';
+import { Lexeme } from '../models/Lexeme';
+export declare class OperatorTokenReader extends BaseTokenReader {
+    tryRead(previous: Lexeme | null): Lexeme | null;
+}

package/dist/tokenReaders/ParameterTokenReader.d.ts

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

package/dist/tokenReaders/StringSpecifierTokenReader.d.ts

@@ -0,0 +1,8 @@
+import { Lexeme } from '../models/Lexeme';
+import { BaseTokenReader } from './BaseTokenReader';
+export declare class StringSpecifierTokenReader extends BaseTokenReader {
+    /**
+     * Try to read an escaped literal like e'...', x'...', etc.
+     */
+    tryRead(previous: Lexeme | null): Lexeme | null;
+}

package/dist/tokenReaders/SymbolTokenReader.d.ts

@@ -0,0 +1,12 @@
+import { BaseTokenReader } from './BaseTokenReader';
+import { Lexeme } from '../models/Lexeme';
+/**
+ * Reads SQL symbol tokens (., ,, (, ))
+ */
+export declare class SpecialSymbolTokenReader extends BaseTokenReader {
+    private static readonly SPECIAL_SYMBOL_TOKENS;
+    /**
+     * Try to read a symbol token
+     */
+    tryRead(previous: Lexeme | null): Lexeme | null;
+}

package/dist/tokenReaders/TokenReaderManager.d.ts

@@ -0,0 +1,53 @@
+import { BaseTokenReader } from './BaseTokenReader';
+import { Lexeme } from '../models/Lexeme';
+/**
+ * Manages and coordinates multiple token readers
+ */
+export declare class TokenReaderManager {
+    private readers;
+    private input;
+    private position;
+    private tokenCache;
+    private cacheHits;
+    private cacheMisses;
+    constructor(input: string, position?: number);
+    /**
+     * Register a token reader
+     * @param reader The reader to register
+     * @returns This manager instance for chaining
+     */
+    register(reader: BaseTokenReader): TokenReaderManager;
+    /**
+     * Register multiple token readers
+     * @param readers The readers to register
+     * @returns This manager instance for chaining
+     */
+    registerAll(readers: BaseTokenReader[]): TokenReaderManager;
+    /**
+     * Update the position for all readers
+     */
+    private setPosition;
+    /**
+     * Try to read a token using all registered readers
+     * @param position The position to read from
+     * @param previous The previous token, if any
+     * @returns The lexeme if a reader could read it, null otherwise
+     */
+    tryRead(position: number, previous: Lexeme | null): Lexeme | null;
+    /**
+     * Get the maximum position among all readers
+     */
+    getMaxPosition(): number;
+    /**
+     * Get the input string
+     */
+    getInput(): string;
+    /**
+     * Get cache statistics
+     */
+    getCacheStats(): {
+        hits: number;
+        misses: number;
+        ratio: number;
+    };
+}