dt-sql-parser 4.4.2 → 4.5.0-beta.1

package/dist/parser/common/entityCollector.js

@@ -30,16 +30,19 @@ export var StmtContextType;
     StmtContextType["ALTER_TABLE_STMT"] = "alterTableStmt";
 })(StmtContextType || (StmtContextType = {}));
 export function toStmtContext(ctx, type, input, rootStmt, parentStmt, isContainCaret) {
+    var _a;
     const text = ctxToText(ctx, input);
     if (!text)
         return null;
-    const { text: _ } = text, position = __rest(text, ["text"]);
+    const { text: stmtText } = text, position = __rest(text, ["text"]);
     return {
         stmtContextType: type,
         position,
         rootStmt: rootStmt !== null && rootStmt !== void 0 ? rootStmt : null,
         parentStmt: parentStmt !== null && parentStmt !== void 0 ? parentStmt : null,
         isContainCaret,
+        text: stmtText,
+        scopeDepth: type === StmtContextType.COMMON_STMT ? 0 : ((_a = parentStmt === null || parentStmt === void 0 ? void 0 : parentStmt.scopeDepth) !== null && _a !== void 0 ? _a : 0) + 1,
     };
 }
 /**
@@ -54,22 +57,56 @@ export var AttrName;
     AttrName["colType"] = "_colType";
     AttrName["alias"] = "_alias";
 })(AttrName || (AttrName = {}));
+/**
+ * Types of column declarations
+ */
+export var ColumnDeclareType;
+(function (ColumnDeclareType) {
+    /** Literal column name */
+    ColumnDeclareType[ColumnDeclareType["LITERAL"] = 0] = "LITERAL";
+    /** Using asterisk syntax (tableName.*) */
+    ColumnDeclareType[ColumnDeclareType["ALL"] = 1] = "ALL";
+    /** Complex expressions like subqueries, case statements, function calls */
+    ColumnDeclareType[ColumnDeclareType["EXPRESSION"] = 2] = "EXPRESSION";
+})(ColumnDeclareType || (ColumnDeclareType = {}));
+/**
+ * Types of table declarations
+ */
+export var TableDeclareType;
+(function (TableDeclareType) {
+    /** Regular table reference */
+    TableDeclareType[TableDeclareType["LITERAL"] = 0] = "LITERAL";
+    /** Table defined by expression (e.g., subquery) */
+    TableDeclareType[TableDeclareType["EXPRESSION"] = 1] = "EXPRESSION";
+})(TableDeclareType || (TableDeclareType = {}));
 export function isCommonEntityContext(entity) {
     if (!entity)
         return false;
-    return 'relatedEntities' in entity && !('arguments' in entity);
+    return !isFuncEntityContext(entity) && !isColumnEntityContext(entity);
 }
 export function isFuncEntityContext(entity) {
     if (!entity)
         return false;
-    return 'arguments' in entity;
+    return [EntityContextType.FUNCTION, EntityContextType.FUNCTION_CREATE].includes(entity.entityContextType);
 }
 export function isColumnEntityContext(entity) {
     if (!entity)
         return false;
-    return AttrName.colType in entity;
+    return [EntityContextType.COLUMN, EntityContextType.COLUMN_CREATE].includes(entity.entityContextType);
+}
+/**
+ * Check if ctx is a child node of a specific rule type
+ */
+export function isChildContextOf(ctx, parentRuleIndex) {
+    let parentCtx = ctx.parent;
+    while (parentCtx) {
+        if (parentCtx.ruleIndex === parentRuleIndex)
+            return true;
+        parentCtx = parentCtx.parent;
+    }
+    return false;
 }
