dt-sql-parser 4.1.2-beta.0 → 4.2.0

package/dist/parser/impala/ImpalaErrorListener.js

@@ -13,6 +13,7 @@ export class ImpalaErrorListener extends ParseErrorListener {
             [ImpalaSqlParser.RULE_viewNameCreate, 'view'],
             [ImpalaSqlParser.RULE_functionNamePath, 'function'],
             [ImpalaSqlParser.RULE_functionNameCreate, 'function'],
+            [ImpalaSqlParser.RULE_columnName, 'column'],
             [ImpalaSqlParser.RULE_columnNamePath, 'column'],
             [ImpalaSqlParser.RULE_columnNamePathCreate, 'column'],
         ]);
@@ -48,8 +49,11 @@ export class ImpalaErrorListener extends ParseErrorListener {
                     case ImpalaSqlParser.RULE_tableNamePath:
                     case ImpalaSqlParser.RULE_functionNamePath:
                     case ImpalaSqlParser.RULE_viewNamePath:
+                    case ImpalaSqlParser.RULE_columnName:
                     case ImpalaSqlParser.RULE_columnNamePath: {
-                        result.push(`{existing}${name}`);
+                        if (!result.includes(`{existing}${name}`)) {
+                            result.push(`{existing}${name}`);
+                        }
                         break;
                     }
                     case ImpalaSqlParser.RULE_databaseNameCreate:
@@ -57,7 +61,9 @@ export class ImpalaErrorListener extends ParseErrorListener {
                     case ImpalaSqlParser.RULE_functionNameCreate:
                     case ImpalaSqlParser.RULE_viewNameCreate:
                     case ImpalaSqlParser.RULE_columnNamePathCreate: {
-                        result.push(`{new}${name}`);
+                        if (!result.includes(`{new}${name}`)) {
+                            result.push(`{new}${name}`);
+                        }
                         break;
                     }
                 }

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

@@ -0,0 +1,9 @@
+import { ImpalaSqlParserListener } from '../../lib';
+import { SingleStatementContext } from '../../lib/impala/ImpalaSqlParser';
+import SemanticContextCollector from '../common/semanticContextCollector';
+declare class ImpalaSemanticContextCollector extends SemanticContextCollector implements ImpalaSqlParserListener {
+    getWhiteSpaceRuleType(): number;
+    getStatementRuleType(): number;
+    enterSingleStatement(ctx: SingleStatementContext): void;
+}
+export { ImpalaSemanticContextCollector };

package/dist/parser/impala/impalaSemanticContextCollector.js

@@ -0,0 +1,14 @@
+import { ImpalaSqlParser } from '../../lib/impala/ImpalaSqlParser';
+import SemanticContextCollector from '../common/semanticContextCollector';
+class ImpalaSemanticContextCollector extends SemanticContextCollector {
+    getWhiteSpaceRuleType() {
+        return ImpalaSqlParser.WHITE_SPACE;
+    }
+    getStatementRuleType() {
+        return ImpalaSqlParser.RULE_singleStatement;
+    }
+    enterSingleStatement(ctx) {
+        this.visitStatement(ctx);
+    }
+}
+export { ImpalaSemanticContextCollector };

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

@@ -3,11 +3,12 @@ import { CharStream, CommonTokenStream, Token } from 'antlr4ng';
 import { ImpalaSqlLexer } from '../../lib/impala/ImpalaSqlLexer';
 import { ImpalaSqlParser, ProgramContext } from '../../lib/impala/ImpalaSqlParser';
 import { BasicSQL } from '../common/basicSQL';
+import { CaretPosition, SemanticCollectOptions, Suggestions } from '../common/types';
 import { ErrorListener } from '../common/parseErrorListener';
-import { Suggestions } from '../common/types';
 import { ImpalaEntityCollector } from './impalaEntityCollector';
 import { ImpalaErrorListener } from './ImpalaErrorListener';
 import { ImpalaSqlSplitListener } from './impalaSplitListener';
+import { ImpalaSemanticContextCollector } from './impalaSemanticContextCollector';
 export { ImpalaEntityCollector, ImpalaSqlSplitListener };
 export declare class ImpalaSQL extends BasicSQL<ImpalaSqlLexer, ProgramContext, ImpalaSqlParser> {
     protected createLexerFromCharStream(charStreams: CharStream): ImpalaSqlLexer;
@@ -16,5 +17,6 @@ export declare class ImpalaSQL extends BasicSQL<ImpalaSqlLexer, ProgramContext,
     protected get splitListener(): ImpalaSqlSplitListener;
     protected createErrorListener(_errorListener: ErrorListener): ImpalaErrorListener;
     protected createEntityCollector(input: string, allTokens?: Token[], caretTokenIndex?: number): ImpalaEntityCollector;
-    protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number, tokenIndexOffset: number): Suggestions<Token>;
+    protected createSemanticContextCollector(input: string, caretPosition: CaretPosition, allTokens: Token[], options?: SemanticCollectOptions): ImpalaSemanticContextCollector;
+    protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number): Suggestions<Token>;
 }

