dt-sql-parser 4.5.0-beta.3 → 4.5.1-beta.0

package/dist/lib/spark/SparkSqlParserListener.d.ts

@@ -131,8 +131,10 @@ import { TableNameCreateContext } from "./SparkSqlParser.js";
 import { TableNameContext } from "./SparkSqlParser.js";
 import { ViewNameCreateContext } from "./SparkSqlParser.js";
 import { ViewNameContext } from "./SparkSqlParser.js";
+import { EmptyColumnContext } from "./SparkSqlParser.js";
 import { ColumnNameContext } from "./SparkSqlParser.js";
 import { ColumnNamePathContext } from "./SparkSqlParser.js";
+import { ColumnNamePathAllowEmptyContext } from "./SparkSqlParser.js";
 import { ColumnNameSeqContext } from "./SparkSqlParser.js";
 import { ColumnNameCreateContext } from "./SparkSqlParser.js";
 import { IdentifierReferenceContext } from "./SparkSqlParser.js";
@@ -206,6 +208,7 @@ import { TableAliasContext } from "./SparkSqlParser.js";
 import { RowFormatContext } from "./SparkSqlParser.js";
 import { MultipartIdentifierListContext } from "./SparkSqlParser.js";
 import { MultipartIdentifierContext } from "./SparkSqlParser.js";
+import { MultipartIdentifierAllowEmptyContext } from "./SparkSqlParser.js";
 import { MultipartIdentifierPropertyListContext } from "./SparkSqlParser.js";
 import { MultipartIdentifierPropertyContext } from "./SparkSqlParser.js";
 import { TableIdentifierContext } from "./SparkSqlParser.js";
