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

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>;
+    protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number): Suggestions<Token>;
 }

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,16 +31,19 @@ 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);
     }
-    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 ImpalaSqlParser.RULE_functionNameCreate: {

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>;
+    protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: 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,16 +31,19 @@ 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);
     }
-    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 MySqlParser.RULE_databaseName: {

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>;
+    protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: 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,16 +35,19 @@ 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);
     }
-    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 PostgreSqlParser.RULE_table_name_create: {

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