dt-sql-parser 4.1.2-beta.0 → 4.2.0

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

@@ -114,7 +114,10 @@ import { InlineTableContext } from "./TrinoSqlParser.js";
 import { SubqueryContext } from "./TrinoSqlParser.js";
 import { SortItemContext } from "./TrinoSqlParser.js";
 import { QuerySpecificationContext } from "./TrinoSqlParser.js";
+import { WhereClauseContext } from "./TrinoSqlParser.js";
+import { HavingClauseContext } from "./TrinoSqlParser.js";
 import { GroupByContext } from "./TrinoSqlParser.js";
+import { PartitionByContext } from "./TrinoSqlParser.js";
 import { SingleGroupingSetContext } from "./TrinoSqlParser.js";
 import { RollupContext } from "./TrinoSqlParser.js";
 import { CubeContext } from "./TrinoSqlParser.js";
@@ -135,7 +138,7 @@ import { SampledRelationContext } from "./TrinoSqlParser.js";
 import { SampleTypeContext } from "./TrinoSqlParser.js";
 import { TrimsSpecificationContext } from "./TrinoSqlParser.js";
 import { ListAggOverflowBehaviorContext } from "./TrinoSqlParser.js";
-import { ListaggCountIndicationContext } from "./TrinoSqlParser.js";
+import { ListAggCountIndicationContext } from "./TrinoSqlParser.js";
 import { PatternRecognitionContext } from "./TrinoSqlParser.js";
 import { MeasureDefinitionContext } from "./TrinoSqlParser.js";
 import { RowsPerMatchContext } from "./TrinoSqlParser.js";
@@ -172,7 +175,7 @@ import { TableArgumentTableContext } from "./TrinoSqlParser.js";
 import { TableArgumentQueryContext } from "./TrinoSqlParser.js";
 import { DescriptorArgumentContext } from "./TrinoSqlParser.js";
 import { DescriptorFieldContext } from "./TrinoSqlParser.js";
-import { CopartitionTablesContext } from "./TrinoSqlParser.js";
+import { CoPartitionTablesContext } from "./TrinoSqlParser.js";
 import { ExpressionContext } from "./TrinoSqlParser.js";
 import { LogicalNotContext } from "./TrinoSqlParser.js";
 import { PredicatedContext } from "./TrinoSqlParser.js";
@@ -203,6 +206,7 @@ import { TrimContext } from "./TrinoSqlParser.js";
 import { ParameterContext } from "./TrinoSqlParser.js";
 import { NormalizeContext } from "./TrinoSqlParser.js";
 import { LocalTimestampContext } from "./TrinoSqlParser.js";
+import { ListAggContext } from "./TrinoSqlParser.js";
 import { JsonObjectContext } from "./TrinoSqlParser.js";
 import { IntervalLiteralContext } from "./TrinoSqlParser.js";
 import { NumericLiteralContext } from "./TrinoSqlParser.js";
@@ -230,7 +234,6 @@ import { CurrentTimestampContext } from "./TrinoSqlParser.js";
 import { CurrentSchemaContext } from "./TrinoSqlParser.js";
 import { ExistsContext } from "./TrinoSqlParser.js";
 import { PositionContext } from "./TrinoSqlParser.js";
-import { ListaggContext } from "./TrinoSqlParser.js";
 import { SearchedCaseContext } from "./TrinoSqlParser.js";
 import { CurrentCatalogContext } from "./TrinoSqlParser.js";
 import { GroupingOperationContext } from "./TrinoSqlParser.js";
@@ -347,6 +350,7 @@ import { CatalogNameCreateContext } from "./TrinoSqlParser.js";
 import { FunctionNameContext } from "./TrinoSqlParser.js";
 import { FunctionNameCreateContext } from "./TrinoSqlParser.js";
 import { ColumnRefContext } from "./TrinoSqlParser.js";
+import { ColumnNameContext } from "./TrinoSqlParser.js";
 import { ColumnNameCreateContext } from "./TrinoSqlParser.js";
 import { QualifiedNameContext } from "./TrinoSqlParser.js";
 import { QueryPeriodContext } from "./TrinoSqlParser.js";
@@ -1160,12 +1164,30 @@ export declare class TrinoSqlVisitor<Result> extends AbstractParseTreeVisitor<Re
      * @return the visitor result
      */
     visitQuerySpecification?: (ctx: QuerySpecificationContext) => Result;
