dt-sql-parser 4.3.2-beta.0 → 4.4.0-beta.0

package/dist/lib/flink/FlinkSqlParserListener.d.ts

@@ -77,6 +77,7 @@ import { InsertSimpleStatementContext } from "./FlinkSqlParser.js";
 import { InsertPartitionDefinitionContext } from "./FlinkSqlParser.js";
 import { ValuesDefinitionContext } from "./FlinkSqlParser.js";
 import { ValuesRowDefinitionContext } from "./FlinkSqlParser.js";
+import { ValueDefinitionContext } from "./FlinkSqlParser.js";
 import { InsertMulStatementCompatibilityContext } from "./FlinkSqlParser.js";
 import { InsertMulStatementContext } from "./FlinkSqlParser.js";
 import { QueryStatementContext } from "./FlinkSqlParser.js";
@@ -1005,6 +1006,16 @@ export declare class FlinkSqlParserListener implements ParseTreeListener {
      * @param ctx the parse tree
      */
     exitValuesRowDefinition?: (ctx: ValuesRowDefinitionContext) => void;
+    /**
+     * Enter a parse tree produced by `FlinkSqlParser.valueDefinition`.
+     * @param ctx the parse tree
+     */
+    enterValueDefinition?: (ctx: ValueDefinitionContext) => void;
+    /**
+     * Exit a parse tree produced by `FlinkSqlParser.valueDefinition`.
+     * @param ctx the parse tree
+     */
+    exitValueDefinition?: (ctx: ValueDefinitionContext) => void;
     /**
      * Enter a parse tree produced by `FlinkSqlParser.insertMulStatementCompatibility`.
      * @param ctx the parse tree

package/dist/lib/flink/FlinkSqlParserVisitor.d.ts

@@ -77,6 +77,7 @@ import { InsertSimpleStatementContext } from "./FlinkSqlParser.js";
 import { InsertPartitionDefinitionContext } from "./FlinkSqlParser.js";
 import { ValuesDefinitionContext } from "./FlinkSqlParser.js";
 import { ValuesRowDefinitionContext } from "./FlinkSqlParser.js";
+import { ValueDefinitionContext } from "./FlinkSqlParser.js";
 import { InsertMulStatementCompatibilityContext } from "./FlinkSqlParser.js";
 import { InsertMulStatementContext } from "./FlinkSqlParser.js";
 import { QueryStatementContext } from "./FlinkSqlParser.js";
@@ -694,6 +695,12 @@ export declare class FlinkSqlParserVisitor<Result> extends AbstractParseTreeVisi
      * @return the visitor result
      */
     visitValuesRowDefinition?: (ctx: ValuesRowDefinitionContext) => Result;
+    /**
+     * Visit a parse tree produced by `FlinkSqlParser.valueDefinition`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitValueDefinition?: (ctx: ValueDefinitionContext) => Result;
     /**
      * Visit a parse tree produced by `FlinkSqlParser.insertMulStatementCompatibility`.
      * @param ctx the parse tree

package/dist/parser/common/basicSQL.js

@@ -36,6 +36,7 @@ export class BasicSQL {
     createParser(input, errorListener) {
         const lexer = this.createLexer(input, errorListener);
         const tokenStream = new CommonTokenStream(lexer);
+        tokenStream.fill();
         const parser = this.createParserFromTokenStream(tokenStream);
         parser.interpreter.predictionMode = PredictionMode.SLL;
         if (errorListener) {
@@ -375,23 +376,24 @@ export class BasicSQL {
         };
     }
     getAllEntities(input, caretPosition) {
-        const allTokens = this.getAllTokens(input);
+        /**
+         * Create a new parser to generate brand new parse tree.
+         * And the new parse tree should not effect cached parse tree which is used by validate and getSuggestionAtCaretPosition method.
+         */
+        const parser = this.createParser(input);
+        const allTokens = parser.tokenStream.getTokens();
         const caretTokenIndex = caretPosition
             ? findCaretTokenIndex(caretPosition, allTokens)
             : void 0;
         const collectListener = this.createEntityCollector(input, allTokens, caretTokenIndex);
-        // const parser = this.createParserWithCache(input);
-        // parser.entityCollecting = true;
-        // if(caretPosition) {
-        //     const allTokens = this.getAllTokens(input);
-        //     const tokenIndex = findCaretTokenIndex(caretPosition, allTokens);
-        //     parser.caretTokenIndex = tokenIndex;
-        // }
-        // const parseTree = parser.program();
-        const parseTree = this.parseWithCache(input);
+        parser.entityCollecting = true;
+        if (caretPosition && caretTokenIndex !== undefined) {
+            parser.caretTokenIndex = caretTokenIndex;
+        }
+        const parseTree = parser.program();
         this.listen(collectListener, parseTree);
-        // parser.caretTokenIndex = -1;
-        // parser.entityCollecting = false;
+        parser.caretTokenIndex = -1;
+        parser.entityCollecting = false;
         return collectListener.getEntities();
     }
     /**

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

@@ -13,6 +13,10 @@ export { FlinkEntityCollector, FlinkSqlSplitListener };
 export declare class FlinkSQL extends BasicSQL<FlinkSqlLexer, ProgramContext, FlinkSqlParser> {
     protected createLexerFromCharStream(charStreams: CharStream): FlinkSqlLexer;
     protected createParserFromTokenStream(tokenStream: CommonTokenStream): FlinkSqlParser;
+    /**
+     * The rules that keywords you don't want to be suggested.
+     */
+    protected excludeKeywordRules: Set<number>;
     protected preferredRules: Set<number>;
     protected get splitListener(): FlinkSqlSplitListener;
     protected createErrorListener(_errorListener: ErrorListener): FlinkErrorListener;

