dt-sql-parser 4.0.2 → 4.1.0-beta.1

package/dist/parser/common/parseErrorListener.js

@@ -1,11 +1,92 @@
+import { Token, LexerNoViableAltException, InputMismatchException, NoViableAltException, } from 'antlr4ng';
+import { transform } from './transform';
 export class ParseErrorListener {
-    constructor(errorListener) {
+    constructor(errorListener, locale = 'en_US') {
+        this.locale = locale;
         this._errorListener = errorListener;
     }
     reportAmbiguity() { }
     reportAttemptingFullContext() { }
     reportContextSensitivity() { }
     syntaxError(recognizer, offendingSymbol, line, charPositionInLine, msg, e) {
+        var _a;
+        let message = '';
+        // If not undefined then offendingSymbol is of type Token.
+        if (offendingSymbol) {
+            let token = offendingSymbol;
+            const parser = recognizer;
+            // judge token is EOF
+            const isEof = token.type === Token.EOF;
+            if (isEof) {
+                token = parser.tokenStream.get(token.tokenIndex - 1);
+            }
+            const wrongText = (_a = token.text) !== null && _a !== void 0 ? _a : '';
+            const isInComplete = isEof && wrongText !== ' ';
+            const expectedText = isInComplete ? '' : this.getExpectedText(parser, token);
+            if (!e) {
+                // handle missing or unwanted tokens.
+                message = msg;
+                if (msg.includes('extraneous')) {
+                    message = `'${wrongText}' {noValidPosition}${expectedText.length ? `{expecting}${expectedText}` : ''}`;
+                }
+                if (msg.includes('missing')) {
+                    const regex = /missing\s+'([^']+)'/;
+                    const match = msg.match(regex);
+                    message = `{missing}`;
+                    if (match) {
+                        const missKeyword = match[1];
+                        message += `'${missKeyword}'`;
+                    }
+                    else {
+                        message += `{keyword}`;
+                    }
+                    message += `{at}'${wrongText}'`;
+                }
+            }
+            else {
+                // handle mismatch exception or no viable alt exception
+                if (e instanceof InputMismatchException || e instanceof NoViableAltException) {
+                    if (isEof) {
+                        message = `{stmtInComplete}`;
+                    }
+                    else {
+                        message = `'${wrongText}' {noValidPosition}`;
+                    }
+                    if (expectedText.length > 0) {
+                        message += `{expecting}${expectedText}`;
+                    }
+                }
+                else {
+                    message = msg;
+                }
+            }
+        }
+        else {
+            // No offending symbol, which indicates this is a lexer error.
+            if (e instanceof LexerNoViableAltException) {
+                const lexer = recognizer;
+                const input = lexer.inputStream;
+                let text = lexer.getErrorDisplay(input.getText(lexer._tokenStartCharIndex, input.index));
+                switch (text[0]) {
+                    case '/':
+                        message = '{unfinishedMultilineComment}';
+                        break;
+                    case '"':
+                        message = '{unfinishedDoubleQuoted}';
+                        break;
+                    case "'":
+                        message = '{unfinishedSingleQuoted}';
+                        break;
+                    case '`':
+                        message = '{unfinishedTickQuoted}';
+                        break;
+                    default:
+                        message = '"' + text + '" {noValidInput}';
+                        break;
+                }
+            }
+        }
+        message = transform(message, this.locale);
         let endCol = charPositionInLine + 1;
         if (offendingSymbol && offendingSymbol.text !== null) {
             endCol = charPositionInLine + offendingSymbol.text.length;
@@ -16,7 +97,7 @@ export class ParseErrorListener {
                 endLine: line,
                 startColumn: charPositionInLine + 1,
                 endColumn: endCol + 1,
-                message: msg,
+                message,
             }, {
                 e,
                 line,

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

@@ -35,18 +35,15 @@ export interface TextSlice extends TextPosition {
 /**
  * Convert Token to Word
  */
-export declare function tokenToWord(token: Token, input: string): WordPosition & {
-    text: string;
-};
-/**
- * Convert ParserRuleContext to Word
- */
-export declare function ctxToWord(ctx: ParserRuleContext, input: string): (WordPosition & {
-    text: string;
-}) | null;
+export declare function tokenToWord(token: Token, input: string): WordRange;
 /**
  * Convert ParserRuleContext to Text
  */
 export declare function ctxToText(ctx: ParserRuleContext, input: string): (TextPosition & {
     text: string;
 }) | null;
+/**
+ * judge whether the context is a WordRange
+ * @param textOrWord TextSlice or WordRange object
+ * */
+export declare function isWordRange(textOrWord: TextSlice | WordRange): textOrWord is WordRange;

package/dist/parser/common/textAndWord.js

@@ -15,26 +15,6 @@ export function tokenToWord(token, input) {
         endColumn: token.column + 1 + text.length,
     };
 }
-/**
- * Convert ParserRuleContext to Word
- */
-export function ctxToWord(ctx, input) {
-    var _a, _b;
-    if (!ctx.start || !ctx.stop) {
-        return null;
-    }
-    const startIndex = ctx.start.start;
-    const endIndex = ctx.stop.stop;
-    const text = input.slice(startIndex, endIndex + 1);
-    return {
-        text,
-        line: ctx.start.line,
-        startIndex,
-        endIndex,
-        startColumn: ctx.start.column + 1,
-        endColumn: ctx.stop.column + 1 + ((_b = (_a = ctx.stop.text) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0),
-    };
-}
 /**
  * Convert ParserRuleContext to Text
  */
@@ -56,3 +36,12 @@ export function ctxToText(ctx, input) {
         endColumn: ctx.stop.column + 1 + ((_b = (_a = ctx.stop.text) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0),
     };
 }
+/**
+ * judge whether the context is a WordRange
+ * @param textOrWord TextSlice or WordRange object
+ * */
+export function isWordRange(textOrWord) {
+    if (!textOrWord)
+        return false;
+    return 'line' in textOrWord;
+}

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

@@ -0,0 +1,8 @@
+import { LOCALE_TYPE } from './types';
+/**
+ * transform message to locale language
+ * @param message error msg
+ * @param locale language setting
+ */
+declare function transform(message: string, locale: LOCALE_TYPE): string;
+export { transform };

package/dist/parser/common/transform.js

@@ -0,0 +1,11 @@
+import { i18n } from '../../locale/locale';
+/**
+ * transform message to locale language
+ * @param message error msg
+ * @param locale language setting
+ */
+function transform(message, locale) {
+    const regex = /{([^}]+)}/g;
+    return message.replace(regex, (_, key) => i18n[locale][key] || '');
+}
+export { transform };

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

@@ -63,3 +63,4 @@ export interface Suggestions<T = WordRange> {
      */
     readonly keywords: string[];
 }
+export type LOCALE_TYPE = 'zh_CN' | 'en_US';

package/dist/parser/flink/flinkEntityCollector.js

@@ -1,5 +1,6 @@
+import { CreateDatabaseContext, CreateTableContext, CreateViewContext, PhysicalColumnDefinitionContext, TableReferenceContext, } from '../../lib/flink/FlinkSqlParser';
+import { AttrName, EntityCollector, StmtContextType } from '../common/entityCollector';
 import { EntityContextType } from '../common/types';
-import { StmtContextType, EntityCollector } from '../common/entityCollector';
 export class FlinkEntityCollector extends EntityCollector {
     /** ====== Entity Begin */
     exitCatalogPathCreate(ctx) {
@@ -9,25 +10,58 @@ export class FlinkEntityCollector extends EntityCollector {
         this.pushEntity(ctx, EntityContextType.CATALOG);
     }
     exitDatabasePathCreate(ctx) {
-        this.pushEntity(ctx, EntityContextType.DATABASE_CREATE);
+        this.pushEntity(ctx, EntityContextType.DATABASE_CREATE, [
+            {
+                attrName: AttrName.comment,
+                endContextList: [CreateDatabaseContext.name],
+            },
+        ]);
     }
     exitDatabasePath(ctx) {
         this.pushEntity(ctx, EntityContextType.DATABASE);
     }
     exitTablePath(ctx) {
-        this.pushEntity(ctx, EntityContextType.TABLE);
+        var _a;
+        const needCollectAttr = ((_a = this.getRootStmt()) === null || _a === void 0 ? void 0 : _a.stmtContextType) === StmtContextType.SELECT_STMT;
+        this.pushEntity(ctx, EntityContextType.TABLE, needCollectAttr
+            ? [
+                {
+                    attrName: AttrName.alias,
+                    endContextList: [TableReferenceContext.name],
+                },
+            ]
+            : undefined);
     }
     exitTablePathCreate(ctx) {
-        this.pushEntity(ctx, EntityContextType.TABLE_CREATE);
+        this.pushEntity(ctx, EntityContextType.TABLE_CREATE, [
+            {
+                attrName: AttrName.comment,
+                endContextList: [CreateTableContext.name],
+            },
+        ]);
     }
     exitViewPath(ctx) {
         this.pushEntity(ctx, EntityContextType.VIEW);
     }
     exitViewPathCreate(ctx) {
-        this.pushEntity(ctx, EntityContextType.VIEW_CREATE);
+        this.pushEntity(ctx, EntityContextType.VIEW_CREATE, [
+            {
+                attrName: AttrName.comment,
+                endContextList: [CreateViewContext.name],
+            },
+        ]);
     }
     exitColumnNameCreate(ctx) {
-        this.pushEntity(ctx, EntityContextType.COLUMN_CREATE);
+        this.pushEntity(ctx, EntityContextType.COLUMN_CREATE, [
+            {
+                attrName: AttrName.comment,
+                endContextList: [PhysicalColumnDefinitionContext.name],
+            },
+            {
+                attrName: AttrName.colType,
+                endContextList: [PhysicalColumnDefinitionContext.name],
+            },
+        ]);
     }
     exitFunctionNameCreate(ctx) {
         this.pushEntity(ctx, EntityContextType.FUNCTION_CREATE);

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

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

package/dist/parser/flink/flinkErrorListener.js

@@ -0,0 +1,67 @@
+import { CodeCompletionCore } from 'antlr4-c3';
+import { ParseErrorListener } from '../common/parseErrorListener';
+import { FlinkSqlParser } from '../../lib/flink/FlinkSqlParser';
+export class FlinkErrorListener extends ParseErrorListener {
+    constructor(errorListener, preferredRules, locale) {
+        super(errorListener, locale);
+        this.objectNames = new Map([
+            [FlinkSqlParser.RULE_catalogPath, 'catalog'],
+            [FlinkSqlParser.RULE_catalogPathCreate, 'catalog'],
+            [FlinkSqlParser.RULE_databasePath, 'database'],
+            [FlinkSqlParser.RULE_databasePathCreate, 'database'],
+            [FlinkSqlParser.RULE_tablePath, 'table'],
+            [FlinkSqlParser.RULE_tablePathCreate, 'table'],
+            [FlinkSqlParser.RULE_viewPath, 'view'],
+            [FlinkSqlParser.RULE_viewPathCreate, 'view'],
+            [FlinkSqlParser.RULE_functionName, 'function'],
+            [FlinkSqlParser.RULE_functionNameCreate, 'function'],
+            [FlinkSqlParser.RULE_columnName, 'column'],
+            [FlinkSqlParser.RULE_columnNameCreate, 'column'],
+        ]);
+        this.preferredRules = preferredRules;
+    }
+    getExpectedText(parser, token) {
+        var _a;
+        let expectedText = '';
+        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);
+        core.preferredRules = this.preferredRules;
+        const candidates = core.collectCandidates(token.tokenIndex, currentContext);
+        if (candidates.rules.size) {
+            const result = [];
+            // get expectedText as collect rules first
+            for (const candidate of candidates.rules) {
+                const [ruleType] = candidate;
+                const name = this.objectNames.get(ruleType);
+                switch (ruleType) {
+                    case FlinkSqlParser.RULE_databasePath:
+                    case FlinkSqlParser.RULE_tablePath:
+                    case FlinkSqlParser.RULE_viewPath:
+                    case FlinkSqlParser.RULE_functionName:
+                    case FlinkSqlParser.RULE_columnName:
+                    case FlinkSqlParser.RULE_catalogPath: {
+                        result.push(`{existing}${name}`);
+                        break;
+                    }
+                    case FlinkSqlParser.RULE_databasePathCreate:
+                    case FlinkSqlParser.RULE_tablePathCreate:
+                    case FlinkSqlParser.RULE_functionNameCreate:
+                    case FlinkSqlParser.RULE_viewPathCreate:
+                    case FlinkSqlParser.RULE_columnNameCreate:
+                    case FlinkSqlParser.RULE_catalogPathCreate: {
+                        result.push(`{new}${name}`);
+                        break;
+                    }
+                }
+            }
+            expectedText = result.join('{or}');
+        }
+        if (candidates.tokens.size) {
+            expectedText += expectedText ? '{orKeyword}' : '{keyword}';
+        }
+        return expectedText;
+    }
+}

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

@@ -6,12 +6,15 @@ import { Suggestions } from '../common/types';
 import { BasicSQL } from '../common/basicSQL';
 import { FlinkSqlSplitListener } from './flinkSplitListener';
 import { FlinkEntityCollector } from './flinkEntityCollector';
+import { ErrorListener } from '../common/parseErrorListener';
+import { FlinkErrorListener } from './flinkErrorListener';
 export { FlinkSqlSplitListener, FlinkEntityCollector };
 export declare class FlinkSQL extends BasicSQL<FlinkSqlLexer, ProgramContext, FlinkSqlParser> {
     protected createLexerFromCharStream(charStreams: CharStream): FlinkSqlLexer;
     protected createParserFromTokenStream(tokenStream: CommonTokenStream): FlinkSqlParser;
     protected preferredRules: Set<number>;
     protected get splitListener(): FlinkSqlSplitListener;
+    protected createErrorListener(_errorListener: ErrorListener): FlinkErrorListener;
     protected createEntityCollector(input: string, caretTokenIndex?: number): FlinkEntityCollector;
-    protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number, tokenIndexOffset: number): Suggestions<Token>;
+    protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number): Suggestions<Token>;
 }

package/dist/parser/flink/index.js

@@ -4,20 +4,21 @@ import { EntityContextType } from '../common/types';
 import { BasicSQL } from '../common/basicSQL';
 import { FlinkSqlSplitListener } from './flinkSplitListener';
 import { FlinkEntityCollector } from './flinkEntityCollector';
+import { FlinkErrorListener } from './flinkErrorListener';
 export { FlinkSqlSplitListener, FlinkEntityCollector };
 export class FlinkSQL extends BasicSQL {
     constructor() {
         super(...arguments);
         this.preferredRules = new Set([
-            FlinkSqlParser.RULE_catalogPath,
-            FlinkSqlParser.RULE_databasePath,
-            FlinkSqlParser.RULE_databasePathCreate,
-            FlinkSqlParser.RULE_tablePath,
-            FlinkSqlParser.RULE_tablePathCreate,
-            FlinkSqlParser.RULE_viewPath,
-            FlinkSqlParser.RULE_viewPathCreate,
-            FlinkSqlParser.RULE_functionName,
-            FlinkSqlParser.RULE_functionNameCreate,
+            FlinkSqlParser.RULE_catalogPath, // catalog name
+            FlinkSqlParser.RULE_databasePath, // database name
+            FlinkSqlParser.RULE_databasePathCreate, // database name that will be created
+            FlinkSqlParser.RULE_tablePath, // table name
+            FlinkSqlParser.RULE_tablePathCreate, // table name that will be created
+            FlinkSqlParser.RULE_viewPath, // view name path
+            FlinkSqlParser.RULE_viewPathCreate, // viewName that will be created
+            FlinkSqlParser.RULE_functionName, // functionName
+            FlinkSqlParser.RULE_functionNameCreate, // functionName that will be created
             FlinkSqlParser.RULE_columnName,
             FlinkSqlParser.RULE_columnNameCreate,
         ]);
@@ -31,16 +32,19 @@ export class FlinkSQL extends BasicSQL {
     get splitListener() {
         return new FlinkSqlSplitListener();
     }
+    createErrorListener(_errorListener) {
+        return new FlinkErrorListener(_errorListener, this.preferredRules, this.locale);
+    }
     createEntityCollector(input, caretTokenIndex) {
         return new FlinkEntityCollector(input, caretTokenIndex);
     }
-    processCandidates(candidates, allTokens, caretTokenIndex, tokenIndexOffset) {
+    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 startTokenIndex = candidateRule.startTokenIndex;
+            const tokenRanges = allTokens.slice(startTokenIndex, caretTokenIndex + 1);
             let syntaxContextType = void 0;
             switch (ruleType) {
                 case FlinkSqlParser.RULE_catalogPath: {

package/dist/parser/hive/hiveEntityCollector.js

@@ -1,24 +1,58 @@
+import { ColumnNameCommentContext, ColumnNameTypeConstraintContext, CreateDatabaseStatementContext, CreateTableStatementContext, CreateViewStatementContext, TableSourceContext, UniqueJoinSourceContext, } from '../../lib/hive/HiveSqlParser';
+import { AttrName, EntityCollector, StmtContextType } from '../common/entityCollector';
 import { EntityContextType } from '../common/types';
-import { StmtContextType, EntityCollector } from '../common/entityCollector';
 export class HiveEntityCollector extends EntityCollector {
     /** ====== Entity Begin */
     exitTableNameCreate(ctx) {
-        this.pushEntity(ctx, EntityContextType.TABLE_CREATE);
+        this.pushEntity(ctx, EntityContextType.TABLE_CREATE, [
+            {
+                attrName: AttrName.comment,
+                endContextList: [CreateTableStatementContext.name],
+            },
+        ]);
     }
     exitTableName(ctx) {
-        this.pushEntity(ctx, EntityContextType.TABLE);
+        var _a;
+        const needCollectAttr = ((_a = this.getRootStmt()) === null || _a === void 0 ? void 0 : _a.stmtContextType) === StmtContextType.SELECT_STMT;
+        this.pushEntity(ctx, EntityContextType.TABLE, needCollectAttr
+            ? [
+                {
+                    attrName: AttrName.alias,
+                    endContextList: [TableSourceContext.name, UniqueJoinSourceContext.name],
+                },
+            ]
+            : undefined);
     }
     exitColumnNameCreate(ctx) {
-        this.pushEntity(ctx, EntityContextType.COLUMN_CREATE);
+        this.pushEntity(ctx, EntityContextType.COLUMN_CREATE, [
+            {
+                attrName: AttrName.comment,
+                endContextList: [ColumnNameCommentContext.name],
+            },
+            {
+                attrName: AttrName.colType,
+                endContextList: [ColumnNameTypeConstraintContext.name],
+            },
+        ]);
     }
     exitViewNameCreate(ctx) {
-        this.pushEntity(ctx, EntityContextType.VIEW_CREATE);
+        this.pushEntity(ctx, EntityContextType.VIEW_CREATE, [
+            {
+                attrName: AttrName.comment,
+                endContextList: [CreateViewStatementContext.name],
+            },
+        ]);
     }
     exitViewName(ctx) {
         this.pushEntity(ctx, EntityContextType.VIEW);
     }
     exitDbSchemaNameCreate(ctx) {
-        this.pushEntity(ctx, EntityContextType.DATABASE_CREATE);
+        this.pushEntity(ctx, EntityContextType.DATABASE_CREATE, [
+            {
+                attrName: AttrName.comment,
+                endContextList: [CreateDatabaseStatementContext.name],
+            },
+        ]);
     }
     exitDbSchemaName(ctx) {
         this.pushEntity(ctx, EntityContextType.DATABASE);

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

@@ -0,0 +1,9 @@
+import { ErrorListener, 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

@@ -0,0 +1,65 @@
+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);
+        this.objectNames = new Map([
+            [HiveSqlParser.RULE_dbSchemaName, 'database'],
+            [HiveSqlParser.RULE_dbSchemaNameCreate, 'database'],
+            [HiveSqlParser.RULE_tableName, 'table'],
+            [HiveSqlParser.RULE_tableNameCreate, 'table'],
+            [HiveSqlParser.RULE_viewName, 'view'],
+            [HiveSqlParser.RULE_viewNameCreate, 'view'],
+            [HiveSqlParser.RULE_functionNameForDDL, 'function'],
+            [HiveSqlParser.RULE_functionNameForInvoke, 'function'],
+            [HiveSqlParser.RULE_functionNameCreate, 'function'],
+            [HiveSqlParser.RULE_columnName, 'column'],
+            [HiveSqlParser.RULE_columnNameCreate, 'column'],
+        ]);
+        this.preferredRules = preferredRules;
+    }
+    getExpectedText(parser, token) {
+        var _a;
+        let expectedText = '';
+        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);
+        core.preferredRules = this.preferredRules;
+        const candidates = core.collectCandidates(token.tokenIndex, currentContext);
+        if (candidates.rules.size) {
+            const result = [];
+            // get expectedText as collect rules first
+            for (const candidate of candidates.rules) {
+                const [ruleType] = candidate;
+                const name = this.objectNames.get(ruleType);
+                switch (ruleType) {
+                    case HiveSqlParser.RULE_dbSchemaName:
+                    case HiveSqlParser.RULE_tableName:
+                    case HiveSqlParser.RULE_viewName:
+                    case HiveSqlParser.RULE_functionNameForDDL:
+                    case HiveSqlParser.RULE_functionNameForInvoke:
+                    case HiveSqlParser.RULE_columnName: {
+                        result.push(`{existing}${name}`);
+                        break;
+                    }
+                    case HiveSqlParser.RULE_dbSchemaNameCreate:
+                    case HiveSqlParser.RULE_tableNameCreate:
+                    case HiveSqlParser.RULE_functionNameCreate:
+                    case HiveSqlParser.RULE_viewNameCreate:
+                    case HiveSqlParser.RULE_columnNameCreate: {
+                        result.push(`{new}${name}`);
+                        break;
+                    }
+                }
+            }
+            expectedText = result.join('{or}');
+        }
+        if (candidates.tokens.size) {
+            expectedText += expectedText ? '{orKeyword}' : '{keyword}';
+        }
+        return expectedText;
+    }
+}

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

@@ -6,12 +6,15 @@ import { BasicSQL } from '../common/basicSQL';
 import { Suggestions } from '../common/types';
 import { HiveSqlSplitListener } from './hiveSplitListener';
 import { HiveEntityCollector } from './hiveEntityCollector';
+import { ErrorListener } from '../common/parseErrorListener';
+import { HiveErrorListener } from './hiveErrorListener';
 export { HiveEntityCollector, HiveSqlSplitListener };
 export declare class HiveSQL extends BasicSQL<HiveSqlLexer, ProgramContext, HiveSqlParser> {
     protected createLexerFromCharStream(charStreams: CharStream): HiveSqlLexer;
     protected createParserFromTokenStream(tokenStream: CommonTokenStream): HiveSqlParser;
     protected preferredRules: Set<number>;
     protected get splitListener(): HiveSqlSplitListener;
+    protected createErrorListener(_errorListener: ErrorListener): HiveErrorListener;
     protected createEntityCollector(input: string, caretTokenIndex?: number): HiveEntityCollector;
-    protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number, tokenIndexOffset: number): Suggestions<Token>;
+    protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number): Suggestions<Token>;
 }

package/dist/parser/hive/index.js

@@ -4,20 +4,21 @@ import { BasicSQL } from '../common/basicSQL';
 import { EntityContextType } from '../common/types';
 import { HiveSqlSplitListener } from './hiveSplitListener';
 import { HiveEntityCollector } from './hiveEntityCollector';
+import { HiveErrorListener } from './hiveErrorListener';
 export { HiveEntityCollector, HiveSqlSplitListener };
 export class HiveSQL extends BasicSQL {
     constructor() {
         super(...arguments);
         this.preferredRules = new Set([
-            HiveSqlParser.RULE_dbSchemaName,
-            HiveSqlParser.RULE_dbSchemaNameCreate,
-            HiveSqlParser.RULE_tableName,
-            HiveSqlParser.RULE_tableNameCreate,
-            HiveSqlParser.RULE_viewName,
-            HiveSqlParser.RULE_viewNameCreate,
-            HiveSqlParser.RULE_functionNameForDDL,
-            HiveSqlParser.RULE_functionNameForInvoke,
-            HiveSqlParser.RULE_functionNameCreate,
+            HiveSqlParser.RULE_dbSchemaName, // db or schema name
+            HiveSqlParser.RULE_dbSchemaNameCreate, // db or schema name that will be created
+            HiveSqlParser.RULE_tableName, // table name
+            HiveSqlParser.RULE_tableNameCreate, // table name that will be created
+            HiveSqlParser.RULE_viewName, // view name
+            HiveSqlParser.RULE_viewNameCreate, // view name that will be created
+            HiveSqlParser.RULE_functionNameForDDL, // function name
+            HiveSqlParser.RULE_functionNameForInvoke, // function name
+            HiveSqlParser.RULE_functionNameCreate, // function name that will be created
             HiveSqlParser.RULE_columnName,
             HiveSqlParser.RULE_columnNameCreate,
         ]);
@@ -31,16 +32,19 @@ export class HiveSQL extends BasicSQL {
     get splitListener() {
         return new HiveSqlSplitListener();
     }
+    createErrorListener(_errorListener) {
+        return new HiveErrorListener(_errorListener, this.preferredRules, this.locale);
+    }
     createEntityCollector(input, caretTokenIndex) {
         return new HiveEntityCollector(input, caretTokenIndex);
     }
-    processCandidates(candidates, allTokens, caretTokenIndex, tokenIndexOffset) {
+    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 startTokenIndex = candidateRule.startTokenIndex;
+            const tokenRanges = allTokens.slice(startTokenIndex, caretTokenIndex + 1);
             let syntaxContextType = void 0;
             switch (ruleType) {
                 case HiveSqlParser.RULE_dbSchemaName: {

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

@@ -0,0 +1,9 @@
+import { ErrorListener, 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;
+}