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

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

@@ -2,11 +2,12 @@ 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, Suggestions } from './types';
+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 SemanticContextCollector from './semanticContextCollector';
 /**
  * Basic SQL class, every sql needs extends it.
  */
@@ -56,6 +57,10 @@ export declare abstract class BasicSQL<L extends Lexer = Lexer, PRC extends Pars
      */
     protected abstract createEntityCollector(input: string, 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
@@ -136,4 +141,12 @@ 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

@@ -300,4 +300,18 @@ 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/semanticContextCollector.d.ts

@@ -0,0 +1,51 @@
+import { ErrorNode, ParserRuleContext, TerminalNode, Token } from 'antlr4ng';
+import { CaretPosition, SemanticCollectOptions, SemanticContext } from '../common/types';
+export declare const SQL_SPLIT_SYMBOL_TEXT = ";";
+declare abstract class SemanticContextCollector {
+    constructor(_input: string, caretPosition: CaretPosition, allTokens: Token[], options?: SemanticCollectOptions);
+    readonly options: SemanticCollectOptions;
+    private _tokenIndex;
+    private _allTokens;
+    /**
+     * If current caret position is in a beginning of statement semantics, it needs to follow some cases:
+     * @case1 there is no statement node with an error before the current statement in the parse tree;
+     *
+     * @case2 if it is an uncomplete keyword, it will be parsed as an `ErrorNode`
+     * and need be a direct child node of `program`;
+     *
+     * @case3 if it is a complete keyword, the parsed TerminalNode or ErrorNode should be
+     * the first leaf node of current statement rule;
+     *
+     * @case4 if it is whiteSpace in caret position, we can't visit it in antlr4 listener,
+     * so we find the first unhidden token before the whiteSpace token, and the unhidden token
+     * should be the last leaf node of statement its belongs to;
+     *
+     * @case5 if the previous token is split symbol like `;`, ignore case1 and forcefully judged as beginning of statement.
+     */
+    private _isStatementBeginning;
+    /**
+     * Prev tokenIndex that not white space before current tokenIndex or caret position
+     */
+    private _prevTokenIndex;
+    get semanticContext(): SemanticContext;
+    abstract getWhiteSpaceRuleType(): number;
+    abstract getStatementRuleType(): number;
+    private prevStatementHasError;
+    /**
+     * Most root rule is `program`.
+     */
+    private isRootRule;
+    /**
+     * link to @case4
+     * It should be called in each language's own `enterStatement`.
+     */
+    protected visitStatement(ctx: ParserRuleContext): void;
+    /**
+     * Uncomplete keyword will be error node
+     */
+    visitErrorNode(node: ErrorNode): void;
+    visitTerminal(node: TerminalNode): void;
+    enterEveryRule(_node: ParserRuleContext): void;
+    exitEveryRule(_node: ParserRuleContext): void;
+}
+export default SemanticContextCollector;

package/dist/parser/common/semanticContextCollector.js

@@ -0,0 +1,202 @@
+import { ErrorNode, ParserRuleContext, Token } from 'antlr4ng';
+import { findCaretTokenIndex } from '../common/findCaretTokenIndex';
+import { SqlSplitStrategy, } from '../common/types';
+export const SQL_SPLIT_SYMBOL_TEXT = ';';
+class SemanticContextCollector {
+    constructor(_input, caretPosition, allTokens, options) {
+        this.options = {
+            sqlSplitStrategy: SqlSplitStrategy.STRICT,
+        };
+        this._allTokens = [];
+        /**
+         * If current caret position is in a beginning of statement semantics, it needs to follow some cases:
+         * @case1 there is no statement node with an error before the current statement in the parse tree;
+         *
+         * @case2 if it is an uncomplete keyword, it will be parsed as an `ErrorNode`
+         * and need be a direct child node of `program`;
+         *
+         * @case3 if it is a complete keyword, the parsed TerminalNode or ErrorNode should be
+         * the first leaf node of current statement rule;
+         *
+         * @case4 if it is whiteSpace in caret position, we can't visit it in antlr4 listener,
+         * so we find the first unhidden token before the whiteSpace token, and the unhidden token
+         * should be the last leaf node of statement its belongs to;
+         *
+         * @case5 if the previous token is split symbol like `;`, ignore case1 and forcefully judged as beginning of statement.
+         */
+        this._isStatementBeginning = false;
+        // If caretPosition token is whiteSpace, tokenIndex may be undefined.
+        const tokenIndex = findCaretTokenIndex(caretPosition, allTokens);
+        if (tokenIndex !== undefined) {
+            this._tokenIndex = tokenIndex;
+        }
+        this._allTokens = allTokens;
+        this.options = Object.assign(Object.assign({}, this.options), options);
+        if (allTokens === null || allTokens === void 0 ? void 0 : allTokens.length) {
+            let i = tokenIndex ? tokenIndex - 1 : allTokens.length - 1;
+            /**
+             * Link to @case4 and @case5
+             * Find the previous unhidden token.
+             * If can't find tokenIndex or current token is whiteSpace at caretPosition,
+             * prevTokenIndex is useful to help us determine if it is beginning of statement.
+             */
+            while (i >= 0) {
+                if (allTokens[i].channel !== Token.HIDDEN_CHANNEL &&
+                    (allTokens[i].line < caretPosition.lineNumber ||
+                        (allTokens[i].line === caretPosition.lineNumber &&
+                            allTokens[i].column < caretPosition.column))) {
+                    this._prevTokenIndex = allTokens[i].tokenIndex;
+                    break;
+                }
+                i--;
+            }
+            /**
+             * We can directly conclude beginning of statement semantics when current token is
+             * the first token of tokenStream or the previous token is semicolon
+             */
+            if (tokenIndex === 0 ||
+                i === -1 ||
+                (this._prevTokenIndex &&
+                    this._allTokens[this._prevTokenIndex].text === SQL_SPLIT_SYMBOL_TEXT)) {
+                this._isStatementBeginning = true;
+            }
+        }
+    }
+    get semanticContext() {
+        return {
+            isStatementBeginning: this._isStatementBeginning,
+        };
+    }
+    prevStatementHasError(node) {
+        let parent = node.parent;
+        if (!parent)
+            return false;
+        const currentNodeIndex = parent.children.findIndex((child) => child === node);
+        if (currentNodeIndex <= 0)
+            return false;
+        for (let i = currentNodeIndex - 1; i >= 0; i--) {
+            const prevNode = parent.children[i];
+            if (prevNode instanceof ErrorNode ||
+                (prevNode instanceof ParserRuleContext && prevNode.exception !== null))
+                return true;
+        }
+        return false;
+    }
+    /**
+     * Most root rule is `program`.
+     */
+    isRootRule(node) {
+        return node instanceof ParserRuleContext && (node === null || node === void 0 ? void 0 : node.parent) === null;
+    }
+    /**
+     * link to @case4
+     * It should be called in each language's own `enterStatement`.
+     */
+    visitStatement(ctx) {
+        var _a, _b, _c;
+        if (this.options.sqlSplitStrategy === SqlSplitStrategy.STRICT)
+            return;
+        const isWhiteSpaceToken = this._tokenIndex === undefined ||
+            ((_a = this._allTokens[this._tokenIndex]) === null || _a === void 0 ? void 0 : _a.type) === this.getWhiteSpaceRuleType() ||
+            // PostgreSQL whiteSpace not inlcudes '\n' symbol
+            ((_b = this._allTokens[this._tokenIndex]) === null || _b === void 0 ? void 0 : _b.text) === '\n';
+        const isPrevTokenEndOfStatement = this._prevTokenIndex && ((_c = ctx.stop) === null || _c === void 0 ? void 0 : _c.tokenIndex) === this._prevTokenIndex;
+        if (isWhiteSpaceToken && isPrevTokenEndOfStatement && ctx.exception === null) {
+            this._isStatementBeginning = !this.prevStatementHasError(ctx)
+                ? true
+                : this._isStatementBeginning;
+        }
+    }
+    /**
+     * Uncomplete keyword will be error node
+     */
+    visitErrorNode(node) {
+        var _a, _b, _c, _d;
+        if (node.symbol.tokenIndex !== this._tokenIndex ||
+            this._isStatementBeginning ||
+            this.options.sqlSplitStrategy === SqlSplitStrategy.STRICT)
+            return;
+        let parent = node.parent;
+        let currentNode = node;
+        /**
+         * Link to @case2
+         * The error node is a direct child node of the program node
+         */
+        if (this.isRootRule(parent)) {
+            this._isStatementBeginning = !this.prevStatementHasError(currentNode);
+            return;
+        }
+        /**
+         * Link to @case3
+         * Error node must be the first leaf node of the statement parse tree.
+         **/
+        while (parent !== null && parent.ruleIndex !== this.getStatementRuleType()) {
+            if (((_a = parent.children) === null || _a === void 0 ? void 0 : _a[0]) !== currentNode) {
+                this._isStatementBeginning = false;
+                return;
+            }
+            currentNode = parent;
+            parent = currentNode.parent;
+        }
+        let isStatementBeginning = true;
+        /**
+         * Link to @case1
+         * Previous statement must have no exception
+         */
+        if ((parent === null || parent === void 0 ? void 0 : parent.ruleIndex) === this.getStatementRuleType()) {
+            const programRule = parent.parent;
+            const currentStatementRuleIndex = ((_b = programRule === null || programRule === void 0 ? void 0 : programRule.children) === null || _b === void 0 ? void 0 : _b.findIndex((node) => node === parent)) || -1;
+            if (currentStatementRuleIndex > 0) {
+                /**
+                 * When you typed a keyword and doesn't match any rule, you will get a EOF error,
+                 * For example, just typed 'CREATE', 'INSERT'.
+                 */
+                const isStatementEOF = ((_d = (_c = parent.exception) === null || _c === void 0 ? void 0 : _c.offendingToken) === null || _d === void 0 ? void 0 : _d.text) === '<EOF>';
+                isStatementBeginning =
+                    this.prevStatementHasError(parent) && !isStatementEOF
+                        ? false
+                        : isStatementBeginning;
+            }
+        }
+        this._isStatementBeginning = isStatementBeginning;
+    }
+    visitTerminal(node) {
+        var _a, _b;
+        if (node.symbol.tokenIndex !== this._tokenIndex ||
+            this._isStatementBeginning ||
+            this.options.sqlSplitStrategy === SqlSplitStrategy.STRICT)
+            return;
+        let currentNode = node;
+        let parent = node.parent;
+        /**
+         * Link to @case3
+         * Current terminal node must be the first leaf node of the statement parse tree.
+         **/
+        while (parent !== null && parent.ruleIndex !== this.getStatementRuleType()) {
+            if (((_a = parent.children) === null || _a === void 0 ? void 0 : _a[0]) !== currentNode) {
+                this._isStatementBeginning = false;
+                return;
+            }
+            currentNode = parent;
+            parent = currentNode.parent;
+        }
+        let isStatementBeginning = true;
+        /**
+         * Link to @case1
+         * Previous statement must have no exception
+         */
+        if ((parent === null || parent === void 0 ? void 0 : parent.ruleIndex) === this.getStatementRuleType()) {
+            const programRule = parent.parent;
+            const currentStatementRuleIndex = ((_b = programRule === null || programRule === void 0 ? void 0 : programRule.children) === null || _b === void 0 ? void 0 : _b.findIndex((node) => node === parent)) || -1;
+            if (currentStatementRuleIndex > 0) {
+                isStatementBeginning = this.prevStatementHasError(parent)
+                    ? false
+                    : isStatementBeginning;
+            }
+        }
+        this._isStatementBeginning = isStatementBeginning;
+    }
+    enterEveryRule(_node) { }
+    exitEveryRule(_node) { }
+}
+export default SemanticContextCollector;

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

@@ -64,3 +64,28 @@ 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,3 +32,10 @@ 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/flinkSemanticContextCollector.d.ts

@@ -0,0 +1,9 @@
+import { FlinkSqlParserListener } from '../../lib';
+import { SingleStatementContext } from '../../lib/flink/FlinkSqlParser';
+import SemanticContextCollector from '../common/semanticContextCollector';
+declare class FlinkSemanticContextCollector extends SemanticContextCollector implements FlinkSqlParserListener {
+    getWhiteSpaceRuleType(): number;
+    getStatementRuleType(): number;
+    enterSingleStatement(ctx: SingleStatementContext): void;
+}
+export { FlinkSemanticContextCollector };

package/dist/parser/flink/flinkSemanticContextCollector.js

@@ -0,0 +1,14 @@
+import { FlinkSqlParser } from '../../lib/flink/FlinkSqlParser';
+import SemanticContextCollector from '../common/semanticContextCollector';
+class FlinkSemanticContextCollector extends SemanticContextCollector {
+    getWhiteSpaceRuleType() {
+        return FlinkSqlParser.SPACE;
+    }
+    getStatementRuleType() {
+        return FlinkSqlParser.RULE_singleStatement;
+    }
+    enterSingleStatement(ctx) {
+        this.visitStatement(ctx);
+    }
+}
+export { FlinkSemanticContextCollector };

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

@@ -2,12 +2,13 @@ import { CharStream, CommonTokenStream, Token } from 'antlr4ng';
 import { CandidatesCollection } from 'antlr4-c3';
 import { FlinkSqlLexer } from '../../lib/flink/FlinkSqlLexer';
 import { FlinkSqlParser, ProgramContext } from '../../lib/flink/FlinkSqlParser';
-import { Suggestions } from '../common/types';
+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 { FlinkErrorListener } from './flinkErrorListener';
+import { FlinkSemanticContextCollector } from './flinkSemanticContextCollector';
 export { FlinkSqlSplitListener, FlinkEntityCollector };
 export declare class FlinkSQL extends BasicSQL<FlinkSqlLexer, ProgramContext, FlinkSqlParser> {
     protected createLexerFromCharStream(charStreams: CharStream): FlinkSqlLexer;
@@ -16,5 +17,6 @@ export declare class FlinkSQL extends BasicSQL<FlinkSqlLexer, ProgramContext, Fl
     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 processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number, tokenIndexOffset: number): Suggestions<Token>;
 }

