dt-sql-parser 4.5.1-beta.2 → 4.5.1

package/dist/lib/hive/HiveSqlParserListener.d.ts

@@ -333,6 +333,8 @@ import { FunctionIdentifierContext } from "./HiveSqlParser.js";
 import { PrincipalIdentifierContext } from "./HiveSqlParser.js";
 import { NonReservedContext } from "./HiveSqlParser.js";
 import { Sql11ReservedKeywordsUsedAsFunctionNameContext } from "./HiveSqlParser.js";
+import { ConfigPropertyContext } from "./HiveSqlParser.js";
+import { ConfigPropertyPartContext } from "./HiveSqlParser.js";
 import { ConfigPropertiesItemContext } from "./HiveSqlParser.js";
 import { ResourcePlanDdlStatementsContext } from "./HiveSqlParser.js";
 import { MappingTypesContext } from "./HiveSqlParser.js";
@@ -3710,6 +3712,26 @@ export declare class HiveSqlParserListener implements ParseTreeListener {
      * @param ctx the parse tree
      */
     exitSql11ReservedKeywordsUsedAsFunctionName?: (ctx: Sql11ReservedKeywordsUsedAsFunctionNameContext) => void;
+    /**
+     * Enter a parse tree produced by `HiveSqlParser.configProperty`.
+     * @param ctx the parse tree
+     */
+    enterConfigProperty?: (ctx: ConfigPropertyContext) => void;
+    /**
+     * Exit a parse tree produced by `HiveSqlParser.configProperty`.
+     * @param ctx the parse tree
+     */
+    exitConfigProperty?: (ctx: ConfigPropertyContext) => void;
+    /**
+     * Enter a parse tree produced by `HiveSqlParser.configPropertyPart`.
+     * @param ctx the parse tree
+     */
+    enterConfigPropertyPart?: (ctx: ConfigPropertyPartContext) => void;
+    /**
+     * Exit a parse tree produced by `HiveSqlParser.configPropertyPart`.
+     * @param ctx the parse tree
+     */
+    exitConfigPropertyPart?: (ctx: ConfigPropertyPartContext) => void;
     /**
      * Enter a parse tree produced by `HiveSqlParser.configPropertiesItem`.
      * @param ctx the parse tree

package/dist/lib/hive/HiveSqlParserVisitor.d.ts

@@ -333,6 +333,8 @@ import { FunctionIdentifierContext } from "./HiveSqlParser.js";
 import { PrincipalIdentifierContext } from "./HiveSqlParser.js";
 import { NonReservedContext } from "./HiveSqlParser.js";
 import { Sql11ReservedKeywordsUsedAsFunctionNameContext } from "./HiveSqlParser.js";
+import { ConfigPropertyContext } from "./HiveSqlParser.js";
+import { ConfigPropertyPartContext } from "./HiveSqlParser.js";
 import { ConfigPropertiesItemContext } from "./HiveSqlParser.js";
 import { ResourcePlanDdlStatementsContext } from "./HiveSqlParser.js";
 import { MappingTypesContext } from "./HiveSqlParser.js";
@@ -2373,6 +2375,18 @@ export declare class HiveSqlParserVisitor<Result> extends AbstractParseTreeVisit
      * @return the visitor result
      */
     visitSql11ReservedKeywordsUsedAsFunctionName?: (ctx: Sql11ReservedKeywordsUsedAsFunctionNameContext) => Result;
+    /**
+     * Visit a parse tree produced by `HiveSqlParser.configProperty`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitConfigProperty?: (ctx: ConfigPropertyContext) => Result;
+    /**
+     * Visit a parse tree produced by `HiveSqlParser.configPropertyPart`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitConfigPropertyPart?: (ctx: ConfigPropertyPartContext) => Result;
     /**
      * Visit a parse tree produced by `HiveSqlParser.configPropertiesItem`.
      * @param ctx the parse tree

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

@@ -7,7 +7,7 @@ import { ErrorListener, ParseError } from './parseErrorListener';
 import SemanticContextCollector from './semanticContextCollector';
 import type { SplitListener } from './splitListener';
 import { TextSlice } from './textAndWord';
-import { CaretPosition, LOCALE_TYPE, SemanticCollectOptions, Suggestions } from './types';
+import { CaretPosition, LOCALE_TYPE, SemanticCollectOptions, SuggestionOptions, Suggestions } from './types';
 export declare const SQL_SPLIT_SYMBOL_TEXT = ";";
 /**
  * Basic SQL class, every sql needs extends it.
@@ -21,6 +21,7 @@ export declare abstract class BasicSQL<L extends Lexer = Lexer, PRC extends Pars
     protected _parseTree: PRC | null;
     protected _parsedInput: string;
     protected _parseErrors: ParseError[];
+    private _statementStartTokenTypes;
     /** members for cache end */
     private _errorListener;
     /**
@@ -44,6 +45,7 @@ export declare abstract class BasicSQL<L extends Lexer = Lexer, PRC extends Pars
      * @param caretTokenIndex tokenIndex of caretPosition
      */
     protected abstract processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number): Suggestions<Token>;
