dt-sql-parser 4.5.0-beta.1 → 4.5.0-beta.2

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

@@ -131,10 +131,8 @@ 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";
@@ -208,7 +206,6 @@ 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";
@@ -1799,16 +1796,6 @@ 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
@@ -1829,16 +1816,6 @@ 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
@@ -2579,16 +2556,6 @@ 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,10 +131,8 @@ 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";
@@ -208,7 +206,6 @@ 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";
@@ -1178,12 +1175,6 @@ 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
@@ -1196,12 +1187,6 @@ 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
@@ -1645,12 +1630,6 @@ 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.

package/dist/parser/common/basicSQL.js

@@ -1,8 +1,8 @@
-import { CodeCompletionCore } from 'antlr4-c3';
 import { CharStreams, CommonTokenStream, ParseTreeWalker, PredictionMode, } from 'antlr4ng';
-import { ErrorStrategy } from './errorStrategy';
+import { CodeCompletionCore } from 'antlr4-c3';
 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.
@@ -360,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,20 +436,8 @@ export class EntityCollector {
         }
         else {
             // Do not collect column and queryResult entities if they are not inside a select statement
-            // 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;
-            });
+            return entitiesInsideStmt.filter((entity) => entity.entityContextType !== EntityContextType.COLUMN &&
+                entity.entityContextType !== EntityContextType.QUERY_RESULT);
         }
     }
     combineQueryResultStmtEntities(stmtContext, entitiesInsideStmt) {

package/dist/parser/flink/index.js

@@ -36,7 +36,6 @@ 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,
@@ -117,15 +116,13 @@ export class FlinkSQL extends BasicSQL {
                     syntaxContextType = EntityContextType.COLUMN_CREATE;
                     break;
                 }
-                case FlinkSqlParser.RULE_columnNamePath:
-                case FlinkSqlParser.RULE_columnNamePathAllowEmpty: {
+                case FlinkSqlParser.RULE_columnNamePath: {
                     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_joinCondition)) {
+                        candidateRule.ruleList.includes(FlinkSqlParser.RULE_havingClause)) {
                         syntaxContextType = EntityContextType.COLUMN;
                     }
                     break;

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

@@ -0,0 +1,29 @@
+import type { GenericSqlListener } from '../../lib/generic/GenericSqlListener';
+import { AlterTableContext, ColumnDefinitionContext, ColumnRefContext, CreateTableContext, DeleteContext, DropTableContext, InsertContext, QuerySpecificationContext, QueryStatementContext, SelectItemContext, 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;
+    exitColumnDefinition(ctx: ColumnDefinitionContext): void;
+    exitQuerySpecification(ctx: QuerySpecificationContext): void;
+    exitSelectItem(ctx: SelectItemContext): void;
+    /** ===== 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,103 @@
+import { ColumnDefinitionContext, CreateTableStatementContext, SelectItemContext, } 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);
+    }
+    exitColumnDefinition(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);
+    }
+    exitSelectItem(ctx) {
+        if (ctx.ASTERISK()) {
+            this.pushEntity(ctx, EntityContextType.COLUMN, [], {
+                declareType: ColumnDeclareType.ALL,
+            });
+        }
+        else {
+            this.pushEntity(ctx, EntityContextType.COLUMN, [
+                {
+                    attrName: AttrName.alias,
+                    endContextList: [SelectItemContext.name],
+                },
+            ], {
+                declareType: ColumnDeclareType.EXPRESSION,
+            });
+        }
+    }
+    /** ===== 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>;
+}

package/dist/parser/generic/index.js

@@ -0,0 +1,94 @@
+import { processTokenCandidates } from '../common/tokenUtils';
+import { GenericSqlLexer } from '../../lib/generic/GenericSqlLexer';
+import { GenericSqlParser } from '../../lib/generic/GenericSqlParser';
+import { BasicSQL } from '../common/basicSQL';
+import { EntityContextType, } from '../common/types';
+import { GenericEntityCollector } from './genericEntityCollector';
+import { GenericErrorListener } from './genericErrorListener';
+import { GenericSplitListener } from './genericSplitListener';
+import { GenericSemanticContextCollector } from './genericSemanticContextCollector';
+export { GenericEntityCollector, GenericSplitListener };
+export class GenericSQL extends BasicSQL {
+    constructor(options) {
+        super();
+        /**
+         * The rules that keywords you don't want to be suggested.
+         */
+        this.excludeKeywordRules = new Set([GenericSqlParser.RULE_nonReserved]);
+        this.preferredRules = new Set([
+            GenericSqlParser.RULE_tableName,
+            GenericSqlParser.RULE_tableNameCreate,
+            GenericSqlParser.RULE_columnRef,
+            ...this.excludeKeywordRules,
+        ]);
+        this._diagnostics = (options === null || options === void 0 ? void 0 : options.diagnostics) !== false;
+    }
+    createLexerFromCharStream(charStreams) {
+        return new GenericSqlLexer(charStreams);
+    }
+    validate(input) {
+        if (!this._diagnostics) {
+            return [];
+        }
+        return super.validate(input);
+    }
+    createParserFromTokenStream(tokenStream) {
+        return new GenericSqlParser(tokenStream);
+    }
+    get splitListener() {
+        return new GenericSplitListener();
+    }
+    createErrorListener(_errorListener) {
+        const parserContext = this;
+        return new GenericErrorListener(_errorListener, parserContext, this.preferredRules);
+    }
+    createEntityCollector(input, allTokens, caretTokenIndex) {
+        return new GenericEntityCollector(input, allTokens, caretTokenIndex);
+    }
+    createSemanticContextCollector(input, caretPosition, allTokens, options) {
+        return new GenericSemanticContextCollector(input, caretPosition, allTokens, options);
+    }
+    processCandidates(candidates, allTokens, caretTokenIndex) {
+        const originalSyntaxSuggestions = [];
+        const keywords = [];
+        for (const candidate of candidates.rules) {
+            const [ruleType, candidateRule] = candidate;
+            const tokenRanges = allTokens.slice(candidateRule.startTokenIndex, caretTokenIndex + 1);
+            let syntaxContextType = void 0;
+            switch (ruleType) {
+                case GenericSqlParser.RULE_tableName: {
+                    syntaxContextType = EntityContextType.TABLE;
+                    break;
+                }
+                case GenericSqlParser.RULE_tableNameCreate: {
+                    syntaxContextType = EntityContextType.TABLE_CREATE;
+                    break;
+                }
+                case GenericSqlParser.RULE_columnRef: {
+                    syntaxContextType = EntityContextType.COLUMN;
+                    break;
+                }
+                default:
+                    break;
+            }
+            if (syntaxContextType &&
+                !originalSyntaxSuggestions.some((syn) => {
+                    var _a, _b;
+                    return syn.syntaxContextType === syntaxContextType &&
+                        ((_a = syn.wordRanges.map((wordRange) => wordRange.text)) === null || _a === void 0 ? void 0 : _a.join(',')) ===
+                            ((_b = tokenRanges.map((tokenRange) => tokenRange.text)) === null || _b === void 0 ? void 0 : _b.join(','));
+                })) {
+                originalSyntaxSuggestions.push({
+                    syntaxContextType,
+                    wordRanges: tokenRanges,
+                });
+            }
+        }
+        const processedKeywords = processTokenCandidates(this._parser, candidates.tokens);
+        keywords.push(...processedKeywords);
+        return {
+            syntax: originalSyntaxSuggestions,
+            keywords,
+        };
+    }
+}

