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

package/dist/parser/postgresql/postgreErrorListener.js

@@ -0,0 +1,71 @@
+import { CodeCompletionCore } from 'antlr4-c3';
+import { ParseErrorListener } from '../common/parseErrorListener';
+import { PostgreSqlParser } from '../../lib/postgresql/PostgreSqlParser';
+export class PostgreSqlErrorListener extends ParseErrorListener {
+    constructor(errorListener, preferredRules, locale) {
+        super(errorListener, locale);
+        this.objectNames = new Map([
+            [PostgreSqlParser.RULE_database_name, 'database'],
+            [PostgreSqlParser.RULE_database_name_create, 'database'],
+            [PostgreSqlParser.RULE_table_name, 'table'],
+            [PostgreSqlParser.RULE_table_name_create, 'table'],
+            [PostgreSqlParser.RULE_view_name, 'view'],
+            [PostgreSqlParser.RULE_view_name_create, 'view'],
+            [PostgreSqlParser.RULE_function_name, 'function'],
+            [PostgreSqlParser.RULE_function_name_create, 'function'],
+            [PostgreSqlParser.RULE_column_name, 'column'],
+            [PostgreSqlParser.RULE_column_name_create, 'column'],
+            [PostgreSqlParser.RULE_schema_name_create, 'schema'],
+            [PostgreSqlParser.RULE_schema_name, 'schema'],
+            [PostgreSqlParser.RULE_procedure_name_create, 'procedure'],
+            [PostgreSqlParser.RULE_procedure_name, 'procedure'],
+        ]);
+        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 PostgreSqlParser.RULE_table_name:
+                    case PostgreSqlParser.RULE_function_name:
+                    case PostgreSqlParser.RULE_schema_name:
+                    case PostgreSqlParser.RULE_view_name:
+                    case PostgreSqlParser.RULE_database_name:
+                    case PostgreSqlParser.RULE_procedure_name:
+                    case PostgreSqlParser.RULE_column_name: {
+                        result.push(`{existing}${name}`);
+                        break;
+                    }
+                    case PostgreSqlParser.RULE_table_name_create:
+                    case PostgreSqlParser.RULE_function_name_create:
+                    case PostgreSqlParser.RULE_schema_name_create:
+                    case PostgreSqlParser.RULE_view_name_create:
+                    case PostgreSqlParser.RULE_database_name_create:
+                    case PostgreSqlParser.RULE_procedure_name_create:
+                    case PostgreSqlParser.RULE_column_name_create: {
+                        result.push(`{new}${name}`);
+                        break;
+                    }
+                }
+            }
+            expectedText = result.join('{or}');
+        }
+        if (candidates.tokens.size) {
+            expectedText += expectedText ? '{orKeyword}' : '{keyword}';
+        }
+        return expectedText;
+    }
+}

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

@@ -6,12 +6,15 @@ import { BasicSQL } from '../common/basicSQL';
 import { Suggestions } from '../common/types';
 import { SparkSqlSplitListener } from './sparkSplitListener';
 import { SparkEntityCollector } from './sparkEntityCollector';