+    protected getCandidateTokenRanges(candidates: CandidatesCollection, candidateStartTokenIndex: number, allTokens: Token[], caretTokenIndex: number): Token[];
     /**
      * Get a new splitListener instance.
      */
@@ -166,13 +168,24 @@ export declare abstract class BasicSQL<L extends Lexer = Lexer, PRC extends Pars
         tokenIndexOffset: number;
         newTokenIndex: number;
     } | null;
+    /**
+     * Get the minimum statement tree for collecting completion candidates
+     * Each supported grammar exposes one top-level statement per direct program child
+     * Keep the lookup shallow to avoid selecting nested statements or subqueries
+     */
+    private getSuggestionParseTree;
+    /**
+     * Collect candidates for the current statement and remove new-statement-only keywords
+     */
+    private collectSuggestionCandidates;
     /**
      * Get suggestions of syntax and token at caretPosition
      * @param input source string
      * @param caretPosition caret position, such as cursor position
+     * @param options suggestion options
      * @returns suggestion
      */
-    getSuggestionAtCaretPosition(input: string, caretPosition: CaretPosition): Suggestions | null;
+    getSuggestionAtCaretPosition(input: string, caretPosition: CaretPosition, options?: SuggestionOptions): Suggestions | null;
     getAllEntities(input: string, caretPosition?: CaretPosition): EntityContext[] | null;
     /**
      * Get semantic context infos

package/dist/parser/common/basicSQL.js

@@ -1,5 +1,5 @@
 import { CodeCompletionCore } from 'antlr4-c3';
-import { CharStreams, CommonTokenStream, ParseTreeWalker, PredictionMode, } from 'antlr4ng';
+import { CharStreams, CommonTokenStream, ParserRuleContext, ParseTreeWalker, PredictionMode, Token, } from 'antlr4ng';
 import { ErrorStrategy } from './errorStrategy';
 import { findCaretTokenIndex } from './findCaretTokenIndex';
 import { ctxToText, tokenToWord } from './textAndWord';
@@ -10,12 +10,56 @@ export const SQL_SPLIT_SYMBOL_TEXT = ';';
 export class BasicSQL {
     constructor() {
         this._parseErrors = [];
+        this._statementStartTokenTypes = null;
         /** members for cache end */
         this._errorListener = (error) => {
             this._parseErrors.push(error);
         };
         this.locale = 'en_US';
     }
