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

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

@@ -0,0 +1,12 @@
+/**
+ * Utility function for processing SQL tokens and generating keyword suggestions
+ */
+import { Parser } from 'antlr4ng';
+import { CandidatesCollection } from 'antlr4-c3';
+/**
+ * Process token candidates and generate a list of keyword suggestions
+ * @param parser SQL parser instance
+ * @param tokens token candidates
+ * @returns list of keyword suggestions
+ */
+export declare function processTokenCandidates(parser: Parser, tokens: CandidatesCollection['tokens']): string[];

package/dist/parser/common/tokenUtils.js

@@ -0,0 +1,38 @@
+/**
+ * Utility function for processing SQL tokens and generating keyword suggestions
+ */
+/**
+ * Process token candidates and generate a list of keyword suggestions
+ * @param parser SQL parser instance
+ * @param tokens token candidates
+ * @returns list of keyword suggestions
+ */
+export function processTokenCandidates(parser, tokens) {
+    const keywords = [];
+    const cleanDisplayName = (displayName) => {
+        return displayName && displayName.startsWith("'") && displayName.endsWith("'")
+            ? displayName.slice(1, -1)
+            : displayName || '';
+    };
+    const isKeywordToken = (token) => {
+        const symbolicName = parser.vocabulary.getSymbolicName(token);
+        return Boolean(symbolicName === null || symbolicName === void 0 ? void 0 : symbolicName.startsWith('KW_'));
+    };
+    for (const [token, followSets] of tokens) {
+        const displayName = parser.vocabulary.getDisplayName(token);
+        if (!displayName || !isKeywordToken(token))
+            continue;
+        const keyword = cleanDisplayName(displayName);
+        keywords.push(keyword);
+        if (followSets.length && followSets.every((s) => isKeywordToken(s))) {
+            const followKeywords = followSets
+                .map((s) => cleanDisplayName(parser.vocabulary.getDisplayName(s)))
+                .filter(Boolean);
+            if (followKeywords.length) {
+                const combinedKeyword = [keyword, ...followKeywords].join(' ');
+                keywords.push(combinedKeyword);
+            }
+        }
+    }
+    return keywords;
+}

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

@@ -64,3 +64,28 @@ export interface Suggestions<T = WordRange> {
     readonly keywords: string[];
 }
 export type LOCALE_TYPE = 'zh_CN' | 'en_US';
+export interface SemanticContext {
+    isStatementBeginning: boolean;
+}
+export declare enum SqlSplitStrategy {
+    /** Only end the statement with semicolon symbol */
+    STRICT = 0,
+    /** Based on parse tree to split statements */
+    LOOSE = 1
+}
+export interface SemanticCollectOptions {
+    /**
+     * `sqlSplitStrategy` will affects the result of `isStatementBeginning`;
+     *
+     * For example:
+     *
+     * The sql is "select id from t1   create\<cart_position\>"
+     *
+     * - `SqlSplitStrategy.STRICT`: split symbol `;` is missing after select statement so that it considerd as one statement, and `isStatementBeginning` is false
+     *
+     * - `SqlSplitStrategy.LOOSE`: in parse tree, it will parse to "select id from t1" and "create" two single statement, so `isStatementBeginning` is true
+     *
+     * @default SqlSplitStrategy.STRICT
+     */
+    sqlSplitStrategy?: SqlSplitStrategy;
+}

package/dist/parser/common/types.js

@@ -32,3 +32,10 @@ export var EntityContextType;
     /** column name that will be created */
     EntityContextType["COLUMN_CREATE"] = "columnCreate";
 })(EntityContextType || (EntityContextType = {}));
+export var SqlSplitStrategy;
+(function (SqlSplitStrategy) {
+    /** Only end the statement with semicolon symbol */
+    SqlSplitStrategy[SqlSplitStrategy["STRICT"] = 0] = "STRICT";
+    /** Based on parse tree to split statements */
+    SqlSplitStrategy[SqlSplitStrategy["LOOSE"] = 1] = "LOOSE";
+})(SqlSplitStrategy || (SqlSplitStrategy = {}));