+    /**
+     * Visit a parse tree produced by `TrinoSqlParser.whereClause`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitWhereClause?: (ctx: WhereClauseContext) => Result;
+    /**
+     * Visit a parse tree produced by `TrinoSqlParser.havingClause`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitHavingClause?: (ctx: HavingClauseContext) => Result;
     /**
      * Visit a parse tree produced by `TrinoSqlParser.groupBy`.
      * @param ctx the parse tree
      * @return the visitor result
      */
     visitGroupBy?: (ctx: GroupByContext) => Result;
+    /**
+     * Visit a parse tree produced by `TrinoSqlParser.partitionBy`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitPartitionBy?: (ctx: PartitionByContext) => Result;
     /**
      * Visit a parse tree produced by the `singleGroupingSet`
      * labeled alternative in `TrinoSqlParser.groupingElement`.
@@ -1295,11 +1317,11 @@ export declare class TrinoSqlVisitor<Result> extends AbstractParseTreeVisitor<Re
      */
     visitListAggOverflowBehavior?: (ctx: ListAggOverflowBehaviorContext) => Result;
     /**
-     * Visit a parse tree produced by `TrinoSqlParser.listaggCountIndication`.
+     * Visit a parse tree produced by `TrinoSqlParser.listAggCountIndication`.
      * @param ctx the parse tree
      * @return the visitor result
      */
-    visitListaggCountIndication?: (ctx: ListaggCountIndicationContext) => Result;
+    visitListAggCountIndication?: (ctx: ListAggCountIndicationContext) => Result;
     /**
      * Visit a parse tree produced by `TrinoSqlParser.patternRecognition`.
      * @param ctx the parse tree
@@ -1534,11 +1556,11 @@ export declare class TrinoSqlVisitor<Result> extends AbstractParseTreeVisitor<Re
      */
     visitDescriptorField?: (ctx: DescriptorFieldContext) => Result;
     /**
-     * Visit a parse tree produced by `TrinoSqlParser.copartitionTables`.
+     * Visit a parse tree produced by `TrinoSqlParser.coPartitionTables`.
      * @param ctx the parse tree
      * @return the visitor result
      */
-    visitCopartitionTables?: (ctx: CopartitionTablesContext) => Result;
+    visitCoPartitionTables?: (ctx: CoPartitionTablesContext) => Result;
     /**
      * Visit a parse tree produced by `TrinoSqlParser.expression`.
      * @param ctx the parse tree
@@ -1748,6 +1770,13 @@ export declare class TrinoSqlVisitor<Result> extends AbstractParseTreeVisitor<Re
      * @return the visitor result
      */
     visitLocalTimestamp?: (ctx: LocalTimestampContext) => Result;
+    /**
+     * Visit a parse tree produced by the `listAgg`
+     * labeled alternative in `TrinoSqlParser.primaryExpression`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitListAgg?: (ctx: ListAggContext) => Result;
     /**
      * Visit a parse tree produced by the `jsonObject`
      * labeled alternative in `TrinoSqlParser.primaryExpression`.
@@ -1937,13 +1966,6 @@ export declare class TrinoSqlVisitor<Result> extends AbstractParseTreeVisitor<Re
      * @return the visitor result
      */
     visitPosition?: (ctx: PositionContext) => Result;
-    /**
-     * Visit a parse tree produced by the `listagg`
-     * labeled alternative in `TrinoSqlParser.primaryExpression`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitListagg?: (ctx: ListaggContext) => Result;
     /**
      * Visit a parse tree produced by the `searchedCase`
      * labeled alternative in `TrinoSqlParser.primaryExpression`.
@@ -2705,6 +2727,12 @@ export declare class TrinoSqlVisitor<Result> extends AbstractParseTreeVisitor<Re
      * @return the visitor result
      */
     visitColumnRef?: (ctx: ColumnRefContext) => Result;
+    /**
+     * Visit a parse tree produced by `TrinoSqlParser.columnName`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitColumnName?: (ctx: ColumnNameContext) => Result;
     /**
      * Visit a parse tree produced by `TrinoSqlParser.columnNameCreate`.
      * @param ctx the parse tree

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

@@ -1,12 +1,14 @@
-import { Lexer, Token, CommonTokenStream, CharStream, ParserRuleContext, ParseTreeListener, ANTLRErrorListener } from 'antlr4ng';
+import { Lexer, Token, CommonTokenStream, CharStream, ParserRuleContext, ParseTreeListener, ANTLRErrorListener, Parser } from 'antlr4ng';
 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';
+export declare const SQL_SPLIT_SYMBOL_TEXT = ";";
 /**
  * Basic SQL class, every sql needs extends it.
  */