@@ -1796,6 +1799,16 @@ export declare class SparkSqlParserListener implements ParseTreeListener {
      * @param ctx the parse tree
      */
     exitViewName?: (ctx: ViewNameContext) => void;
+    /**
+     * Enter a parse tree produced by `SparkSqlParser.emptyColumn`.
+     * @param ctx the parse tree
+     */
+    enterEmptyColumn?: (ctx: EmptyColumnContext) => void;
+    /**
+     * Exit a parse tree produced by `SparkSqlParser.emptyColumn`.
+     * @param ctx the parse tree
+     */
+    exitEmptyColumn?: (ctx: EmptyColumnContext) => void;
     /**
      * Enter a parse tree produced by `SparkSqlParser.columnName`.
      * @param ctx the parse tree
@@ -1816,6 +1829,16 @@ export declare class SparkSqlParserListener implements ParseTreeListener {
      * @param ctx the parse tree
      */
     exitColumnNamePath?: (ctx: ColumnNamePathContext) => void;
+    /**
+     * Enter a parse tree produced by `SparkSqlParser.columnNamePathAllowEmpty`.
+     * @param ctx the parse tree
+     */
+    enterColumnNamePathAllowEmpty?: (ctx: ColumnNamePathAllowEmptyContext) => void;
+    /**
+     * Exit a parse tree produced by `SparkSqlParser.columnNamePathAllowEmpty`.
+     * @param ctx the parse tree
+     */
+    exitColumnNamePathAllowEmpty?: (ctx: ColumnNamePathAllowEmptyContext) => void;
     /**
      * Enter a parse tree produced by `SparkSqlParser.columnNameSeq`.
      * @param ctx the parse tree
@@ -2556,6 +2579,16 @@ export declare class SparkSqlParserListener implements ParseTreeListener {
      * @param ctx the parse tree
      */
     exitMultipartIdentifier?: (ctx: MultipartIdentifierContext) => void;
+    /**
+     * Enter a parse tree produced by `SparkSqlParser.multipartIdentifierAllowEmpty`.
+     * @param ctx the parse tree
+     */
+    enterMultipartIdentifierAllowEmpty?: (ctx: MultipartIdentifierAllowEmptyContext) => void;
+    /**
+     * Exit a parse tree produced by `SparkSqlParser.multipartIdentifierAllowEmpty`.
+     * @param ctx the parse tree
+     */
+    exitMultipartIdentifierAllowEmpty?: (ctx: MultipartIdentifierAllowEmptyContext) => void;
     /**
      * Enter a parse tree produced by `SparkSqlParser.multipartIdentifierPropertyList`.
      * @param ctx the parse tree

package/dist/lib/spark/SparkSqlParserVisitor.d.ts

@@ -131,8 +131,10 @@ import { TableNameCreateContext } from "./SparkSqlParser.js";
 import { TableNameContext } from "./SparkSqlParser.js";
 import { ViewNameCreateContext } from "./SparkSqlParser.js";
 import { ViewNameContext } from "./SparkSqlParser.js";
+import { EmptyColumnContext } from "./SparkSqlParser.js";
 import { ColumnNameContext } from "./SparkSqlParser.js";
 import { ColumnNamePathContext } from "./SparkSqlParser.js";
+import { ColumnNamePathAllowEmptyContext } from "./SparkSqlParser.js";
 import { ColumnNameSeqContext } from "./SparkSqlParser.js";
 import { ColumnNameCreateContext } from "./SparkSqlParser.js";
 import { IdentifierReferenceContext } from "./SparkSqlParser.js";
@@ -206,6 +208,7 @@ import { TableAliasContext } from "./SparkSqlParser.js";
 import { RowFormatContext } from "./SparkSqlParser.js";
 import { MultipartIdentifierListContext } from "./SparkSqlParser.js";
 import { MultipartIdentifierContext } from "./SparkSqlParser.js";
+import { MultipartIdentifierAllowEmptyContext } from "./SparkSqlParser.js";
 import { MultipartIdentifierPropertyListContext } from "./SparkSqlParser.js";
 import { MultipartIdentifierPropertyContext } from "./SparkSqlParser.js";
 import { TableIdentifierContext } from "./SparkSqlParser.js";
@@ -1175,6 +1178,12 @@ export declare class SparkSqlParserVisitor<Result> extends AbstractParseTreeVisi
      * @return the visitor result
      */
     visitViewName?: (ctx: ViewNameContext) => Result;
+    /**
+     * Visit a parse tree produced by `SparkSqlParser.emptyColumn`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitEmptyColumn?: (ctx: EmptyColumnContext) => Result;
     /**
      * Visit a parse tree produced by `SparkSqlParser.columnName`.
      * @param ctx the parse tree
@@ -1187,6 +1196,12 @@ export declare class SparkSqlParserVisitor<Result> extends AbstractParseTreeVisi
      * @return the visitor result
      */
     visitColumnNamePath?: (ctx: ColumnNamePathContext) => Result;
+    /**
+     * Visit a parse tree produced by `SparkSqlParser.columnNamePathAllowEmpty`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitColumnNamePathAllowEmpty?: (ctx: ColumnNamePathAllowEmptyContext) => Result;
     /**
      * Visit a parse tree produced by `SparkSqlParser.columnNameSeq`.
      * @param ctx the parse tree
@@ -1630,6 +1645,12 @@ export declare class SparkSqlParserVisitor<Result> extends AbstractParseTreeVisi
      * @return the visitor result
      */
     visitMultipartIdentifier?: (ctx: MultipartIdentifierContext) => Result;
+    /**
+     * Visit a parse tree produced by `SparkSqlParser.multipartIdentifierAllowEmpty`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitMultipartIdentifierAllowEmpty?: (ctx: MultipartIdentifierAllowEmptyContext) => Result;
     /**
      * Visit a parse tree produced by `SparkSqlParser.multipartIdentifierPropertyList`.
      * @param ctx the parse tree

package/dist/parser/common/basicSQL.d.ts

@@ -1,13 +1,13 @@
-import { Lexer, Token, CommonTokenStream, CharStream, ParserRuleContext, ParseTreeListener, ANTLRErrorListener, Parser } from 'antlr4ng';
 import { CandidatesCollection } from 'antlr4-c3';
+import { ANTLRErrorListener, CharStream, CommonTokenStream, Lexer, Parser, ParserRuleContext, ParseTreeListener, Token } from 'antlr4ng';
 import { SQLParserBase } from '../../lib/SQLParserBase';
-import { TextSlice } from './textAndWord';
-import { CaretPosition, LOCALE_TYPE, SemanticCollectOptions, Suggestions } from './types';
-import { ParseError, ErrorListener } from './parseErrorListener';
-import type { SplitListener } from './splitListener';
 import type { EntityCollector } from './entityCollector';
 import { EntityContext } from './entityCollector';
+import { ErrorListener, ParseError } from './parseErrorListener';
 import SemanticContextCollector from './semanticContextCollector';
+import type { SplitListener } from './splitListener';
+import { TextSlice } from './textAndWord';
+import { CaretPosition, LOCALE_TYPE, SemanticCollectOptions, Suggestions } from './types';
 export declare const SQL_SPLIT_SYMBOL_TEXT = ";";
 /**
  * Basic SQL class, every sql needs extends it.
@@ -95,22 +95,10 @@ export declare abstract class BasicSQL<L extends Lexer = Lexer, PRC extends Pars
     private parseWithCache;
     /**
      * Validate input string and return syntax errors if exists.
-     * When input contains multiple statements separated by semicolons
-     * and the initial parse doesn't capture all errors, each statement
-     * is validated independently to collect all errors.
      * @param input source string
      * @returns syntax errors
      */
     validate(input: string): ParseError[];
-    /**
-     * Validate each statement fragment independently and collect all errors.
-     */
-    private validateStatements;
-    /**
-     * Split input into individual statement strings by semicolons.
-     * Handles semicolons inside quoted strings correctly.
-     */
-    private splitStatements;
     /**
      * Get the input string that has been parsed.
      */

package/dist/parser/common/basicSQL.js

@@ -1,8 +1,8 @@
-import { CharStreams, CommonTokenStream, ParseTreeWalker, PredictionMode, } from 'antlr4ng';
 import { CodeCompletionCore } from 'antlr4-c3';
+import { CharStreams, CommonTokenStream, ParseTreeWalker, PredictionMode, } from 'antlr4ng';
+import { ErrorStrategy } from './errorStrategy';
 import { findCaretTokenIndex } from './findCaretTokenIndex';
 import { ctxToText, tokenToWord } from './textAndWord';
-import { ErrorStrategy } from './errorStrategy';
 export const SQL_SPLIT_SYMBOL_TEXT = ';';
 /**
  * Basic SQL class, every sql needs extends it.
@@ -104,84 +104,13 @@ export class BasicSQL {
     }
     /**
      * Validate input string and return syntax errors if exists.
-     * When input contains multiple statements separated by semicolons
-     * and the initial parse doesn't capture all errors, each statement
-     * is validated independently to collect all errors.
      * @param input source string
      * @returns syntax errors
      */
     validate(input) {
         this.parseWithCache(input);
-        if (this._parseErrors.length > 0) {
-            const statements = this.splitStatements(input);
-            if (statements.length > 1) {
-                const splitErrors = this.validateStatements(statements);
-                if (splitErrors.length > this._parseErrors.length) {
-                    this._parseErrors = splitErrors;
-                }
-            }
-        }
         return this._parseErrors;
     }
-    /**
-     * Validate each statement fragment independently and collect all errors.
-     */
-    validateStatements(statements) {
-        const allErrors = [];
-        let lineOffset = 0;
-        for (const statement of statements) {
-            if (!statement.text.trim()) {
-                const newlines = (statement.text.match(/\n/g) || []).length;
-                lineOffset += newlines;
-                continue;
-            }
-            const parser = this.createParser(statement.text);
-            const errors = [];
-            parser.removeErrorListeners();
-            parser.addErrorListener(this.createErrorListener((error) => {
-                errors.push({
-                    startLine: error.startLine + lineOffset,
-                    endLine: error.endLine + lineOffset,
-                    startColumn: error.startColumn,
-                    endColumn: error.endColumn,
-                    message: error.message,
-                });
-            }));
-            parser.errorHandler = new ErrorStrategy();
-            parser.program();
-            allErrors.push(...errors);
-            const newlines = (statement.text.match(/\n/g) || []).length;
-            lineOffset += newlines;
-        }
-        return allErrors;
-    }
-    /**
-     * Split input into individual statement strings by semicolons.
-     * Handles semicolons inside quoted strings correctly.
-     */
-    splitStatements(input) {
-        const statements = [];
-        let inSingleQuote = false;
-        let inDoubleQuote = false;
-        let lastSplit = 0;
-        for (let i = 0; i < input.length; i++) {
-            const ch = input[i];
-            if (ch === "'" && !inDoubleQuote) {
-                inSingleQuote = !inSingleQuote;
-            }
-            else if (ch === '"' && !inSingleQuote) {
-                inDoubleQuote = !inDoubleQuote;
-            }
-            else if (ch === ';' && !inSingleQuote && !inDoubleQuote) {
-                statements.push({ text: input.slice(lastSplit, i + 1), start: lastSplit });
-                lastSplit = i + 1;
-            }
-        }
-        if (lastSplit < input.length) {
-            statements.push({ text: input.slice(lastSplit), start: lastSplit });
-        }
-        return statements;
-    }
     /**
      * Get the input string that has been parsed.
      */
@@ -431,7 +360,7 @@ export class BasicSQL {
         const core = new CodeCompletionCore(sqlParserIns);
         core.preferredRules = this.preferredRules;
         // core.showRuleStack = true;
-        //  core.showResult = true;
+        // core.showResult = true;
         const candidates = core.collectCandidates(caretTokenIndex, parseTree);
         const originalSuggestions = this.processCandidates(candidates, allTokens, caretTokenIndex);
         const syntaxSuggestions = originalSuggestions.syntax.map((syntaxCtx) => {

package/dist/parser/common/entityCollector.js

@@ -436,8 +436,20 @@ export class EntityCollector {
         }
         else {
             // Do not collect column and queryResult entities if they are not inside a select statement
-            return entitiesInsideStmt.filter((entity) => entity.entityContextType !== EntityContextType.COLUMN &&
-                entity.entityContextType !== EntityContextType.QUERY_RESULT);
+            // Exception: empty column entities (text === '') should be kept
+            return entitiesInsideStmt.filter((entity) => {
+                // Keep non-COLUMN and non-QUERY_RESULT entities
+                if (entity.entityContextType !== EntityContextType.COLUMN &&
+                    entity.entityContextType !== EntityContextType.QUERY_RESULT) {
+                    return true;
+                }
+                // Also keep empty QUERY_RESULT entities (text === '')
+                if (entity.entityContextType === EntityContextType.QUERY_RESULT &&
+                    entity.text === '') {
+                    return true;
+                }
+                return false;
+            });
         }
     }
     combineQueryResultStmtEntities(stmtContext, entitiesInsideStmt) {

package/dist/parser/flink/index.js

@@ -36,6 +36,7 @@ export class FlinkSQL extends BasicSQL {
             FlinkSqlParser.RULE_functionNameCreate, // functionName that will be created
             FlinkSqlParser.RULE_columnName,
             FlinkSqlParser.RULE_columnNamePath,
+            FlinkSqlParser.RULE_columnNamePathAllowEmpty,
             FlinkSqlParser.RULE_columnNameCreate,
             FlinkSqlParser.RULE_tablePropertyKey,
             FlinkSqlParser.RULE_tablePropertyValue,
@@ -116,13 +117,15 @@ export class FlinkSQL extends BasicSQL {
                     syntaxContextType = EntityContextType.COLUMN_CREATE;
                     break;
                 }
-                case FlinkSqlParser.RULE_columnNamePath: {
+                case FlinkSqlParser.RULE_columnNamePath:
+                case FlinkSqlParser.RULE_columnNamePathAllowEmpty: {
                     if (candidateRule.ruleList.includes(FlinkSqlParser.RULE_selectClause) ||
                         candidateRule.ruleList.includes(FlinkSqlParser.RULE_whereClause) ||
                         candidateRule.ruleList.includes(FlinkSqlParser.RULE_groupByClause) ||
                         candidateRule.ruleList.includes(FlinkSqlParser.RULE_limitClause) ||
                         candidateRule.ruleList.includes(FlinkSqlParser.RULE_whenClause) ||
-                        candidateRule.ruleList.includes(FlinkSqlParser.RULE_havingClause)) {
+                        candidateRule.ruleList.includes(FlinkSqlParser.RULE_havingClause) ||
+                        candidateRule.ruleList.includes(FlinkSqlParser.RULE_joinCondition)) {
                         syntaxContextType = EntityContextType.COLUMN;
                     }
                     break;

package/dist/parser/generic/genericEntityCollector.d.ts

@@ -0,0 +1,33 @@
+import type { GenericSqlListener } from '../../lib/generic/GenericSqlListener';
+import { AlterTableContext, ColumnRefContext, ColumnRefCreateContext, CreateTableContext, DeleteContext, DropTableContext, InsertContext, QuerySpecificationContext, QueryStatementContext, SelectAllElementContext, SelectEmptyElementContext, SelectExpressionElementContext, SelectStarElementContext, SingleStatementContext, TableNameContext, TableNameCreateContext, UpdateContext } from '../../lib/generic/GenericSqlParser';
+import { EntityCollector } from '../common/entityCollector';
+export declare class GenericEntityCollector extends EntityCollector implements GenericSqlListener {
+    /** ====== Entity Begin */
+    exitTableName(ctx: TableNameContext): void;
+    exitTableNameCreate(ctx: TableNameCreateContext): void;
+    exitColumnRef(ctx: ColumnRefContext): void;
+    exitColumnRefCreate(ctx: ColumnRefCreateContext): void;
+    exitQuerySpecification(ctx: QuerySpecificationContext): void;
+    exitSelectExpressionElement(ctx: SelectExpressionElementContext): void;
+    exitSelectStarElement(ctx: SelectStarElementContext): void;
+    exitSelectAllElement(ctx: SelectAllElementContext): void;
+    exitSelectEmptyElement(ctx: SelectEmptyElementContext): void;
+    private isSimpleColumnReference;
+    /** ===== Statement begin */
+    enterSingleStatement(ctx: SingleStatementContext): void;
+    exitSingleStatement(ctx: SingleStatementContext): void;
+    enterCreateTable(ctx: CreateTableContext): void;
+    exitCreateTable(ctx: CreateTableContext): void;
+    enterQueryStatement(ctx: QueryStatementContext): void;
+    exitQueryStatement(ctx: QueryStatementContext): void;
+    enterInsert(ctx: InsertContext): void;
+    exitInsert(ctx: InsertContext): void;
+    enterUpdate(ctx: UpdateContext): void;
+    exitUpdate(ctx: UpdateContext): void;
+    enterDelete(ctx: DeleteContext): void;
+    exitDelete(ctx: DeleteContext): void;
+    enterAlterTable(ctx: AlterTableContext): void;
+    exitAlterTable(ctx: AlterTableContext): void;
+    enterDropTable(ctx: DropTableContext): void;
+    exitDropTable(ctx: DropTableContext): void;
+}

package/dist/parser/generic/genericEntityCollector.js

@@ -0,0 +1,124 @@
+import { ColumnDefinitionContext, CreateTableStatementContext, SelectExpressionElementContext, } from '../../lib/generic/GenericSqlParser';
+import { AttrName, ColumnDeclareType, EntityCollector, StmtContextType, TableDeclareType, } from '../common/entityCollector';
+import { EntityContextType } from '../common/types';
+export class GenericEntityCollector extends EntityCollector {
+    /** ====== Entity Begin */
+    exitTableName(ctx) {
+        this.pushEntity(ctx, EntityContextType.TABLE, [], {
+            declareType: TableDeclareType.LITERAL,
+        });
+    }
+    exitTableNameCreate(ctx) {
+        this.pushEntity(ctx, EntityContextType.TABLE_CREATE, [
+            {
+                attrName: AttrName.comment,
+                endContextList: [CreateTableStatementContext.name],
+            },
+        ]);
+    }
+    exitColumnRef(ctx) {
+        this.pushEntity(ctx, EntityContextType.COLUMN);
+    }
+    exitColumnRefCreate(ctx) {
+        this.pushEntity(ctx, EntityContextType.COLUMN_CREATE, [
+            {
+                attrName: AttrName.colType,
+                endContextList: [ColumnDefinitionContext.name],
+            },
+            {
+                attrName: AttrName.comment,
+                endContextList: [ColumnDefinitionContext.name],
+            },
+        ]);
+    }
+    exitQuerySpecification(ctx) {
+        this.pushEntity(ctx, EntityContextType.QUERY_RESULT);
+    }
+    exitSelectExpressionElement(ctx) {
+        const isSimpleColumn = this.isSimpleColumnReference(ctx);
+        this.pushEntity(ctx, EntityContextType.COLUMN, [
+            {
+                attrName: AttrName.alias,
+                endContextList: [SelectExpressionElementContext.name],
+            },
+        ], {
+            declareType: isSimpleColumn
+                ? ColumnDeclareType.LITERAL
+                : ColumnDeclareType.EXPRESSION,
+        });
+    }
+    exitSelectStarElement(ctx) {
+        this.pushEntity(ctx, EntityContextType.COLUMN, [], {
+            declareType: ColumnDeclareType.ALL,
+        });
+    }
+    exitSelectAllElement(ctx) {
+        this.pushEntity(ctx, EntityContextType.COLUMN, [], {
+            declareType: ColumnDeclareType.ALL,
+        });
+    }
+    exitSelectEmptyElement(ctx) {
+        this.pushEntity(ctx, EntityContextType.COLUMN, [], {
+            declareType: ColumnDeclareType.LITERAL,
+        });
+    }
+    isSimpleColumnReference(ctx) {
+        const text = ctx.getText();
+        // Simple column reference: no parentheses, no operators, no spaces
+        return (!text.includes('(') &&
+            !text.includes(' ') &&
+            !text.includes('+') &&
+            !text.includes('-') &&
+            !text.includes('*') &&
+            !text.includes('/'));
+    }
+    /** ===== Statement begin */
+    enterSingleStatement(ctx) {
+        this.pushStmt(ctx, StmtContextType.COMMON_STMT);
+    }
+    exitSingleStatement(ctx) {
+        this.popStmt();
+    }
+    enterCreateTable(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_TABLE_STMT);
+    }
+    exitCreateTable(ctx) {
+        this.popStmt();
+    }
+    enterQueryStatement(ctx) {
+        this.pushStmt(ctx, StmtContextType.SELECT_STMT);
+    }
+    exitQueryStatement(ctx) {
+        this.popStmt();
+    }
+    enterInsert(ctx) {
+        this.pushStmt(ctx, StmtContextType.INSERT_STMT);
+    }
+    exitInsert(ctx) {
+        this.popStmt();
+    }
+    enterUpdate(ctx) {
+        this.pushStmt(ctx, StmtContextType.COMMON_STMT);
+    }
+    exitUpdate(ctx) {
+        this.popStmt();
+    }
+    enterDelete(ctx) {
+        this.pushStmt(ctx, StmtContextType.COMMON_STMT);
+    }
+    exitDelete(ctx) {
+        this.popStmt();
+    }
+    enterAlterTable(ctx) {
+        this.pushStmt(ctx, StmtContextType.ALTER_TABLE_STMT);
+    }
+    exitAlterTable(ctx) {
+        this.popStmt();
+    }
+    enterDropTable(ctx) {
+        this.pushStmt(ctx, StmtContextType.COMMON_STMT);
+    }
+    exitDropTable(ctx) {
+        this.popStmt();
+    }
+}

package/dist/parser/generic/genericErrorListener.d.ts

@@ -0,0 +1,6 @@
+import { Parser, Token } from 'antlr4ng';
+import { ParseErrorListener } from '../common/parseErrorListener';
+export declare class GenericErrorListener extends ParseErrorListener {
+    private objectNames;
+    getExpectedText(parser: Parser, token: Token): string;
+}

package/dist/parser/generic/genericErrorListener.js

@@ -0,0 +1,56 @@
+import { CodeCompletionCore } from 'antlr4-c3';
+import { GenericSqlParser } from '../../lib/generic/GenericSqlParser';
+import { ParseErrorListener } from '../common/parseErrorListener';
+export class GenericErrorListener extends ParseErrorListener {
+    constructor() {
+        super(...arguments);
+        this.objectNames = new Map([
+            [GenericSqlParser.RULE_tableName, 'table'],
+            [GenericSqlParser.RULE_tableNameCreate, 'table'],
+            [GenericSqlParser.RULE_columnRef, 'column'],
+        ]);
+    }
+    getExpectedText(parser, token) {
+        var _a;
+        let expectedText = '';
+        const input = this.parserContext.getParsedInput();
+        let currentContext = (_a = parser.context) !== null && _a !== void 0 ? _a : undefined;
+        while (currentContext === null || currentContext === void 0 ? void 0 : currentContext.parent) {
+            currentContext = currentContext.parent;
+        }
+        const parserInfo = this.parserContext.getMinimumParserInfo(input, token.tokenIndex, currentContext);
+        if (!parserInfo)
+            return '';
+        const { parser: c3Parser, newTokenIndex, parseTree: c3Context } = parserInfo;
+        const core = new CodeCompletionCore(c3Parser);
+        core.preferredRules = this.preferredRules;
+        const candidates = core.collectCandidates(newTokenIndex, c3Context);
+        if (candidates.rules.size) {
+            const result = [];
+            for (const candidate of candidates.rules) {
+                const [ruleType] = candidate;
+                const name = this.objectNames.get(ruleType);
+                switch (ruleType) {
+                    case GenericSqlParser.RULE_tableName:
+                    case GenericSqlParser.RULE_columnRef: {
+                        if (name && !result.includes(`{existing}${name}`)) {
+                            result.push(`{existing}${name}`);
+                        }
+                        break;
+                    }
+                    case GenericSqlParser.RULE_tableNameCreate: {
+                        if (name && !result.includes(`{new}${name}`)) {
+                            result.push(`{new}${name}`);
+                        }
+                        break;
+                    }
+                }
+            }
+            expectedText = result.join('{or}');
+        }
+        if (candidates.tokens.size) {
+            expectedText += expectedText ? '{orKeyword}' : '{keyword}';
+        }
+        return expectedText;
+    }
+}

package/dist/parser/generic/genericSemanticContextCollector.d.ts

@@ -0,0 +1,9 @@
+import { GenericSqlListener } from '../../lib/generic/GenericSqlListener';
+import { StatementsContext } from '../../lib/generic/GenericSqlParser';
+import SemanticContextCollector from '../common/semanticContextCollector';
+declare class GenericSemanticContextCollector extends SemanticContextCollector implements GenericSqlListener {
+    getWhiteSpaceRuleType(): number;
+    getStatementRuleType(): number;
+    enterStatements(ctx: StatementsContext): void;
+}
+export { GenericSemanticContextCollector };

package/dist/parser/generic/genericSemanticContextCollector.js

@@ -0,0 +1,14 @@
+import { GenericSqlParser } from '../../lib/generic/GenericSqlParser';
+import SemanticContextCollector from '../common/semanticContextCollector';
+class GenericSemanticContextCollector extends SemanticContextCollector {
+    getWhiteSpaceRuleType() {
+        return GenericSqlParser.WHITE_SPACE;
+    }
+    getStatementRuleType() {
+        return GenericSqlParser.RULE_statements;
+    }
+    enterStatements(ctx) {
+        this.visitStatement(ctx);
+    }
+}
+export { GenericSemanticContextCollector };

package/dist/parser/generic/genericSplitListener.d.ts

@@ -0,0 +1,6 @@
+import { SingleStatementContext } from '../../lib/generic/GenericSqlParser';
+import { GenericSqlListener } from '../../lib/generic/GenericSqlListener';
+import { SplitListener } from '../common/splitListener';
+export declare class GenericSplitListener extends SplitListener<SingleStatementContext> implements GenericSqlListener {
+    exitSingleStatement(ctx: SingleStatementContext): void;
+}

package/dist/parser/generic/genericSplitListener.js

@@ -0,0 +1,6 @@
+import { SplitListener } from '../common/splitListener';
+export class GenericSplitListener extends SplitListener {
+    exitSingleStatement(ctx) {
+        this._statementsContext.push(ctx);
+    }
+}

package/dist/parser/generic/index.d.ts

@@ -0,0 +1,33 @@
+import { CandidatesCollection } from 'antlr4-c3';
+import { CharStream, CommonTokenStream, Token } from 'antlr4ng';
+import { GenericSqlLexer } from '../../lib/generic/GenericSqlLexer';
+import { GenericSqlParser, ProgramContext } from '../../lib/generic/GenericSqlParser';
+import { BasicSQL } from '../common/basicSQL';
+import { Suggestions, CaretPosition, SemanticCollectOptions } from '../common/types';
+import { ErrorListener, ParseError } from '../common/parseErrorListener';
+import { GenericEntityCollector } from './genericEntityCollector';
+import { GenericErrorListener } from './genericErrorListener';
+import { GenericSplitListener } from './genericSplitListener';
+import { GenericSemanticContextCollector } from './genericSemanticContextCollector';
+export { GenericEntityCollector, GenericSplitListener };
+export interface GenericSQLOptions {
+    /** Enable or disable diagnostics (parse error collection). Defaults to true. */
+    diagnostics?: boolean;
+}
+export declare class GenericSQL extends BasicSQL<GenericSqlLexer, ProgramContext, GenericSqlParser> {
+    private _diagnostics;
+    constructor(options?: GenericSQLOptions);
+    protected createLexerFromCharStream(charStreams: CharStream): GenericSqlLexer;
+    validate(input: string): ParseError[];
+    protected createParserFromTokenStream(tokenStream: CommonTokenStream): GenericSqlParser;
+    /**
+     * The rules that keywords you don't want to be suggested.
+     */
+    protected excludeKeywordRules: Set<number>;
+    protected preferredRules: Set<number>;
+    protected get splitListener(): GenericSplitListener;
+    protected createErrorListener(_errorListener: ErrorListener): GenericErrorListener;
+    protected createEntityCollector(input: string, allTokens?: Token[], caretTokenIndex?: number): GenericEntityCollector;
+    protected createSemanticContextCollector(input: string, caretPosition: CaretPosition, allTokens: Token[], options?: SemanticCollectOptions): GenericSemanticContextCollector;
+    protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number): Suggestions<Token>;
+}