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

package/dist/parser/spark/sparkErrorListener.js

@@ -2,8 +2,8 @@ import { CodeCompletionCore } from 'antlr4-c3';
 import { ParseErrorListener } from '../common/parseErrorListener';
 import { SparkSqlParser } from '../../lib/spark/SparkSqlParser';
 export class SparkErrorListener extends ParseErrorListener {
-    constructor(errorListener, preferredRules, locale) {
-        super(errorListener, locale);
+    constructor() {
+        super(...arguments);
         this.objectNames = new Map([
             [SparkSqlParser.RULE_namespaceName, 'namespace'],
             [SparkSqlParser.RULE_namespaceNameCreate, 'namespace'],
@@ -16,18 +16,27 @@ export class SparkErrorListener extends ParseErrorListener {
             [SparkSqlParser.RULE_columnName, 'column'],
             [SparkSqlParser.RULE_columnNameCreate, 'column'],
         ]);
-        this.preferredRules = preferredRules;
     }
     getExpectedText(parser, token) {
         var _a;
         let expectedText = '';
+        const input = this.parserContext.getParsedInput();
+        /**
+         * Get the program context.
+         * When called error listener, `this._parseTree` is still `undefined`,
+         * so we can't use cached parseTree in `getMinimumParserInfo`
+         */
         let currentContext = (_a = parser.context) !== null && _a !== void 0 ? _a : undefined;
         while (currentContext === null || currentContext === void 0 ? void 0 : currentContext.parent) {
             currentContext = currentContext.parent;
         }
-        const core = new CodeCompletionCore(parser);
+        const parserInfo = this.parserContext.getMinimumParserInfo(input, token.tokenIndex, currentContext);
+        if (!parserInfo)
+            return '';
+        const { parser: c3Parser, newTokenIndex, parseTree: c3Context } = parserInfo;
+        const core = new CodeCompletionCore(c3Parser);
         core.preferredRules = this.preferredRules;
-        const candidates = core.collectCandidates(token.tokenIndex, currentContext);
+        const candidates = core.collectCandidates(newTokenIndex, c3Context);
         if (candidates.rules.size) {
             const result = [];
             // get expectedText as collect rules first

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

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

package/dist/parser/spark/sparkSemanticContextCollector.js

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

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

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

package/dist/parser/trino/index.js

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

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

@@ -1,9 +1,6 @@
 import { Parser, Token } from 'antlr4ng';
-import { ErrorListener, ParseErrorListener } from '../common/parseErrorListener';
-import { LOCALE_TYPE } from '../common/types';
+import { ParseErrorListener } from '../common/parseErrorListener';
 export declare class TrinoErrorListener extends ParseErrorListener {
-    private preferredRules;
     private objectNames;
-    constructor(errorListener: ErrorListener, preferredRules: Set<number>, locale: LOCALE_TYPE);
     getExpectedText(parser: Parser, token: Token): string;
 }

package/dist/parser/trino/trinoErrorListener.js

@@ -2,8 +2,8 @@ import { CodeCompletionCore } from 'antlr4-c3';
 import { TrinoSqlParser } from '../../lib/trino/TrinoSqlParser';
 import { ParseErrorListener } from '../common/parseErrorListener';
 export class TrinoErrorListener extends ParseErrorListener {
-    constructor(errorListener, preferredRules, locale) {
-        super(errorListener, locale);
+    constructor() {
+        super(...arguments);
         this.objectNames = new Map([
             [TrinoSqlParser.RULE_catalogRef, 'catalog'],
             [TrinoSqlParser.RULE_catalogNameCreate, 'catalog'],
@@ -17,18 +17,27 @@ export class TrinoErrorListener extends ParseErrorListener {
             [TrinoSqlParser.RULE_columnRef, 'column'],
             [TrinoSqlParser.RULE_columnNameCreate, 'column'],
         ]);
-        this.preferredRules = preferredRules;
     }
     getExpectedText(parser, token) {
         var _a;
         let expectedText = '';
+        const input = this.parserContext.getParsedInput();
+        /**
+         * Get the program context.
+         * When called error listener, `this._parseTree` is still `undefined`,
+         * so we can't use cached parseTree in `getMinimumParserInfo`
+         */
         let currentContext = (_a = parser.context) !== null && _a !== void 0 ? _a : undefined;
         while (currentContext === null || currentContext === void 0 ? void 0 : currentContext.parent) {
             currentContext = currentContext.parent;
         }
-        const core = new CodeCompletionCore(parser);
+        const parserInfo = this.parserContext.getMinimumParserInfo(input, token.tokenIndex, currentContext);
+        if (!parserInfo)
+            return '';
+        const { parser: c3Parser, newTokenIndex, parseTree: c3Context } = parserInfo;
+        const core = new CodeCompletionCore(c3Parser);
         core.preferredRules = this.preferredRules;
-        const candidates = core.collectCandidates(token.tokenIndex, currentContext);
+        const candidates = core.collectCandidates(newTokenIndex, c3Context);
         if (candidates.rules.size) {
             const result = [];
             // get expectedText as collect rules first

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

@@ -0,0 +1,9 @@
+import { TrinoSqlListener } from '../../lib';
+import { StatementsContext } from '../../lib/trino/TrinoSqlParser';
+import SemanticContextCollector from '../common/semanticContextCollector';
+declare class TrinoSemanticContextCollector extends SemanticContextCollector implements TrinoSqlListener {
+    getWhiteSpaceRuleType(): number;
+    getStatementRuleType(): number;
+    enterStatements(ctx: StatementsContext): void;
+}
+export { TrinoSemanticContextCollector };

package/dist/parser/trino/trinoSemanticContextCollector.js

@@ -0,0 +1,14 @@
+import { TrinoSqlParser } from '../../lib/trino/TrinoSqlParser';
+import SemanticContextCollector from '../common/semanticContextCollector';
+class TrinoSemanticContextCollector extends SemanticContextCollector {
+    getWhiteSpaceRuleType() {
+        return TrinoSqlParser.WS;
+    }
+    getStatementRuleType() {
+        return TrinoSqlParser.RULE_statements;
+    }
+    enterStatements(ctx) {
+        this.visitStatement(ctx);
+    }
+}
+export { TrinoSemanticContextCollector };

package/package.json

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