package/dist/parser/flink/index.js

@@ -1,10 +1,11 @@
 import { FlinkSqlLexer } from '../../lib/flink/FlinkSqlLexer';
 import { FlinkSqlParser } from '../../lib/flink/FlinkSqlParser';
-import { EntityContextType } from '../common/types';
+import { EntityContextType, } from '../common/types';
 import { BasicSQL } from '../common/basicSQL';
 import { FlinkSqlSplitListener } from './flinkSplitListener';
 import { FlinkEntityCollector } from './flinkEntityCollector';
 import { FlinkErrorListener } from './flinkErrorListener';
+import { FlinkSemanticContextCollector } from './flinkSemanticContextCollector';
 export { FlinkSqlSplitListener, FlinkEntityCollector };
 export class FlinkSQL extends BasicSQL {
     constructor() {
@@ -39,6 +40,9 @@ export class FlinkSQL extends BasicSQL {
     createEntityCollector(input, caretTokenIndex) {
         return new FlinkEntityCollector(input, caretTokenIndex);
     }
+    createSemanticContextCollector(input, caretPosition, allTokens, options) {
+        return new FlinkSemanticContextCollector(input, caretPosition, allTokens, options);
+    }
     processCandidates(candidates, allTokens, caretTokenIndex, tokenIndexOffset) {
         const originalSyntaxSuggestions = [];
         const keywords = [];

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

@@ -0,0 +1,9 @@
+import { HiveSqlParserListener } from '../../lib';
+import { StatementContext } from '../../lib/hive/HiveSqlParser';
+import SemanticContextCollector from '../common/semanticContextCollector';
+declare class HiveSemanticContextCollector extends SemanticContextCollector implements HiveSqlParserListener {
+    getWhiteSpaceRuleType(): number;
+    getStatementRuleType(): number;
+    enterStatement(ctx: StatementContext): void;
+}
+export { HiveSemanticContextCollector };

package/dist/parser/hive/hiveSemanticContextCollector.js

@@ -0,0 +1,14 @@
+import { HiveSqlParser } from '../../lib/hive/HiveSqlParser';
+import SemanticContextCollector from '../common/semanticContextCollector';
+class HiveSemanticContextCollector extends SemanticContextCollector {
+    getWhiteSpaceRuleType() {
+        return HiveSqlParser.WHITE_SPACE;
+    }
+    getStatementRuleType() {
+        return HiveSqlParser.RULE_statement;
+    }
+    enterStatement(ctx) {
+        this.visitStatement(ctx);
+    }
+}
+export { HiveSemanticContextCollector };

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

@@ -3,11 +3,12 @@ import { CandidatesCollection } from 'antlr4-c3';
 import { HiveSqlLexer } from '../../lib/hive/HiveSqlLexer';
 import { HiveSqlParser, ProgramContext } from '../../lib/hive/HiveSqlParser';
 import { BasicSQL } from '../common/basicSQL';
-import { Suggestions } from '../common/types';
+import { CaretPosition, SemanticCollectOptions, Suggestions } from '../common/types';
 import { HiveSqlSplitListener } from './hiveSplitListener';
 import { HiveEntityCollector } from './hiveEntityCollector';
 import { ErrorListener } from '../common/parseErrorListener';
 import { HiveErrorListener } from './hiveErrorListener';
+import { HiveSemanticContextCollector } from './hiveSemanticContextCollector';
 export { HiveEntityCollector, HiveSqlSplitListener };
 export declare class HiveSQL extends BasicSQL<HiveSqlLexer, ProgramContext, HiveSqlParser> {
     protected createLexerFromCharStream(charStreams: CharStream): HiveSqlLexer;
@@ -16,5 +17,6 @@ export declare class HiveSQL extends BasicSQL<HiveSqlLexer, ProgramContext, Hive
     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 processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number, tokenIndexOffset: number): Suggestions<Token>;
 }

package/dist/parser/hive/index.js

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

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

@@ -0,0 +1,9 @@
+import { ImpalaSqlParserListener } from '../../lib';
+import { SingleStatementContext } from '../../lib/impala/ImpalaSqlParser';
+import SemanticContextCollector from '../common/semanticContextCollector';
+declare class ImpalaSemanticContextCollector extends SemanticContextCollector implements ImpalaSqlParserListener {
+    getWhiteSpaceRuleType(): number;
+    getStatementRuleType(): number;
+    enterSingleStatement(ctx: SingleStatementContext): void;
+}
+export { ImpalaSemanticContextCollector };

package/dist/parser/impala/impalaSemanticContextCollector.js

@@ -0,0 +1,14 @@
+import { ImpalaSqlParser } from '../../lib/impala/ImpalaSqlParser';
+import SemanticContextCollector from '../common/semanticContextCollector';
+class ImpalaSemanticContextCollector extends SemanticContextCollector {
+    getWhiteSpaceRuleType() {
+        return ImpalaSqlParser.WS;
+    }
+    getStatementRuleType() {
+        return ImpalaSqlParser.RULE_singleStatement;
+    }
+    enterSingleStatement(ctx) {
+        this.visitStatement(ctx);
+    }
+}
+export { ImpalaSemanticContextCollector };

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

@@ -3,11 +3,12 @@ import { CandidatesCollection } from 'antlr4-c3';
 import { ImpalaSqlLexer } from '../../lib/impala/ImpalaSqlLexer';
 import { ImpalaSqlParser, ProgramContext } from '../../lib/impala/ImpalaSqlParser';
 import { BasicSQL } from '../common/basicSQL';
-import { Suggestions } from '../common/types';
+import { CaretPosition, SemanticCollectOptions, Suggestions } from '../common/types';
 import { ImpalaSqlSplitListener } from './impalaSplitListener';
 import { ImpalaEntityCollector } from './impalaEntityCollector';
 import { ErrorListener } from '../common/parseErrorListener';
 import { ImpalaErrorListener } from './ImpalaErrorListener';
+import { ImpalaSemanticContextCollector } from './impalaSemanticContextCollector';
 export { ImpalaEntityCollector, ImpalaSqlSplitListener };
 export declare class ImpalaSQL extends BasicSQL<ImpalaSqlLexer, ProgramContext, ImpalaSqlParser> {
     protected createLexerFromCharStream(charStreams: CharStream): ImpalaSqlLexer;
@@ -16,5 +17,6 @@ export declare class ImpalaSQL extends BasicSQL<ImpalaSqlLexer, ProgramContext,
     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 processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number, tokenIndexOffset: number): Suggestions<Token>;
 }

package/dist/parser/impala/index.js

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

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

@@ -3,11 +3,12 @@ import { CandidatesCollection } from 'antlr4-c3';
 import { MySqlLexer } from '../../lib/mysql/MySqlLexer';
 import { MySqlParser, ProgramContext } from '../../lib/mysql/MySqlParser';
 import { BasicSQL } from '../common/basicSQL';
-import { Suggestions } from '../common/types';
+import { Suggestions, CaretPosition, SemanticCollectOptions } from '../common/types';
 import { MysqlSplitListener } from './mysqlSplitListener';
 import { MySqlEntityCollector } from './mysqlEntityCollector';
 import { MysqlErrorListener } from './mysqlErrorListener';
 import { ErrorListener } from '../common/parseErrorListener';
+import { MySqlSemanticContextCollector } from '../mysql/mysqlSemanticContextCollector';
 export { MySqlEntityCollector, MysqlSplitListener };
 export declare class MySQL extends BasicSQL<MySqlLexer, ProgramContext, MySqlParser> {
     protected createLexerFromCharStream(charStreams: CharStream): MySqlLexer;
@@ -16,5 +17,6 @@ export declare class MySQL extends BasicSQL<MySqlLexer, ProgramContext, MySqlPar
     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 processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number, tokenIndexOffset: number): Suggestions<Token>;
 }

package/dist/parser/mysql/index.js

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

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

@@ -0,0 +1,9 @@
+import { MySqlParserListener } from '../../lib';
+import { SingleStatementContext } from '../../lib/mysql/MySqlParser';
+import SemanticContextCollector from '../common/semanticContextCollector';
+declare class MySqlSemanticContextCollector extends SemanticContextCollector implements MySqlParserListener {
+    getWhiteSpaceRuleType(): number;
+    getStatementRuleType(): number;
+    enterSingleStatement(ctx: SingleStatementContext): void;
+}
+export { MySqlSemanticContextCollector };

package/dist/parser/mysql/mysqlSemanticContextCollector.js

@@ -0,0 +1,14 @@
+import { MySqlParser } from '../../lib/mysql/MySqlParser';
+import SemanticContextCollector from '../common/semanticContextCollector';
+class MySqlSemanticContextCollector extends SemanticContextCollector {
+    getWhiteSpaceRuleType() {
+        return MySqlParser.SPACE;
+    }
+    getStatementRuleType() {
+        return MySqlParser.RULE_singleStatement;
+    }
+    enterSingleStatement(ctx) {
+        this.visitStatement(ctx);
+    }
+}
+export { MySqlSemanticContextCollector };