@@ -38,11 +40,10 @@ export declare abstract class BasicSQL<L extends Lexer = Lexer, PRC extends Pars
     /**
      * Convert candidates to suggestions
      * @param candidates candidate list
-     * @param allTokens all tokens from input
+     * @param allTokens slice all tokens from input by tokenIndexOffset
      * @param caretTokenIndex tokenIndex of caretPosition
-     * @param tokenIndexOffset offset of the tokenIndex in the candidates compared to the tokenIndex in allTokens
      */
-    protected abstract processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number, tokenIndexOffset: number): Suggestions<Token>;
+    protected abstract processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number): Suggestions<Token>;
     /**
      * Get a new splitListener instance.
      */
@@ -56,6 +57,10 @@ export declare abstract class BasicSQL<L extends Lexer = Lexer, PRC extends Pars
      */
     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
@@ -116,14 +121,35 @@ export declare abstract class BasicSQL<L extends Lexer = Lexer, PRC extends Pars
      */
     splitSQLByStatement(input: string): TextSlice[] | null;
     /**
-     * Get a minimum boundary parser near tokenIndex.
+     * Get the smaller range of input
+     * @param input string
+     * @param allTokens all tokens from input
+     * @param tokenIndexOffset offset of the tokenIndex in the range of input
+     * @param caretTokenIndex tokenIndex of caretPosition
+     * @returns inputSlice: string, caretTokenIndex: number
+     */
+    private splitInputBySymbolText;
+    /**
+     * Get the minimum input string that can be parsed successfully by c3.
+     * @param input source string
+     * @param caretTokenIndex tokenIndex of caretPosition
+     * @param originParseTree origin parseTree
+     * @returns MinimumInputInfo
+     */
+    getMinimumInputInfo(input: string, caretTokenIndex: number, originParseTree: ParserRuleContext | undefined): {
+        input: string;
+        tokenIndexOffset: number;
+        statementCount: number;
+    } | null;
+    /**
+     * Get a minimum boundary parser near caretTokenIndex.
      * @param input source string.
-     * @param tokenIndex start from which index to minimize the boundary.
+     * @param caretTokenIndex start from which index to minimize the boundary.
      * @param originParseTree the parse tree need to be minimized, default value is the result of parsing `input`.
      * @returns minimum parser info
      */