+    getCandidateTokenRanges(candidates, candidateStartTokenIndex, allTokens, caretTokenIndex) {
+        var _a;
+        // antlr4-c3 may return both entity and alias candidates; use the nearest candidate's start index as boundary
+        const endTokenIndex = Array.from(candidates.rules.values()).reduce((nearestStartTokenIndex, candidateRule) => {
+            if (candidateRule.startTokenIndex <= candidateStartTokenIndex) {
+                return nearestStartTokenIndex;
+            }
+            return Math.min(nearestStartTokenIndex, candidateRule.startTokenIndex);
+        }, caretTokenIndex + 1);
+        const previousVisibleToken = allTokens
+            .slice(candidateStartTokenIndex, endTokenIndex)
+            .reverse()
+            .find((token) => token.channel === Token.DEFAULT_CHANNEL);
+        const visibleTokenIndexes = allTokens
+            .slice(endTokenIndex, caretTokenIndex + 1)
+            .reduce((indexes, token, offset) => {
+            if (token.channel === Token.DEFAULT_CHANNEL) {
+                indexes.push(endTokenIndex + offset);
+            }
+            return indexes;
+        }, []);
+        const firstVisibleToken = allTokens[visibleTokenIndexes[0]];
+        let rangeEndTokenIndex = endTokenIndex;
+        // candidate boundary may fall inside a multi-level qualified name; extend along the identifier and dot chain
+        if ((previousVisibleToken === null || previousVisibleToken === void 0 ? void 0 : previousVisibleToken.text) === '.' || (firstVisibleToken === null || firstVisibleToken === void 0 ? void 0 : firstVisibleToken.text) === '.') {
+            let visibleTokenOffset = 0;
+            if ((previousVisibleToken === null || previousVisibleToken === void 0 ? void 0 : previousVisibleToken.text) === '.' && firstVisibleToken) {
+                rangeEndTokenIndex = visibleTokenIndexes[visibleTokenOffset] + 1;
+                visibleTokenOffset += 1;
+            }
+            while (((_a = allTokens[visibleTokenIndexes[visibleTokenOffset]]) === null || _a === void 0 ? void 0 : _a.text) === '.') {
+                rangeEndTokenIndex = visibleTokenIndexes[visibleTokenOffset] + 1;
+                visibleTokenOffset += 1;
+                if (visibleTokenOffset < visibleTokenIndexes.length) {
+                    rangeEndTokenIndex = visibleTokenIndexes[visibleTokenOffset] + 1;
+                    visibleTokenOffset += 1;
+                }
+            }
+        }
+        return allTokens
+            .slice(candidateStartTokenIndex, rangeEndTokenIndex)
+            .filter((token) => token.channel === Token.DEFAULT_CHANNEL);
+    }
     /**
      * Create an antlr4 lexer from input.
      * @param input string
@@ -384,13 +428,77 @@ export class BasicSQL {
             newTokenIndex: caretTokenIndex,
         };
     }
+    /**
+     * Get the minimum statement tree for collecting completion candidates
+     * Each supported grammar exposes one top-level statement per direct program child
+     * Keep the lookup shallow to avoid selecting nested statements or subqueries
+     */
+    getSuggestionParseTree(parseTree, caretTokenIndex) {
+        var _a, _b, _c;
+        const children = parseTree.children;
+        if (!(children === null || children === void 0 ? void 0 : children.length))
+            return parseTree;
+        for (let index = children.length - 1; index >= 0; index--) {
+            const child = children[index];
+            if (!(child instanceof ParserRuleContext))
+                continue;
+            const startTokenIndex = (_a = child.start) === null || _a === void 0 ? void 0 : _a.tokenIndex;
+            const stopTokenIndex = (_b = child.stop) === null || _b === void 0 ? void 0 : _b.tokenIndex;
+            if (startTokenIndex === undefined ||
+                stopTokenIndex === undefined ||
+                startTokenIndex > caretTokenIndex)
+                continue;
+            // Use the current statement tree when the caret is inside it
+            if (stopTokenIndex >= caretTokenIndex)
+                return child;
+            // Keep using the current statement until it ends with a semicolon
+            return ((_c = child.stop) === null || _c === void 0 ? void 0 : _c.text) === SQL_SPLIT_SYMBOL_TEXT ? parseTree : child;
+        }
+        return parseTree;
+    }
+    /**
+     * Collect candidates for the current statement and remove new-statement-only keywords
+     */
+    collectSuggestionCandidates(parser, parseTree, caretTokenIndex) {
+        const core = new CodeCompletionCore(parser);
+        core.preferredRules = this.preferredRules;
+        const candidates = core.collectCandidates(caretTokenIndex, parseTree);
+        const suggestionParseTree = this.getSuggestionParseTree(parseTree, caretTokenIndex);
+        if (suggestionParseTree === parseTree)
+            return candidates;
+        // Keep the program candidates for outer rule paths and use statement candidates for isolation
+        const statementCore = new CodeCompletionCore(parser);
+        statementCore.preferredRules = this.preferredRules;
+        const statementCandidates = statementCore.collectCandidates(caretTokenIndex, suggestionParseTree);
+        if (this._statementStartTokenTypes === null) {
+            const statementStartCore = new CodeCompletionCore(parser);
+            statementStartCore.preferredRules = this.preferredRules;
+            const statementStartCandidates = statementStartCore.collectCandidates(0, parseTree);
+            this._statementStartTokenTypes = new Set(statementStartCandidates.tokens.keys());
+        }
+        const tokens = new Map(candidates.tokens);
+        for (const tokenType of this._statementStartTokenTypes) {
+            if (!statementCandidates.tokens.has(tokenType)) {
+                tokens.delete(tokenType);
+            }
+            else if (tokens.has(tokenType)) {
+                // Use the current statement follow-list to preserve valid combined keywords
+                tokens.set(tokenType, statementCandidates.tokens.get(tokenType));
+            }
+        }
+        return {
+            rules: candidates.rules,
+            tokens,
+        };
+    }
     /**
      * Get suggestions of syntax and token at caretPosition
      * @param input source string
      * @param caretPosition caret position, such as cursor position
+     * @param options suggestion options
      * @returns suggestion
      */
