dt-sql-parser 4.1.0-beta.8 → 4.1.0

package/dist/lib/trino/TrinoSqlVisitor.d.ts

@@ -259,6 +259,7 @@ import { RowTypeContext } from "./TrinoSqlParser.js";
 import { IntervalTypeContext } from "./TrinoSqlParser.js";
 import { ArrayTypeContext } from "./TrinoSqlParser.js";
 import { DoublePrecisionTypeContext } from "./TrinoSqlParser.js";
+import { TimeTypeContext } from "./TrinoSqlParser.js";
 import { LegacyArrayTypeContext } from "./TrinoSqlParser.js";
 import { GenericTypeContext } from "./TrinoSqlParser.js";
 import { DateTimeTypeContext } from "./TrinoSqlParser.js";
@@ -2122,6 +2123,13 @@ export declare class TrinoSqlVisitor<Result> extends AbstractParseTreeVisitor<Re
      * @return the visitor result
      */
     visitDoublePrecisionType?: (ctx: DoublePrecisionTypeContext) => Result;
+    /**
+     * Visit a parse tree produced by the `timeType`
+     * labeled alternative in `TrinoSqlParser.type`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitTimeType?: (ctx: TimeTypeContext) => Result;
     /**
      * Visit a parse tree produced by the `legacyArrayType`
      * labeled alternative in `TrinoSqlParser.type`.

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

@@ -2,12 +2,11 @@ import { Lexer, Token, CommonTokenStream, CharStream, ParserRuleContext, ParseTr
 import { CandidatesCollection } from 'antlr4-c3';
 import { SQLParserBase } from '../../lib/SQLParserBase';
 import { TextSlice } from './textAndWord';
-import { CaretPosition, LOCALE_TYPE, SemanticCollectOptions, Suggestions } from './types';
+import { CaretPosition, LOCALE_TYPE, Suggestions } from './types';
 import { ParseError, ErrorListener } from './parseErrorListener';
 import type { SplitListener } from './splitListener';
 import type { EntityCollector } from './entityCollector';
 import { EntityContext } from './entityCollector';
-import SemanticContextCollector from './semanticContextCollector';
 /**
  * Basic SQL class, every sql needs extends it.
  */
@@ -55,12 +54,8 @@ export declare abstract class BasicSQL<L extends Lexer = Lexer, PRC extends Pars
     /**
      * Get a new entityCollector instance.
      */
-    protected abstract createEntityCollector(input: string, caretTokenIndex?: number): EntityCollector;
+    protected abstract createEntityCollector(input: string, allTokens?: Token[], caretTokenIndex?: number): EntityCollector;
     locale: LOCALE_TYPE;
-    /**
-     * Get a new semanticContextCollector instance.
-     */
-    protected abstract createSemanticContextCollector(input: string, caretPosition: CaretPosition, allTokens: Token[], options?: SemanticCollectOptions): SemanticContextCollector;
     /**
      * Create an antlr4 lexer from input.
      * @param input string
@@ -141,12 +136,4 @@ export declare abstract class BasicSQL<L extends Lexer = Lexer, PRC extends Pars
      */
     getSuggestionAtCaretPosition(input: string, caretPosition: CaretPosition): Suggestions | null;
     getAllEntities(input: string, caretPosition?: CaretPosition): EntityContext[] | null;
-    /**
-     * Get semantic context infos
-     * @param input source string
-     * @param caretPosition caret position, such as cursor position
-     * @param options semantic context options
-     * @returns analyzed semantic context
-     */
-    getSemanticContextAtCaretPosition(input: string, caretPosition: CaretPosition, options?: SemanticCollectOptions): import("./types").SemanticContext;
 }

package/dist/parser/common/basicSQL.js

@@ -285,7 +285,7 @@ export class BasicSQL {
         const caretTokenIndex = caretPosition
             ? findCaretTokenIndex(caretPosition, allTokens)
             : void 0;
-        const collectListener = this.createEntityCollector(input, caretTokenIndex);
+        const collectListener = this.createEntityCollector(input, allTokens, caretTokenIndex);
         // const parser = this.createParserWithCache(input);
         // parser.entityCollecting = true;
         // if(caretPosition) {
@@ -300,18 +300,4 @@ export class BasicSQL {
         // parser.entityCollecting = false;
         return collectListener.getEntities();
     }
-    /**
-     * Get semantic context infos
-     * @param input source string
-     * @param caretPosition caret position, such as cursor position
-     * @param options semantic context options
-     * @returns analyzed semantic context
-     */
-    getSemanticContextAtCaretPosition(input, caretPosition, options) {
-        const allTokens = this.getAllTokens(input);
-        const parseTree = this.parseWithCache(input);
-        const statementContextListener = this.createSemanticContextCollector(input, caretPosition, allTokens, options);
-        this.listen(statementContextListener, parseTree);
-        return statementContextListener.semanticContext;
-    }
 }

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