package/dist/parser/impala/index.js

@@ -1,10 +1,12 @@
+import { processTokenCandidates } from '../common/tokenUtils';
 import { ImpalaSqlLexer } from '../../lib/impala/ImpalaSqlLexer';
 import { ImpalaSqlParser } from '../../lib/impala/ImpalaSqlParser';
 import { BasicSQL } from '../common/basicSQL';
-import { EntityContextType } from '../common/types';
+import { EntityContextType, } from '../common/types';
 import { ImpalaEntityCollector } from './impalaEntityCollector';
 import { ImpalaErrorListener } from './ImpalaErrorListener';
 import { ImpalaSqlSplitListener } from './impalaSplitListener';
+import { ImpalaSemanticContextCollector } from './impalaSemanticContextCollector';
 export { ImpalaEntityCollector, ImpalaSqlSplitListener };
 export class ImpalaSQL extends BasicSQL {
     constructor() {
@@ -20,6 +22,7 @@ export class ImpalaSQL extends BasicSQL {
             ImpalaSqlParser.RULE_viewNamePath,
             ImpalaSqlParser.RULE_databaseNamePath,
             ImpalaSqlParser.RULE_columnNamePath,
+            ImpalaSqlParser.RULE_columnName,
         ]);
     }
     createLexerFromCharStream(charStreams) {
@@ -38,13 +41,15 @@ export class ImpalaSQL extends BasicSQL {
     createEntityCollector(input, allTokens, caretTokenIndex) {
         return new ImpalaEntityCollector(input, allTokens, caretTokenIndex);
     }
-    processCandidates(candidates, allTokens, caretTokenIndex, tokenIndexOffset) {
+    createSemanticContextCollector(input, caretPosition, allTokens, options) {
+        return new ImpalaSemanticContextCollector(input, caretPosition, allTokens, options);
+    }
+    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 tokenRanges = allTokens.slice(candidateRule.startTokenIndex, caretTokenIndex + 1);
             let syntaxContextType = void 0;
             switch (ruleType) {
                 case ImpalaSqlParser.RULE_functionNameCreate: {
@@ -86,6 +91,16 @@ export class ImpalaSQL extends BasicSQL {
                 case ImpalaSqlParser.RULE_columnNamePath: {
                     syntaxContextType = EntityContextType.COLUMN;
                 }
+                case ImpalaSqlParser.RULE_columnName: {
+                    if (candidateRule.ruleList.includes(ImpalaSqlParser.RULE_columnItem) ||
+                        candidateRule.ruleList.includes(ImpalaSqlParser.RULE_havingClause) ||
+                        candidateRule.ruleList.includes(ImpalaSqlParser.RULE_whereClause) ||
+                        candidateRule.ruleList.includes(ImpalaSqlParser.RULE_whenClause) ||
+                        candidateRule.ruleList.includes(ImpalaSqlParser.RULE_partitionByClause) ||
+                        candidateRule.ruleList.includes(ImpalaSqlParser.RULE_relation)) {
+                        syntaxContextType = EntityContextType.COLUMN;
+                    }
+                }
                 default:
                     break;
             }
@@ -96,16 +111,8 @@ export class ImpalaSQL extends BasicSQL {
                 });
             }
         }
-        for (let candidate of candidates.tokens) {
-            const symbolicName = this._parser.vocabulary.getSymbolicName(candidate[0]);
-            const displayName = this._parser.vocabulary.getDisplayName(candidate[0]);
-            if (displayName && symbolicName && symbolicName.startsWith('KW_')) {
-                const keyword = displayName.startsWith("'") && displayName.endsWith("'")
-                    ? displayName.slice(1, -1)
-                    : displayName;
-                keywords.push(keyword);
-            }
-        }
+        const processedKeywords = processTokenCandidates(this._parser, candidates.tokens);
+        keywords.push(...processedKeywords);
         return {
             syntax: originalSyntaxSuggestions,
             keywords,

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

@@ -3,11 +3,12 @@ import { CharStream, CommonTokenStream, Token } from 'antlr4ng';
 import { MySqlLexer } from '../../lib/mysql/MySqlLexer';
 import { MySqlParser, ProgramContext } from '../../lib/mysql/MySqlParser';
 import { BasicSQL } from '../common/basicSQL';
+import { Suggestions, CaretPosition, SemanticCollectOptions } from '../common/types';
 import { ErrorListener } from '../common/parseErrorListener';
-import { Suggestions } from '../common/types';
 import { MySqlEntityCollector } from './mysqlEntityCollector';
 import { MysqlErrorListener } from './mysqlErrorListener';
 import { MysqlSplitListener } from './mysqlSplitListener';
+import { MySqlSemanticContextCollector } from '../mysql/mysqlSemanticContextCollector';
 export { MySqlEntityCollector, MysqlSplitListener };
 export declare class MySQL extends BasicSQL<MySqlLexer, ProgramContext, MySqlParser> {
     protected createLexerFromCharStream(charStreams: CharStream): MySqlLexer;
@@ -16,5 +17,6 @@ export declare class MySQL extends BasicSQL<MySqlLexer, ProgramContext, MySqlPar
     protected get splitListener(): MysqlSplitListener;
     protected createErrorListener(_errorListener: ErrorListener): MysqlErrorListener;
     protected createEntityCollector(input: string, allTokens?: Token[], caretTokenIndex?: number): MySqlEntityCollector;
-    protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number, tokenIndexOffset: number): Suggestions<Token>;
+    protected createSemanticContextCollector(input: string, caretPosition: CaretPosition, allTokens: Token[], options?: SemanticCollectOptions): MySqlSemanticContextCollector;
+    protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number): Suggestions<Token>;
 }

package/dist/parser/mysql/index.js

@@ -1,10 +1,12 @@
+import { processTokenCandidates } from '../common/tokenUtils';
 import { MySqlLexer } from '../../lib/mysql/MySqlLexer';
 import { MySqlParser } from '../../lib/mysql/MySqlParser';
 import { BasicSQL } from '../common/basicSQL';
-import { EntityContextType } from '../common/types';
+import { EntityContextType, } from '../common/types';
 import { MySqlEntityCollector } from './mysqlEntityCollector';
 import { MysqlErrorListener } from './mysqlErrorListener';
 import { MysqlSplitListener } from './mysqlSplitListener';
+import { MySqlSemanticContextCollector } from '../mysql/mysqlSemanticContextCollector';
 export { MySqlEntityCollector, MysqlSplitListener };
 export class MySQL extends BasicSQL {
     constructor() {
@@ -38,13 +40,15 @@ export class MySQL extends BasicSQL {
     createEntityCollector(input, allTokens, caretTokenIndex) {
         return new MySqlEntityCollector(input, allTokens, caretTokenIndex);
     }
-    processCandidates(candidates, allTokens, caretTokenIndex, tokenIndexOffset) {
+    createSemanticContextCollector(input, caretPosition, allTokens, options) {
+        return new MySqlSemanticContextCollector(input, caretPosition, allTokens, options);
+    }
+    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 tokenRanges = allTokens.slice(candidateRule.startTokenIndex, caretTokenIndex + 1);
             let syntaxContextType = void 0;
             switch (ruleType) {
                 case MySqlParser.RULE_databaseName: {
@@ -97,16 +101,8 @@ export class MySQL extends BasicSQL {
                 });
             }
         }
-        for (const candidate of candidates.tokens) {
-            const symbolicName = this._parser.vocabulary.getSymbolicName(candidate[0]);
-            const displayName = this._parser.vocabulary.getDisplayName(candidate[0]);
-            if (displayName && symbolicName && symbolicName.startsWith('KW_')) {
-                const keyword = displayName.startsWith("'") && displayName.endsWith("'")
-                    ? displayName.slice(1, -1)
-                    : displayName;
-                keywords.push(keyword);
-            }
-        }
+        const processedKeywords = processTokenCandidates(this._parser, candidates.tokens);
+        keywords.push(...processedKeywords);
         return {
             syntax: originalSyntaxSuggestions,
             keywords,

package/dist/parser/mysql/mysqlErrorListener.js

@@ -49,7 +49,9 @@ export class MysqlErrorListener extends ParseErrorListener {
                     case MySqlParser.RULE_functionName:
                     case MySqlParser.RULE_viewName:
                     case MySqlParser.RULE_columnName: {
-                        result.push(`{existing}${name}`);
+                        if (!result.includes(`{existing}${name}`)) {
+                            result.push(`{existing}${name}`);
+                        }
                         break;
                     }
                     case MySqlParser.RULE_databaseNameCreate:
@@ -57,7 +59,9 @@ export class MysqlErrorListener extends ParseErrorListener {
                     case MySqlParser.RULE_functionNameCreate:
                     case MySqlParser.RULE_viewNameCreate:
                     case MySqlParser.RULE_columnNameCreate: {
-                        result.push(`{new}${name}`);
+                        if (!result.includes(`{new}${name}`)) {
+                            result.push(`{new}${name}`);
+                        }
                         break;
                     }
                 }

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

@@ -0,0 +1,9 @@
+import { MySqlParserListener } from '../../lib';
+import { SingleStatementContext } from '../../lib/mysql/MySqlParser';
+import SemanticContextCollector from '../common/semanticContextCollector';
+declare class MySqlSemanticContextCollector extends SemanticContextCollector implements MySqlParserListener {
+    getWhiteSpaceRuleType(): number;
+    getStatementRuleType(): number;
+    enterSingleStatement(ctx: SingleStatementContext): void;
+}
+export { MySqlSemanticContextCollector };

package/dist/parser/mysql/mysqlSemanticContextCollector.js

@@ -0,0 +1,14 @@
+import { MySqlParser } from '../../lib/mysql/MySqlParser';
+import SemanticContextCollector from '../common/semanticContextCollector';
+class MySqlSemanticContextCollector extends SemanticContextCollector {
+    getWhiteSpaceRuleType() {
+        return MySqlParser.WHITE_SPACE;
+    }
+    getStatementRuleType() {
+        return MySqlParser.RULE_singleStatement;
+    }
+    enterSingleStatement(ctx) {
+        this.visitStatement(ctx);
+    }
+}
+export { MySqlSemanticContextCollector };

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

@@ -2,12 +2,13 @@ import { CandidatesCollection } from 'antlr4-c3';
 import { CharStream, CommonTokenStream, Token } from 'antlr4ng';
 import { PostgreSqlLexer } from '../../lib/postgresql/PostgreSqlLexer';
 import { PostgreSqlParser, ProgramContext } from '../../lib/postgresql/PostgreSqlParser';
+import { CaretPosition, SemanticCollectOptions, Suggestions } from '../common/types';
 import { BasicSQL } from '../common/basicSQL';
 import { ErrorListener } from '../common/parseErrorListener';
-import { Suggestions } from '../common/types';
 import { PostgreSqlEntityCollector } from './postgreEntityCollector';
 import { PostgreSqlErrorListener } from './postgreErrorListener';
 import { PostgreSqlSplitListener } from './postgreSplitListener';
+import { PostgreSemanticContextCollector } from './postgreSemanticContextCollector';
 export { PostgreSqlEntityCollector, PostgreSqlSplitListener };
 export declare class PostgreSQL extends BasicSQL<PostgreSqlLexer, ProgramContext, PostgreSqlParser> {
     protected createLexerFromCharStream(charStreams: CharStream): PostgreSqlLexer;
@@ -16,5 +17,6 @@ export declare class PostgreSQL extends BasicSQL<PostgreSqlLexer, ProgramContext
     protected get splitListener(): PostgreSqlSplitListener;
     protected createErrorListener(_errorListener: ErrorListener): PostgreSqlErrorListener;
     protected createEntityCollector(input: string, allTokens?: Token[], caretTokenIndex?: number): PostgreSqlEntityCollector;
-    protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number, tokenIndexOffset: number): Suggestions<Token>;
+    protected createSemanticContextCollector(input: string, caretPosition: CaretPosition, allTokens: Token[], options?: SemanticCollectOptions): PostgreSemanticContextCollector;
+    protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number): Suggestions<Token>;
 }

package/dist/parser/postgresql/index.js

@@ -1,29 +1,32 @@
+import { processTokenCandidates } from '../common/tokenUtils';
 import { PostgreSqlLexer } from '../../lib/postgresql/PostgreSqlLexer';
 import { PostgreSqlParser } from '../../lib/postgresql/PostgreSqlParser';
+import { EntityContextType, } from '../common/types';
 import { BasicSQL } from '../common/basicSQL';
-import { EntityContextType } from '../common/types';
 import { PostgreSqlEntityCollector } from './postgreEntityCollector';
 import { PostgreSqlErrorListener } from './postgreErrorListener';
 import { PostgreSqlSplitListener } from './postgreSplitListener';
+import { PostgreSemanticContextCollector } from './postgreSemanticContextCollector';
 export { PostgreSqlEntityCollector, PostgreSqlSplitListener };
 export class PostgreSQL extends BasicSQL {
     constructor() {
         super(...arguments);
         this.preferredRules = new Set([
-            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
+            PostgreSqlParser.RULE_tableNameCreate, // table name
+            PostgreSqlParser.RULE_tableName, // table name that will be created
+            PostgreSqlParser.RULE_functionName, // function name
+            PostgreSqlParser.RULE_functionNameCreate, // function name that will be created
+            PostgreSqlParser.RULE_schemaNameCreate, // schema name that will be created
+            PostgreSqlParser.RULE_schemaName, // schema name
+            PostgreSqlParser.RULE_viewNameCreate, // view name that will be created
+            PostgreSqlParser.RULE_viewName, // view name
+            PostgreSqlParser.RULE_databaseNameCreate, // database name that will be created
+            PostgreSqlParser.RULE_databaseName, // database name
+            PostgreSqlParser.RULE_procedureNameCreate, // procedure name that will be created
+            PostgreSqlParser.RULE_procedureName, // procedure name
+            PostgreSqlParser.RULE_columnNameCreate, // column name that will be created
+            PostgreSqlParser.RULE_columnName, // column name
+            PostgreSqlParser.RULE_columnNamePath, // column name
         ]);
     }
     createLexerFromCharStream(charStreams) {
@@ -42,71 +45,85 @@ export class PostgreSQL extends BasicSQL {
     createEntityCollector(input, allTokens, caretTokenIndex) {
         return new PostgreSqlEntityCollector(input, allTokens, caretTokenIndex);
     }
-    processCandidates(candidates, allTokens, caretTokenIndex, tokenIndexOffset) {
+    createSemanticContextCollector(input, caretPosition, allTokens, options) {
+        return new PostgreSemanticContextCollector(input, caretPosition, allTokens, options);
+    }
+    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 tokenRanges = allTokens.slice(candidateRule.startTokenIndex, caretTokenIndex + 1);
             let syntaxContextType = void 0;
             switch (ruleType) {
-                case PostgreSqlParser.RULE_table_name_create: {
+                case PostgreSqlParser.RULE_tableNameCreate: {
                     syntaxContextType = EntityContextType.TABLE_CREATE;
                     break;
                 }
-                case PostgreSqlParser.RULE_table_name: {
+                case PostgreSqlParser.RULE_tableName: {
                     syntaxContextType = EntityContextType.TABLE;
                     break;
                 }
-                case PostgreSqlParser.RULE_function_name_create: {
+                case PostgreSqlParser.RULE_functionNameCreate: {
                     syntaxContextType = EntityContextType.FUNCTION_CREATE;
                     break;
                 }
-                case PostgreSqlParser.RULE_function_name: {
+                case PostgreSqlParser.RULE_functionName: {
                     syntaxContextType = EntityContextType.FUNCTION;
                     break;
                 }
-                case PostgreSqlParser.RULE_schema_name_create: {
+                case PostgreSqlParser.RULE_schemaNameCreate: {
                     syntaxContextType = EntityContextType.DATABASE_CREATE;
                     break;
                 }
-                case PostgreSqlParser.RULE_schema_name: {
+                case PostgreSqlParser.RULE_schemaName: {
                     syntaxContextType = EntityContextType.DATABASE;
                     break;
                 }
-                case PostgreSqlParser.RULE_view_name_create: {
+                case PostgreSqlParser.RULE_viewNameCreate: {
                     syntaxContextType = EntityContextType.VIEW_CREATE;
                     break;
                 }
-                case PostgreSqlParser.RULE_view_name: {
+                case PostgreSqlParser.RULE_viewName: {
                     syntaxContextType = EntityContextType.VIEW;
                     break;
                 }
-                case PostgreSqlParser.RULE_database_name_create: {
+                case PostgreSqlParser.RULE_databaseNameCreate: {
                     syntaxContextType = EntityContextType.DATABASE_CREATE;
                     break;
                 }
-                case PostgreSqlParser.RULE_database_name: {
+                case PostgreSqlParser.RULE_databaseName: {
                     syntaxContextType = EntityContextType.DATABASE;
                     break;
                 }
-                case PostgreSqlParser.RULE_procedure_name_create: {
+                case PostgreSqlParser.RULE_procedureNameCreate: {
                     syntaxContextType = EntityContextType.PROCEDURE_CREATE;
                     break;
                 }
-                case PostgreSqlParser.RULE_procedure_name: {
+                case PostgreSqlParser.RULE_procedureName: {
                     syntaxContextType = EntityContextType.PROCEDURE;
                     break;
                 }
-                case PostgreSqlParser.RULE_column_name_create: {
+                case PostgreSqlParser.RULE_columnNameCreate: {
                     syntaxContextType = EntityContextType.COLUMN_CREATE;
                     break;
                 }
-                case PostgreSqlParser.RULE_column_name: {
+                case PostgreSqlParser.RULE_columnName: {
                     syntaxContextType = EntityContextType.COLUMN;
                     break;
                 }
+                case PostgreSqlParser.RULE_columnNamePath: {
+                    if (candidateRule.ruleList.includes(PostgreSqlParser.RULE_groupClause) ||
+                        candidateRule.ruleList.includes(PostgreSqlParser.RULE_sortClause) ||
+                        candidateRule.ruleList.includes(PostgreSqlParser.RULE_limitClause) ||
+                        candidateRule.ruleList.includes(PostgreSqlParser.RULE_whereClause) ||
+                        candidateRule.ruleList.includes(PostgreSqlParser.RULE_havingClause) ||
+                        candidateRule.ruleList.includes(PostgreSqlParser.RULE_windowClause) ||
+                        candidateRule.ruleList.includes(PostgreSqlParser.RULE_triggerWhen)) {
+                        syntaxContextType = EntityContextType.COLUMN;
+                    }
+                    break;
+                }
                 default:
                     break;
             }
@@ -117,16 +134,8 @@ export class PostgreSQL extends BasicSQL {
                 });
             }
         }
-        for (let candidate of candidates.tokens) {
-            const symbolicName = this._parser.vocabulary.getSymbolicName(candidate[0]);
-            const displayName = this._parser.vocabulary.getDisplayName(candidate[0]);
-            if (displayName && symbolicName && symbolicName.startsWith('KW_')) {
-                const keyword = displayName.startsWith("'") && displayName.endsWith("'")
-                    ? displayName.slice(1, -1)
-                    : displayName;
-                keywords.push(keyword);
-            }
-        }
+        const processedKeywords = processTokenCandidates(this._parser, candidates.tokens);
+        keywords.push(...processedKeywords);
         return {
             syntax: originalSyntaxSuggestions,
             keywords,

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

@@ -1,4 +1,4 @@
-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 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 {
@@ -34,8 +34,8 @@ export declare class PostgreSqlEntityCollector extends EntityCollector implement
     exitSelectStatement(ctx: SelectStatementContext): void;
     enterInsertStatement(ctx: InsertStatementContext): void;
     exitInsertStatement(ctx: InsertStatementContext): void;
-    enterCreatefunctionstmt(ctx: CreatefunctionstmtContext): void;
-    exitCreatefunctionstmt(ctx: CreatefunctionstmtContext): void;
-    enterAltertablestmt(ctx: AltertablestmtContext): void;
-    exitAltertablestmt(ctx: AltertablestmtContext): void;
+    enterCreateFunctionStmt(ctx: CreateFunctionStmtContext): void;
+    exitCreateFunctionStmt(ctx: CreateFunctionStmtContext): void;
+    enterAlterTableStmt(ctx: AlterTableStmtContext): void;
+    exitAlterTableStmt(ctx: AlterTableStmtContext): void;
 }

package/dist/parser/postgresql/postgreEntityCollector.js

@@ -1,4 +1,4 @@
-import { Column_defContext, Table_refContext, } from '../../lib/postgresql/PostgreSqlParser';
+import { Column_defContext, TableRefContext, } from '../../lib/postgresql/PostgreSqlParser';
 import { AttrName, EntityCollector, StmtContextType } from '../common/entityCollector';
 import { EntityContextType } from '../common/types';
 export class PostgreSqlEntityCollector extends EntityCollector {
@@ -16,7 +16,7 @@ export class PostgreSqlEntityCollector extends EntityCollector {
             ? [
                 {
                     attrName: AttrName.alias,
-                    endContextList: [Table_refContext.name],
+                    endContextList: [TableRefContext.name],
                 },
             ]
             : undefined);
@@ -31,7 +31,7 @@ export class PostgreSqlEntityCollector extends EntityCollector {
             ? [
                 {
                     attrName: AttrName.alias,
-                    endContextList: [Table_refContext.name],
+                    endContextList: [TableRefContext.name],
                 },
             ]
             : undefined);
@@ -121,16 +121,16 @@ export class PostgreSqlEntityCollector extends EntityCollector {
     exitInsertStatement(ctx) {
         this.popStmt();
     }
-    enterCreatefunctionstmt(ctx) {
+    enterCreateFunctionStmt(ctx) {
         this.pushStmt(ctx, StmtContextType.CREATE_FUNCTION_STMT);
     }
-    exitCreatefunctionstmt(ctx) {
+    exitCreateFunctionStmt(ctx) {
         this.popStmt();
     }
-    enterAltertablestmt(ctx) {
+    enterAlterTableStmt(ctx) {
         this.pushStmt(ctx, StmtContextType.ALTER_TABLE_STMT);
     }
-    exitAltertablestmt(ctx) {
+    exitAlterTableStmt(ctx) {
         this.popStmt();
     }
 }

package/dist/parser/postgresql/postgreErrorListener.js

@@ -5,20 +5,21 @@ export class PostgreSqlErrorListener extends ParseErrorListener {
     constructor() {
         super(...arguments);
         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'],
+            [PostgreSqlParser.RULE_databaseName, 'database'],
+            [PostgreSqlParser.RULE_databaseNameCreate, 'database'],
+            [PostgreSqlParser.RULE_tableName, 'table'],
+            [PostgreSqlParser.RULE_tableNameCreate, 'table'],
+            [PostgreSqlParser.RULE_viewName, 'view'],
+            [PostgreSqlParser.RULE_viewNameCreate, 'view'],
+            [PostgreSqlParser.RULE_functionName, 'function'],
+            [PostgreSqlParser.RULE_functionNameCreate, 'function'],
+            [PostgreSqlParser.RULE_columnName, 'column'],
+            [PostgreSqlParser.RULE_columnNameCreate, 'column'],
+            [PostgreSqlParser.RULE_columnNamePath, 'column'],
+            [PostgreSqlParser.RULE_schemaNameCreate, 'schema'],
+            [PostgreSqlParser.RULE_schemaName, 'schema'],
+            [PostgreSqlParser.RULE_procedureNameCreate, 'procedure'],
+            [PostgreSqlParser.RULE_procedureName, 'procedure'],
         ]);
     }
     getExpectedText(parser, token) {
@@ -48,24 +49,29 @@ export class PostgreSqlErrorListener extends ParseErrorListener {
                 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}`);
+                    case PostgreSqlParser.RULE_tableName:
+                    case PostgreSqlParser.RULE_functionName:
+                    case PostgreSqlParser.RULE_schemaName:
+                    case PostgreSqlParser.RULE_viewName:
+                    case PostgreSqlParser.RULE_databaseName:
+                    case PostgreSqlParser.RULE_procedureName:
+                    case PostgreSqlParser.RULE_columnName:
+                    case PostgreSqlParser.RULE_columnNamePath: {
+                        if (!result.includes(`{existing}${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}`);
+                    case PostgreSqlParser.RULE_tableNameCreate:
+                    case PostgreSqlParser.RULE_functionNameCreate:
+                    case PostgreSqlParser.RULE_schemaNameCreate:
+                    case PostgreSqlParser.RULE_viewNameCreate:
+                    case PostgreSqlParser.RULE_databaseNameCreate:
+                    case PostgreSqlParser.RULE_procedureNameCreate:
+                    case PostgreSqlParser.RULE_columnNameCreate: {
+                        if (!result.includes(`{new}${name}`)) {
+                            result.push(`{new}${name}`);
+                        }
                         break;
                     }
                 }