-export function toEntityContext(ctx, type, input, belongStmt, attrInfo) {
+export function toEntityContext(ctx, type, input, belongStmt, attrInfo, metaInfo) {
     var _a, _b;
     const word = ctxToText(ctx, input);
     if (!word)
@@ -81,6 +118,7 @@ export function toEntityContext(ctx, type, input, belongStmt, attrInfo) {
         text,
         position,
         belongStmt,
+        declareType: metaInfo === null || metaInfo === void 0 ? void 0 : metaInfo.declareType,
         [AttrName.comment]: null,
     };
     switch (entityInfo.entityContextType) {
@@ -168,6 +206,24 @@ function findAttributeChildren(ctx, keyName) {
     }
     return attrVal;
 }
+/**
+ * Check if an entity is contained within the range entity's context
+ * @param entity - The entity to check if it's contained
+ * @param rangeEntity - The entity that defines the containing range
+ * @returns true if entity is contained within rangeEntity's range
+ */
+function isEntityInScope(entity, rangeEntity) {
+    const entityStart = entity.position.startTokenIndex;
+    const entityStop = entity.position.endTokenIndex;
+    const rangeStart = rangeEntity.position.startTokenIndex;
+    const rangeStop = rangeEntity.position.endTokenIndex;
+    return (entityStart != null &&
+        entityStop != null &&
+        rangeStart != null &&
+        rangeStop != null &&
+        rangeStart <= entityStart &&
+        rangeStop >= entityStop);
+}
 /**
  * @todo: Handle alias, includes column alias, table alias, query as alias and so on.
  * @todo: [may be need] Combine the entities in each clause.
@@ -181,6 +237,8 @@ export class EntityCollector {
         this._stmtStack = new SimpleStack();
         this._entityStack = new SimpleStack();
         this._rootStmt = null;
+        this._caretStmtScopeDepth = 0;
+        this._caretStmt = null;
     }
     visitTerminal() { }
     visitErrorNode() { }
@@ -198,6 +256,78 @@ export class EntityCollector {
         this._entityStack.clear();
         this._rootStmt = null;
     }
+    exitProgram() {
+        const entities = Array.from(this._entitiesSet);
+        if (this._caretTokenIndex !== -1) {
+            this.attachAccessibleToEntities(entities);
+        }
+        this._entityStack.clear();
+    }
+    /**
+     * Adds accessibility markers to entities
+     * @param entities The list of entities to process
+     */
+    attachAccessibleToEntities(entities) {
+        var _a;
+        if (!entities.length) {
+            return;
+        }
+        for (const entity of entities) {
+            if (entity.isAccessible !== undefined) {
+                continue;
+            }
+            const entityScopeDepth = (_a = entity.belongStmt.scopeDepth) !== null && _a !== void 0 ? _a : 0;
+            if (entity.entityContextType === EntityContextType.TABLE) {
+                entity.isAccessible =
+                    !!entity.belongStmt.isContainCaret &&
+                        entityScopeDepth === this._caretStmtScopeDepth;
+            }
+            else {
+                entity.isAccessible = null;
+            }
+            // Recursively process related entities
+            if (entity.relatedEntities) {
+                this.attachAccessibleToEntities(entity.relatedEntities);
+            }
+            // Process columns of the table
+            if (entity.columns) {
+                const columnEntities = entity.columns || [];
+                this.attachAccessibleToEntities(columnEntities);
+            }
+        }
+    }
+    /**
+     * Attach query result to column if the column is derived from expression.
+     */
+    attachQueryResultToColumn(column, queryResults) {
+        const relatedEntities = queryResults.filter((queryResult) => isEntityInScope(queryResult, column));
+        column.relatedEntities = relatedEntities;
+    }
+    /**
+     * Attach related columns to query result
+     */
+    attachColumnsToQueryResult(queryResult, columns) {
+        const relatedColumns = columns.filter((column) => column.belongStmt === queryResult.belongStmt);
+        queryResult.columns = relatedColumns;
+    }
+    /**
+     * Attach query result to table if the table is derived from expression.
+     */
+    attachQueryResultToTable(table, queryResults) {
+        const relatedQueryResults = queryResults.filter((queryResult) => isEntityInScope(queryResult, table));
+        table.relatedEntities = relatedQueryResults;
+    }
+    /**
+     * Gets query result entities inside a statement
+     * @param stmt The statement to search within
+     * @returns Array of query result entity contexts
+     */
+    getQueryResultEntitiesInsideStmt(stmt) {
+        return this.getEntities()
+            .filter((entity) => entity.entityContextType === EntityContextType.QUERY_RESULT &&
+            entity.belongStmt.parentStmt === stmt)
+            .filter(isCommonEntityContext);
+    }
     /**
      * The antlr4 will ignore hidden tokens, if we type whitespace at the end of a statement,
      * the whitespace token will not as stop token, so we consider the whitespace token as a part of the nonhidden token in front of it
@@ -223,6 +353,9 @@ export class EntityCollector {
                     !!ctx.stop &&
                     ctx.start.tokenIndex <= this._caretTokenIndex &&
                     ctx.stop.tokenIndex >= this.getPrevNonHiddenTokenIndex(this._caretTokenIndex);
+            if (isContainCaret && type !== StmtContextType.COMMON_STMT) {
+                this._caretStmtScopeDepth++;
+            }
         }
         const stmtContext = toStmtContext(ctx, type, this._input, this._rootStmt, this._stmtStack.peek(), isContainCaret);
         if (stmtContext) {
@@ -236,16 +369,24 @@ export class EntityCollector {
     }
     popStmt() {
         const stmtContext = this._stmtStack.pop();
-        if (stmtContext && this._rootStmt === stmtContext) {
-            this._rootStmt = this._stmtStack.peek();
+        if (stmtContext) {
+            if (stmtContext.stmtContextType === StmtContextType.COMMON_STMT) {
+                this._rootStmt = this._stmtStack.peek();
+            }
             if (!this._entityStack.isEmpty()) {
                 this.combineEntitiesAndAdd(stmtContext);
             }
+            // If the current statement contains the caret and its scope depth equals the caret statement's scope depth
+            // then set it as the nearest statement containing the caret
+            if (stmtContext.isContainCaret &&
+                stmtContext.scopeDepth === this._caretStmtScopeDepth) {
+                this._caretStmt = stmtContext;
+            }
         }
         return stmtContext;
     }
-    pushEntity(ctx, type, attrInfo) {
-        const entityContext = toEntityContext(ctx, type, this._input, this._stmtStack.peek(), attrInfo);
+    pushEntity(ctx, type, attrInfo, metaInfo) {
+        const entityContext = toEntityContext(ctx, type, this._input, this._stmtStack.peek(), attrInfo, metaInfo);
         if (entityContext) {
             if (this._stmtStack.isEmpty()) {
                 this._entitiesSet.add(entityContext);
@@ -283,13 +424,88 @@ export class EntityCollector {
             stmtContext.stmtContextType === StmtContextType.CREATE_TABLE_STMT) {
             return this.combineCreateTableOrViewStmtEntities(stmtContext, entitiesInsideStmt);
         }
-        return entitiesInsideStmt;
+        else if (stmtContext.stmtContextType === StmtContextType.SELECT_STMT) {
+            const tableSourceEntities = this.combineFromTableSource(stmtContext, entitiesInsideStmt);
+            const queryResultEntities = this.combineQueryResultStmtEntities(stmtContext, entitiesInsideStmt);
+            const otherEntities = entitiesInsideStmt.filter((entity) => ![
+                EntityContextType.QUERY_RESULT,
+                EntityContextType.TABLE,
+                EntityContextType.COLUMN,
+            ].includes(entity.entityContextType));
+            return Array.from(new Set([...tableSourceEntities, ...queryResultEntities, ...otherEntities]));
+        }
+        else {
+            // Do not collect column and queryResult entities if they are not inside a select statement
+            // Exception: empty column entities (text === '') should be kept
+            return entitiesInsideStmt.filter((entity) => {
+                // Keep non-COLUMN and non-QUERY_RESULT entities
+                if (entity.entityContextType !== EntityContextType.COLUMN &&
+                    entity.entityContextType !== EntityContextType.QUERY_RESULT) {
+                    return true;
+                }
+                // Also keep empty QUERY_RESULT entities (text === '')
+                if (entity.entityContextType === EntityContextType.QUERY_RESULT &&
+                    entity.text === '') {
+                    return true;
+                }
+                return false;
+            });
+        }
+    }
+    combineQueryResultStmtEntities(stmtContext, entitiesInsideStmt) {
+        if (!stmtContext || !(entitiesInsideStmt === null || entitiesInsideStmt === void 0 ? void 0 : entitiesInsideStmt.length)) {
+            return [];
+        }
+        const columnEntities = [];
+        const relatedTableEntities = [];
+        const finalEntities = [];
+        const queryResultEntitiesInsideStmt = this.getQueryResultEntitiesInsideStmt(stmtContext);
+        // Categorize and process entities
+        entitiesInsideStmt.forEach((entity) => {
+            if (entity.belongStmt !== stmtContext)
+                return;
+            if (entity.entityContextType === EntityContextType.QUERY_RESULT &&
+                isCommonEntityContext(entity)) {
+                finalEntities.push(entity);
+            }
+            else if (entity.entityContextType === EntityContextType.COLUMN &&
+                isColumnEntityContext(entity)) {
+                if (entity.declareType === ColumnDeclareType.EXPRESSION) {
+                    this.attachQueryResultToColumn(entity, queryResultEntitiesInsideStmt);
+                }
+                columnEntities.push(entity);
+            }
+            else if (entity.entityContextType === EntityContextType.TABLE &&
+                isCommonEntityContext(entity)) {
+                relatedTableEntities.push(entity);
+            }
+        });
+        // combine collected entities to query result entity
+        finalEntities.forEach((queryResultEntity) => {
+            this.attachColumnsToQueryResult(queryResultEntity, columnEntities);
+            queryResultEntity.relatedEntities = relatedTableEntities;
+        });
+        return finalEntities;
+    }
+    combineFromTableSource(stmtContext, entitiesInsideStmt) {
+        const finalEntities = [];
+        const queryResultEntitiesInsideStmt = this.getQueryResultEntitiesInsideStmt(stmtContext);
+        const tableEntities = (entitiesInsideStmt.filter((entity) => entity.entityContextType === EntityContextType.TABLE));
+        tableEntities.forEach((table) => {
+            // If it's an EXPRESSION type (subquery), need to associate with QUERY_RESULT entities
+            if (table.declareType === TableDeclareType.EXPRESSION) {
+                this.attachQueryResultToTable(table, queryResultEntitiesInsideStmt);
+            }
+            finalEntities.push(table);
+        });
+        return finalEntities;
     }
     combineCreateTableOrViewStmtEntities(stmtContext, entitiesInsideStmt) {
         const columns = [];
         const relatedEntities = [];
+        const queryResultEntitiesInsideStmt = this.getQueryResultEntitiesInsideStmt(stmtContext);
         let mainEntity = null;
-        const finalEntities = entitiesInsideStmt.reduce((result, entity) => {
+        const finalEntities = [...entitiesInsideStmt, ...queryResultEntitiesInsideStmt].reduce((result, entity) => {
             if (entity.belongStmt !== stmtContext) {
                 if (entity.entityContextType !== EntityContextType.COLUMN &&
                     entity.entityContextType !== EntityContextType.COLUMN_CREATE) {

package/dist/parser/common/textAndWord.d.ts

@@ -10,8 +10,12 @@ export interface WordPosition {
     readonly startColumn: number;
     /** end at ..n + 1 */
     readonly endColumn: number;
+    /** start at 0 */
+    readonly startTokenIndex: number;
+    /** end at ..n-1 */
+    readonly endTokenIndex: number;
 }
-export interface WordRange extends WordPosition {
+export interface WordRange extends Omit<WordPosition, 'startTokenIndex' | 'endTokenIndex'> {
     /** content of word */
     readonly text: string;
 }
@@ -28,6 +32,10 @@ export interface TextPosition {
     readonly startColumn: number;
     /** end at ..n + 1 */
     readonly endColumn: number;
+    /** start at 0 */
+    readonly startTokenIndex: number;
+    /** end at ..n-1 */
+    readonly endTokenIndex: number;
 }
 export interface TextSlice extends TextPosition {
     readonly text: string;

package/dist/parser/common/textAndWord.js

@@ -34,6 +34,8 @@ export function ctxToText(ctx, input) {
         endIndex,
         startColumn: ctx.start.column + 1,
         endColumn: ctx.stop.column + 1 + ((_b = (_a = ctx.stop.text) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0),
+        startTokenIndex: ctx.start.tokenIndex,
+        endTokenIndex: ctx.stop.tokenIndex,
     };
 }
 /**

package/dist/parser/common/types.d.ts

@@ -42,6 +42,8 @@ export declare enum EntityContextType {
     COLUMN = "column",
     /** column name that will be created */
     COLUMN_CREATE = "columnCreate",
+    /** query result */
+    QUERY_RESULT = "queryResult",
     /** table property key when creating table*/
     TABLE_PROPERTY_KEY = "tablePropertyKey",
     /** table property value when creating table*/

package/dist/parser/common/types.js

@@ -31,6 +31,8 @@ export var EntityContextType;
     EntityContextType["COLUMN"] = "column";
     /** column name that will be created */
     EntityContextType["COLUMN_CREATE"] = "columnCreate";
+    /** query result */
+    EntityContextType["QUERY_RESULT"] = "queryResult";
     /** table property key when creating table*/
     EntityContextType["TABLE_PROPERTY_KEY"] = "tablePropertyKey";
     /** table property value when creating table*/

package/dist/parser/flink/flinkEntityCollector.d.ts

@@ -1,4 +1,4 @@
-import { CatalogPathContext, CatalogPathCreateContext, ColumnNameCreateContext, CreateCatalogContext, CreateDatabaseContext, CreateFunctionContext, CreateTableContext, CreateViewContext, DatabasePathContext, DatabasePathCreateContext, FunctionNameCreateContext, InsertStatementContext, QueryStatementContext, SqlStatementContext, TablePathContext, TablePathCreateContext, ViewPathContext, ViewPathCreateContext } from '../../lib/flink/FlinkSqlParser';
+import { AtomExpressionTableContext, AtomFunctionTableContext, CatalogPathContext, CatalogPathCreateContext, ColumnNameCreateContext, CreateCatalogContext, CreateDatabaseContext, CreateFunctionContext, CreateTableContext, CreateViewContext, DatabasePathContext, DatabasePathCreateContext, FunctionNameCreateContext, InsertStatementContext, QueryStatementContext, SelectExpressionColumnNameContext, SelectListContext, SelectLiteralColumnNameContext, SelectWindowItemColumnNameContext, SqlStatementContext, TableAllColumnsContext, TablePathContext, TablePathCreateContext, ViewPathContext, ViewPathCreateContext } from '../../lib/flink/FlinkSqlParser';
 import { FlinkSqlParserListener } from '../../lib/flink/FlinkSqlParserListener';
 import { EntityCollector } from '../common/entityCollector';
 export declare class FlinkEntityCollector extends EntityCollector implements FlinkSqlParserListener {
@@ -8,11 +8,19 @@ export declare class FlinkEntityCollector extends EntityCollector implements Fli
     exitDatabasePathCreate(ctx: DatabasePathCreateContext): void;
     exitDatabasePath(ctx: DatabasePathContext): void;
     exitTablePath(ctx: TablePathContext): void;
+    exitAtomFunctionTable(ctx: AtomFunctionTableContext): void;
+    exitAtomExpressionTable(ctx: AtomExpressionTableContext): void;
     exitTablePathCreate(ctx: TablePathCreateContext): void;
     exitViewPath(ctx: ViewPathContext): void;
     exitViewPathCreate(ctx: ViewPathCreateContext): void;
-    exitColumnNameCreate(ctx: ColumnNameCreateContext): void;
     exitFunctionNameCreate(ctx: FunctionNameCreateContext): void;
+    exitSelectList(ctx: SelectListContext): void;
+    /** Column entity rules */
+    exitColumnNameCreate(ctx: ColumnNameCreateContext): void;
+    exitSelectLiteralColumnName(ctx: SelectLiteralColumnNameContext): void;
+    exitSelectExpressionColumnName(ctx: SelectExpressionColumnNameContext): void;
+    exitSelectWindowItemColumnName(ctx: SelectWindowItemColumnNameContext): void;
+    exitTableAllColumns(ctx: TableAllColumnsContext): void;
     /** ===== Statement begin */
     enterSqlStatement(ctx: SqlStatementContext): void;
     exitSqlStatement(ctx: SqlStatementContext): void;

package/dist/parser/flink/flinkEntityCollector.js

@@ -1,5 +1,5 @@
-import { CreateDatabaseContext, CreateTableContext, CreateViewContext, PhysicalColumnDefinitionContext, TableReferenceContext, } from '../../lib/flink/FlinkSqlParser';
-import { AttrName, EntityCollector, StmtContextType } from '../common/entityCollector';
+import { ColumnProjectItemContext, CreateDatabaseContext, CreateTableContext, CreateViewContext, OverWindowItemContext, PhysicalColumnDefinitionContext, TableReferenceContext, } from '../../lib/flink/FlinkSqlParser';
+import { AttrName, ColumnDeclareType, EntityCollector, StmtContextType, TableDeclareType, } from '../common/entityCollector';
 import { EntityContextType } from '../common/types';
 export class FlinkEntityCollector extends EntityCollector {
     /** ====== Entity Begin */
@@ -21,16 +21,34 @@ export class FlinkEntityCollector extends EntityCollector {
         this.pushEntity(ctx, EntityContextType.DATABASE);
     }
     exitTablePath(ctx) {
-        var _a;
-        const needCollectAttr = ((_a = this.getRootStmt()) === null || _a === void 0 ? void 0 : _a.stmtContextType) === StmtContextType.SELECT_STMT;
-        this.pushEntity(ctx, EntityContextType.TABLE, needCollectAttr
-            ? [
-                {
-                    attrName: AttrName.alias,
-                    endContextList: [TableReferenceContext.name],
-                },
-            ]
-            : undefined);
+        this.pushEntity(ctx, EntityContextType.TABLE, [
+            {
+                attrName: AttrName.alias,
+                endContextList: [TableReferenceContext.name],
+            },
+        ], {
+            declareType: TableDeclareType.LITERAL,
+        });
+    }
+    exitAtomFunctionTable(ctx) {
+        this.pushEntity(ctx, EntityContextType.TABLE, [
+            {
+                attrName: AttrName.alias,
+                endContextList: [TableReferenceContext.name],
+            },
+        ], {
+            declareType: TableDeclareType.EXPRESSION,
+        });
+    }
+    exitAtomExpressionTable(ctx) {
+        this.pushEntity(ctx, EntityContextType.TABLE, [
+            {
+                attrName: AttrName.alias,
+                endContextList: [TableReferenceContext.name],
+            },
+        ], {
+            declareType: TableDeclareType.EXPRESSION,
+        });
     }
     exitTablePathCreate(ctx) {
         this.pushEntity(ctx, EntityContextType.TABLE_CREATE, [
@@ -51,6 +69,13 @@ export class FlinkEntityCollector extends EntityCollector {
             },
         ]);
     }
+    exitFunctionNameCreate(ctx) {
+        this.pushEntity(ctx, EntityContextType.FUNCTION_CREATE);
+    }
+    exitSelectList(ctx) {
+        this.pushEntity(ctx, EntityContextType.QUERY_RESULT);
+    }
+    /** Column entity rules */
     exitColumnNameCreate(ctx) {
         this.pushEntity(ctx, EntityContextType.COLUMN_CREATE, [
             {
@@ -63,8 +88,45 @@ export class FlinkEntityCollector extends EntityCollector {
             },
         ]);
     }
-    exitFunctionNameCreate(ctx) {
-        this.pushEntity(ctx, EntityContextType.FUNCTION_CREATE);
+    exitSelectLiteralColumnName(ctx) {
+        this.pushEntity(ctx, EntityContextType.COLUMN, [
+            {
+                attrName: AttrName.alias,
+                endContextList: [ColumnProjectItemContext.name],
+            },
+        ], {
+            declareType: ColumnDeclareType.LITERAL,
+        });
+    }
+    exitSelectExpressionColumnName(ctx) {
+        this.pushEntity(ctx, EntityContextType.COLUMN, [
+            {
+                attrName: AttrName.alias,
+                endContextList: [ColumnProjectItemContext.name],
+            },
+        ], {
+            declareType: ColumnDeclareType.EXPRESSION,
+        });
+    }
+    exitSelectWindowItemColumnName(ctx) {
+        this.pushEntity(ctx, EntityContextType.COLUMN, [
+            {
+                attrName: AttrName.alias,
+                endContextList: [ColumnProjectItemContext.name, OverWindowItemContext.name],
+            },
+        ], {
+            declareType: ColumnDeclareType.EXPRESSION,
+        });
+    }
+    exitTableAllColumns(ctx) {
+        this.pushEntity(ctx, EntityContextType.COLUMN, [
+            {
+                attrName: AttrName.alias,
+                endContextList: [ColumnProjectItemContext.name],
+            },
+        ], {
+            declareType: ColumnDeclareType.ALL,
+        });
     }
     /** ===== Statement begin */
     enterSqlStatement(ctx) {

package/dist/parser/flink/index.js

@@ -36,6 +36,7 @@ export class FlinkSQL extends BasicSQL {
             FlinkSqlParser.RULE_functionNameCreate, // functionName that will be created
             FlinkSqlParser.RULE_columnName,
             FlinkSqlParser.RULE_columnNamePath,
+            FlinkSqlParser.RULE_columnNamePathAllowEmpty,
             FlinkSqlParser.RULE_columnNameCreate,
             FlinkSqlParser.RULE_tablePropertyKey,
             FlinkSqlParser.RULE_tablePropertyValue,
@@ -116,13 +117,15 @@ export class FlinkSQL extends BasicSQL {
                     syntaxContextType = EntityContextType.COLUMN_CREATE;
                     break;
                 }
-                case FlinkSqlParser.RULE_columnNamePath: {
+                case FlinkSqlParser.RULE_columnNamePath:
+                case FlinkSqlParser.RULE_columnNamePathAllowEmpty: {
                     if (candidateRule.ruleList.includes(FlinkSqlParser.RULE_selectClause) ||
                         candidateRule.ruleList.includes(FlinkSqlParser.RULE_whereClause) ||
                         candidateRule.ruleList.includes(FlinkSqlParser.RULE_groupByClause) ||
                         candidateRule.ruleList.includes(FlinkSqlParser.RULE_limitClause) ||
                         candidateRule.ruleList.includes(FlinkSqlParser.RULE_whenClause) ||
-                        candidateRule.ruleList.includes(FlinkSqlParser.RULE_havingClause)) {
+                        candidateRule.ruleList.includes(FlinkSqlParser.RULE_havingClause) ||
+                        candidateRule.ruleList.includes(FlinkSqlParser.RULE_joinCondition)) {
                         syntaxContextType = EntityContextType.COLUMN;
                     }
                     break;

package/dist/parser/hive/hiveEntityCollector.d.ts

@@ -1,12 +1,24 @@
 import { HiveSqlParserListener } from '../../lib';
-import { ColumnNameCreateContext, CreateDatabaseStatementContext, CreateFunctionStatementContext, CreateMaterializedViewStatementContext, CreateTableStatementContext, CreateViewStatementContext, DbSchemaNameContext, DbSchemaNameCreateContext, FromInsertStmtContext, FromSelectStmtContext, FunctionNameCreateContext, InsertStmtContext, SelectStatementContext, StatementContext, TableNameContext, TableNameCreateContext, ViewNameContext, ViewNameCreateContext } from '../../lib/hive/HiveSqlParser';
+import { AtomPartitionedTableFunctionContext, AtomValuesClauseContext, ColumnNameCreateContext, CreateDatabaseStatementContext, CreateFunctionStatementContext, CreateMaterializedViewStatementContext, CreateTableStatementContext, CreateViewStatementContext, DbSchemaNameContext, DbSchemaNameCreateContext, FromInsertStmtContext, FromSelectStmtContext, FunctionNameCreateContext, InsertStmtContext, QueryStatementExpressionContext, SelectExpressionColumnNameContext, SelectListContext, SelectLiteralColumnNameContext, SelectStatementContext, StatementContext, TableAllColumnsContext, TableNameContext, TableNameCreateContext, ViewNameContext, ViewNameCreateContext } from '../../lib/hive/HiveSqlParser';
 import { EntityCollector } from '../common/entityCollector';
 export declare class HiveEntityCollector extends EntityCollector implements HiveSqlParserListener {
     /** ====== Entity Begin */
     exitTableNameCreate(ctx: TableNameCreateContext): void;
+    /** Table Entity Rules */
     exitTableName(ctx: TableNameContext): void;
+    /** Virtual Table Entity Rules */
+    exitAtomValuesClause(ctx: AtomValuesClauseContext): void;
+    /** SubQuery Table Entity Rules */
+    exitQueryStatementExpression(ctx: QueryStatementExpressionContext): void;
+    /** Partitioned Table Entity Rules */
+    exitAtomPartitionedTableFunction(ctx: AtomPartitionedTableFunctionContext): void;
+    /** Column Entity Rules */
     exitColumnNameCreate(ctx: ColumnNameCreateContext): void;
+    exitSelectLiteralColumnName(ctx: SelectLiteralColumnNameContext): void;
+    exitSelectExpressionColumnName(ctx: SelectExpressionColumnNameContext): void;
+    exitTableAllColumns(ctx: TableAllColumnsContext): void;
     exitViewNameCreate(ctx: ViewNameCreateContext): void;
+    exitSelectList(ctx: SelectListContext): void;
     exitViewName(ctx: ViewNameContext): void;
     exitDbSchemaNameCreate(ctx: DbSchemaNameCreateContext): void;
     exitDbSchemaName(ctx: DbSchemaNameContext): void;