dt-sql-parser 4.4.0-beta.0 → 4.5.0-beta.0

package/dist/lib/trino/TrinoSqlVisitor.d.ts

@@ -116,6 +116,7 @@ import { SortItemContext } from "./TrinoSqlParser.js";
 import { QuerySpecificationContext } from "./TrinoSqlParser.js";
 import { WhereClauseContext } from "./TrinoSqlParser.js";
 import { HavingClauseContext } from "./TrinoSqlParser.js";
+import { SelectListContext } from "./TrinoSqlParser.js";
 import { GroupByContext } from "./TrinoSqlParser.js";
 import { PartitionByContext } from "./TrinoSqlParser.js";
 import { SingleGroupingSetContext } from "./TrinoSqlParser.js";
@@ -128,8 +129,11 @@ import { WindowDefinitionContext } from "./TrinoSqlParser.js";
 import { WindowSpecificationContext } from "./TrinoSqlParser.js";
 import { NamedQueryContext } from "./TrinoSqlParser.js";
 import { SetQuantifierContext } from "./TrinoSqlParser.js";
-import { SelectSingleContext } from "./TrinoSqlParser.js";
-import { SelectAllContext } from "./TrinoSqlParser.js";
+import { SelectItemContext } from "./TrinoSqlParser.js";
+import { SelectAllWithoutTableContext } from "./TrinoSqlParser.js";
+import { TableAllColumnsContext } from "./TrinoSqlParser.js";
+import { SelectLiteralColumnNameContext } from "./TrinoSqlParser.js";
+import { SelectExpressionColumnNameContext } from "./TrinoSqlParser.js";
 import { RelationDefaultContext } from "./TrinoSqlParser.js";
 import { JoinRelationContext } from "./TrinoSqlParser.js";
 import { JoinTypeContext } from "./TrinoSqlParser.js";
@@ -151,11 +155,12 @@ import { ColumnListCreateContext } from "./TrinoSqlParser.js";
 import { ColumnListContext } from "./TrinoSqlParser.js";
 import { ColumnAliasesContext } from "./TrinoSqlParser.js";
 import { TableNameContext } from "./TrinoSqlParser.js";
+import { ExpressionSourceTableContext } from "./TrinoSqlParser.js";
+import { ParenthesizedRelationContext } from "./TrinoSqlParser.js";
 import { SubqueryRelationContext } from "./TrinoSqlParser.js";
 import { UnnestContext } from "./TrinoSqlParser.js";
 import { LateralContext } from "./TrinoSqlParser.js";
 import { TableFunctionInvocationContext } from "./TrinoSqlParser.js";
-import { ParenthesizedRelationContext } from "./TrinoSqlParser.js";
 import { JsonTableContext } from "./TrinoSqlParser.js";
 import { OrdinalityColumnContext } from "./TrinoSqlParser.js";
 import { ValueColumnContext } from "./TrinoSqlParser.js";
@@ -1176,6 +1181,12 @@ export declare class TrinoSqlVisitor<Result> extends AbstractParseTreeVisitor<Re
      * @return the visitor result
      */
     visitHavingClause?: (ctx: HavingClauseContext) => Result;
+    /**
+     * Visit a parse tree produced by `TrinoSqlParser.selectList`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitSelectList?: (ctx: SelectListContext) => Result;
     /**
      * Visit a parse tree produced by `TrinoSqlParser.groupBy`.
      * @param ctx the parse tree
@@ -1253,19 +1264,35 @@ export declare class TrinoSqlVisitor<Result> extends AbstractParseTreeVisitor<Re
      */
     visitSetQuantifier?: (ctx: SetQuantifierContext) => Result;
     /**
-     * Visit a parse tree produced by the `selectSingle`
-     * labeled alternative in `TrinoSqlParser.selectItem`.
+     * Visit a parse tree produced by `TrinoSqlParser.selectItem`.
      * @param ctx the parse tree
      * @return the visitor result
      */