package/dist/parser/flink/index.js

@@ -11,6 +11,16 @@ export { FlinkEntityCollector, FlinkSqlSplitListener };
 export class FlinkSQL extends BasicSQL {
     constructor() {
         super(...arguments);
+        /**
+         * The rules that keywords you don't want to be suggested.
+         */
+        this.excludeKeywordRules = new Set([
+            FlinkSqlParser.RULE_nonReservedKeywords,
+            FlinkSqlParser.RULE_reservedKeywordsUsedAsFuncName,
+            FlinkSqlParser.RULE_reservedKeywordsFollowParamsUsedAsFuncName,
+            FlinkSqlParser.RULE_reservedKeywordsNoParamsUsedAsFuncName,
+            FlinkSqlParser.RULE_reservedKeywordsUsedAsFuncParam,
+        ]);
         this.preferredRules = new Set([
             FlinkSqlParser.RULE_catalogPath, // catalog name
             FlinkSqlParser.RULE_databasePath, // database name
@@ -29,6 +39,7 @@ export class FlinkSQL extends BasicSQL {
             FlinkSqlParser.RULE_columnNameCreate,
             FlinkSqlParser.RULE_tablePropertyKey,
             FlinkSqlParser.RULE_tablePropertyValue,
+            ...this.excludeKeywordRules,
         ]);
     }
     createLexerFromCharStream(charStreams) {
@@ -127,7 +138,13 @@ export class FlinkSQL extends BasicSQL {
                 default:
                     break;
             }
-            if (syntaxContextType) {
+            if (syntaxContextType &&
+                !originalSyntaxSuggestions.some((syn) => {
+                    var _a, _b;
+                    return syn.syntaxContextType === syntaxContextType &&
+                        ((_a = syn.wordRanges.map((wordRange) => wordRange.text)) === null || _a === void 0 ? void 0 : _a.join(',')) ===
+                            ((_b = tokenRanges.map((tokenRange) => tokenRange.text)) === null || _b === void 0 ? void 0 : _b.join(','));
+                })) {
                 originalSyntaxSuggestions.push({
                     syntaxContextType,
                     wordRanges: tokenRanges,

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

@@ -13,6 +13,10 @@ export { HiveEntityCollector, HiveSqlSplitListener };
 export declare class HiveSQL extends BasicSQL<HiveSqlLexer, ProgramContext, HiveSqlParser> {
     protected createLexerFromCharStream(charStreams: CharStream): HiveSqlLexer;
     protected createParserFromTokenStream(tokenStream: CommonTokenStream): HiveSqlParser;
+    /**
+     * The rules that keywords you don't want to be suggested.
+     */
+    protected excludeKeywordRules: Set<number>;
     protected preferredRules: Set<number>;
     protected get splitListener(): HiveSqlSplitListener;
     protected createErrorListener(_errorListener: ErrorListener): HiveErrorListener;

package/dist/parser/hive/index.js

@@ -11,6 +11,10 @@ export { HiveEntityCollector, HiveSqlSplitListener };
 export class HiveSQL extends BasicSQL {
     constructor() {
         super(...arguments);
+        /**
+         * The rules that keywords you don't want to be suggested.
+         */
+        this.excludeKeywordRules = new Set([HiveSqlParser.RULE_nonReserved]);
         this.preferredRules = new Set([
             HiveSqlParser.RULE_dbSchemaName, // db or schema name
             HiveSqlParser.RULE_dbSchemaNameCreate, // db or schema name that will be created
@@ -24,6 +28,7 @@ export class HiveSQL extends BasicSQL {
             HiveSqlParser.RULE_columnName,
             HiveSqlParser.RULE_columnNamePath,
             HiveSqlParser.RULE_columnNameCreate,
+            ...this.excludeKeywordRules,
         ]);
     }
     createLexerFromCharStream(charStreams) {
@@ -115,7 +120,13 @@ export class HiveSQL extends BasicSQL {
                 default:
                     break;
             }
-            if (syntaxContextType) {
+            if (syntaxContextType &&
+                !originalSyntaxSuggestions.some((syn) => {
+                    var _a, _b;
+                    return syn.syntaxContextType === syntaxContextType &&
+                        ((_a = syn.wordRanges.map((wordRange) => wordRange.text)) === null || _a === void 0 ? void 0 : _a.join(',')) ===
+                            ((_b = tokenRanges.map((tokenRange) => tokenRange.text)) === null || _b === void 0 ? void 0 : _b.join(','));
+                })) {
                 originalSyntaxSuggestions.push({
                     syntaxContextType,
                     wordRanges: tokenRanges,

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

@@ -13,6 +13,10 @@ export { ImpalaEntityCollector, ImpalaSqlSplitListener };
 export declare class ImpalaSQL extends BasicSQL<ImpalaSqlLexer, ProgramContext, ImpalaSqlParser> {
     protected createLexerFromCharStream(charStreams: CharStream): ImpalaSqlLexer;
     protected createParserFromTokenStream(tokenStream: CommonTokenStream): ImpalaSqlParser;
+    /**
+     * The rules that keywords you don't want to be suggested.
+     */
+    protected excludeKeywordRules: Set<number>;
     protected preferredRules: Set<number>;
     protected get splitListener(): ImpalaSqlSplitListener;
     protected createErrorListener(_errorListener: ErrorListener): ImpalaErrorListener;

package/dist/parser/impala/index.js

@@ -11,6 +11,10 @@ export { ImpalaEntityCollector, ImpalaSqlSplitListener };
 export class ImpalaSQL extends BasicSQL {
     constructor() {
         super(...arguments);
+        /**
+         * The rules that keywords you don't want to be suggested.
+         */
+        this.excludeKeywordRules = new Set([ImpalaSqlParser.RULE_nonReserved]);
         this.preferredRules = new Set([
             ImpalaSqlParser.RULE_functionNameCreate,
             ImpalaSqlParser.RULE_tableNameCreate,
@@ -23,6 +27,7 @@ export class ImpalaSQL extends BasicSQL {
             ImpalaSqlParser.RULE_databaseNamePath,
             ImpalaSqlParser.RULE_columnNamePath,
             ImpalaSqlParser.RULE_columnName,
+            ...this.excludeKeywordRules,
         ]);
     }
     createLexerFromCharStream(charStreams) {
@@ -104,7 +109,13 @@ export class ImpalaSQL extends BasicSQL {
                 default:
                     break;
             }
-            if (syntaxContextType) {
+            if (syntaxContextType &&
+                !originalSyntaxSuggestions.some((syn) => {
+                    var _a, _b;
+                    return syn.syntaxContextType === syntaxContextType &&
+                        ((_a = syn.wordRanges.map((wordRange) => wordRange.text)) === null || _a === void 0 ? void 0 : _a.join(',')) ===
+                            ((_b = tokenRanges.map((tokenRange) => tokenRange.text)) === null || _b === void 0 ? void 0 : _b.join(','));
+                })) {
                 originalSyntaxSuggestions.push({
                     syntaxContextType,
                     wordRanges: tokenRanges,

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

@@ -13,6 +13,10 @@ export { MySqlEntityCollector, MysqlSplitListener };
 export declare class MySQL extends BasicSQL<MySqlLexer, ProgramContext, MySqlParser> {
     protected createLexerFromCharStream(charStreams: CharStream): MySqlLexer;
     protected createParserFromTokenStream(tokenStream: CommonTokenStream): MySqlParser;
+    /**
+     * The rules that keywords you don't want to be suggested.
+     */
+    protected excludeKeywordRules: Set<number>;
     protected preferredRules: Set<number>;
     protected get splitListener(): MysqlSplitListener;
     protected createErrorListener(_errorListener: ErrorListener): MysqlErrorListener;

package/dist/parser/mysql/index.js

@@ -11,6 +11,10 @@ export { MySqlEntityCollector, MysqlSplitListener };
 export class MySQL extends BasicSQL {
     constructor() {
         super(...arguments);
+        /**
+         * The rules that keywords you don't want to be suggested.
+         */
+        this.excludeKeywordRules = new Set([MySqlParser.RULE_keywordsCanBeId]);
         this.preferredRules = new Set([
             MySqlParser.RULE_databaseName,
             MySqlParser.RULE_databaseNameCreate,
@@ -22,6 +26,7 @@ export class MySQL extends BasicSQL {
             MySqlParser.RULE_functionNameCreate,
             MySqlParser.RULE_columnName,
             MySqlParser.RULE_columnNameCreate,
+            ...this.excludeKeywordRules,
         ]);
     }
     createLexerFromCharStream(charStreams) {
@@ -94,7 +99,13 @@ export class MySQL extends BasicSQL {
                 default:
                     break;
             }
-            if (syntaxContextType) {
+            if (syntaxContextType &&
+                !originalSyntaxSuggestions.some((syn) => {
+                    var _a, _b;
+                    return syn.syntaxContextType === syntaxContextType &&
+                        ((_a = syn.wordRanges.map((wordRange) => wordRange.text)) === null || _a === void 0 ? void 0 : _a.join(',')) ===
+                            ((_b = tokenRanges.map((tokenRange) => tokenRange.text)) === null || _b === void 0 ? void 0 : _b.join(','));
+                })) {
                 originalSyntaxSuggestions.push({
                     syntaxContextType,
                     wordRanges: tokenRanges,

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

@@ -13,6 +13,10 @@ export { PostgreSqlEntityCollector, PostgreSqlSplitListener };
 export declare class PostgreSQL extends BasicSQL<PostgreSqlLexer, ProgramContext, PostgreSqlParser> {
     protected createLexerFromCharStream(charStreams: CharStream): PostgreSqlLexer;
     protected createParserFromTokenStream(tokenStream: CommonTokenStream): PostgreSqlParser;
+    /**
+     * The rules that keywords you don't want to be suggested.
+     */
+    protected excludeKeywordRules: Set<number>;
     protected preferredRules: Set<number>;
     protected get splitListener(): PostgreSqlSplitListener;
     protected createErrorListener(_errorListener: ErrorListener): PostgreSqlErrorListener;

package/dist/parser/postgresql/index.js

@@ -11,6 +11,16 @@ export { PostgreSqlEntityCollector, PostgreSqlSplitListener };
 export class PostgreSQL extends BasicSQL {
     constructor() {
         super(...arguments);
+        /**
+         * The rules that keywords you don't want to be suggested.
+         */
+        this.excludeKeywordRules = new Set([
+            PostgreSqlParser.RULE_nonReservedWord,
+            PostgreSqlParser.RULE_identifier,
+            PostgreSqlParser.RULE_reservedKeyword,
+            PostgreSqlParser.RULE_typeFuncNameKeyword,
+            PostgreSqlParser.RULE_colNameKeyword,
+        ]);
         this.preferredRules = new Set([
             PostgreSqlParser.RULE_tableNameCreate, // table name
             PostgreSqlParser.RULE_tableName, // table name that will be created
@@ -27,6 +37,7 @@ export class PostgreSQL extends BasicSQL {
             PostgreSqlParser.RULE_columnNameCreate, // column name that will be created
             PostgreSqlParser.RULE_columnName, // column name
             PostgreSqlParser.RULE_columnNamePath, // column name
+            ...this.excludeKeywordRules,
         ]);
     }
     createLexerFromCharStream(charStreams) {
@@ -127,7 +138,13 @@ export class PostgreSQL extends BasicSQL {
                 default:
                     break;
             }
-            if (syntaxContextType) {
+            if (syntaxContextType &&
+                !originalSyntaxSuggestions.some((syn) => {
+                    var _a, _b;
+                    return syn.syntaxContextType === syntaxContextType &&
+                        ((_a = syn.wordRanges.map((wordRange) => wordRange.text)) === null || _a === void 0 ? void 0 : _a.join(',')) ===
+                            ((_b = tokenRanges.map((tokenRange) => tokenRange.text)) === null || _b === void 0 ? void 0 : _b.join(','));
+                })) {
                 originalSyntaxSuggestions.push({
                     syntaxContextType,
                     wordRanges: tokenRanges,

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

@@ -13,6 +13,10 @@ export { SparkEntityCollector, SparkSqlSplitListener };
 export declare class SparkSQL extends BasicSQL<SparkSqlLexer, ProgramContext, SparkSqlParser> {
     protected createLexerFromCharStream(charStreams: CharStream): SparkSqlLexer;
     protected createParserFromTokenStream(tokenStream: CommonTokenStream): SparkSqlParser;
+    /**
+     * The rules that keywords you don't want to be suggested.
+     */
+    protected excludeKeywordRules: Set<number>;
     protected preferredRules: Set<number>;
     protected get splitListener(): SparkSqlSplitListener;
     protected createErrorListener(_errorListener: ErrorListener): SparkErrorListener;

package/dist/parser/spark/index.js

@@ -11,6 +11,14 @@ export { SparkEntityCollector, SparkSqlSplitListener };
 export class SparkSQL extends BasicSQL {
     constructor() {
         super(...arguments);
+        /**
+         * The rules that keywords you don't want to be suggested.
+         */
+        this.excludeKeywordRules = new Set([
+            SparkSqlParser.RULE_strictIdentifier,
+            SparkSqlParser.RULE_strictNonReserved,
+            SparkSqlParser.RULE_nonReserved,
+        ]);
         this.preferredRules = new Set([
             SparkSqlParser.RULE_namespaceName,
             SparkSqlParser.RULE_namespaceNameCreate,
@@ -23,6 +31,7 @@ export class SparkSQL extends BasicSQL {
             SparkSqlParser.RULE_columnName,
             SparkSqlParser.RULE_columnNamePath,
             SparkSqlParser.RULE_columnNameCreate,
+            ...this.excludeKeywordRules,
         ]);
     }
     createLexerFromCharStream(charStreams) {
@@ -110,7 +119,13 @@ export class SparkSQL extends BasicSQL {
                 default:
                     break;
             }
-            if (syntaxContextType) {
+            if (syntaxContextType &&
+                !originalSyntaxSuggestions.some((syn) => {
+                    var _a, _b;
+                    return syn.syntaxContextType === syntaxContextType &&
+                        ((_a = syn.wordRanges.map((wordRange) => wordRange.text)) === null || _a === void 0 ? void 0 : _a.join(',')) ===
+                            ((_b = tokenRanges.map((tokenRange) => tokenRange.text)) === null || _b === void 0 ? void 0 : _b.join(','));
+                })) {
                 originalSyntaxSuggestions.push({
                     syntaxContextType,
                     wordRanges: tokenRanges,

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

@@ -17,6 +17,10 @@ export declare class TrinoSQL extends BasicSQL<TrinoSqlLexer, ProgramContext, Tr
     protected createErrorListener(_errorListener: ErrorListener): TrinoErrorListener;
     protected createEntityCollector(input: string, allTokens?: Token[], caretTokenIndex?: number): TrinoEntityCollector;
     protected createSemanticContextCollector(input: string, caretPosition: CaretPosition, allTokens: Token[], options?: SemanticCollectOptions): TrinoSemanticContextCollector;
+    /**
+     * The rules that keywords you don't want to be suggested.
+     */
+    protected excludeKeywordRules: Set<number>;
     protected preferredRules: Set<number>;
     protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number): Suggestions<Token>;
 }

package/dist/parser/trino/index.js

@@ -11,6 +11,10 @@ export { TrinoEntityCollector, TrinoSqlSplitListener };
 export class TrinoSQL extends BasicSQL {
     constructor() {
         super(...arguments);
+        /**
+         * The rules that keywords you don't want to be suggested.
+         */
+        this.excludeKeywordRules = new Set([TrinoSqlParser.RULE_nonReserved]);
         this.preferredRules = new Set([
             TrinoSqlParser.RULE_catalogRef,
             TrinoSqlParser.RULE_catalogNameCreate,
@@ -25,6 +29,7 @@ export class TrinoSQL extends BasicSQL {
             TrinoSqlParser.RULE_columnRef,
             TrinoSqlParser.RULE_columnName,
             TrinoSqlParser.RULE_columnNameCreate,
+            ...this.excludeKeywordRules,
         ]);
     }
     createLexerFromCharStream(charStreams) {
@@ -116,7 +121,13 @@ export class TrinoSQL extends BasicSQL {
                 default:
                     break;
             }
-            if (syntaxContextType) {
+            if (syntaxContextType &&
+                !originalSyntaxSuggestions.some((syn) => {
+                    var _a, _b;
+                    return syn.syntaxContextType === syntaxContextType &&
+                        ((_a = syn.wordRanges.map((wordRange) => wordRange.text)) === null || _a === void 0 ? void 0 : _a.join(',')) ===
+                            ((_b = tokenRanges.map((tokenRange) => tokenRange.text)) === null || _b === void 0 ? void 0 : _b.join(','));
+                })) {
                 originalSyntaxSuggestions.push({
                     syntaxContextType,
                     wordRanges: tokenRanges,

package/package.json

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