-    getSuggestionAtCaretPosition(input, caretPosition) {
+    getSuggestionAtCaretPosition(input, caretPosition, options) {
         this.parseWithCache(input);
         if (!this._parseTree)
             return null;
@@ -428,11 +536,7 @@ export class BasicSQL {
             sqlParserIns = this.createParser(inputSlice);
             parseTree = sqlParserIns.program();
         }
-        const core = new CodeCompletionCore(sqlParserIns);
-        core.preferredRules = this.preferredRules;
-        // core.showRuleStack = true;
-        // core.showResult = true;
-        const candidates = core.collectCandidates(caretTokenIndex, parseTree);
+        const candidates = this.collectSuggestionCandidates(sqlParserIns, parseTree, caretTokenIndex);
         const originalSuggestions = this.processCandidates(candidates, allTokens, caretTokenIndex);
         const syntaxSuggestions = originalSuggestions.syntax.map((syntaxCtx) => {
             const wordRanges = syntaxCtx.wordRanges.map((token) => {
@@ -443,9 +547,13 @@ export class BasicSQL {
                 wordRanges,
             };
         });
+        const keywordFilter = options === null || options === void 0 ? void 0 : options.keywordFilter;
+        const keywords = keywordFilter
+            ? originalSuggestions.keywords.filter((keyword) => keywordFilter(keyword))
+            : originalSuggestions.keywords;
         return {
             syntax: syntaxSuggestions,
-            keywords: originalSuggestions.keywords,
+            keywords,
         };
     }
     getAllEntities(input, caretPosition) {

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

@@ -69,6 +69,15 @@ export interface Suggestions<T = WordRange> {
      */
     readonly keywords: string[];
 }
+/**
+ * Suggested information options
+ */
+export interface SuggestionOptions {
+    /**
+     * Return true to keep the keyword, otherwise remove it
+     */
+    keywordFilter?: (keyword: string) => boolean;
+}
 export type LOCALE_TYPE = 'zh_CN' | 'en_US';
 export interface SemanticContext {
     isStatementBeginning: boolean;

package/dist/parser/flink/index.js

@@ -67,7 +67,7 @@ export class FlinkSQL extends BasicSQL {
         const keywords = [];
         for (let candidate of candidates.rules) {
             const [ruleType, candidateRule] = candidate;
-            const tokenRanges = allTokens.slice(candidateRule.startTokenIndex, caretTokenIndex + 1);
+            const tokenRanges = this.getCandidateTokenRanges(candidates, candidateRule.startTokenIndex, allTokens, caretTokenIndex);
             let syntaxContextType = void 0;
             switch (ruleType) {
                 case FlinkSqlParser.RULE_catalogPath: {

package/dist/parser/generic/index.js

@@ -53,7 +53,7 @@ export class GenericSQL extends BasicSQL {
         const keywords = [];
         for (const candidate of candidates.rules) {
             const [ruleType, candidateRule] = candidate;
-            const tokenRanges = allTokens.slice(candidateRule.startTokenIndex, caretTokenIndex + 1);
+            const tokenRanges = this.getCandidateTokenRanges(candidates, candidateRule.startTokenIndex, allTokens, caretTokenIndex);
             let syntaxContextType = void 0;
             switch (ruleType) {
                 case GenericSqlParser.RULE_tableName: {

package/dist/parser/hive/index.js

@@ -55,7 +55,7 @@ export class HiveSQL extends BasicSQL {
         const keywords = [];
         for (let candidate of candidates.rules) {
             const [ruleType, candidateRule] = candidate;
-            const tokenRanges = allTokens.slice(candidateRule.startTokenIndex, caretTokenIndex + 1);
+            const tokenRanges = this.getCandidateTokenRanges(candidates, candidateRule.startTokenIndex, allTokens, caretTokenIndex);
             let syntaxContextType = void 0;
             switch (ruleType) {
                 case HiveSqlParser.RULE_dbSchemaName: {

package/dist/parser/impala/index.js

@@ -54,7 +54,7 @@ export class ImpalaSQL extends BasicSQL {
         const keywords = [];
         for (let candidate of candidates.rules) {
             const [ruleType, candidateRule] = candidate;
-            const tokenRanges = allTokens.slice(candidateRule.startTokenIndex, caretTokenIndex + 1);
+            const tokenRanges = this.getCandidateTokenRanges(candidates, candidateRule.startTokenIndex, allTokens, caretTokenIndex);
             let syntaxContextType = void 0;
             switch (ruleType) {
                 case ImpalaSqlParser.RULE_functionNameCreate: {

package/dist/parser/mysql/index.js

@@ -62,7 +62,7 @@ export class MySQL extends BasicSQL {
         const keywords = [];
         for (const candidate of candidates.rules) {
             const [ruleType, candidateRule] = candidate;
-            const tokenRanges = allTokens.slice(candidateRule.startTokenIndex, caretTokenIndex + 1);
+            const tokenRanges = this.getCandidateTokenRanges(candidates, candidateRule.startTokenIndex, allTokens, caretTokenIndex);
             let syntaxContextType = void 0;
             switch (ruleType) {
                 case MySqlParser.RULE_databaseName: {

package/dist/parser/postgresql/index.js

@@ -64,7 +64,7 @@ export class PostgreSQL extends BasicSQL {
         const keywords = [];
         for (let candidate of candidates.rules) {
             const [ruleType, candidateRule] = candidate;
-            const tokenRanges = allTokens.slice(candidateRule.startTokenIndex, caretTokenIndex + 1);
+            const tokenRanges = this.getCandidateTokenRanges(candidates, candidateRule.startTokenIndex, allTokens, caretTokenIndex);
             let syntaxContextType = void 0;
             switch (ruleType) {
                 case PostgreSqlParser.RULE_tableNameCreate: {

package/dist/parser/spark/index.js

@@ -59,7 +59,7 @@ export class SparkSQL extends BasicSQL {
         const keywords = [];
         for (const candidate of candidates.rules) {
             const [ruleType, candidateRule] = candidate;
-            const tokenRanges = allTokens.slice(candidateRule.startTokenIndex, caretTokenIndex + 1);
+            const tokenRanges = this.getCandidateTokenRanges(candidates, candidateRule.startTokenIndex, allTokens, caretTokenIndex);
             let syntaxContextType = void 0;
             switch (ruleType) {
                 case SparkSqlParser.RULE_namespaceName: {

package/dist/parser/trino/index.js

@@ -56,7 +56,7 @@ export class TrinoSQL extends BasicSQL {
         const keywords = [];
         for (let candidate of candidates.rules) {
             const [ruleType, candidateRule] = candidate;
-            const tokenRanges = allTokens.slice(candidateRule.startTokenIndex, caretTokenIndex + 1);
+            const tokenRanges = this.getCandidateTokenRanges(candidates, candidateRule.startTokenIndex, allTokens, caretTokenIndex);
             let syntaxContextType = void 0;
             switch (ruleType) {
                 case TrinoSqlParser.RULE_catalogRef: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dt-sql-parser",
-  "version": "4.5.1-beta.2",
+  "version": "4.5.1",
   "authors": "DTStack Corporation",
   "description": "SQL Parsers for BigData, built with antlr4",
   "keywords": [