package/dist/parser/flink/flinkErrorListener.js

@@ -14,8 +14,12 @@ export class FlinkErrorListener extends ParseErrorListener {
             [FlinkSqlParser.RULE_viewPath, 'view'],
             [FlinkSqlParser.RULE_viewPathCreate, 'view'],
             [FlinkSqlParser.RULE_functionName, 'function'],
+            [FlinkSqlParser.RULE_functionNameWithParams, 'function'],
+            [FlinkSqlParser.RULE_reservedKeywordsFollowParamsUsedAsFuncName, 'function'],
+            [FlinkSqlParser.RULE_reservedKeywordsNoParamsUsedAsFuncName, 'function'],
             [FlinkSqlParser.RULE_functionNameCreate, 'function'],
             [FlinkSqlParser.RULE_columnName, 'column'],
+            [FlinkSqlParser.RULE_columnNamePath, 'column'],
             [FlinkSqlParser.RULE_columnNameCreate, 'column'],
         ]);
     }
@@ -50,9 +54,15 @@ export class FlinkErrorListener extends ParseErrorListener {
                     case FlinkSqlParser.RULE_tablePath:
                     case FlinkSqlParser.RULE_viewPath:
                     case FlinkSqlParser.RULE_functionName:
+                    case FlinkSqlParser.RULE_functionNameWithParams:
+                    case FlinkSqlParser.RULE_reservedKeywordsFollowParamsUsedAsFuncName:
+                    case FlinkSqlParser.RULE_reservedKeywordsNoParamsUsedAsFuncName:
                     case FlinkSqlParser.RULE_columnName:
+                    case FlinkSqlParser.RULE_columnNamePath:
                     case FlinkSqlParser.RULE_catalogPath: {
-                        result.push(`{existing}${name}`);
+                        if (!result.includes(`{existing}${name}`)) {
+                            result.push(`{existing}${name}`);
+                        }
                         break;
                     }
                     case FlinkSqlParser.RULE_databasePathCreate:
@@ -61,7 +71,9 @@ export class FlinkErrorListener extends ParseErrorListener {
                     case FlinkSqlParser.RULE_viewPathCreate:
                     case FlinkSqlParser.RULE_columnNameCreate:
                     case FlinkSqlParser.RULE_catalogPathCreate: {
-                        result.push(`{new}${name}`);
+                        if (!result.includes(`{new}${name}`)) {
+                            result.push(`{new}${name}`);
+                        }
                         break;
                     }
                 }

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

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

package/dist/parser/flink/flinkSemanticContextCollector.js

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

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

@@ -2,12 +2,13 @@ import { CandidatesCollection } from 'antlr4-c3';
 import { CharStream, CommonTokenStream, Token } from 'antlr4ng';
 import { FlinkSqlLexer } from '../../lib/flink/FlinkSqlLexer';
 import { FlinkSqlParser, ProgramContext } from '../../lib/flink/FlinkSqlParser';
+import { CaretPosition, SemanticCollectOptions, Suggestions } from '../common/types';
 import { BasicSQL } from '../common/basicSQL';
 import { ErrorListener } from '../common/parseErrorListener';
-import { Suggestions } from '../common/types';
 import { FlinkEntityCollector } from './flinkEntityCollector';
 import { FlinkErrorListener } from './flinkErrorListener';
 import { FlinkSqlSplitListener } from './flinkSplitListener';
+import { FlinkSemanticContextCollector } from './flinkSemanticContextCollector';
 export { FlinkEntityCollector, FlinkSqlSplitListener };
 export declare class FlinkSQL extends BasicSQL<FlinkSqlLexer, ProgramContext, FlinkSqlParser> {
     protected createLexerFromCharStream(charStreams: CharStream): FlinkSqlLexer;
@@ -16,5 +17,6 @@ export declare class FlinkSQL extends BasicSQL<FlinkSqlLexer, ProgramContext, Fl
     protected get splitListener(): FlinkSqlSplitListener;
     protected createErrorListener(_errorListener: ErrorListener): FlinkErrorListener;
     protected createEntityCollector(input: string, allTokens?: Token[], caretTokenIndex?: number): FlinkEntityCollector;
-    protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number, tokenIndexOffset: number): Suggestions<Token>;
+    protected createSemanticContextCollector(input: string, caretPosition: CaretPosition, allTokens: Token[], options?: SemanticCollectOptions): FlinkSemanticContextCollector;
+    protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number): Suggestions<Token>;
 }

