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

package/dist/parser/impala/index.js

@@ -4,6 +4,7 @@ import { BasicSQL } from '../common/basicSQL';
 import { EntityContextType } from '../common/types';
 import { ImpalaSqlSplitListener } from './impalaSplitListener';
 import { ImpalaEntityCollector } from './impalaEntityCollector';
+import { ImpalaErrorListener } from './ImpalaErrorListener';
 export { ImpalaEntityCollector, ImpalaSqlSplitListener };
 export class ImpalaSQL extends BasicSQL {
     constructor() {
@@ -30,6 +31,9 @@ export class ImpalaSQL extends BasicSQL {
     get splitListener() {
         return new ImpalaSqlSplitListener();
     }
+    createErrorListener(_errorListener) {
+        return new ImpalaErrorListener(_errorListener, this.preferredRules, this.locale);
+    }
     createEntityCollector(input, caretTokenIndex) {
         return new ImpalaEntityCollector(input, caretTokenIndex);
     }

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

@@ -6,12 +6,15 @@ import { BasicSQL } from '../common/basicSQL';
 import { Suggestions } from '../common/types';
 import { MysqlSplitListener } from './mysqlSplitListener';
 import { MySqlEntityCollector } from './mysqlEntityCollector';
+import { MysqlErrorListener } from './mysqlErrorListener';
+import { ErrorListener } from '../common/parseErrorListener';
 export { MySqlEntityCollector, MysqlSplitListener };
 export declare class MySQL extends BasicSQL<MySqlLexer, ProgramContext, MySqlParser> {
     protected createLexerFromCharStream(charStreams: CharStream): MySqlLexer;
     protected createParserFromTokenStream(tokenStream: CommonTokenStream): MySqlParser;
     protected preferredRules: Set<number>;
     protected get splitListener(): MysqlSplitListener;
+    protected createErrorListener(_errorListener: ErrorListener): MysqlErrorListener;
     protected createEntityCollector(input: string, caretTokenIndex?: number): MySqlEntityCollector;
     protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number, tokenIndexOffset: number): Suggestions<Token>;
 }

package/dist/parser/mysql/index.js

@@ -4,6 +4,7 @@ import { BasicSQL } from '../common/basicSQL';
 import { EntityContextType } from '../common/types';
 import { MysqlSplitListener } from './mysqlSplitListener';
 import { MySqlEntityCollector } from './mysqlEntityCollector';
+import { MysqlErrorListener } from './mysqlErrorListener';
 export { MySqlEntityCollector, MysqlSplitListener };
 export class MySQL extends BasicSQL {
     constructor() {
@@ -30,6 +31,9 @@ export class MySQL extends BasicSQL {
     get splitListener() {
         return new MysqlSplitListener();
     }
+    createErrorListener(_errorListener) {
+        return new MysqlErrorListener(_errorListener, this.preferredRules, this.locale);
+    }
     createEntityCollector(input, caretTokenIndex) {
         return new MySqlEntityCollector(input, caretTokenIndex);
     }

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

@@ -1,4 +1,4 @@
-import type { ColumnCreateTableContext, ColumnNameCreateContext, CopyCreateTableContext, CreateDatabaseContext, CreateFunctionContext, CreateViewContext, DatabaseNameContext, DatabaseNameCreateContext, FunctionNameCreateContext, InsertStatementContext, QueryCreateTableContext, SelectStatementContext, SingleStatementContext, TableNameContext, TableNameCreateContext, ViewNameContext, ViewNameCreateContext } from '../../lib/mysql/MySqlParser';
+import { ColumnCreateTableContext, ColumnNameCreateContext, CopyCreateTableContext, CreateDatabaseContext, CreateFunctionContext, CreateFunctionLoadableContext, CreateViewContext, DatabaseNameContext, DatabaseNameCreateContext, FunctionNameCreateContext, InsertStatementContext, QueryCreateTableContext, SelectStatementContext, SingleStatementContext, TableNameContext, TableNameCreateContext, ViewNameContext, ViewNameCreateContext } from '../../lib/mysql/MySqlParser';
 import type { MySqlParserListener } from '../../lib/mysql/MySqlParserListener';
 import { EntityCollector } from '../common/entityCollector';
 export declare class MySqlEntityCollector extends EntityCollector implements MySqlParserListener {
@@ -34,4 +34,6 @@ export declare class MySqlEntityCollector extends EntityCollector implements MyS
     exitCreateDatabase(ctx: CreateDatabaseContext): void;
     enterCreateFunction(ctx: CreateFunctionContext): void;
     exitCreateFunction(ctx: CreateFunctionContext): void;
+    enterCreateFunctionLoadable(ctx: CreateFunctionLoadableContext): void;
+    exitCreateFunctionLoadable(ctx: CreateFunctionLoadableContext): void;
 }

package/dist/parser/mysql/mysqlEntityCollector.js

@@ -1,5 +1,6 @@
+import { ColumnCreateTableContext, CreateDefinitionContext, CreateFunctionContext, TableSourceContext, } from '../../lib/mysql/MySqlParser';
+import { AttrName, EntityCollector, StmtContextType } from '../common/entityCollector';
 import { EntityContextType } from '../common/types';
-import { StmtContextType, EntityCollector } from '../common/entityCollector';
 export class MySqlEntityCollector extends EntityCollector {
     /** ====== Entity Begin */
     exitDatabaseName(ctx) {
@@ -9,10 +10,24 @@ export class MySqlEntityCollector extends EntityCollector {
         this.pushEntity(ctx, EntityContextType.DATABASE_CREATE);
     }
     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],
+                },
+            ]
+            : undefined);
     }
     exitTableNameCreate(ctx) {
-        this.pushEntity(ctx, EntityContextType.TABLE_CREATE);
+        this.pushEntity(ctx, EntityContextType.TABLE_CREATE, [
+            {
+                attrName: AttrName.comment,
+                endContextList: [ColumnCreateTableContext.name],
+            },
+        ]);
     }
     exitViewName(ctx) {
         this.pushEntity(ctx, EntityContextType.VIEW);
@@ -21,10 +36,24 @@ export class MySqlEntityCollector extends EntityCollector {
         this.pushEntity(ctx, EntityContextType.VIEW_CREATE);
     }
     exitFunctionNameCreate(ctx) {
-        this.pushEntity(ctx, EntityContextType.FUNCTION_CREATE);
+        this.pushEntity(ctx, EntityContextType.FUNCTION_CREATE, [
+            {
+                attrName: AttrName.comment,
+                endContextList: [CreateFunctionContext.name],
+            },
+        ]);
     }
     exitColumnNameCreate(ctx) {
-        this.pushEntity(ctx, EntityContextType.COLUMN_CREATE);
+        this.pushEntity(ctx, EntityContextType.COLUMN_CREATE, [
+            {
+                attrName: AttrName.comment,
+                endContextList: [CreateDefinitionContext.name],
+            },
+            {
+                attrName: AttrName.colType,
+                endContextList: [CreateDefinitionContext.name],
+            },
+        ]);
     }
     /** ===== Statement begin */
     enterSingleStatement(ctx) {
@@ -93,4 +122,10 @@ export class MySqlEntityCollector extends EntityCollector {
     exitCreateFunction(ctx) {
         this.popStmt();
     }
+    enterCreateFunctionLoadable(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_FUNCTION_STMT);
+    }
+    exitCreateFunctionLoadable(ctx) {
+        this.popStmt();
+    }
 }

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

package/dist/parser/mysql/mysqlErrorListener.js

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

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

@@ -6,12 +6,15 @@ import { Suggestions } from '../common/types';
 import { BasicSQL } from '../common/basicSQL';
 import { PostgreSqlEntityCollector } from './postgreEntityCollector';
 import { PostgreSqlSplitListener } from './postgreSplitListener';
+import { ErrorListener } from '../common/parseErrorListener';
+import { PostgreSqlErrorListener } from './postgreErrorListener';
 export { PostgreSqlEntityCollector, PostgreSqlSplitListener };
 export declare class PostgreSQL extends BasicSQL<PostgreSqlLexer, ProgramContext, PostgreSqlParser> {
     protected createLexerFromCharStream(charStreams: CharStream): PostgreSqlLexer;
     protected createParserFromTokenStream(tokenStream: CommonTokenStream): PostgreSqlParser;
     protected preferredRules: Set<number>;
     protected get splitListener(): PostgreSqlSplitListener;
+    protected createErrorListener(_errorListener: ErrorListener): PostgreSqlErrorListener;
     protected createEntityCollector(input: string, caretTokenIndex?: number): PostgreSqlEntityCollector;
     protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number, tokenIndexOffset: number): Suggestions<Token>;
 }

package/dist/parser/postgresql/index.js

@@ -4,24 +4,25 @@ import { EntityContextType } from '../common/types';
 import { BasicSQL } from '../common/basicSQL';
 import { PostgreSqlEntityCollector } from './postgreEntityCollector';
 import { PostgreSqlSplitListener } from './postgreSplitListener';
+import { PostgreSqlErrorListener } from './postgreErrorListener';
 export { PostgreSqlEntityCollector, PostgreSqlSplitListener };
 export class PostgreSQL extends BasicSQL {
     constructor() {
         super(...arguments);
         this.preferredRules = new Set([
-            PostgreSqlParser.RULE_table_name_create,
-            PostgreSqlParser.RULE_table_name,
-            PostgreSqlParser.RULE_function_name,
-            PostgreSqlParser.RULE_function_name_create,
-            PostgreSqlParser.RULE_schema_name_create,
-            PostgreSqlParser.RULE_schema_name,
-            PostgreSqlParser.RULE_view_name_create,
-            PostgreSqlParser.RULE_view_name,
-            PostgreSqlParser.RULE_database_name_create,
-            PostgreSqlParser.RULE_database_name,
-            PostgreSqlParser.RULE_procedure_name_create,
-            PostgreSqlParser.RULE_procedure_name,
-            PostgreSqlParser.RULE_column_name_create,
+            PostgreSqlParser.RULE_table_name_create, // table name
+            PostgreSqlParser.RULE_table_name, // table name that will be created
+            PostgreSqlParser.RULE_function_name, // function name
+            PostgreSqlParser.RULE_function_name_create, // function name that will be created
+            PostgreSqlParser.RULE_schema_name_create, // schema name that will be created
+            PostgreSqlParser.RULE_schema_name, // schema name
+            PostgreSqlParser.RULE_view_name_create, // view name that will be created
+            PostgreSqlParser.RULE_view_name, // view name
+            PostgreSqlParser.RULE_database_name_create, // database name that will be created
+            PostgreSqlParser.RULE_database_name, // database name
+            PostgreSqlParser.RULE_procedure_name_create, // procedure name that will be created
+            PostgreSqlParser.RULE_procedure_name, // procedure name
+            PostgreSqlParser.RULE_column_name_create, // column name that will be created
             PostgreSqlParser.RULE_column_name, // column name
         ]);
     }
@@ -34,6 +35,9 @@ export class PostgreSQL extends BasicSQL {
     get splitListener() {
         return new PostgreSqlSplitListener();
     }
+    createErrorListener(_errorListener) {
+        return new PostgreSqlErrorListener(_errorListener, this.preferredRules, this.locale);
+    }
     createEntityCollector(input, caretTokenIndex) {
         return new PostgreSqlEntityCollector(input, caretTokenIndex);
     }

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

@@ -1,4 +1,4 @@
-import type { ColumnCreateTableContext, ColumnNameCreateContext, CreateDatabaseContext, CreateForeignTableContext, CreateMaterializedViewContext, CreatePartitionForeignTableContext, CreateViewContext, CreatefunctionstmtContext, DatabaseNameContext, DatabaseNameCreateContext, FunctionNameCreateContext, InsertStatementContext, QueryCreateTableContext, SelectStatementContext, SingleStmtContext, TableNameContext, TableNameCreateContext, ViewNameContext, ViewNameCreateContext } from '../../lib/postgresql/PostgreSqlParser';
+import { type AltertablestmtContext, type ColumnCreateTableContext, type ColumnNameCreateContext, type CreateDatabaseContext, type CreateForeignTableContext, type CreatefunctionstmtContext, type CreateMaterializedViewContext, type CreatePartitionForeignTableContext, type CreateViewContext, type DatabaseNameContext, type DatabaseNameCreateContext, type FunctionNameCreateContext, type InsertStatementContext, type ProcedureNameContext, type ProcedureNameCreateContext, type QueryCreateTableContext, type SelectStatementContext, type SingleStmtContext, type TableNameContext, type TableNameCreateContext, type ViewNameContext, type ViewNameCreateContext } from '../../lib/postgresql/PostgreSqlParser';
 import type { PostgreSqlParserListener } from '../../lib/postgresql/PostgreSqlParserListener';
 import { EntityCollector } from '../common/entityCollector';
 export declare class PostgreSqlEntityCollector extends EntityCollector implements PostgreSqlParserListener {
@@ -11,6 +11,8 @@ export declare class PostgreSqlEntityCollector extends EntityCollector implement
     exitViewNameCreate(ctx: ViewNameCreateContext): void;
     exitFunctionNameCreate(ctx: FunctionNameCreateContext): void;
     exitColumnNameCreate(ctx: ColumnNameCreateContext): void;
+    exitProcedureName(ctx: ProcedureNameContext): void;
+    exitProcedureNameCreate(ctx: ProcedureNameCreateContext): void;
     /** ===== Statement begin */
     enterSingleStatement(ctx: SingleStmtContext): void;
     exitSingleStatement(ctx: SingleStmtContext): void;
@@ -34,4 +36,6 @@ export declare class PostgreSqlEntityCollector extends EntityCollector implement
     exitInsertStatement(ctx: InsertStatementContext): void;
     enterCreatefunctionstmt(ctx: CreatefunctionstmtContext): void;
     exitCreatefunctionstmt(ctx: CreatefunctionstmtContext): void;
+    enterAltertablestmt(ctx: AltertablestmtContext): void;
+    exitAltertablestmt(ctx: AltertablestmtContext): void;
 }

package/dist/parser/postgresql/postgreEntityCollector.js

@@ -1,5 +1,6 @@
+import { Column_defContext, Table_refContext, } from '../../lib/postgresql/PostgreSqlParser';
+import { AttrName, EntityCollector, StmtContextType } from '../common/entityCollector';
 import { EntityContextType } from '../common/types';
-import { StmtContextType, EntityCollector } from '../common/entityCollector';
 export class PostgreSqlEntityCollector extends EntityCollector {
     /** ====== Entity Begin */
     exitDatabaseName(ctx) {
@@ -9,13 +10,31 @@ export class PostgreSqlEntityCollector extends EntityCollector {
         this.pushEntity(ctx, EntityContextType.DATABASE_CREATE);
     }
     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: [Table_refContext.name],
+                },
+            ]
+            : undefined);
     }
     exitTableNameCreate(ctx) {
         this.pushEntity(ctx, EntityContextType.TABLE_CREATE);
     }
     exitViewName(ctx) {
-        this.pushEntity(ctx, EntityContextType.VIEW);
+        var _a;
+        const needCollectAttr = ((_a = this.getRootStmt()) === null || _a === void 0 ? void 0 : _a.stmtContextType) === StmtContextType.SELECT_STMT;
+        this.pushEntity(ctx, EntityContextType.VIEW, needCollectAttr
+            ? [
+                {
+                    attrName: AttrName.alias,
+                    endContextList: [Table_refContext.name],
+                },
+            ]
+            : undefined);
     }
     exitViewNameCreate(ctx) {
         this.pushEntity(ctx, EntityContextType.VIEW_CREATE);
@@ -24,7 +43,22 @@ export class PostgreSqlEntityCollector extends EntityCollector {
         this.pushEntity(ctx, EntityContextType.FUNCTION_CREATE);
     }
     exitColumnNameCreate(ctx) {
-        this.pushEntity(ctx, EntityContextType.COLUMN_CREATE);
+        this.pushEntity(ctx, EntityContextType.COLUMN_CREATE, [
+            {
+                attrName: AttrName.comment,
+                endContextList: [Column_defContext.name],
+            },
+            {
+                attrName: AttrName.colType,
+                endContextList: [Column_defContext.name],
+            },
+        ]);
+    }
+    exitProcedureName(ctx) {
+        this.pushEntity(ctx, EntityContextType.PROCEDURE);
+    }
+    exitProcedureNameCreate(ctx) {
+        this.pushEntity(ctx, EntityContextType.PROCEDURE_CREATE);
     }
     /** ===== Statement begin */
     enterSingleStatement(ctx) {
@@ -93,4 +127,10 @@ export class PostgreSqlEntityCollector extends EntityCollector {
     exitCreatefunctionstmt(ctx) {
         this.popStmt();
     }
+    enterAltertablestmt(ctx) {
+        this.pushStmt(ctx, StmtContextType.ALTER_TABLE_STMT);
+    }
+    exitAltertablestmt(ctx) {
+        this.popStmt();
+    }
 }

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

package/dist/parser/postgresql/postgreErrorListener.js

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

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

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