@@ -88,8 +88,9 @@ export declare function findAttribute(ctx: ParserRuleContextWithAttr | null, key
  * @todo: [may be need] Combine the entities in each clause.
  */
 export declare abstract class EntityCollector {
-    constructor(input: string, caretTokenIndex?: number);
+    constructor(input: string, allTokens?: Token[], caretTokenIndex?: number);
     private readonly _input;
+    private readonly _allTokens;
     private readonly _caretTokenIndex;
     private readonly _entitiesSet;
     /** Staging statements that have already entered. */
@@ -108,6 +109,11 @@ export declare abstract class EntityCollector {
     getRootStmt(): StmtContext | null;
     getEntities(): EntityContext[];
     enterProgram(): void;
+    /**
+     * The antlr4 will ignore hidden tokens, if we type whitespace at the end of a statement,
+     * the whitespace token will not as stop token, so we consider the whitespace token as a part of the nonhidden token in front of it
+     */
+    protected getPrevNonHiddenTokenIndex(caretTokenIndex: number): number;
     protected pushStmt(ctx: ParserRuleContext, type: StmtContextType): StmtContext | null;
     protected popStmt(): StmtContext;
     protected pushEntity(ctx: ParserRuleContext, type: EntityContextType, attrInfo?: AttrInfo[]): EntityContext | null;

package/dist/parser/common/entityCollector.js

@@ -9,7 +9,7 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
-import { isToken } from 'antlr4ng';
+import { isToken, Token } from 'antlr4ng';
 import { SimpleStack } from './simpleStack';
 import { ctxToText, isWordRange, tokenToWord, } from './textAndWord';
 import { EntityContextType } from './types';
@@ -173,8 +173,9 @@ function findAttributeChildren(ctx, keyName) {
  * @todo: [may be need] Combine the entities in each clause.
  */
 export class EntityCollector {
-    constructor(input, caretTokenIndex) {
+    constructor(input, allTokens, caretTokenIndex) {
         this._input = input;
+        this._allTokens = allTokens || [];
         this._caretTokenIndex = caretTokenIndex !== null && caretTokenIndex !== void 0 ? caretTokenIndex : -1;
         this._entitiesSet = new Set();
         this._stmtStack = new SimpleStack();
@@ -197,6 +198,22 @@ export class EntityCollector {
         this._entityStack.clear();
         this._rootStmt = null;
     }
+    /**
+     * The antlr4 will ignore hidden tokens, if we type whitespace at the end of a statement,
+     * the whitespace token will not as stop token, so we consider the whitespace token as a part of the nonhidden token in front of it
+     */
+    getPrevNonHiddenTokenIndex(caretTokenIndex) {
+        if (this._allTokens[caretTokenIndex].channel !== Token.HIDDEN_CHANNEL)
+            return caretTokenIndex;
+        for (let i = caretTokenIndex - 1; i >= 0; i--) {
+            const token = this._allTokens[i];
+            if (token.channel !== Token.HIDDEN_CHANNEL) {
+                // If prev nonhidden token is ';', the current token does not belong to any statement.
+                return token.text === ';' ? Infinity : token.tokenIndex;
+            }
+        }
+        return Infinity;
+    }
     pushStmt(ctx, type) {
         var _a;
         let isContainCaret;
@@ -205,7 +222,7 @@ export class EntityCollector {
                 !!ctx.start &&
                     !!ctx.stop &&
                     ctx.start.tokenIndex <= this._caretTokenIndex &&
-                    ctx.stop.tokenIndex >= this._caretTokenIndex;
+                    ctx.stop.tokenIndex >= this.getPrevNonHiddenTokenIndex(this._caretTokenIndex);
         }
         const stmtContext = toStmtContext(ctx, type, this._input, this._rootStmt, this._stmtStack.peek(), isContainCaret);
         if (stmtContext) {

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

@@ -64,28 +64,3 @@ export interface Suggestions<T = WordRange> {
     readonly keywords: string[];
 }
 export type LOCALE_TYPE = 'zh_CN' | 'en_US';
-export interface SemanticContext {
-    isStatementBeginning: boolean;
-}
-export declare enum SqlSplitStrategy {
-    /** Only end the statement with semicolon symbol */
-    STRICT = 0,
-    /** Based on parse tree to split statements */
-    LOOSE = 1
-}
-export interface SemanticCollectOptions {
-    /**
-     * `sqlSplitStrategy` will affects the result of `isStatementBeginning`;
-     *
-     * For example:
-     *
-     * The sql is "select id from t1   create\<cart_position\>"
-     *
-     * - `SqlSplitStrategy.STRICT`: split symbol `;` is missing after select statement so that it considerd as one statement, and `isStatementBeginning` is false
-     *
-     * - `SqlSplitStrategy.LOOSE`: in parse tree, it will parse to "select id from t1" and "create" two single statement, so `isStatementBeginning` is true
-     *
-     * @default SqlSplitStrategy.STRICT
-     */
-    sqlSplitStrategy?: SqlSplitStrategy;
-}

package/dist/parser/common/types.js

@@ -32,10 +32,3 @@ export var EntityContextType;
     /** column name that will be created */
     EntityContextType["COLUMN_CREATE"] = "columnCreate";
 })(EntityContextType || (EntityContextType = {}));
-export var SqlSplitStrategy;
-(function (SqlSplitStrategy) {
-    /** Only end the statement with semicolon symbol */
-    SqlSplitStrategy[SqlSplitStrategy["STRICT"] = 0] = "STRICT";
-    /** Based on parse tree to split statements */
-    SqlSplitStrategy[SqlSplitStrategy["LOOSE"] = 1] = "LOOSE";
-})(SqlSplitStrategy || (SqlSplitStrategy = {}));

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

@@ -1,22 +1,20 @@
-import { CharStream, CommonTokenStream, Token } from 'antlr4ng';
 import { CandidatesCollection } from 'antlr4-c3';
+import { CharStream, CommonTokenStream, Token } from 'antlr4ng';
 import { FlinkSqlLexer } from '../../lib/flink/FlinkSqlLexer';
 import { FlinkSqlParser, ProgramContext } from '../../lib/flink/FlinkSqlParser';
-import { CaretPosition, SemanticCollectOptions, Suggestions } from '../common/types';
 import { BasicSQL } from '../common/basicSQL';
-import { FlinkSqlSplitListener } from './flinkSplitListener';
-import { FlinkEntityCollector } from './flinkEntityCollector';
 import { ErrorListener } from '../common/parseErrorListener';
+import { Suggestions } from '../common/types';
+import { FlinkEntityCollector } from './flinkEntityCollector';
 import { FlinkErrorListener } from './flinkErrorListener';
-import { FlinkSemanticContextCollector } from './flinkSemanticContextCollector';
-export { FlinkSqlSplitListener, FlinkEntityCollector };
+import { FlinkSqlSplitListener } from './flinkSplitListener';
+export { FlinkEntityCollector, FlinkSqlSplitListener };
 export declare class FlinkSQL extends BasicSQL<FlinkSqlLexer, ProgramContext, FlinkSqlParser> {
     protected createLexerFromCharStream(charStreams: CharStream): FlinkSqlLexer;
     protected createParserFromTokenStream(tokenStream: CommonTokenStream): FlinkSqlParser;
     protected preferredRules: Set<number>;
     protected get splitListener(): FlinkSqlSplitListener;
     protected createErrorListener(_errorListener: ErrorListener): FlinkErrorListener;
-    protected createEntityCollector(input: string, caretTokenIndex?: number): FlinkEntityCollector;
-    protected createSemanticContextCollector(input: string, caretPosition: CaretPosition, allTokens: Token[], options?: SemanticCollectOptions): FlinkSemanticContextCollector;
+    protected createEntityCollector(input: string, allTokens?: Token[], caretTokenIndex?: number): FlinkEntityCollector;
     protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number, tokenIndexOffset: number): Suggestions<Token>;
 }

package/dist/parser/flink/index.js

@@ -1,12 +1,11 @@
 import { FlinkSqlLexer } from '../../lib/flink/FlinkSqlLexer';
 import { FlinkSqlParser } from '../../lib/flink/FlinkSqlParser';
-import { EntityContextType, } from '../common/types';
 import { BasicSQL } from '../common/basicSQL';
-import { FlinkSqlSplitListener } from './flinkSplitListener';
+import { EntityContextType } from '../common/types';
 import { FlinkEntityCollector } from './flinkEntityCollector';
 import { FlinkErrorListener } from './flinkErrorListener';
-import { FlinkSemanticContextCollector } from './flinkSemanticContextCollector';
-export { FlinkSqlSplitListener, FlinkEntityCollector };
+import { FlinkSqlSplitListener } from './flinkSplitListener';
+export { FlinkEntityCollector, FlinkSqlSplitListener };
 export class FlinkSQL extends BasicSQL {
     constructor() {
         super(...arguments);
@@ -37,11 +36,8 @@ export class FlinkSQL extends BasicSQL {
         const parserContext = this;
         return new FlinkErrorListener(_errorListener, parserContext, this.preferredRules);
     }
-    createEntityCollector(input, caretTokenIndex) {
-        return new FlinkEntityCollector(input, caretTokenIndex);
-    }
-    createSemanticContextCollector(input, caretPosition, allTokens, options) {
-        return new FlinkSemanticContextCollector(input, caretPosition, allTokens, options);
+    createEntityCollector(input, allTokens, caretTokenIndex) {
+        return new FlinkEntityCollector(input, allTokens, caretTokenIndex);
     }
     processCandidates(candidates, allTokens, caretTokenIndex, tokenIndexOffset) {
         const originalSyntaxSuggestions = [];

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

@@ -1,14 +1,13 @@
-import { CharStream, CommonTokenStream, Token } from 'antlr4ng';
 import { CandidatesCollection } from 'antlr4-c3';
+import { CharStream, CommonTokenStream, Token } from 'antlr4ng';
 import { HiveSqlLexer } from '../../lib/hive/HiveSqlLexer';
 import { HiveSqlParser, ProgramContext } from '../../lib/hive/HiveSqlParser';
 import { BasicSQL } from '../common/basicSQL';
-import { CaretPosition, SemanticCollectOptions, Suggestions } from '../common/types';
-import { HiveSqlSplitListener } from './hiveSplitListener';
-import { HiveEntityCollector } from './hiveEntityCollector';
 import { ErrorListener } from '../common/parseErrorListener';
+import { Suggestions } from '../common/types';
+import { HiveEntityCollector } from './hiveEntityCollector';
 import { HiveErrorListener } from './hiveErrorListener';
-import { HiveSemanticContextCollector } from './hiveSemanticContextCollector';
+import { HiveSqlSplitListener } from './hiveSplitListener';
 export { HiveEntityCollector, HiveSqlSplitListener };
 export declare class HiveSQL extends BasicSQL<HiveSqlLexer, ProgramContext, HiveSqlParser> {
     protected createLexerFromCharStream(charStreams: CharStream): HiveSqlLexer;
@@ -16,7 +15,6 @@ export declare class HiveSQL extends BasicSQL<HiveSqlLexer, ProgramContext, Hive
     protected preferredRules: Set<number>;
     protected get splitListener(): HiveSqlSplitListener;
     protected createErrorListener(_errorListener: ErrorListener): HiveErrorListener;
-    protected createEntityCollector(input: string, caretTokenIndex?: number): HiveEntityCollector;
-    protected createSemanticContextCollector(input: string, caretPosition: CaretPosition, allTokens: Token[], options?: SemanticCollectOptions): HiveSemanticContextCollector;
+    protected createEntityCollector(input: string, allTokens?: Token[], caretTokenIndex?: number): HiveEntityCollector;
     protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number, tokenIndexOffset: number): Suggestions<Token>;
 }

package/dist/parser/hive/index.js

@@ -1,11 +1,10 @@
 import { HiveSqlLexer } from '../../lib/hive/HiveSqlLexer';
 import { HiveSqlParser } from '../../lib/hive/HiveSqlParser';
 import { BasicSQL } from '../common/basicSQL';
-import { EntityContextType, } from '../common/types';
-import { HiveSqlSplitListener } from './hiveSplitListener';
+import { EntityContextType } from '../common/types';
 import { HiveEntityCollector } from './hiveEntityCollector';
 import { HiveErrorListener } from './hiveErrorListener';
-import { HiveSemanticContextCollector } from './hiveSemanticContextCollector';
+import { HiveSqlSplitListener } from './hiveSplitListener';
 export { HiveEntityCollector, HiveSqlSplitListener };
 export class HiveSQL extends BasicSQL {
     constructor() {
@@ -37,11 +36,8 @@ export class HiveSQL extends BasicSQL {
         const parserContext = this;
         return new HiveErrorListener(_errorListener, parserContext, this.preferredRules);
     }
-    createEntityCollector(input, caretTokenIndex) {
-        return new HiveEntityCollector(input, caretTokenIndex);
-    }
-    createSemanticContextCollector(input, caretPosition, allTokens, options) {
-        return new HiveSemanticContextCollector(input, caretPosition, allTokens, options);
+    createEntityCollector(input, allTokens, caretTokenIndex) {
+        return new HiveEntityCollector(input, allTokens, caretTokenIndex);
     }
     processCandidates(candidates, allTokens, caretTokenIndex, tokenIndexOffset) {
         const originalSyntaxSuggestions = [];

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

@@ -1,14 +1,13 @@
-import { CharStream, CommonTokenStream, Token } from 'antlr4ng';
 import { CandidatesCollection } from 'antlr4-c3';
+import { CharStream, CommonTokenStream, Token } from 'antlr4ng';
 import { ImpalaSqlLexer } from '../../lib/impala/ImpalaSqlLexer';
 import { ImpalaSqlParser, ProgramContext } from '../../lib/impala/ImpalaSqlParser';
 import { BasicSQL } from '../common/basicSQL';
-import { CaretPosition, SemanticCollectOptions, Suggestions } from '../common/types';
-import { ImpalaSqlSplitListener } from './impalaSplitListener';
-import { ImpalaEntityCollector } from './impalaEntityCollector';
 import { ErrorListener } from '../common/parseErrorListener';
+import { Suggestions } from '../common/types';
+import { ImpalaEntityCollector } from './impalaEntityCollector';
 import { ImpalaErrorListener } from './ImpalaErrorListener';
-import { ImpalaSemanticContextCollector } from './impalaSemanticContextCollector';
+import { ImpalaSqlSplitListener } from './impalaSplitListener';
 export { ImpalaEntityCollector, ImpalaSqlSplitListener };
 export declare class ImpalaSQL extends BasicSQL<ImpalaSqlLexer, ProgramContext, ImpalaSqlParser> {
     protected createLexerFromCharStream(charStreams: CharStream): ImpalaSqlLexer;
@@ -16,7 +15,6 @@ export declare class ImpalaSQL extends BasicSQL<ImpalaSqlLexer, ProgramContext,
     protected preferredRules: Set<number>;
     protected get splitListener(): ImpalaSqlSplitListener;
     protected createErrorListener(_errorListener: ErrorListener): ImpalaErrorListener;
-    protected createEntityCollector(input: string, caretTokenIndex?: number): ImpalaEntityCollector;
-    protected createSemanticContextCollector(input: string, caretPosition: CaretPosition, allTokens: Token[], options?: SemanticCollectOptions): ImpalaSemanticContextCollector;
+    protected createEntityCollector(input: string, allTokens?: Token[], caretTokenIndex?: number): ImpalaEntityCollector;
     protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number, tokenIndexOffset: number): Suggestions<Token>;
 }

package/dist/parser/impala/index.js

@@ -1,11 +1,10 @@
 import { ImpalaSqlLexer } from '../../lib/impala/ImpalaSqlLexer';
 import { ImpalaSqlParser } from '../../lib/impala/ImpalaSqlParser';
 import { BasicSQL } from '../common/basicSQL';
-import { EntityContextType, } from '../common/types';
-import { ImpalaSqlSplitListener } from './impalaSplitListener';
+import { EntityContextType } from '../common/types';
 import { ImpalaEntityCollector } from './impalaEntityCollector';
 import { ImpalaErrorListener } from './ImpalaErrorListener';
-import { ImpalaSemanticContextCollector } from './impalaSemanticContextCollector';
+import { ImpalaSqlSplitListener } from './impalaSplitListener';
 export { ImpalaEntityCollector, ImpalaSqlSplitListener };
 export class ImpalaSQL extends BasicSQL {
     constructor() {
@@ -36,11 +35,8 @@ export class ImpalaSQL extends BasicSQL {
         const parserContext = this;
         return new ImpalaErrorListener(_errorListener, parserContext, this.preferredRules);
     }
-    createEntityCollector(input, caretTokenIndex) {
-        return new ImpalaEntityCollector(input, caretTokenIndex);
-    }
-    createSemanticContextCollector(input, caretPosition, allTokens, options) {
-        return new ImpalaSemanticContextCollector(input, caretPosition, allTokens, options);
+    createEntityCollector(input, allTokens, caretTokenIndex) {
+        return new ImpalaEntityCollector(input, allTokens, caretTokenIndex);
     }
     processCandidates(candidates, allTokens, caretTokenIndex, tokenIndexOffset) {
         const originalSyntaxSuggestions = [];

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

@@ -1,14 +1,13 @@
-import { CharStream, CommonTokenStream, Token } from 'antlr4ng';
 import { CandidatesCollection } from 'antlr4-c3';
+import { CharStream, CommonTokenStream, Token } from 'antlr4ng';
 import { MySqlLexer } from '../../lib/mysql/MySqlLexer';
 import { MySqlParser, ProgramContext } from '../../lib/mysql/MySqlParser';
 import { BasicSQL } from '../common/basicSQL';
-import { Suggestions, CaretPosition, SemanticCollectOptions } from '../common/types';
-import { MysqlSplitListener } from './mysqlSplitListener';
+import { ErrorListener } from '../common/parseErrorListener';
+import { Suggestions } from '../common/types';
 import { MySqlEntityCollector } from './mysqlEntityCollector';
 import { MysqlErrorListener } from './mysqlErrorListener';
-import { ErrorListener } from '../common/parseErrorListener';
-import { MySqlSemanticContextCollector } from '../mysql/mysqlSemanticContextCollector';
+import { MysqlSplitListener } from './mysqlSplitListener';
 export { MySqlEntityCollector, MysqlSplitListener };
 export declare class MySQL extends BasicSQL<MySqlLexer, ProgramContext, MySqlParser> {
     protected createLexerFromCharStream(charStreams: CharStream): MySqlLexer;
@@ -16,7 +15,6 @@ export declare class MySQL extends BasicSQL<MySqlLexer, ProgramContext, MySqlPar
     protected preferredRules: Set<number>;
     protected get splitListener(): MysqlSplitListener;
     protected createErrorListener(_errorListener: ErrorListener): MysqlErrorListener;
-    protected createEntityCollector(input: string, caretTokenIndex?: number): MySqlEntityCollector;
-    protected createSemanticContextCollector(input: string, caretPosition: CaretPosition, allTokens: Token[], options?: SemanticCollectOptions): MySqlSemanticContextCollector;
+    protected createEntityCollector(input: string, allTokens?: Token[], caretTokenIndex?: number): MySqlEntityCollector;
     protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number, tokenIndexOffset: number): Suggestions<Token>;
 }

package/dist/parser/mysql/index.js

@@ -1,11 +1,10 @@
 import { MySqlLexer } from '../../lib/mysql/MySqlLexer';
 import { MySqlParser } from '../../lib/mysql/MySqlParser';
 import { BasicSQL } from '../common/basicSQL';
-import { EntityContextType, } from '../common/types';
-import { MysqlSplitListener } from './mysqlSplitListener';
+import { EntityContextType } from '../common/types';
 import { MySqlEntityCollector } from './mysqlEntityCollector';
 import { MysqlErrorListener } from './mysqlErrorListener';
-import { MySqlSemanticContextCollector } from '../mysql/mysqlSemanticContextCollector';
+import { MysqlSplitListener } from './mysqlSplitListener';
 export { MySqlEntityCollector, MysqlSplitListener };
 export class MySQL extends BasicSQL {
     constructor() {
@@ -36,11 +35,8 @@ export class MySQL extends BasicSQL {
         const parserContext = this;
         return new MysqlErrorListener(_errorListener, parserContext, this.preferredRules);
     }
-    createEntityCollector(input, caretTokenIndex) {
-        return new MySqlEntityCollector(input, caretTokenIndex);
-    }
-    createSemanticContextCollector(input, caretPosition, allTokens, options) {
-        return new MySqlSemanticContextCollector(input, caretPosition, allTokens, options);
+    createEntityCollector(input, allTokens, caretTokenIndex) {
+        return new MySqlEntityCollector(input, allTokens, caretTokenIndex);
     }
     processCandidates(candidates, allTokens, caretTokenIndex, tokenIndexOffset) {
         const originalSyntaxSuggestions = [];

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

@@ -2,13 +2,12 @@ import { CandidatesCollection } from 'antlr4-c3';
 import { CharStream, CommonTokenStream, Token } from 'antlr4ng';
 import { PostgreSqlLexer } from '../../lib/postgresql/PostgreSqlLexer';
 import { PostgreSqlParser, ProgramContext } from '../../lib/postgresql/PostgreSqlParser';
-import { CaretPosition, SemanticCollectOptions, Suggestions } from '../common/types';
 import { BasicSQL } from '../common/basicSQL';
-import { PostgreSqlEntityCollector } from './postgreEntityCollector';
-import { PostgreSqlSplitListener } from './postgreSplitListener';
 import { ErrorListener } from '../common/parseErrorListener';
+import { Suggestions } from '../common/types';
+import { PostgreSqlEntityCollector } from './postgreEntityCollector';
 import { PostgreSqlErrorListener } from './postgreErrorListener';
-import { PostgreSemanticContextCollector } from './postgreSemanticContextCollector';
+import { PostgreSqlSplitListener } from './postgreSplitListener';
 export { PostgreSqlEntityCollector, PostgreSqlSplitListener };
 export declare class PostgreSQL extends BasicSQL<PostgreSqlLexer, ProgramContext, PostgreSqlParser> {
     protected createLexerFromCharStream(charStreams: CharStream): PostgreSqlLexer;
@@ -16,7 +15,6 @@ export declare class PostgreSQL extends BasicSQL<PostgreSqlLexer, ProgramContext
     protected preferredRules: Set<number>;
     protected get splitListener(): PostgreSqlSplitListener;
     protected createErrorListener(_errorListener: ErrorListener): PostgreSqlErrorListener;
-    protected createEntityCollector(input: string, caretTokenIndex?: number): PostgreSqlEntityCollector;
-    protected createSemanticContextCollector(input: string, caretPosition: CaretPosition, allTokens: Token[], options?: SemanticCollectOptions): PostgreSemanticContextCollector;
+    protected createEntityCollector(input: string, allTokens?: Token[], caretTokenIndex?: number): PostgreSqlEntityCollector;
     protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number, tokenIndexOffset: number): Suggestions<Token>;
 }

package/dist/parser/postgresql/index.js

@@ -1,11 +1,10 @@
 import { PostgreSqlLexer } from '../../lib/postgresql/PostgreSqlLexer';
 import { PostgreSqlParser } from '../../lib/postgresql/PostgreSqlParser';
-import { EntityContextType, } from '../common/types';
 import { BasicSQL } from '../common/basicSQL';
+import { EntityContextType } from '../common/types';
 import { PostgreSqlEntityCollector } from './postgreEntityCollector';
-import { PostgreSqlSplitListener } from './postgreSplitListener';
 import { PostgreSqlErrorListener } from './postgreErrorListener';
-import { PostgreSemanticContextCollector } from './postgreSemanticContextCollector';
+import { PostgreSqlSplitListener } from './postgreSplitListener';
 export { PostgreSqlEntityCollector, PostgreSqlSplitListener };
 export class PostgreSQL extends BasicSQL {
     constructor() {
@@ -40,11 +39,8 @@ export class PostgreSQL extends BasicSQL {
         const parserContext = this;
         return new PostgreSqlErrorListener(_errorListener, parserContext, this.preferredRules);
     }
-    createEntityCollector(input, caretTokenIndex) {
-        return new PostgreSqlEntityCollector(input, caretTokenIndex);
-    }
-    createSemanticContextCollector(input, caretPosition, allTokens, options) {
-        return new PostgreSemanticContextCollector(input, caretPosition, allTokens, options);
+    createEntityCollector(input, allTokens, caretTokenIndex) {
+        return new PostgreSqlEntityCollector(input, allTokens, caretTokenIndex);
     }
     processCandidates(candidates, allTokens, caretTokenIndex, tokenIndexOffset) {
         const originalSyntaxSuggestions = [];

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

@@ -1,22 +1,20 @@
-import { CharStream, CommonTokenStream, Token } from 'antlr4ng';
 import { CandidatesCollection } from 'antlr4-c3';
+import { CharStream, CommonTokenStream, Token } from 'antlr4ng';
 import { SparkSqlLexer } from '../../lib/spark/SparkSqlLexer';
-import { SparkSqlParser, ProgramContext } from '../../lib/spark/SparkSqlParser';
+import { ProgramContext, SparkSqlParser } from '../../lib/spark/SparkSqlParser';
 import { BasicSQL } from '../common/basicSQL';
-import { Suggestions, CaretPosition, SemanticCollectOptions } from '../common/types';
-import { SparkSqlSplitListener } from './sparkSplitListener';
+import { ErrorListener } from '../common/parseErrorListener';
+import { Suggestions } from '../common/types';
 import { SparkEntityCollector } from './sparkEntityCollector';
 import { SparkErrorListener } from './sparkErrorListener';
-import { ErrorListener } from '../common/parseErrorListener';
-import { SparkSemanticContextCollector } from './sparkSemanticContextCollector';
-export { SparkSqlSplitListener, SparkEntityCollector };
+import { SparkSqlSplitListener } from './sparkSplitListener';
+export { SparkEntityCollector, SparkSqlSplitListener };
 export declare class SparkSQL extends BasicSQL<SparkSqlLexer, ProgramContext, SparkSqlParser> {
     protected createLexerFromCharStream(charStreams: CharStream): SparkSqlLexer;
     protected createParserFromTokenStream(tokenStream: CommonTokenStream): SparkSqlParser;
     protected preferredRules: Set<number>;
     protected get splitListener(): SparkSqlSplitListener;
     protected createErrorListener(_errorListener: ErrorListener): SparkErrorListener;
-    protected createEntityCollector(input: string, caretTokenIndex?: number): SparkEntityCollector;
-    protected createSemanticContextCollector(input: string, caretPosition: CaretPosition, allTokens: Token[], options?: SemanticCollectOptions): SparkSemanticContextCollector;
+    protected createEntityCollector(input: string, allTokens?: Token[], caretTokenIndex?: number): SparkEntityCollector;
     protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number, tokenIndexOffset: number): Suggestions<Token>;
 }

package/dist/parser/spark/index.js

@@ -1,12 +1,11 @@
 import { SparkSqlLexer } from '../../lib/spark/SparkSqlLexer';
 import { SparkSqlParser } from '../../lib/spark/SparkSqlParser';
 import { BasicSQL } from '../common/basicSQL';
-import { EntityContextType, } from '../common/types';
-import { SparkSqlSplitListener } from './sparkSplitListener';
+import { EntityContextType } from '../common/types';
 import { SparkEntityCollector } from './sparkEntityCollector';
 import { SparkErrorListener } from './sparkErrorListener';
-import { SparkSemanticContextCollector } from './sparkSemanticContextCollector';
-export { SparkSqlSplitListener, SparkEntityCollector };
+import { SparkSqlSplitListener } from './sparkSplitListener';
+export { SparkEntityCollector, SparkSqlSplitListener };
 export class SparkSQL extends BasicSQL {
     constructor() {
         super(...arguments);
@@ -36,11 +35,8 @@ export class SparkSQL extends BasicSQL {
         const parserContext = this;
         return new SparkErrorListener(_errorListener, parserContext, this.preferredRules);
     }
-    createEntityCollector(input, caretTokenIndex) {
-        return new SparkEntityCollector(input, caretTokenIndex);
-    }
-    createSemanticContextCollector(input, caretPosition, allTokens, options) {
-        return new SparkSemanticContextCollector(input, caretPosition, allTokens, options);
+    createEntityCollector(input, allTokens, caretTokenIndex) {
+        return new SparkEntityCollector(input, allTokens, caretTokenIndex);
     }
     processCandidates(candidates, allTokens, caretTokenIndex, tokenIndexOffset) {
         const originalSyntaxSuggestions = [];

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

@@ -1,22 +1,20 @@
-import { CharStream, CommonTokenStream, Token } from 'antlr4ng';
 import { CandidatesCollection } from 'antlr4-c3';
+import { CharStream, CommonTokenStream, Token } from 'antlr4ng';
 import { TrinoSqlLexer } from '../../lib/trino/TrinoSqlLexer';
-import { TrinoSqlParser, ProgramContext } from '../../lib/trino/TrinoSqlParser';
+import { ProgramContext, TrinoSqlParser } from '../../lib/trino/TrinoSqlParser';
 import { BasicSQL } from '../common/basicSQL';
-import { Suggestions, CaretPosition, SemanticCollectOptions } from '../common/types';
-import { TrinoSqlSplitListener } from './trinoSplitListener';
-import { TrinoEntityCollector } from './trinoEntityCollector';
 import { ErrorListener } from '../common/parseErrorListener';
+import { Suggestions } from '../common/types';
+import { TrinoEntityCollector } from './trinoEntityCollector';
 import { TrinoErrorListener } from './trinoErrorListener';
-import { TrinoSemanticContextCollector } from './trinoSemanticContextCollector';
-export { TrinoSqlSplitListener, TrinoEntityCollector };
+import { TrinoSqlSplitListener } from './trinoSplitListener';
+export { TrinoEntityCollector, TrinoSqlSplitListener };
 export declare class TrinoSQL extends BasicSQL<TrinoSqlLexer, ProgramContext, TrinoSqlParser> {
     protected createLexerFromCharStream(charStreams: CharStream): TrinoSqlLexer;
     protected createParserFromTokenStream(tokenStream: CommonTokenStream): TrinoSqlParser;
     protected get splitListener(): TrinoSqlSplitListener;
     protected createErrorListener(_errorListener: ErrorListener): TrinoErrorListener;
-    protected createEntityCollector(input: string, caretTokenIndex?: number): TrinoEntityCollector;
-    protected createSemanticContextCollector(input: string, caretPosition: CaretPosition, allTokens: Token[], options?: SemanticCollectOptions): TrinoSemanticContextCollector;
+    protected createEntityCollector(input: string, allTokens?: Token[], caretTokenIndex?: number): TrinoEntityCollector;
     protected preferredRules: Set<number>;
     protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number, tokenIndexOffset: number): Suggestions<Token>;
 }

package/dist/parser/trino/index.js

@@ -1,12 +1,11 @@
 import { TrinoSqlLexer } from '../../lib/trino/TrinoSqlLexer';
 import { TrinoSqlParser } from '../../lib/trino/TrinoSqlParser';
 import { BasicSQL } from '../common/basicSQL';
-import { EntityContextType, } from '../common/types';
-import { TrinoSqlSplitListener } from './trinoSplitListener';
+import { EntityContextType } from '../common/types';
 import { TrinoEntityCollector } from './trinoEntityCollector';
 import { TrinoErrorListener } from './trinoErrorListener';
-import { TrinoSemanticContextCollector } from './trinoSemanticContextCollector';
-export { TrinoSqlSplitListener, TrinoEntityCollector };
+import { TrinoSqlSplitListener } from './trinoSplitListener';
+export { TrinoEntityCollector, TrinoSqlSplitListener };
 export class TrinoSQL extends BasicSQL {
     constructor() {
         super(...arguments);
@@ -38,11 +37,8 @@ export class TrinoSQL extends BasicSQL {
         const parserContext = this;
         return new TrinoErrorListener(_errorListener, parserContext, this.preferredRules);
     }
-    createEntityCollector(input, caretTokenIndex) {
-        return new TrinoEntityCollector(input, caretTokenIndex);
-    }
-    createSemanticContextCollector(input, caretPosition, allTokens, options) {
-        return new TrinoSemanticContextCollector(input, caretPosition, allTokens, options);
+    createEntityCollector(input, allTokens, caretTokenIndex) {
+        return new TrinoEntityCollector(input, allTokens, caretTokenIndex);
     }
     processCandidates(candidates, allTokens, caretTokenIndex, tokenIndexOffset) {
         const originalSyntaxSuggestions = [];