package/dist/parser/index.d.ts

@@ -5,3 +5,4 @@ export { SparkSQL } from './spark';
 export { PostgreSQL } from './postgresql';
 export { TrinoSQL } from './trino';
 export { ImpalaSQL } from './impala';
+export { GenericSQL } from './generic';

package/dist/parser/index.js

@@ -5,3 +5,4 @@ export { SparkSQL } from './spark';
 export { PostgreSQL } from './postgresql';
 export { TrinoSQL } from './trino';
 export { ImpalaSQL } from './impala';
+export { GenericSQL } from './generic';

package/dist/parser/mysql/index.js

@@ -25,7 +25,6 @@ export class MySQL extends BasicSQL {
             MySqlParser.RULE_functionName,
             MySqlParser.RULE_functionNameCreate,
             MySqlParser.RULE_columnName,
-            MySqlParser.RULE_columnNamePath,
             MySqlParser.RULE_columnNameCreate,
             ...this.excludeKeywordRules,
         ]);
@@ -89,8 +88,7 @@ export class MySQL extends BasicSQL {
                     syntaxContextType = EntityContextType.FUNCTION_CREATE;
                     break;
                 }
-                case MySqlParser.RULE_columnName:
-                case MySqlParser.RULE_columnNamePath: {
+                case MySqlParser.RULE_columnName: {
                     syntaxContextType = EntityContextType.COLUMN;
                     break;
                 }

package/dist/parser/mysql/mysqlEntityCollector.d.ts

@@ -1,4 +1,4 @@
-import { ColumnCreateTableContext, ColumnNameCreateContext, CopyCreateTableContext, CreateDatabaseContext, CreateFunctionContext, CreateFunctionLoadableContext, CreateViewContext, DatabaseNameContext, DatabaseNameCreateContext, FunctionNameCreateContext, InsertStatementContext, QueryCreateTableContext, SelectElementsContext, SelectExpressionElementContext, SelectLiteralColumnNameContext, SelectStatementContext, SingleStatementContext, TableNameContext, TableNameCreateContext, ViewNameContext, ViewNameCreateContext, TableAllColumnsContext, AtomSubQueryTableSourceContext, PureAllColumnsContext, SelectElement_dot_emptyContext } from '../../lib/mysql/MySqlParser';
+import { ColumnCreateTableContext, ColumnNameCreateContext, CopyCreateTableContext, CreateDatabaseContext, CreateFunctionContext, CreateFunctionLoadableContext, CreateViewContext, DatabaseNameContext, DatabaseNameCreateContext, FunctionNameCreateContext, InsertStatementContext, QueryCreateTableContext, SelectExpressionElementContext, SelectStatementContext, SingleStatementContext, TableNameContext, TableNameCreateContext, ViewNameContext, ViewNameCreateContext, TableAllColumnsContext, SelectLiteralColumnNameContext, AtomSubQueryTableSourceContext, SelectElementsContext, PureAllColumnsContext } from '../../lib/mysql/MySqlParser';
 import type { MySqlParserListener } from '../../lib/mysql/MySqlParserListener';
 import { EntityCollector } from '../common/entityCollector';
 export declare class MySqlEntityCollector extends EntityCollector implements MySqlParserListener {
@@ -18,7 +18,6 @@ export declare class MySqlEntityCollector extends EntityCollector implements MyS
     exitTableAllColumns(ctx: TableAllColumnsContext): void;
     exitPureAllColumns(ctx: PureAllColumnsContext): void;
     exitSelectLiteralColumnName(ctx: SelectLiteralColumnNameContext): void;
-    exitSelectElement_dot_empty(ctx: SelectElement_dot_emptyContext): void;
     exitSelectExpressionElement(ctx: SelectExpressionElementContext): void;
     /** ===== Statement begin */
     enterSingleStatement(ctx: SingleStatementContext): void;