package/dist/parser/flink/index.js

@@ -1,10 +1,12 @@
+import { processTokenCandidates } from '../common/tokenUtils';
 import { FlinkSqlLexer } from '../../lib/flink/FlinkSqlLexer';
 import { FlinkSqlParser } from '../../lib/flink/FlinkSqlParser';
+import { EntityContextType, } from '../common/types';
 import { BasicSQL } from '../common/basicSQL';
-import { EntityContextType } from '../common/types';
 import { FlinkEntityCollector } from './flinkEntityCollector';
 import { FlinkErrorListener } from './flinkErrorListener';
 import { FlinkSqlSplitListener } from './flinkSplitListener';
+import { FlinkSemanticContextCollector } from './flinkSemanticContextCollector';
 export { FlinkEntityCollector, FlinkSqlSplitListener };
 export class FlinkSQL extends BasicSQL {
     constructor() {
@@ -23,6 +25,7 @@ export class FlinkSQL extends BasicSQL {
             FlinkSqlParser.RULE_reservedKeywordsNoParamsUsedAsFuncName, // functionName
             FlinkSqlParser.RULE_functionNameCreate, // functionName that will be created
             FlinkSqlParser.RULE_columnName,
+            FlinkSqlParser.RULE_columnNamePath,
             FlinkSqlParser.RULE_columnNameCreate,
         ]);
     }