-    getMinimumParserInfo(input: string, tokenIndex: number, originParseTree?: ParserRuleContext | null): {
-        parser: P;
+    getMinimumParserInfo(input: string, caretTokenIndex: number, originParseTree: ParserRuleContext | undefined): {
+        parser: Parser;
         parseTree: ParserRuleContext;
         tokenIndexOffset: number;
         newTokenIndex: number;
@@ -136,4 +162,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

@@ -3,6 +3,7 @@ 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.
  */
@@ -155,31 +156,83 @@ export class BasicSQL {
         return res;
     }
     /**
-     * Get a minimum boundary parser near tokenIndex.
-     * @param input source string.
-     * @param tokenIndex start from which index to minimize the boundary.
-     * @param originParseTree the parse tree need to be minimized, default value is the result of parsing `input`.
-     * @returns minimum parser info
+     * Get the smaller range of input
+     * @param input string
+     * @param allTokens all tokens from input
+     * @param tokenIndexOffset offset of the tokenIndex in the range of input
+     * @param caretTokenIndex tokenIndex of caretPosition
+     * @returns inputSlice: string, caretTokenIndex: number
      */
-    getMinimumParserInfo(input, tokenIndex, originParseTree) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
-        if (arguments.length <= 2) {
-            this.parseWithCache(input);
-            originParseTree = this._parseTree;
+    splitInputBySymbolText(input, allTokens, tokenIndexOffset, caretTokenIndex) {
+        const tokens = allTokens.slice(tokenIndexOffset);
+        /**
+         * Set startToken
+         */
+        let startToken = null;
+        for (let tokenIndex = caretTokenIndex - tokenIndexOffset; tokenIndex >= 0; tokenIndex--) {
+            const token = tokens[tokenIndex];
+            if ((token === null || token === void 0 ? void 0 : token.text) === SQL_SPLIT_SYMBOL_TEXT) {
+                startToken = tokens[tokenIndex + 1];
+                break;
+            }
+        }
+        if (startToken === null) {
+            startToken = tokens[0];
         }
+        /**
+         * Set stopToken
+         */
+        let stopToken = null;
+        for (let tokenIndex = caretTokenIndex - tokenIndexOffset; tokenIndex < tokens.length; tokenIndex++) {
+            const token = tokens[tokenIndex];
+            if ((token === null || token === void 0 ? void 0 : token.text) === SQL_SPLIT_SYMBOL_TEXT) {
+                stopToken = token;
+                break;
+            }
+        }
+        if (stopToken === null) {
+            stopToken = tokens[tokens.length - 1];
+        }
+        const indexOffset = tokens[0].start;
+        let startIndex = startToken.start - indexOffset;
+        let stopIndex = stopToken.stop + 1 - indexOffset;
+        /**
+         * Save offset of the tokenIndex in the range of input
+         * compared to the tokenIndex in the whole input
+         */
+        const _tokenIndexOffset = startToken.tokenIndex;
+        const _caretTokenIndex = caretTokenIndex - _tokenIndexOffset;
+        /**
+         * Get the smaller range of _input
+         */
+        const _input = input.slice(startIndex, stopIndex);
+        return {
+            inputSlice: _input,
+            allTokens: allTokens.slice(_tokenIndexOffset),
+            caretTokenIndex: _caretTokenIndex,
+        };
+    }
+    /**
+     * Get the minimum input string that can be parsed successfully by c3.
+     * @param input source string
+     * @param caretTokenIndex tokenIndex of caretPosition
+     * @param originParseTree origin parseTree
+     * @returns MinimumInputInfo
+     */
+    getMinimumInputInfo(input, caretTokenIndex, originParseTree) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
         if (!originParseTree || !(input === null || input === void 0 ? void 0 : input.length))
             return null;
-        const splitListener = this.splitListener;
+        let inputSlice = input;
         /**
          * Split sql by statement.
          * Try to collect candidates in as small a range as possible.
          */
+        const splitListener = this.splitListener;
         this.listen(splitListener, originParseTree);
         const statementCount = (_a = splitListener.statementsContext) === null || _a === void 0 ? void 0 : _a.length;
         const statementsContext = splitListener.statementsContext;
         let tokenIndexOffset = 0;
-        let sqlParserIns = this._parser;
-        let parseTree = originParseTree;
         // If there are multiple statements.
         if (statementCount > 1) {
             /**
@@ -200,12 +253,12 @@ export class BasicSQL {
                  */
                 const isPrevCtxValid = index === 0 || !((_b = statementsContext[index - 1]) === null || _b === void 0 ? void 0 : _b.exception);
                 const isNextCtxValid = index === statementCount - 1 || !((_c = statementsContext[index + 1]) === null || _c === void 0 ? void 0 : _c.exception);
-                if (ctx.stop && ctx.stop.tokenIndex < tokenIndex && isPrevCtxValid) {
+                if (ctx.stop && ctx.stop.tokenIndex < caretTokenIndex && isPrevCtxValid) {
                     startStatement = ctx;
                 }
                 if (ctx.start &&
                     !stopStatement &&
-                    ctx.start.tokenIndex > tokenIndex &&
+                    ctx.start.tokenIndex > caretTokenIndex &&
                     isNextCtxValid) {
                     stopStatement = ctx;
                     break;
@@ -213,35 +266,50 @@ export class BasicSQL {
             }
             // A boundary consisting of the index of the input.
             const startIndex = (_e = (_d = startStatement === null || startStatement === void 0 ? void 0 : startStatement.start) === null || _d === void 0 ? void 0 : _d.start) !== null && _e !== void 0 ? _e : 0;
-            const stopIndex = (_g = (_f = stopStatement === null || stopStatement === void 0 ? void 0 : stopStatement.stop) === null || _f === void 0 ? void 0 : _f.stop) !== null && _g !== void 0 ? _g : input.length - 1;
+            const stopIndex = (_g = (_f = stopStatement === null || stopStatement === void 0 ? void 0 : stopStatement.stop) === null || _f === void 0 ? void 0 : _f.stop) !== null && _g !== void 0 ? _g : inputSlice.length - 1;
             /**
              * Save offset of the tokenIndex in the range of input
              * compared to the tokenIndex in the whole input
              */
             tokenIndexOffset = (_j = (_h = startStatement === null || startStatement === void 0 ? void 0 : startStatement.start) === null || _h === void 0 ? void 0 : _h.tokenIndex) !== null && _j !== void 0 ? _j : 0;
-            tokenIndex = tokenIndex - tokenIndexOffset;
-            /**
-             * Reparse the input fragment，
-             * and c3 will collect candidates in the newly generated parseTree.
-             */
-            const inputSlice = input.slice(startIndex, stopIndex);
-            const lexer = this.createLexer(inputSlice);
-            lexer.removeErrorListeners();
-            const tokenStream = new CommonTokenStream(lexer);
-            tokenStream.fill();
-            const parser = this.createParserFromTokenStream(tokenStream);
-            parser.interpreter.predictionMode = PredictionMode.SLL;
-            parser.removeErrorListeners();
-            parser.buildParseTrees = true;
-            parser.errorHandler = new ErrorStrategy();
-            sqlParserIns = parser;
-            parseTree = parser.program();
+            inputSlice = inputSlice.slice(startIndex, stopIndex);
+        }
+        return {
+            input: inputSlice,
+            tokenIndexOffset,
+            statementCount,
+        };
+    }
+    /**
+     * Get a minimum boundary parser near caretTokenIndex.
+     * @param input source string.
+     * @param caretTokenIndex start from which index to minimize the boundary.
+     * @param originParseTree the parse tree need to be minimized, default value is the result of parsing `input`.
+     * @returns minimum parser info
+     */
+    getMinimumParserInfo(input, caretTokenIndex, originParseTree) {
+        if (!originParseTree || !(input === null || input === void 0 ? void 0 : input.length))
+            return null;
+        const inputInfo = this.getMinimumInputInfo(input, caretTokenIndex, originParseTree);
+        if (!inputInfo)
+            return null;
+        const { input: inputSlice, tokenIndexOffset } = inputInfo;
+        caretTokenIndex = caretTokenIndex - tokenIndexOffset;
+        let sqlParserIns = this._parser;
+        let parseTree = originParseTree;
+        /**
+         * Reparse the input fragment,
+         * and c3 will collect candidates in the newly generated parseTree when input changed.
+         */
+        if (inputSlice !== input) {
+            sqlParserIns = this.createParser(inputSlice);
+            parseTree = sqlParserIns.program();
         }
         return {
             parser: sqlParserIns,
             parseTree,
             tokenIndexOffset,
-            newTokenIndex: tokenIndex,
+            newTokenIndex: caretTokenIndex,
         };
     }
     /**
@@ -254,18 +322,43 @@ export class BasicSQL {
         this.parseWithCache(input);
         if (!this._parseTree)
             return null;
-        const allTokens = this.getAllTokens(input);
+        let allTokens = this.getAllTokens(input);
         let caretTokenIndex = findCaretTokenIndex(caretPosition, allTokens);
         if (!caretTokenIndex && caretTokenIndex !== 0)
             return null;
-        const minimumParser = this.getMinimumParserInfo(input, caretTokenIndex);
-        if (!minimumParser)
+        const inputInfo = this.getMinimumInputInfo(input, caretTokenIndex, this._parseTree);
+        if (!inputInfo)
             return null;
-        const { parser: sqlParserIns, tokenIndexOffset, newTokenIndex, parseTree: c3Context, } = minimumParser;
+        const { input: _input, tokenIndexOffset, statementCount } = inputInfo;
+        let inputSlice = _input;
+        /**
+         * Split the inputSlice by separator to get the smaller range of inputSlice.
+         */
+        if (inputSlice.includes(SQL_SPLIT_SYMBOL_TEXT)) {
+            const { inputSlice: _inputSlice, allTokens: _allTokens, caretTokenIndex: _caretTokenIndex, } = this.splitInputBySymbolText(inputSlice, allTokens, tokenIndexOffset, caretTokenIndex);
+            allTokens = _allTokens;
+            caretTokenIndex = _caretTokenIndex;
+            inputSlice = _inputSlice;
+        }
+        else {
+            if (statementCount > 1) {
+                caretTokenIndex = caretTokenIndex - tokenIndexOffset;
+            }
+        }
+        let sqlParserIns = this._parser;
+        let parseTree = this._parseTree;
+        /**
+         * Reparse the input fragment,
+         * and c3 will collect candidates in the newly generated parseTree when input changed.
+         */
+        if (inputSlice !== input) {
+            sqlParserIns = this.createParser(inputSlice);
+            parseTree = sqlParserIns.program();
+        }
         const core = new CodeCompletionCore(sqlParserIns);
         core.preferredRules = this.preferredRules;
-        const candidates = core.collectCandidates(newTokenIndex, c3Context);
-        const originalSuggestions = this.processCandidates(candidates, allTokens, newTokenIndex, tokenIndexOffset);
+        const candidates = core.collectCandidates(caretTokenIndex, parseTree);
+        const originalSuggestions = this.processCandidates(candidates, allTokens, caretTokenIndex);
         const syntaxSuggestions = originalSuggestions.syntax.map((syntaxCtx) => {
             const wordRanges = syntaxCtx.wordRanges.map((token) => {
                 return tokenToWord(token, this._parsedInput);
@@ -300,4 +393,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,50 @@
+import { ErrorNode, ParserRuleContext, TerminalNode, Token } from 'antlr4ng';
+import { CaretPosition, SemanticCollectOptions, SemanticContext } from '../common/types';
+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;