+import { SparkErrorListener } from './sparkErrorListener';
+import { ErrorListener } from '../common/parseErrorListener';
 export { SparkSqlSplitListener, SparkEntityCollector };
 export declare class SparkSQL extends BasicSQL<SparkSqlLexer, ProgramContext, SparkSqlParser> {
     protected createLexerFromCharStream(charStreams: CharStream): SparkSqlLexer;
     protected createParserFromTokenStream(tokenStream: CommonTokenStream): SparkSqlParser;
     protected preferredRules: Set<number>;
     protected get splitListener(): SparkSqlSplitListener;
+    protected createErrorListener(_errorListener: ErrorListener): SparkErrorListener;
     protected createEntityCollector(input: string, caretTokenIndex?: number): SparkEntityCollector;
-    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/spark/index.js

@@ -4,6 +4,7 @@ import { BasicSQL } from '../common/basicSQL';
 import { EntityContextType } from '../common/types';
 import { SparkSqlSplitListener } from './sparkSplitListener';
 import { SparkEntityCollector } from './sparkEntityCollector';
+import { SparkErrorListener } from './sparkErrorListener';
 export { SparkSqlSplitListener, SparkEntityCollector };
 export class SparkSQL extends BasicSQL {
     constructor() {
@@ -30,16 +31,19 @@ export class SparkSQL extends BasicSQL {
     get splitListener() {
         return new SparkSqlSplitListener();
     }
+    createErrorListener(_errorListener) {
+        return new SparkErrorListener(_errorListener, this.preferredRules, this.locale);
+    }
     createEntityCollector(input, caretTokenIndex) {
         return new SparkEntityCollector(input, caretTokenIndex);
     }
-    processCandidates(candidates, allTokens, caretTokenIndex, tokenIndexOffset) {
+    processCandidates(candidates, allTokens, caretTokenIndex) {
         const originalSyntaxSuggestions = [];
         const keywords = [];
         for (const 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 SparkSqlParser.RULE_namespaceName: {

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

@@ -1,4 +1,4 @@
-import type { NamespaceNameContext, NamespaceNameCreateContext, SingleStatementContext, TableNameContext, TableNameCreateContext, ViewNameContext, ViewNameCreateContext, FunctionNameCreateContext, ColumnNameCreateContext, CreateTableContext, CreateTableLikeContext, ReplaceTableContext, QueryStatementContext, InsertFromQueryContext, MultipleInsertContext, CreateViewContext, CreateTempViewUsingContext, CreateNamespaceContext, CreateFunctionContext } from '../../lib/spark/SparkSqlParser';
+import { ColumnNameCreateContext, CreateFunctionContext, CreateNamespaceContext, CreateTableContext, CreateTableLikeContext, CreateTempViewUsingContext, CreateViewContext, FunctionNameCreateContext, InsertFromQueryContext, MultipleInsertContext, NamespaceNameContext, NamespaceNameCreateContext, QueryStatementContext, ReplaceTableContext, SingleStatementContext, TableNameContext, TableNameCreateContext, ViewNameContext, ViewNameCreateContext } from '../../lib/spark/SparkSqlParser';
 import type { SparkSqlParserListener } from '../../lib/spark/SparkSqlParserListener';
 import { EntityCollector } from '../common/entityCollector';
 export declare class SparkEntityCollector extends EntityCollector implements SparkSqlParserListener {

package/dist/parser/spark/sparkEntityCollector.js

@@ -1,30 +1,67 @@
+import { CreateNamespaceContext, CreateOrReplaceTableColTypeContext, CreateTableContext, CreateViewContext, IdentifierCommentContext, RelationPrimaryContext, } from '../../lib/spark/SparkSqlParser';
+import { AttrName, EntityCollector, StmtContextType } from '../common/entityCollector';
 import { EntityContextType } from '../common/types';
-import { StmtContextType, EntityCollector } from '../common/entityCollector';
 export class SparkEntityCollector extends EntityCollector {
     /** ====== Entity Begin */
     exitNamespaceName(ctx) {
         this.pushEntity(ctx, EntityContextType.DATABASE);
     }
     exitNamespaceNameCreate(ctx) {
-        this.pushEntity(ctx, EntityContextType.DATABASE_CREATE);
+        this.pushEntity(ctx, EntityContextType.DATABASE_CREATE, [
+            {
+                attrName: AttrName.comment,
+                endContextList: [CreateNamespaceContext.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: [RelationPrimaryContext.name],
+                },
+            ]
+            : undefined);
     }
     exitTableNameCreate(ctx) {
-        this.pushEntity(ctx, EntityContextType.TABLE_CREATE);
+        this.pushEntity(ctx, EntityContextType.TABLE_CREATE, [
+            {
+                attrName: AttrName.comment,
+                endContextList: [CreateTableContext.name],
+            },
+        ]);
     }
     exitViewName(ctx) {
         this.pushEntity(ctx, EntityContextType.VIEW);
     }
     exitViewNameCreate(ctx) {
-        this.pushEntity(ctx, EntityContextType.VIEW_CREATE);
+        this.pushEntity(ctx, EntityContextType.VIEW_CREATE, [
+            {
+                attrName: AttrName.comment,
+                endContextList: [CreateViewContext.name],
+            },
+        ]);
     }
     exitFunctionNameCreate(ctx) {
         this.pushEntity(ctx, EntityContextType.FUNCTION_CREATE);
     }
     exitColumnNameCreate(ctx) {
-        this.pushEntity(ctx, EntityContextType.COLUMN_CREATE);
+        this.pushEntity(ctx, EntityContextType.COLUMN_CREATE, [
+            {
+                attrName: AttrName.comment,
+                endContextList: [
+                    CreateOrReplaceTableColTypeContext.name,
+                    IdentifierCommentContext.name,
+                ],
+            },
+            {
+                attrName: AttrName.colType,
+                endContextList: [CreateOrReplaceTableColTypeContext.name],
+            },
+        ]);
     }
     /** ===== Statement begin */
     enterSingleStatement(ctx) {

package/dist/parser/spark/sparkErrorListener.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 SparkErrorListener extends ParseErrorListener {
+    private preferredRules;
+    private objectNames;
+    constructor(errorListener: ErrorListener, preferredRules: Set<number>, locale: LOCALE_TYPE);
+    getExpectedText(parser: Parser, token: Token): string;
+}

package/dist/parser/spark/sparkErrorListener.js

@@ -0,0 +1,63 @@
+import { CodeCompletionCore } from 'antlr4-c3';
+import { ParseErrorListener } from '../common/parseErrorListener';
+import { SparkSqlParser } from '../../lib/spark/SparkSqlParser';
+export class SparkErrorListener extends ParseErrorListener {
+    constructor(errorListener, preferredRules, locale) {
+        super(errorListener, locale);
+        this.objectNames = new Map([
+            [SparkSqlParser.RULE_namespaceName, 'namespace'],
+            [SparkSqlParser.RULE_namespaceNameCreate, 'namespace'],
+            [SparkSqlParser.RULE_tableName, 'table'],
+            [SparkSqlParser.RULE_tableNameCreate, 'table'],
+            [SparkSqlParser.RULE_viewName, 'view'],
+            [SparkSqlParser.RULE_viewNameCreate, 'view'],
+            [SparkSqlParser.RULE_functionName, 'function'],
+            [SparkSqlParser.RULE_functionNameCreate, 'function'],
+            [SparkSqlParser.RULE_columnName, 'column'],
+            [SparkSqlParser.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 SparkSqlParser.RULE_namespaceName:
+                    case SparkSqlParser.RULE_tableName:
+                    case SparkSqlParser.RULE_viewName:
+                    case SparkSqlParser.RULE_functionName:
+                    case SparkSqlParser.RULE_columnName: {
+                        result.push(`{existing}${name}`);
+                        break;
+                    }
+                    case SparkSqlParser.RULE_namespaceNameCreate:
+                    case SparkSqlParser.RULE_tableNameCreate:
+                    case SparkSqlParser.RULE_functionNameCreate:
+                    case SparkSqlParser.RULE_viewNameCreate:
+                    case SparkSqlParser.RULE_columnNameCreate: {
+                        result.push(`{new}${name}`);
+                        break;
+                    }
+                }
+            }
+            expectedText = result.join('{or}');
+        }
+        if (candidates.tokens.size) {
+            expectedText += expectedText ? '{orKeyword}' : '{keyword}';
+        }
+        return expectedText;
+    }
+}

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

@@ -6,12 +6,15 @@ import { BasicSQL } from '../common/basicSQL';
 import { Suggestions } from '../common/types';
 import { TrinoSqlSplitListener } from './trinoSplitListener';
 import { TrinoEntityCollector } from './trinoEntityCollector';
+import { ErrorListener } from '../common/parseErrorListener';
+import { TrinoErrorListener } from './trinoErrorListener';
 export { TrinoSqlSplitListener, TrinoEntityCollector };
 export declare class TrinoSQL extends BasicSQL<TrinoSqlLexer, ProgramContext, TrinoSqlParser> {
     protected createLexerFromCharStream(charStreams: CharStream): TrinoSqlLexer;
     protected createParserFromTokenStream(tokenStream: CommonTokenStream): TrinoSqlParser;
     protected get splitListener(): TrinoSqlSplitListener;
+    protected createErrorListener(_errorListener: ErrorListener): TrinoErrorListener;
     protected createEntityCollector(input: string, caretTokenIndex?: number): TrinoEntityCollector;
     protected preferredRules: Set<number>;
-    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/trino/index.js

@@ -4,21 +4,23 @@ import { BasicSQL } from '../common/basicSQL';
 import { EntityContextType } from '../common/types';
 import { TrinoSqlSplitListener } from './trinoSplitListener';
 import { TrinoEntityCollector } from './trinoEntityCollector';
+import { TrinoErrorListener } from './trinoErrorListener';
 export { TrinoSqlSplitListener, TrinoEntityCollector };
 export class TrinoSQL extends BasicSQL {
     constructor() {
         super(...arguments);
         this.preferredRules = new Set([
-            TrinoSqlParser.RULE_catalogName,
+            TrinoSqlParser.RULE_catalogRef,
             TrinoSqlParser.RULE_catalogNameCreate,
-            TrinoSqlParser.RULE_schemaName,
+            TrinoSqlParser.RULE_schemaRef,
             TrinoSqlParser.RULE_schemaNameCreate,
-            TrinoSqlParser.RULE_tableName,
+            TrinoSqlParser.RULE_tableRef,
             TrinoSqlParser.RULE_tableNameCreate,
-            TrinoSqlParser.RULE_viewName,
+            TrinoSqlParser.RULE_viewRef,
             TrinoSqlParser.RULE_viewNameCreate,
             TrinoSqlParser.RULE_functionName,
-            TrinoSqlParser.RULE_columnName,
+            TrinoSqlParser.RULE_functionNameCreate,
+            TrinoSqlParser.RULE_columnRef,
             TrinoSqlParser.RULE_columnNameCreate,
         ]);
     }
@@ -31,23 +33,30 @@ export class TrinoSQL extends BasicSQL {
     get splitListener() {
         return new TrinoSqlSplitListener();
     }
+    createErrorListener(_errorListener) {
+        return new TrinoErrorListener(_errorListener, this.preferredRules, this.locale);
+    }
     createEntityCollector(input, caretTokenIndex) {
         return new TrinoEntityCollector(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 TrinoSqlParser.RULE_catalogName: {
+                case TrinoSqlParser.RULE_catalogRef: {
                     syntaxContextType = EntityContextType.CATALOG;
                     break;
                 }
-                case TrinoSqlParser.RULE_schemaName: {
+                case TrinoSqlParser.RULE_catalogNameCreate: {
+                    syntaxContextType = EntityContextType.CATALOG_CREATE;
+                    break;
+                }
+                case TrinoSqlParser.RULE_schemaRef: {
                     syntaxContextType = EntityContextType.DATABASE;
                     break;
                 }
@@ -55,7 +64,7 @@ export class TrinoSQL extends BasicSQL {
                     syntaxContextType = EntityContextType.DATABASE_CREATE;
                     break;
                 }
-                case TrinoSqlParser.RULE_tableName: {
+                case TrinoSqlParser.RULE_tableRef: {
                     syntaxContextType = EntityContextType.TABLE;
                     break;
                 }
@@ -63,7 +72,7 @@ export class TrinoSQL extends BasicSQL {
                     syntaxContextType = EntityContextType.TABLE_CREATE;
                     break;
                 }
-                case TrinoSqlParser.RULE_viewName: {
+                case TrinoSqlParser.RULE_viewRef: {
                     syntaxContextType = EntityContextType.VIEW;
                     break;
                 }
@@ -75,11 +84,15 @@ export class TrinoSQL extends BasicSQL {
                     syntaxContextType = EntityContextType.FUNCTION;
                     break;
                 }
+                case TrinoSqlParser.RULE_functionNameCreate: {
+                    syntaxContextType = EntityContextType.FUNCTION_CREATE;
+                    break;
+                }
                 case TrinoSqlParser.RULE_columnNameCreate: {
                     syntaxContextType = EntityContextType.COLUMN_CREATE;
                     break;
                 }
-                case TrinoSqlParser.RULE_columnName: {
+                case TrinoSqlParser.RULE_columnRef: {
                     syntaxContextType = EntityContextType.COLUMN;
                     break;
                 }

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

@@ -1,13 +1,15 @@
-import type { ColumnNameCreateContext, CreateMaterializedViewContext, CreateSchemaContext, CreateTableAsSelectContext, CreateTableContext, CreateViewContext, InsertIntoContext, QueryStatementContext, SchemaNameContext, SchemaNameCreateContext, SingleStatementContext, TableNameContext, TableNameCreateContext, ViewNameContext, ViewNameCreateContext } from '../../lib/trino/TrinoSqlParser';
 import type { TrinoSqlListener } from '../../lib/trino/TrinoSqlListener';
+import { CatalogNameCreateContext, CatalogRefContext, ColumnNameCreateContext, CreateMaterializedViewContext, CreateSchemaContext, CreateTableAsSelectContext, CreateTableContext, CreateViewContext, InsertIntoContext, QueryStatementContext, SchemaNameCreateContext, SchemaRefContext, SingleStatementContext, TableNameCreateContext, TableRefContext, ViewNameCreateContext, ViewRefContext } from '../../lib/trino/TrinoSqlParser';
 import { EntityCollector } from '../common/entityCollector';
 export declare class TrinoEntityCollector extends EntityCollector implements TrinoSqlListener {
     /** ====== Entity Begin */
-    exitSchemaName(ctx: SchemaNameContext): void;
+    exitCatalogRef(ctx: CatalogRefContext): void;
+    exitCatalogNameCreate(ctx: CatalogNameCreateContext): void;
+    exitSchemaRef(ctx: SchemaRefContext): void;
     exitSchemaNameCreate(ctx: SchemaNameCreateContext): void;
-    exitTableName(ctx: TableNameContext): void;
+    exitTableRef(ctx: TableRefContext): void;
     exitTableNameCreate(ctx: TableNameCreateContext): void;
-    exitViewName(ctx: ViewNameContext): void;
+    exitViewRef(ctx: ViewRefContext): void;
     exitViewNameCreate(ctx: ViewNameCreateContext): void;
     exitColumnNameCreate(ctx: ColumnNameCreateContext): void;
     /** ===== Statement begin */

package/dist/parser/trino/trinoEntityCollector.js

@@ -1,27 +1,62 @@
+import { AliasedRelationContext, ColumnDefinitionContext, CreateMaterializedViewContext, CreateTableAsSelectContext, CreateTableContext, CreateViewContext, } from '../../lib/trino/TrinoSqlParser';
+import { AttrName, EntityCollector, StmtContextType } from '../common/entityCollector';
 import { EntityContextType } from '../common/types';
-import { StmtContextType, EntityCollector } from '../common/entityCollector';
 export class TrinoEntityCollector extends EntityCollector {
     /** ====== Entity Begin */
-    exitSchemaName(ctx) {
+    exitCatalogRef(ctx) {
+        this.pushEntity(ctx, EntityContextType.CATALOG);
+    }
+    exitCatalogNameCreate(ctx) {
+        this.pushEntity(ctx, EntityContextType.CATALOG_CREATE);
+    }
+    exitSchemaRef(ctx) {
         this.pushEntity(ctx, EntityContextType.DATABASE);
     }
     exitSchemaNameCreate(ctx) {
         this.pushEntity(ctx, EntityContextType.DATABASE_CREATE);
     }
-    exitTableName(ctx) {
-        this.pushEntity(ctx, EntityContextType.TABLE);
+    exitTableRef(ctx) {
+        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: [AliasedRelationContext.name],
+                },
+            ]
+            : undefined);
     }
     exitTableNameCreate(ctx) {
-        this.pushEntity(ctx, EntityContextType.TABLE_CREATE);
-    }
-    exitViewName(ctx) {
+        this.pushEntity(ctx, EntityContextType.TABLE_CREATE, [
+            {
+                attrName: AttrName.comment,
+                endContextList: [CreateTableContext.name, CreateTableAsSelectContext.name],
+            },
+        ]);
+    }
+    exitViewRef(ctx) {
         this.pushEntity(ctx, EntityContextType.VIEW);
     }
     exitViewNameCreate(ctx) {
-        this.pushEntity(ctx, EntityContextType.VIEW_CREATE);
+        this.pushEntity(ctx, EntityContextType.VIEW_CREATE, [
+            {
+                attrName: AttrName.comment,
+                endContextList: [CreateMaterializedViewContext.name, CreateViewContext.name],
+            },
+        ]);
     }
     exitColumnNameCreate(ctx) {
-        this.pushEntity(ctx, EntityContextType.COLUMN_CREATE);
+        this.pushEntity(ctx, EntityContextType.COLUMN_CREATE, [
+            {
+                attrName: AttrName.colType,
+                endContextList: [ColumnDefinitionContext.name],
+            },
+            {
+                attrName: AttrName.comment,
+                endContextList: [ColumnDefinitionContext.name],
+            },
+        ]);
     }
     /** ===== Statement begin */
     enterSingleStatement(ctx) {

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

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

package/dist/parser/trino/trinoErrorListener.js

@@ -0,0 +1,65 @@
+import { CodeCompletionCore } from 'antlr4-c3';
+import { TrinoSqlParser } from '../../lib/trino/TrinoSqlParser';
+import { ParseErrorListener } from '../common/parseErrorListener';
+export class TrinoErrorListener extends ParseErrorListener {
+    constructor(errorListener, preferredRules, locale) {
+        super(errorListener, locale);
+        this.objectNames = new Map([
+            [TrinoSqlParser.RULE_catalogRef, 'catalog'],
+            [TrinoSqlParser.RULE_catalogNameCreate, 'catalog'],
+            [TrinoSqlParser.RULE_tableRef, 'table'],
+            [TrinoSqlParser.RULE_tableNameCreate, 'table'],
+            [TrinoSqlParser.RULE_viewRef, 'view'],
+            [TrinoSqlParser.RULE_viewNameCreate, 'view'],
+            [TrinoSqlParser.RULE_schemaRef, 'schema'],
+            [TrinoSqlParser.RULE_schemaNameCreate, 'schema'],
+            [TrinoSqlParser.RULE_functionName, 'function'],
+            [TrinoSqlParser.RULE_columnRef, 'column'],
+            [TrinoSqlParser.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 TrinoSqlParser.RULE_catalogRef:
+                    case TrinoSqlParser.RULE_schemaRef:
+                    case TrinoSqlParser.RULE_tableRef:
+                    case TrinoSqlParser.RULE_viewRef:
+                    case TrinoSqlParser.RULE_functionName:
+                    case TrinoSqlParser.RULE_columnRef: {
+                        result.push(`{existing}${name}`);
+                        break;
+                    }
+                    case TrinoSqlParser.RULE_catalogNameCreate:
+                    case TrinoSqlParser.RULE_tableNameCreate:
+                    case TrinoSqlParser.RULE_schemaNameCreate:
+                    case TrinoSqlParser.RULE_viewNameCreate:
+                    case TrinoSqlParser.RULE_tableNameCreate: {
+                        result.push(`{new}${name}`);
+                        break;
+                    }
+                }
+            }
+            expectedText = result.join('{or}');
+        }
+        if (candidates.tokens.size) {
+            expectedText += expectedText ? '{orKeyword}' : '{keyword}';
+        }
+        return expectedText;
+    }
+}

package/package.json

@@ -1,16 +1,20 @@
 {
   "name": "dt-sql-parser",
-  "version": "4.0.2",
+  "version": "4.1.0-beta.1",
   "authors": "DTStack Corporation",
   "description": "SQL Parsers for BigData, built with antlr4",
   "keywords": [
+    "antlr4",
     "sql",
     "parser",
-    "monaco-editor",
+    "code-completion",
     "hive",
     "spark",
     "flink",
-    "bigdata"
+    "mysql",
+    "postgresql",
+    "trino",
+    "impala"
   ],
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -26,13 +30,17 @@
     "check-types": "tsc -p ./tsconfig.json && tsc -p ./test/tsconfig.json",
     "test": "NODE_OPTIONS=--max_old_space_size=4096 && jest",
     "release": "node ./scripts/release.js",
-    "lint": "prettier --check '**/*.ts' --config ./.prettierrc",
-    "lint-fix": "prettier --write '**/*.ts' --config ./.prettierrc",
+    "prettier-check": "prettier --check .",
+    "format": "prettier --write .",
     "format-g4": "antlr-format -c ./antlr.format.json -v ./src/grammar/**/*.g4",
     "cleanComment": "node ./scripts/cleanCommentCli.js",
     "benchmark": "node --no-warnings ./scripts/benchmark.js"
   },
   "license": "MIT",
+  "dependencies": {
+    "antlr4-c3": "3.3.7",
+    "antlr4ng": "2.0.11"
+  },
   "devDependencies": {
     "@commitlint/cli": "^17.7.2",
     "@commitlint/config-conventional": "^17.7.0",
@@ -53,19 +61,35 @@
     "jest": "^29.5.0",
     "lint-staged": "12.5.0",
     "prettier": "^3.0.3",
+    "semver": "^7.6.2",
     "standard-version": "^9.5.0",
     "tsx": "^4.7.1",
     "typescript": "^5.0.4",
     "yargs-parser": "^21.1.1"
   },
-  "git repository": "https://github.com/DTStack/dt-sql-parser",
-  "repository": "https://github.com/DTStack/dt-sql-parser",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/DTStack/dt-sql-parser.git"
+  },
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"
   },
-  "dependencies": {
-    "antlr4-c3": "3.3.7",
-    "antlr4ng": "2.0.11"
+  "sideEffects": false,
+  "engines": {
+    "node": ">=18"
+  },
+  "packageManager": "pnpm@9.7.0",
+  "config": {
+    "commitizen": {
+      "path": "./node_modules/@commitlint/cz-commitlint"
+    }
   },
-  "sideEffects": false
+  "lint-staged": {
+    "*": [
+      "prettier --write --ignore-unknown"
+    ],
+    "*.g4": [
+      "antlr-format -c ./antlr.format.json -v"
+    ]
+  }
 }