@@ -42,13 +45,15 @@ export class FlinkSQL extends BasicSQL {
     createEntityCollector(input, allTokens, caretTokenIndex) {
         return new FlinkEntityCollector(input, allTokens, caretTokenIndex);
     }
-    processCandidates(candidates, allTokens, caretTokenIndex, tokenIndexOffset) {
+    createSemanticContextCollector(input, caretPosition, allTokens, options) {
+        return new FlinkSemanticContextCollector(input, caretPosition, allTokens, options);
+    }
+    processCandidates(candidates, allTokens, caretTokenIndex) {
         const originalSyntaxSuggestions = [];
         const keywords = [];
         for (let candidate of candidates.rules) {
             const [ruleType, candidateRule] = candidate;
-            const startTokenIndex = candidateRule.startTokenIndex + tokenIndexOffset;
-            const tokenRanges = allTokens.slice(startTokenIndex, caretTokenIndex + tokenIndexOffset + 1);
+            const tokenRanges = allTokens.slice(candidateRule.startTokenIndex, caretTokenIndex + 1);
             let syntaxContextType = void 0;
             switch (ruleType) {
                 case FlinkSqlParser.RULE_catalogPath: {
@@ -98,6 +103,17 @@ export class FlinkSQL extends BasicSQL {
                     syntaxContextType = EntityContextType.COLUMN_CREATE;
                     break;
                 }
+                case FlinkSqlParser.RULE_columnNamePath: {
+                    if (candidateRule.ruleList.includes(FlinkSqlParser.RULE_selectClause) ||
+                        candidateRule.ruleList.includes(FlinkSqlParser.RULE_whereClause) ||
+                        candidateRule.ruleList.includes(FlinkSqlParser.RULE_groupByClause) ||
+                        candidateRule.ruleList.includes(FlinkSqlParser.RULE_limitClause) ||
+                        candidateRule.ruleList.includes(FlinkSqlParser.RULE_whenClause) ||
+                        candidateRule.ruleList.includes(FlinkSqlParser.RULE_havingClause)) {
+                        syntaxContextType = EntityContextType.COLUMN;
+                    }
+                    break;
+                }
                 default:
                     break;
             }
@@ -108,16 +124,8 @@ export class FlinkSQL extends BasicSQL {
                 });
             }
         }
-        for (let candidate of candidates.tokens) {
-            const symbolicName = this._parser.vocabulary.getSymbolicName(candidate[0]);
-            const displayName = this._parser.vocabulary.getDisplayName(candidate[0]);
-            if (displayName && symbolicName && symbolicName.startsWith('KW_')) {
-                const keyword = displayName.startsWith("'") && displayName.endsWith("'")
-                    ? displayName.slice(1, -1)
-                    : displayName;
-                keywords.push(keyword);
-            }
-        }
+        const processedKeywords = processTokenCandidates(this._parser, candidates.tokens);
+        keywords.push(...processedKeywords);
         return {
             syntax: originalSyntaxSuggestions,
             keywords,

package/dist/parser/hive/hiveErrorListener.js

@@ -16,6 +16,7 @@ export class HiveErrorListener extends ParseErrorListener {
             [HiveSqlParser.RULE_functionNameCreate, 'function'],
             [HiveSqlParser.RULE_columnName, 'column'],
             [HiveSqlParser.RULE_columnNameCreate, 'column'],
+            [HiveSqlParser.RULE_columnNamePath, 'column'],
         ]);
     }
     getExpectedText(parser, token) {
@@ -50,8 +51,11 @@ export class HiveErrorListener extends ParseErrorListener {
                     case HiveSqlParser.RULE_viewName:
                     case HiveSqlParser.RULE_functionNameForDDL:
                     case HiveSqlParser.RULE_functionNameForInvoke:
-                    case HiveSqlParser.RULE_columnName: {
-                        result.push(`{existing}${name}`);
+                    case HiveSqlParser.RULE_columnName:
+                    case HiveSqlParser.RULE_columnNamePath: {
+                        if (!result.includes(`{existing}${name}`)) {
+                            result.push(`{existing}${name}`);
+                        }
                         break;
                     }
                     case HiveSqlParser.RULE_dbSchemaNameCreate:
@@ -59,7 +63,9 @@ export class HiveErrorListener extends ParseErrorListener {
                     case HiveSqlParser.RULE_functionNameCreate:
                     case HiveSqlParser.RULE_viewNameCreate:
                     case HiveSqlParser.RULE_columnNameCreate: {
-                        result.push(`{new}${name}`);
+                        if (!result.includes(`{new}${name}`)) {
+                            result.push(`{new}${name}`);
+                        }
                         break;
                     }
                 }

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 { CharStream, CommonTokenStream, Token } from 'antlr4ng';
 import { HiveSqlLexer } from '../../lib/hive/HiveSqlLexer';
 import { HiveSqlParser, ProgramContext } from '../../lib/hive/HiveSqlParser';
 import { BasicSQL } from '../common/basicSQL';
+import { CaretPosition, SemanticCollectOptions, Suggestions } from '../common/types';
 import { ErrorListener } from '../common/parseErrorListener';
-import { Suggestions } from '../common/types';
 import { HiveEntityCollector } from './hiveEntityCollector';
 import { HiveErrorListener } from './hiveErrorListener';
 import { HiveSqlSplitListener } from './hiveSplitListener';
+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, allTokens?: Token[], caretTokenIndex?: number): HiveEntityCollector;
-    protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number, tokenIndexOffset: number): Suggestions<Token>;
+    protected createSemanticContextCollector(input: string, caretPosition: CaretPosition, allTokens: Token[], options?: SemanticCollectOptions): HiveSemanticContextCollector;
+    protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number): Suggestions<Token>;
 }

package/dist/parser/hive/index.js

@@ -1,10 +1,12 @@
+import { processTokenCandidates } from '../common/tokenUtils';
 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 { HiveEntityCollector } from './hiveEntityCollector';
 import { HiveErrorListener } from './hiveErrorListener';
 import { HiveSqlSplitListener } from './hiveSplitListener';
+import { HiveSemanticContextCollector } from './hiveSemanticContextCollector';
 export { HiveEntityCollector, HiveSqlSplitListener };
 export class HiveSQL extends BasicSQL {
     constructor() {
@@ -20,6 +22,7 @@ export class HiveSQL extends BasicSQL {
             HiveSqlParser.RULE_functionNameForInvoke, // function name
             HiveSqlParser.RULE_functionNameCreate, // function name that will be created
             HiveSqlParser.RULE_columnName,
+            HiveSqlParser.RULE_columnNamePath,
             HiveSqlParser.RULE_columnNameCreate,
         ]);
     }