-    visitSelectSingle?: (ctx: SelectSingleContext) => Result;
+    visitSelectItem?: (ctx: SelectItemContext) => Result;
     /**
-     * Visit a parse tree produced by the `selectAll`
-     * labeled alternative in `TrinoSqlParser.selectItem`.
+     * Visit a parse tree produced by `TrinoSqlParser.selectAllWithoutTable`.
      * @param ctx the parse tree
      * @return the visitor result
      */
-    visitSelectAll?: (ctx: SelectAllContext) => Result;
+    visitSelectAllWithoutTable?: (ctx: SelectAllWithoutTableContext) => Result;
+    /**
+     * Visit a parse tree produced by `TrinoSqlParser.tableAllColumns`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitTableAllColumns?: (ctx: TableAllColumnsContext) => Result;
+    /**
+     * Visit a parse tree produced by `TrinoSqlParser.selectLiteralColumnName`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitSelectLiteralColumnName?: (ctx: SelectLiteralColumnNameContext) => Result;
+    /**
+     * Visit a parse tree produced by `TrinoSqlParser.selectExpressionColumnName`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitSelectExpressionColumnName?: (ctx: SelectExpressionColumnNameContext) => Result;
     /**
      * Visit a parse tree produced by the `relationDefault`
      * labeled alternative in `TrinoSqlParser.relation`.
@@ -1396,43 +1423,50 @@ export declare class TrinoSqlVisitor<Result> extends AbstractParseTreeVisitor<Re
      */
     visitTableName?: (ctx: TableNameContext) => Result;
     /**
-     * Visit a parse tree produced by the `subqueryRelation`
+     * Visit a parse tree produced by the `expressionSourceTable`
+     * labeled alternative in `TrinoSqlParser.relationPrimary`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitExpressionSourceTable?: (ctx: ExpressionSourceTableContext) => Result;
+    /**
+     * Visit a parse tree produced by the `parenthesizedRelation`
      * labeled alternative in `TrinoSqlParser.relationPrimary`.
      * @param ctx the parse tree
      * @return the visitor result
      */
+    visitParenthesizedRelation?: (ctx: ParenthesizedRelationContext) => Result;
+    /**
+     * Visit a parse tree produced by the `subqueryRelation`
+     * labeled alternative in `TrinoSqlParser.relationSourceTable`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
     visitSubqueryRelation?: (ctx: SubqueryRelationContext) => Result;
     /**
      * Visit a parse tree produced by the `unnest`
-     * labeled alternative in `TrinoSqlParser.relationPrimary`.
+     * labeled alternative in `TrinoSqlParser.relationSourceTable`.
      * @param ctx the parse tree
      * @return the visitor result
      */
     visitUnnest?: (ctx: UnnestContext) => Result;
     /**
      * Visit a parse tree produced by the `lateral`
-     * labeled alternative in `TrinoSqlParser.relationPrimary`.
+     * labeled alternative in `TrinoSqlParser.relationSourceTable`.
      * @param ctx the parse tree
      * @return the visitor result
      */
     visitLateral?: (ctx: LateralContext) => Result;
     /**
      * Visit a parse tree produced by the `tableFunctionInvocation`
-     * labeled alternative in `TrinoSqlParser.relationPrimary`.
+     * labeled alternative in `TrinoSqlParser.relationSourceTable`.
      * @param ctx the parse tree
      * @return the visitor result
      */
     visitTableFunctionInvocation?: (ctx: TableFunctionInvocationContext) => Result;
-    /**
-     * Visit a parse tree produced by the `parenthesizedRelation`
-     * labeled alternative in `TrinoSqlParser.relationPrimary`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitParenthesizedRelation?: (ctx: ParenthesizedRelationContext) => Result;
     /**
      * Visit a parse tree produced by the `jsonTable`
-     * labeled alternative in `TrinoSqlParser.relationPrimary`.
+     * labeled alternative in `TrinoSqlParser.relationSourceTable`.
      * @param ctx the parse tree
      * @return the visitor result
      */

package/dist/parser/common/basicSQL.js

@@ -359,6 +359,8 @@ export class BasicSQL {
         }
         const core = new CodeCompletionCore(sqlParserIns);
         core.preferredRules = this.preferredRules;
