dt-sql-parser 4.0.1 → 4.1.0-beta.0

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>;
 }

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,6 +32,9 @@ 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);
     }

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>;
 }

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,6 +32,9 @@ 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);
     }

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;
+}

package/dist/parser/impala/ImpalaErrorListener.js

@@ -0,0 +1,63 @@
+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);
+        this.objectNames = new Map([
+            [ImpalaSqlParser.RULE_databaseNamePath, 'database'],
+            [ImpalaSqlParser.RULE_databaseNameCreate, 'database'],
+            [ImpalaSqlParser.RULE_tableNamePath, 'table'],
+            [ImpalaSqlParser.RULE_tableNameCreate, 'table'],
+            [ImpalaSqlParser.RULE_viewNamePath, 'view'],
+            [ImpalaSqlParser.RULE_viewNameCreate, 'view'],
+            [ImpalaSqlParser.RULE_functionNamePath, 'function'],
+            [ImpalaSqlParser.RULE_functionNameCreate, 'function'],
+            [ImpalaSqlParser.RULE_columnNamePath, 'column'],
+            [ImpalaSqlParser.RULE_columnNamePathCreate, '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 ImpalaSqlParser.RULE_databaseNamePath:
+                    case ImpalaSqlParser.RULE_tableNamePath:
+                    case ImpalaSqlParser.RULE_functionNamePath:
+                    case ImpalaSqlParser.RULE_viewNamePath:
+                    case ImpalaSqlParser.RULE_columnNamePath: {
+                        result.push(`{existing}${name}`);
+                        break;
+                    }
+                    case ImpalaSqlParser.RULE_databaseNameCreate:
+                    case ImpalaSqlParser.RULE_tableNameCreate:
+                    case ImpalaSqlParser.RULE_functionNameCreate:
+                    case ImpalaSqlParser.RULE_viewNameCreate:
+                    case ImpalaSqlParser.RULE_columnNamePathCreate: {
+                        result.push(`{new}${name}`);
+                        break;
+                    }
+                }
+            }
+            expectedText = result.join(`{or}`);
+        }
+        if (candidates.tokens.size) {
+            expectedText += expectedText ? '{orKeyword}' : '{keyword}';
+        }
+        return expectedText;
+    }
+}

package/dist/parser/impala/impalaEntityCollector.js

@@ -1,18 +1,58 @@
+import { ColumnDefinitionContext, CreateKuduTableAsSelectContext, CreateSchemaContext, CreateTableSelectContext, CreateViewContext, KuduTableElementContext, SampledRelationContext, ViewColumnItemContext, } from '../../lib/impala/ImpalaSqlParser';
+import { AttrName, EntityCollector, StmtContextType } from '../common/entityCollector';
 import { EntityContextType } from '../common/types';
-import { StmtContextType, EntityCollector } from '../common/entityCollector';
 export class ImpalaEntityCollector extends EntityCollector {
     /** ===== Entity begin */
     exitTableNameCreate(ctx) {
-        this.pushEntity(ctx, EntityContextType.TABLE_CREATE);
+        this.pushEntity(ctx, EntityContextType.TABLE_CREATE, [
+            {
+                attrName: AttrName.comment,
+                endContextList: [
+                    CreateTableSelectContext.name,
+                    CreateKuduTableAsSelectContext.name,
+                ],
+            },
+        ]);
     }
     exitTableNamePath(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: [SampledRelationContext.name],
+                },
+            ]
+            : undefined);
     }
     exitColumnNamePathCreate(ctx) {
-        this.pushEntity(ctx, EntityContextType.COLUMN_CREATE);
+        this.pushEntity(ctx, EntityContextType.COLUMN_CREATE, [
+            {
+                attrName: AttrName.comment,
+                endContextList: [
+                    ColumnDefinitionContext.name,
+                    KuduTableElementContext.name,
+                    ViewColumnItemContext.name,
+                ],
+            },
+            {
+                attrName: AttrName.colType,
+                endContextList: [
+                    ColumnDefinitionContext.name,
+                    KuduTableElementContext.name,
+                    ViewColumnItemContext.name,
+                ],
+            },
+        ]);
     }
     exitViewNameCreate(ctx) {
-        this.pushEntity(ctx, EntityContextType.VIEW_CREATE);
+        this.pushEntity(ctx, EntityContextType.VIEW_CREATE, [
+            {
+                attrName: AttrName.comment,
+                endContextList: [CreateViewContext.name],
+            },
+        ]);
     }
     exitViewNamePath(ctx) {
         this.pushEntity(ctx, EntityContextType.VIEW);
@@ -21,7 +61,12 @@ export class ImpalaEntityCollector extends EntityCollector {
         this.pushEntity(ctx, EntityContextType.DATABASE);
     }
     exitDatabaseNameCreate(ctx) {
-        this.pushEntity(ctx, EntityContextType.DATABASE_CREATE);
+        this.pushEntity(ctx, EntityContextType.DATABASE_CREATE, [
+            {
+                attrName: AttrName.comment,
+                endContextList: [CreateSchemaContext.name],
+            },
+        ]);
     }
     exitFunctionNameCreate(ctx) {
         this.pushEntity(ctx, EntityContextType.FUNCTION_CREATE);

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

@@ -6,12 +6,15 @@ import { BasicSQL } from '../common/basicSQL';
 import { Suggestions } from '../common/types';
 import { ImpalaSqlSplitListener } from './impalaSplitListener';
 import { ImpalaEntityCollector } from './impalaEntityCollector';
+import { ErrorListener } from '../common/parseErrorListener';
+import { ImpalaErrorListener } from './ImpalaErrorListener';
 export { ImpalaEntityCollector, ImpalaSqlSplitListener };
 export declare class ImpalaSQL extends BasicSQL<ImpalaSqlLexer, ProgramContext, ImpalaSqlParser> {
     protected createLexerFromCharStream(charStreams: CharStream): ImpalaSqlLexer;
     protected createParserFromTokenStream(tokenStream: CommonTokenStream): ImpalaSqlParser;
     protected preferredRules: Set<number>;
     protected get splitListener(): ImpalaSqlSplitListener;
+    protected createErrorListener(_errorListener: ErrorListener): ImpalaErrorListener;
     protected createEntityCollector(input: string, caretTokenIndex?: number): ImpalaEntityCollector;
     protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number, tokenIndexOffset: number): Suggestions<Token>;
 }