@@ -39,13 +42,15 @@ export class HiveSQL extends BasicSQL {
     createEntityCollector(input, allTokens, caretTokenIndex) {
         return new HiveEntityCollector(input, allTokens, caretTokenIndex);
     }
-    processCandidates(candidates, allTokens, caretTokenIndex, tokenIndexOffset) {
+    createSemanticContextCollector(input, caretPosition, allTokens, options) {
+        return new HiveSemanticContextCollector(input, caretPosition, allTokens, options);
+    }
+    processCandidates(candidates, allTokens, caretTokenIndex) {
         const originalSyntaxSuggestions = [];
         const keywords = [];
         for (let candidate of candidates.rules) {
             const [ruleType, candidateRule] = candidate;
-            const startTokenIndex = candidateRule.startTokenIndex + tokenIndexOffset;
-            const tokenRanges = allTokens.slice(startTokenIndex, caretTokenIndex + tokenIndexOffset + 1);
+            const tokenRanges = allTokens.slice(candidateRule.startTokenIndex, caretTokenIndex + 1);
             let syntaxContextType = void 0;
             switch (ruleType) {
                 case HiveSqlParser.RULE_dbSchemaName: {
@@ -89,6 +94,24 @@ export class HiveSQL extends BasicSQL {
                     syntaxContextType = EntityContextType.COLUMN_CREATE;
                     break;
                 }
+                case HiveSqlParser.RULE_columnNamePath: {
+                    if (candidateRule.ruleList.includes(HiveSqlParser.RULE_orderByClause) ||
+                        candidateRule.ruleList.includes(HiveSqlParser.RULE_havingClause) ||
+                        candidateRule.ruleList.includes(HiveSqlParser.RULE_groupByClause) ||
+                        candidateRule.ruleList.includes(HiveSqlParser.RULE_sortByClause) ||
+                        candidateRule.ruleList.includes(HiveSqlParser.RULE_whereClause) ||
+                        candidateRule.ruleList.includes(HiveSqlParser.RULE_qualifyClause) ||
+                        candidateRule.ruleList.includes(HiveSqlParser.RULE_clusterByClause) ||
+                        candidateRule.ruleList.includes(HiveSqlParser.RULE_distributeByClause) ||
+                        candidateRule.ruleList.includes(HiveSqlParser.RULE_selectClause) ||
+                        candidateRule.ruleList.includes(HiveSqlParser.RULE_joinSource) ||
+                        candidateRule.ruleList.includes(HiveSqlParser.RULE_caseExpression) ||
+                        candidateRule.ruleList.includes(HiveSqlParser.RULE_whenExpression) ||
+                        candidateRule.ruleList.includes(HiveSqlParser.RULE_castExpression)) {
+                        syntaxContextType = EntityContextType.COLUMN;
+                    }
+                    break;
+                }
                 default:
                     break;
             }
@@ -99,16 +122,8 @@ export class HiveSQL extends BasicSQL {
                 });
             }
         }
-        for (let candidate of candidates.tokens) {
-            const symbolicName = this._parser.vocabulary.getSymbolicName(candidate[0]);
-            const displayName = this._parser.vocabulary.getDisplayName(candidate[0]);
-            if (displayName && symbolicName && symbolicName.startsWith('KW_')) {
-                const keyword = displayName.startsWith("'") && displayName.endsWith("'")
-                    ? displayName.slice(1, -1)
-                    : displayName;
-                keywords.push(keyword);
-            }
-        }
+        const processedKeywords = processTokenCandidates(this._parser, candidates.tokens);
+        keywords.push(...processedKeywords);
         return {
             syntax: originalSyntaxSuggestions,
             keywords,

package/dist/parser/impala/ImpalaErrorListener.js

@@ -13,6 +13,7 @@ export class ImpalaErrorListener extends ParseErrorListener {
             [ImpalaSqlParser.RULE_viewNameCreate, 'view'],
             [ImpalaSqlParser.RULE_functionNamePath, 'function'],
             [ImpalaSqlParser.RULE_functionNameCreate, 'function'],
+            [ImpalaSqlParser.RULE_columnName, 'column'],
             [ImpalaSqlParser.RULE_columnNamePath, 'column'],
             [ImpalaSqlParser.RULE_columnNamePathCreate, 'column'],
         ]);
@@ -48,8 +49,11 @@ export class ImpalaErrorListener extends ParseErrorListener {
                     case ImpalaSqlParser.RULE_tableNamePath:
                     case ImpalaSqlParser.RULE_functionNamePath:
                     case ImpalaSqlParser.RULE_viewNamePath:
+                    case ImpalaSqlParser.RULE_columnName:
                     case ImpalaSqlParser.RULE_columnNamePath: {
-                        result.push(`{existing}${name}`);
+                        if (!result.includes(`{existing}${name}`)) {
+                            result.push(`{existing}${name}`);
+                        }
                         break;
                     }
                     case ImpalaSqlParser.RULE_databaseNameCreate:
@@ -57,7 +61,9 @@ export class ImpalaErrorListener extends ParseErrorListener {
                     case ImpalaSqlParser.RULE_functionNameCreate:
                     case ImpalaSqlParser.RULE_viewNameCreate:
                     case ImpalaSqlParser.RULE_columnNamePathCreate: {
-                        result.push(`{new}${name}`);
+                        if (!result.includes(`{new}${name}`)) {
+                            result.push(`{new}${name}`);
+                        }
                         break;
                     }
                 }

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.WHITE_SPACE;
+    }
+    getStatementRuleType() {
+        return ImpalaSqlParser.RULE_singleStatement;
+    }
+    enterSingleStatement(ctx) {
+        this.visitStatement(ctx);
+    }
+}
+export { ImpalaSemanticContextCollector };

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

@@ -3,11 +3,12 @@ import { CharStream, CommonTokenStream, Token } from 'antlr4ng';
 import { ImpalaSqlLexer } from '../../lib/impala/ImpalaSqlLexer';
 import { ImpalaSqlParser, ProgramContext } from '../../lib/impala/ImpalaSqlParser';
 import { BasicSQL } from '../common/basicSQL';
+import { CaretPosition, SemanticCollectOptions, Suggestions } from '../common/types';
 import { ErrorListener } from '../common/parseErrorListener';
-import { Suggestions } from '../common/types';
 import { ImpalaEntityCollector } from './impalaEntityCollector';
 import { ImpalaErrorListener } from './ImpalaErrorListener';
 import { ImpalaSqlSplitListener } from './impalaSplitListener';
+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, allTokens?: Token[], caretTokenIndex?: number): ImpalaEntityCollector;
-    protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number, tokenIndexOffset: number): Suggestions<Token>;
+    protected createSemanticContextCollector(input: string, caretPosition: CaretPosition, allTokens: Token[], options?: SemanticCollectOptions): ImpalaSemanticContextCollector;
+    protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number): Suggestions<Token>;
 }