+        // core.showRuleStack = true;
+        //  core.showResult = true;
         const candidates = core.collectCandidates(caretTokenIndex, parseTree);
         const originalSuggestions = this.processCandidates(candidates, allTokens, caretTokenIndex);
         const syntaxSuggestions = originalSuggestions.syntax.map((syntaxCtx) => {

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

@@ -22,6 +22,8 @@ export interface StmtContext {
     readonly rootStmt: StmtContext | null;
     readonly parentStmt: StmtContext | null;
     readonly isContainCaret?: boolean;
+    readonly scopeDepth: number;
+    readonly text: string;
 }
 export declare function toStmtContext(ctx: ParserRuleContext, type: StmtContextType, input: string, rootStmt: StmtContext | null, parentStmt: StmtContext | null, isContainCaret?: boolean): StmtContext | null;
 /**
@@ -49,31 +51,77 @@ export interface Argument {
     argName?: WordRange;
     argType: WordRange;
 }
+/**
+ * Base interface for all entity contexts in SQL parsing
+ */
 export interface BaseEntityContext {
+    /** The type of entity context */
     readonly entityContextType: EntityContextType;
+    /** The text representation of this entity */
     readonly text: string;
+    /** The position information for this entity */
     readonly position: WordPosition;
+    /** The statement this entity belongs to */
     readonly belongStmt: StmtContext;
+    /** Reference to another entity or string */
     reference?: string | EntityContext;
+    /** Whether the entity is accessible from the caret position, **ONLY** applicable to table entity */
+    isAccessible: boolean | null;
+    /** Entities related to this entity */
+    relatedEntities: EntityContext[] | null;
+    /** Comment attribute for this entity */
     [AttrName.comment]: WordRange | null;
+    /** Alias attribute for this entity */
     [AttrName.alias]?: WordRange | null;
 }
+/**
+ * Types of column declarations
+ */
+export declare enum ColumnDeclareType {
+    /** Literal column name */
+    LITERAL = 0,
+    /** Using asterisk syntax (tableName.*) */
+    ALL = 1,
+    /** Complex expressions like subqueries, case statements, function calls */
+    EXPRESSION = 2
+}
+/**
+ * Types of table declarations
+ */
+export declare enum TableDeclareType {
+    /** Regular table reference */
+    LITERAL = 0,
+    /** Table defined by expression (e.g., subquery) */
+    EXPRESSION = 1
+}
 export interface CommonEntityContext extends BaseEntityContext {
-    relatedEntities: CommonEntityContext[] | null;
+    /** Columns associated with this entity */
     columns?: ColumnEntityContext[];
+    /** Type of table declaration */
+    declareType?: TableDeclareType;
 }
 export interface ColumnEntityContext extends BaseEntityContext {
+    /** Type of column declaration */
+    declareType?: ColumnDeclareType;
+    /** Column type information */
     [AttrName.colType]: WordRange | null;
+    /** Column alias */
+    [AttrName.alias]?: WordRange | null;
 }
 export interface FuncEntityContext extends BaseEntityContext {
-    relatedEntities: CommonEntityContext[] | null;
+    /** Function arguments */
     arguments: Argument[] | null;
+    /** Function return value */
     returns?: Argument;
 }
 export type EntityContext = CommonEntityContext | FuncEntityContext | ColumnEntityContext;
 export declare function isCommonEntityContext(entity: EntityContext): entity is CommonEntityContext;
 export declare function isFuncEntityContext(entity: EntityContext): entity is FuncEntityContext;
 export declare function isColumnEntityContext(entity: EntityContext): entity is ColumnEntityContext;
+/**
+ * Check if ctx is a child node of a specific rule type
+ */
+export declare function isChildContextOf(ctx: ParserRuleContext, parentRuleIndex: number): boolean;
 /**
  *  what we need when collect attribute information
  * */
@@ -81,7 +129,10 @@ interface AttrInfo {
     attrName: AttrName;
     endContextList: string[];
 }
-export declare function toEntityContext(ctx: ParserRuleContext, type: EntityContextType, input: string, belongStmt: StmtContext, attrInfo?: AttrInfo[]): EntityContext | null;
+interface MetaInfo {
+    declareType: TableDeclareType | ColumnDeclareType;
+}
+export declare function toEntityContext(ctx: ParserRuleContext, type: EntityContextType, input: string, belongStmt: StmtContext, attrInfo?: AttrInfo[], metaInfo?: MetaInfo): EntityContext | null;
 export declare function findAttribute(ctx: ParserRuleContextWithAttr | null, keyName: AttrName, endContextNameList: string[]): Token | null;
 /**
  * @todo: Handle alias, includes column alias, table alias, query as alias and so on.
@@ -97,6 +148,16 @@ export declare abstract class EntityCollector {
     private readonly _stmtStack;
     /** Staging entities inside a single statement or clause. */
     private readonly _entityStack;
+    /**
+     * The scope depth of the statement containing the caret.
+     * This is used to determine the accessibility of entities.
+     */
+    private _caretStmtScopeDepth;
+    /**
+     * The nearest statement containing the caret,
+     * Not used for now.
+     */
+    private _caretStmt;
     /**
      * Always point to the first non-commonStmt at the bottom of the _stmtStack,
      * unless there are only commonStmts in the _stmtStack.
@@ -109,6 +170,30 @@ export declare abstract class EntityCollector {
     getRootStmt(): StmtContext | null;
     getEntities(): EntityContext[];
     enterProgram(): void;
+    exitProgram(): void;
+    /**
+     * Adds accessibility markers to entities
+     * @param entities The list of entities to process
+     */
+    protected attachAccessibleToEntities(entities: EntityContext[]): void;
+    /**
+     * Attach query result to column if the column is derived from expression.
+     */
+    protected attachQueryResultToColumn(column: ColumnEntityContext, queryResults: CommonEntityContext[]): void;
+    /**
+     * Attach related columns to query result
+     */
+    protected attachColumnsToQueryResult(queryResult: CommonEntityContext, columns: ColumnEntityContext[]): void;
+    /**
+     * Attach query result to table if the table is derived from expression.
+     */
+    protected attachQueryResultToTable(table: CommonEntityContext, queryResults: CommonEntityContext[]): void;
+    /**
+     * Gets query result entities inside a statement
+     * @param stmt The statement to search within
+     * @returns Array of query result entity contexts
+     */
+    protected getQueryResultEntitiesInsideStmt(stmt: StmtContext): CommonEntityContext[];
     /**
      * 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
@@ -116,7 +201,7 @@ export declare abstract class EntityCollector {
     protected getPrevNonHiddenTokenIndex(caretTokenIndex: number): number;
     protected pushStmt(ctx: ParserRuleContext, type: StmtContextType): StmtContext | null;
     protected popStmt(): StmtContext;
-    protected pushEntity(ctx: ParserRuleContext, type: EntityContextType, attrInfo?: AttrInfo[]): EntityContext | null;
+    protected pushEntity(ctx: ParserRuleContext, type: EntityContextType, attrInfo?: AttrInfo[], metaInfo?: MetaInfo): EntityContext | null;
     /**
      * Combine entities that inside a single statement.
      * e.g. combine tableName and column if they are inside a same createTableStatement.
@@ -127,6 +212,8 @@ export declare abstract class EntityCollector {
      * Combined all entities under a rootStmt.
      */
     protected combineRootStmtEntities(stmtContext: StmtContext, entitiesInsideStmt: EntityContext[]): EntityContext[];
+    protected combineQueryResultStmtEntities(stmtContext: StmtContext, entitiesInsideStmt: EntityContext[]): EntityContext[];
+    protected combineFromTableSource(stmtContext: StmtContext, entitiesInsideStmt: EntityContext[]): EntityContext[];
     protected combineCreateTableOrViewStmtEntities(stmtContext: StmtContext, entitiesInsideStmt: EntityContext[]): EntityContext[];
 }
 export {};

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,76 @@ 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
+            return entitiesInsideStmt.filter((entity) => entity.entityContextType !== EntityContextType.COLUMN &&
+                entity.entityContextType !== EntityContextType.QUERY_RESULT);
+        }
+    }
+    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;