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

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() {
@@ -33,11 +34,15 @@ export class FlinkSQL extends BasicSQL {
         return new FlinkSqlSplitListener();
     }
     createErrorListener(_errorListener) {
-        return new FlinkErrorListener(_errorListener, this.preferredRules, this.locale);
+        const parserContext = this;
+        return new FlinkErrorListener(_errorListener, parserContext, this.preferredRules);
     }
     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/hiveErrorListener.d.ts

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

package/dist/parser/hive/hiveErrorListener.js

@@ -2,8 +2,8 @@ import { CodeCompletionCore } from 'antlr4-c3';
 import { ParseErrorListener } from '../common/parseErrorListener';
 import { HiveSqlParser } from '../../lib/hive/HiveSqlParser';
 export class HiveErrorListener extends ParseErrorListener {
-    constructor(errorListener, preferredRules, locale) {
-        super(errorListener, locale);
+    constructor() {
+        super(...arguments);
         this.objectNames = new Map([
             [HiveSqlParser.RULE_dbSchemaName, 'database'],
             [HiveSqlParser.RULE_dbSchemaNameCreate, 'database'],
@@ -17,18 +17,27 @@ export class HiveErrorListener extends ParseErrorListener {
             [HiveSqlParser.RULE_columnName, 'column'],
             [HiveSqlParser.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/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() {
@@ -33,11 +34,15 @@ export class HiveSQL extends BasicSQL {
         return new HiveSqlSplitListener();
     }
     createErrorListener(_errorListener) {
-        return new HiveErrorListener(_errorListener, this.preferredRules, this.locale);
+        const parserContext = this;
+        return new HiveErrorListener(_errorListener, parserContext, this.preferredRules);
     }
     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/ImpalaErrorListener.d.ts

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

package/dist/parser/impala/ImpalaErrorListener.js

@@ -2,8 +2,8 @@ import { CodeCompletionCore } from 'antlr4-c3';
 import { ParseErrorListener } from '../common/parseErrorListener';
 import { ImpalaSqlParser } from '../../lib/impala/ImpalaSqlParser';
 export class ImpalaErrorListener extends ParseErrorListener {
-    constructor(errorListener, preferredRules, locale) {
-        super(errorListener, locale);
+    constructor() {
+        super(...arguments);
         this.objectNames = new Map([
             [ImpalaSqlParser.RULE_databaseNamePath, 'database'],
             [ImpalaSqlParser.RULE_databaseNameCreate, 'database'],
@@ -16,18 +16,27 @@ export class ImpalaErrorListener extends ParseErrorListener {
             [ImpalaSqlParser.RULE_columnNamePath, 'column'],
             [ImpalaSqlParser.RULE_columnNamePathCreate, '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/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() {
@@ -32,11 +33,15 @@ export class ImpalaSQL extends BasicSQL {
         return new ImpalaSqlSplitListener();
     }
     createErrorListener(_errorListener) {
-        return new ImpalaErrorListener(_errorListener, this.preferredRules, this.locale);
+        const parserContext = this;
+        return new ImpalaErrorListener(_errorListener, parserContext, this.preferredRules);
     }
     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() {
@@ -32,11 +33,15 @@ export class MySQL extends BasicSQL {
         return new MysqlSplitListener();
     }
     createErrorListener(_errorListener) {
-        return new MysqlErrorListener(_errorListener, this.preferredRules, this.locale);
+        const parserContext = this;
+        return new MysqlErrorListener(_errorListener, parserContext, this.preferredRules);
     }
     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/mysqlErrorListener.d.ts

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

package/dist/parser/mysql/mysqlErrorListener.js

@@ -2,8 +2,8 @@ import { CodeCompletionCore } from 'antlr4-c3';
 import { ParseErrorListener } from '../common/parseErrorListener';
 import { MySqlParser } from '../../lib/mysql/MySqlParser';
 export class MysqlErrorListener extends ParseErrorListener {
-    constructor(errorListener, preferredRules, locale) {
-        super(errorListener, locale);
+    constructor() {
+        super(...arguments);
         this.objectNames = new Map([
             [MySqlParser.RULE_databaseName, 'database'],
             [MySqlParser.RULE_databaseNameCreate, 'database'],
@@ -16,18 +16,27 @@ export class MysqlErrorListener extends ParseErrorListener {
             [MySqlParser.RULE_columnName, 'column'],
             [MySqlParser.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/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 };

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

@@ -2,12 +2,13 @@ import { CandidatesCollection } from 'antlr4-c3';
 import { CharStream, CommonTokenStream, Token } from 'antlr4ng';
 import { PostgreSqlLexer } from '../../lib/postgresql/PostgreSqlLexer';
 import { PostgreSqlParser, ProgramContext } from '../../lib/postgresql/PostgreSqlParser';
-import { Suggestions } from '../common/types';
+import { CaretPosition, SemanticCollectOptions, Suggestions } from '../common/types';
 import { BasicSQL } from '../common/basicSQL';
 import { PostgreSqlEntityCollector } from './postgreEntityCollector';
 import { PostgreSqlSplitListener } from './postgreSplitListener';
 import { ErrorListener } from '../common/parseErrorListener';
 import { PostgreSqlErrorListener } from './postgreErrorListener';
+import { PostgreSemanticContextCollector } from './postgreSemanticContextCollector';
 export { PostgreSqlEntityCollector, PostgreSqlSplitListener };
 export declare class PostgreSQL extends BasicSQL<PostgreSqlLexer, ProgramContext, PostgreSqlParser> {
     protected createLexerFromCharStream(charStreams: CharStream): PostgreSqlLexer;
@@ -16,5 +17,6 @@ export declare class PostgreSQL extends BasicSQL<PostgreSqlLexer, ProgramContext
     protected get splitListener(): PostgreSqlSplitListener;
     protected createErrorListener(_errorListener: ErrorListener): PostgreSqlErrorListener;
     protected createEntityCollector(input: string, caretTokenIndex?: number): PostgreSqlEntityCollector;
+    protected createSemanticContextCollector(input: string, caretPosition: CaretPosition, allTokens: Token[], options?: SemanticCollectOptions): PostgreSemanticContextCollector;
     protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number, tokenIndexOffset: number): Suggestions<Token>;
 }

package/dist/parser/postgresql/index.js

@@ -1,10 +1,11 @@
 import { PostgreSqlLexer } from '../../lib/postgresql/PostgreSqlLexer';
 import { PostgreSqlParser } from '../../lib/postgresql/PostgreSqlParser';
-import { EntityContextType } from '../common/types';
+import { EntityContextType, } from '../common/types';
 import { BasicSQL } from '../common/basicSQL';
 import { PostgreSqlEntityCollector } from './postgreEntityCollector';
 import { PostgreSqlSplitListener } from './postgreSplitListener';
 import { PostgreSqlErrorListener } from './postgreErrorListener';
+import { PostgreSemanticContextCollector } from './postgreSemanticContextCollector';
 export { PostgreSqlEntityCollector, PostgreSqlSplitListener };
 export class PostgreSQL extends BasicSQL {
     constructor() {
@@ -36,11 +37,15 @@ export class PostgreSQL extends BasicSQL {
         return new PostgreSqlSplitListener();
     }
     createErrorListener(_errorListener) {
-        return new PostgreSqlErrorListener(_errorListener, this.preferredRules, this.locale);
+        const parserContext = this;
+        return new PostgreSqlErrorListener(_errorListener, parserContext, this.preferredRules);
     }
     createEntityCollector(input, caretTokenIndex) {
         return new PostgreSqlEntityCollector(input, caretTokenIndex);
     }
+    createSemanticContextCollector(input, caretPosition, allTokens, options) {
+        return new PostgreSemanticContextCollector(input, caretPosition, allTokens, options);
+    }
     processCandidates(candidates, allTokens, caretTokenIndex, tokenIndexOffset) {
         const originalSyntaxSuggestions = [];
         const keywords = [];

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

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

package/dist/parser/postgresql/postgreErrorListener.js

@@ -2,8 +2,8 @@ import { CodeCompletionCore } from 'antlr4-c3';
 import { ParseErrorListener } from '../common/parseErrorListener';
 import { PostgreSqlParser } from '../../lib/postgresql/PostgreSqlParser';
 export class PostgreSqlErrorListener extends ParseErrorListener {
-    constructor(errorListener, preferredRules, locale) {
-        super(errorListener, locale);
+    constructor() {
+        super(...arguments);
         this.objectNames = new Map([
             [PostgreSqlParser.RULE_database_name, 'database'],
             [PostgreSqlParser.RULE_database_name_create, 'database'],
@@ -20,18 +20,27 @@ export class PostgreSqlErrorListener extends ParseErrorListener {
             [PostgreSqlParser.RULE_procedure_name_create, 'procedure'],
             [PostgreSqlParser.RULE_procedure_name, 'procedure'],
         ]);
-        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/postgresql/postgreSemanticContextCollector.d.ts

@@ -0,0 +1,9 @@
+import { PostgreSqlParserListener } from '../../lib';
+import { SingleStmtContext } from '../../lib/postgresql/PostgreSqlParser';
+import SemanticContextCollector from '../common/semanticContextCollector';
+declare class PostgreSemanticContextCollector extends SemanticContextCollector implements PostgreSqlParserListener {
+    getWhiteSpaceRuleType(): number;
+    getStatementRuleType(): number;
+    enterSingleStmt(ctx: SingleStmtContext): void;
+}
+export { PostgreSemanticContextCollector };

package/dist/parser/postgresql/postgreSemanticContextCollector.js

@@ -0,0 +1,14 @@
+import { PostgreSqlParser } from '../../lib/postgresql/PostgreSqlParser';
+import SemanticContextCollector from '../common/semanticContextCollector';
+class PostgreSemanticContextCollector extends SemanticContextCollector {
+    getWhiteSpaceRuleType() {
+        return PostgreSqlParser.Whitespace;
+    }
+    getStatementRuleType() {
+        return PostgreSqlParser.RULE_singleStmt;
+    }
+    enterSingleStmt(ctx) {
+        this.visitStatement(ctx);
+    }
+}
+export { PostgreSemanticContextCollector };

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

@@ -3,11 +3,12 @@ import { CandidatesCollection } from 'antlr4-c3';
 import { SparkSqlLexer } from '../../lib/spark/SparkSqlLexer';
 import { SparkSqlParser, ProgramContext } from '../../lib/spark/SparkSqlParser';
 import { BasicSQL } from '../common/basicSQL';
-import { Suggestions } from '../common/types';
+import { Suggestions, CaretPosition, SemanticCollectOptions } from '../common/types';
 import { SparkSqlSplitListener } from './sparkSplitListener';
 import { SparkEntityCollector } from './sparkEntityCollector';
 import { SparkErrorListener } from './sparkErrorListener';
 import { ErrorListener } from '../common/parseErrorListener';
+import { SparkSemanticContextCollector } from './sparkSemanticContextCollector';
 export { SparkSqlSplitListener, SparkEntityCollector };
 export declare class SparkSQL extends BasicSQL<SparkSqlLexer, ProgramContext, SparkSqlParser> {
     protected createLexerFromCharStream(charStreams: CharStream): SparkSqlLexer;
@@ -16,5 +17,6 @@ export declare class SparkSQL extends BasicSQL<SparkSqlLexer, ProgramContext, Sp
     protected get splitListener(): SparkSqlSplitListener;
     protected createErrorListener(_errorListener: ErrorListener): SparkErrorListener;
     protected createEntityCollector(input: string, caretTokenIndex?: number): SparkEntityCollector;
+    protected createSemanticContextCollector(input: string, caretPosition: CaretPosition, allTokens: Token[], options?: SemanticCollectOptions): SparkSemanticContextCollector;
     protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number, tokenIndexOffset: number): Suggestions<Token>;
 }

package/dist/parser/spark/index.js

@@ -1,10 +1,11 @@
 import { SparkSqlLexer } from '../../lib/spark/SparkSqlLexer';
 import { SparkSqlParser } from '../../lib/spark/SparkSqlParser';
 import { BasicSQL } from '../common/basicSQL';
-import { EntityContextType } from '../common/types';
+import { EntityContextType, } from '../common/types';
 import { SparkSqlSplitListener } from './sparkSplitListener';
 import { SparkEntityCollector } from './sparkEntityCollector';
 import { SparkErrorListener } from './sparkErrorListener';
+import { SparkSemanticContextCollector } from './sparkSemanticContextCollector';
 export { SparkSqlSplitListener, SparkEntityCollector };
 export class SparkSQL extends BasicSQL {
     constructor() {
@@ -32,11 +33,15 @@ export class SparkSQL extends BasicSQL {
         return new SparkSqlSplitListener();
     }
     createErrorListener(_errorListener) {
-        return new SparkErrorListener(_errorListener, this.preferredRules, this.locale);
+        const parserContext = this;
+        return new SparkErrorListener(_errorListener, parserContext, this.preferredRules);
     }
     createEntityCollector(input, caretTokenIndex) {
         return new SparkEntityCollector(input, caretTokenIndex);
     }
+    createSemanticContextCollector(input, caretPosition, allTokens, options) {
+        return new SparkSemanticContextCollector(input, caretPosition, allTokens, options);
+    }
     processCandidates(candidates, allTokens, caretTokenIndex, tokenIndexOffset) {
         const originalSyntaxSuggestions = [];
         const keywords = [];

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

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