package/dist/parser/impala/index.js

@@ -1,10 +1,12 @@
+import { processTokenCandidates } from '../common/tokenUtils';
 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 { ImpalaEntityCollector } from './impalaEntityCollector';
 import { ImpalaErrorListener } from './ImpalaErrorListener';
 import { ImpalaSqlSplitListener } from './impalaSplitListener';
+import { ImpalaSemanticContextCollector } from './impalaSemanticContextCollector';
 export { ImpalaEntityCollector, ImpalaSqlSplitListener };
 export class ImpalaSQL extends BasicSQL {
     constructor() {
@@ -20,6 +22,7 @@ export class ImpalaSQL extends BasicSQL {
             ImpalaSqlParser.RULE_viewNamePath,
             ImpalaSqlParser.RULE_databaseNamePath,
             ImpalaSqlParser.RULE_columnNamePath,
+            ImpalaSqlParser.RULE_columnName,
         ]);
     }
     createLexerFromCharStream(charStreams) {
@@ -38,13 +41,15 @@ export class ImpalaSQL extends BasicSQL {
     createEntityCollector(input, allTokens, caretTokenIndex) {
         return new ImpalaEntityCollector(input, allTokens, caretTokenIndex);
     }
-    processCandidates(candidates, allTokens, caretTokenIndex, tokenIndexOffset) {
+    createSemanticContextCollector(input, caretPosition, allTokens, options) {
+        return new ImpalaSemanticContextCollector(input, caretPosition, allTokens, options);
+    }
+    processCandidates(candidates, allTokens, caretTokenIndex) {
         const originalSyntaxSuggestions = [];
         const keywords = [];
         for (let candidate of candidates.rules) {
             const [ruleType, candidateRule] = candidate;
-            const startTokenIndex = candidateRule.startTokenIndex + tokenIndexOffset;
-            const tokenRanges = allTokens.slice(startTokenIndex, caretTokenIndex + tokenIndexOffset + 1);
+            const tokenRanges = allTokens.slice(candidateRule.startTokenIndex, caretTokenIndex + 1);
             let syntaxContextType = void 0;
             switch (ruleType) {
                 case ImpalaSqlParser.RULE_functionNameCreate: {
@@ -86,6 +91,16 @@ export class ImpalaSQL extends BasicSQL {
                 case ImpalaSqlParser.RULE_columnNamePath: {
                     syntaxContextType = EntityContextType.COLUMN;
                 }
+                case ImpalaSqlParser.RULE_columnName: {
+                    if (candidateRule.ruleList.includes(ImpalaSqlParser.RULE_columnItem) ||
+                        candidateRule.ruleList.includes(ImpalaSqlParser.RULE_havingClause) ||
+                        candidateRule.ruleList.includes(ImpalaSqlParser.RULE_whereClause) ||
+                        candidateRule.ruleList.includes(ImpalaSqlParser.RULE_whenClause) ||
+                        candidateRule.ruleList.includes(ImpalaSqlParser.RULE_partitionByClause) ||
+                        candidateRule.ruleList.includes(ImpalaSqlParser.RULE_relation)) {
+                        syntaxContextType = EntityContextType.COLUMN;
+                    }
+                }
                 default:
                     break;
             }
@@ -96,16 +111,8 @@ export class ImpalaSQL extends BasicSQL {
                 });
             }
         }
-        for (let candidate of candidates.tokens) {
-            const symbolicName = this._parser.vocabulary.getSymbolicName(candidate[0]);
-            const displayName = this._parser.vocabulary.getDisplayName(candidate[0]);
-            if (displayName && symbolicName && symbolicName.startsWith('KW_')) {
-                const keyword = displayName.startsWith("'") && displayName.endsWith("'")
-                    ? displayName.slice(1, -1)
-                    : displayName;
-                keywords.push(keyword);
-            }
-        }
+        const processedKeywords = processTokenCandidates(this._parser, candidates.tokens);
+        keywords.push(...processedKeywords);
         return {
             syntax: originalSyntaxSuggestions,
             keywords,

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

@@ -3,11 +3,12 @@ import { CharStream, CommonTokenStream, Token } from 'antlr4ng';
 import { MySqlLexer } from '../../lib/mysql/MySqlLexer';
 import { MySqlParser, ProgramContext } from '../../lib/mysql/MySqlParser';
 import { BasicSQL } from '../common/basicSQL';
+import { Suggestions, CaretPosition, SemanticCollectOptions } from '../common/types';
 import { ErrorListener } from '../common/parseErrorListener';
-import { Suggestions } from '../common/types';
 import { MySqlEntityCollector } from './mysqlEntityCollector';
 import { MysqlErrorListener } from './mysqlErrorListener';
 import { MysqlSplitListener } from './mysqlSplitListener';
+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, allTokens?: Token[], caretTokenIndex?: number): MySqlEntityCollector;
-    protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number, tokenIndexOffset: number): Suggestions<Token>;
+    protected createSemanticContextCollector(input: string, caretPosition: CaretPosition, allTokens: Token[], options?: SemanticCollectOptions): MySqlSemanticContextCollector;
+    protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number): Suggestions<Token>;
 }