package gudusoft.gsqlparser.resolver2;

import gudusoft.gsqlparser.*;
import gudusoft.gsqlparser.compiler.TContext;
import gudusoft.gsqlparser.nodes.*;
import gudusoft.gsqlparser.resolver2.matcher.DefaultNameMatcher;
import gudusoft.gsqlparser.resolver2.matcher.INameMatcher;
import gudusoft.gsqlparser.resolver2.namespace.CTENamespace;
import gudusoft.gsqlparser.resolver2.namespace.INamespace;
import gudusoft.gsqlparser.resolver2.namespace.PivotNamespace;
import gudusoft.gsqlparser.resolver2.namespace.PlsqlVariableNamespace;
import gudusoft.gsqlparser.resolver2.namespace.SubqueryNamespace;
import gudusoft.gsqlparser.resolver2.namespace.TableNamespace;
import gudusoft.gsqlparser.resolver2.namespace.UnionNamespace;
import gudusoft.gsqlparser.resolver2.namespace.UnnestNamespace;
import gudusoft.gsqlparser.resolver2.namespace.ValuesNamespace;
import gudusoft.gsqlparser.resolver2.scope.*;
import gudusoft.gsqlparser.resolver2.model.ScopeChild;
import gudusoft.gsqlparser.sqlenv.ESQLDataObjectType;
import gudusoft.gsqlparser.sqlenv.TSQLEnv;
import gudusoft.gsqlparser.stmt.TCommonBlock;
import gudusoft.gsqlparser.util.OraclePseudoColumnUtil;
import gudusoft.gsqlparser.util.SQLUtil;
import gudusoft.gsqlparser.stmt.TCreateTableSqlStatement;
import gudusoft.gsqlparser.stmt.TCreateTriggerStmt;
import gudusoft.gsqlparser.stmt.TAlterTableStatement;
import gudusoft.gsqlparser.stmt.TCreateIndexSqlStatement;
import gudusoft.gsqlparser.stmt.TDeleteSqlStatement;
import gudusoft.gsqlparser.stmt.TDropIndexSqlStatement;
import gudusoft.gsqlparser.stmt.TInsertSqlStatement;
import gudusoft.gsqlparser.stmt.TSelectSqlStatement;
import gudusoft.gsqlparser.stmt.TUpdateSqlStatement;
import gudusoft.gsqlparser.stmt.TMergeSqlStatement;
import gudusoft.gsqlparser.stmt.TExecImmeStmt;
import gudusoft.gsqlparser.stmt.TVarDeclStmt;
import gudusoft.gsqlparser.stmt.oracle.TPlsqlCreateProcedure;
import gudusoft.gsqlparser.stmt.oracle.TPlsqlCreateFunction;
import gudusoft.gsqlparser.stmt.oracle.TPlsqlCreateTrigger;
import gudusoft.gsqlparser.stmt.oracle.TPlsqlCreatePackage;
import gudusoft.gsqlparser.resolver2.namespace.OraclePackageNamespace;
import gudusoft.gsqlparser.stmt.TCreateProcedureStmt;
import gudusoft.gsqlparser.stmt.TCreateFunctionStmt;
import gudusoft.gsqlparser.stmt.TBlockSqlStatement;
import gudusoft.gsqlparser.stmt.mysql.TMySQLCreateProcedure;
import gudusoft.gsqlparser.stmt.mssql.TMssqlDeclare;
import gudusoft.gsqlparser.stmt.mssql.TMssqlReturn;
import gudusoft.gsqlparser.stmt.db2.TDb2SqlVariableDeclaration;
import gudusoft.gsqlparser.stmt.db2.TDb2DeclareCursorStatement;
import gudusoft.gsqlparser.stmt.db2.TDb2CreateFunction;
import gudusoft.gsqlparser.stmt.db2.TDb2ReturnStmt;
import gudusoft.gsqlparser.stmt.TForStmt;
import gudusoft.gsqlparser.nodes.teradata.TTDUnpivot;
import gudusoft.gsqlparser.stmt.TLoopStmt;
import gudusoft.gsqlparser.stmt.TCursorDeclStmt;
import gudusoft.gsqlparser.stmt.TOpenforStmt;
import gudusoft.gsqlparser.stmt.snowflake.TCreateFileFormatStmt;
import gudusoft.gsqlparser.stmt.snowflake.TCreateStageStmt;
import gudusoft.gsqlparser.stmt.snowflake.TCreatePipeStmt;
import gudusoft.gsqlparser.nodes.TDeclareVariable;
import gudusoft.gsqlparser.nodes.mssql.TMssqlCreateTriggerUpdateColumn;
import gudusoft.gsqlparser.util.TBuiltFunctionUtil;
import gudusoft.gsqlparser.util.TNiladicFunctionUtil;

import java.util.*;

/**
 * Builds a complete scope tree using the Visitor pattern.
 *
 * <p>This class traverses the AST and creates a properly nested scope tree
 * that reflects the SQL structure. All SELECT statements (including subqueries
 * and CTEs) get their own SelectScope with correct parent-child relationships.
 *
 * <p>Key features:
 * <ul>
 *   <li>Handles nested subqueries with correct parent scope</li>
 *   <li>Handles CTEs with forward reference support</li>
 *   <li>Collects all column references with their scope mappings</li>
 *   <li>Supports complex SQL patterns (CTE + subquery combinations)</li>
 * </ul>
 *
 * <p>Usage:
 * <pre>
 * ScopeBuilder builder = new ScopeBuilder(context, nameMatcher);
 * ScopeBuildResult result = builder.build(statements);
 * </pre>
 */
public class ScopeBuilder extends TParseTreeVisitor {

    // ========== Configuration ==========

    /** Global context from parser */
    private final TContext globalContext;

    /** Name matcher for case sensitivity */
    private final INameMatcher nameMatcher;

    /** SQL environment for table metadata lookup */
    private TSQLEnv sqlEnv;

    /** Database vendor */
    private EDbVendor dbVendor = EDbVendor.dbvoracle;

    /**
     * Strategy for handling ambiguous columns.
     * -1 means use global TBaseType.GUESS_COLUMN_STRATEGY.
     * This value is passed to namespaces for config-based isolation.
     */
    private int guessColumnStrategy = -1;

    // ========== Scope Stack ==========

    /** Scope stack - tracks current scope during traversal */
    private final Stack<IScope> scopeStack = new Stack<>();

    /** Global scope - root of scope tree */
    private GlobalScope globalScope;

    // ========== Result Collection ==========

    /** Column reference -> Scope mapping */
    private final Map<TObjectName, IScope> columnToScopeMap = new LinkedHashMap<>();

    /** All column references in traversal order */
    private final List<TObjectName> allColumnReferences = new ArrayList<>();

    /** Statement -> SelectScope mapping */
    private final Map<TSelectSqlStatement, SelectScope> statementScopeMap = new LinkedHashMap<>();

    /** Statement -> UpdateScope mapping */
    private final Map<TUpdateSqlStatement, UpdateScope> updateScopeMap = new LinkedHashMap<>();

    /** Statement -> MergeScope mapping */
    private final Map<TMergeSqlStatement, MergeScope> mergeScopeMap = new LinkedHashMap<>();

    /** Statement -> DeleteScope mapping */
    private final Map<TDeleteSqlStatement, DeleteScope> deleteScopeMap = new LinkedHashMap<>();

    // ========== Current State ==========

    /** Current SelectScope being built */
    private SelectScope currentSelectScope;

    /** Current UpdateScope being built */
    private UpdateScope currentUpdateScope;

    /** Current MergeScope being built */
    private MergeScope currentMergeScope;

    /** Current DeleteScope being built */
    private DeleteScope currentDeleteScope;

    /** Current FromScope being built */
    private FromScope currentFromScope;

    /** Stack to save/restore FromScope when processing nested subqueries */
    private final Stack<FromScope> fromScopeStack = new Stack<>();

    /** Current CTEScope being built */
    private CTEScope currentCTEScope;

    /** Depth counter for CTE definition processing.
     *  Incremented in preVisit(TCTE), decremented in postVisit(TCTE).
     *  When > 0, we're inside a CTE body, so CTAS target column handling should be skipped. */
    private int cteDefinitionDepth = 0;

    /** Set of TObjectName nodes that are table references (not column references) */
    private final Set<TObjectName> tableNameReferences = new HashSet<>();

    /** Set of TObjectName nodes that are SQL Server proprietary column aliases (not column references) */
    private final Set<TObjectName> sqlServerProprietaryAliases = new HashSet<>();

    /** Set of TObjectName nodes that are tuple alias columns (CTAS output columns, not references) */
    private final Set<TObjectName> tupleAliasColumns = new HashSet<>();

    /** Set of TObjectName nodes that are CTAS target columns (columns created by CREATE TABLE AS SELECT).
     *  These include standard alias columns and simple column reference columns.
     *  They are column DEFINITIONS that create new output columns in the target table, NOT column references.
     *  They should NOT be re-resolved through name resolution. */
    private final Set<TObjectName> ctasTargetColumns = new HashSet<>();

    /** Set of TObjectName nodes that are VALUES table alias column definitions.
     *  These are column NAME definitions in VALUES table alias clauses like:
     *  VALUES (1, 'a') AS t(id, name) - 'id' and 'name' are definitions, not references.
     *  They should NOT be collected as column references. */
    private final Set<TObjectName> valuesTableAliasColumns = new HashSet<>();

    /** Set of TObjectName nodes that are result column alias names (not column references).
     *  These include standard AS aliases and Teradata NAMED aliases like "COUNT(1)(NAMED CNT_LOGIN)". */
    private final Set<TObjectName> resultColumnAliasNames = new HashSet<>();

    /** Set of TObjectName nodes that are SET clause target columns (UPDATE SET left-side columns).
     *  These columns already have sourceTable correctly set to the UPDATE target table
     *  and should NOT be re-resolved through star column push-down. */
    private final Set<TObjectName> setClauseTargetColumns = new HashSet<>();

    /** Set of TObjectName nodes that are INSERT ALL target columns (from TInsertIntoValue columnList).
     *  These columns already have sourceTable correctly set to the INSERT target table
     *  and should NOT be re-resolved against the subquery scope. */
    private final Set<TObjectName> insertAllTargetColumns = new HashSet<>();

    /** Map of MERGE INSERT VALUES columns to their USING (source) table.
     *  These columns have sourceTable set to the USING table in preVisit(TMergeInsertClause).
     *  After name resolution (needed for star column push-down when USING is a subquery),
     *  their sourceTable must be restored to the USING table to ensure correct data lineage. */
    private final Map<TObjectName, TTable> mergeInsertValuesColumns = new java.util.IdentityHashMap<>();

    /** Set of unqualified MERGE INSERT VALUES columns that are PROVABLY not projected by the
     *  USING source (the source is a derived table whose full projection list is visible in the
     *  AST and does not contain the name).
     *
     *  In "WHEN NOT MATCHED THEN INSERT ... VALUES (...)" the only relation in scope is the USING
     *  source — the target row does not exist yet — so such an identifier is genuinely undefined
     *  (a host/bind variable, a typo, ...). It must stay unresolved rather than be linked to the
     *  USING table, which would tell consumers "this is a real column of that table" when it
     *  demonstrably is not. Collected in preVisit(TMergeInsertClause); preVisit(TObjectName) then
     *  keeps them in allColumnReferences but out of columnToScopeMap, which is what stops every
     *  later resolution pass from binding them. */
    private final Set<TObjectName> mergeInsertValuesUnboundColumns =
            java.util.Collections.newSetFromMap(new java.util.IdentityHashMap<TObjectName, Boolean>());

    /** Set of TObjectName nodes that are function keyword arguments (e.g., SECOND in TIMESTAMP_DIFF).
     *  These are marked during TFunctionCall traversal so they can be skipped during column collection. */
    private final Set<TObjectName> functionKeywordArguments = new HashSet<>();

    /** Set of TObjectName nodes that are named argument parameter names (e.g., INPUT in "INPUT => value").
     *  These are marked during TExpression traversal and should NOT be treated as column references.
     *  Named arguments use the "=>" syntax (e.g., Snowflake FLATTEN: "INPUT => parse_json(col), outer => TRUE"). */
    private final Set<TObjectName> namedArgumentParameters = new HashSet<>();

    /** Set of TObjectName nodes that are PIVOT IN clause items.
     *  These define pivot column names and should NOT be resolved as column references to the source table.
     *  Their sourceTable is already correctly set to the pivot table by addPivotInClauseColumns(). */
    private final Set<TObjectName> pivotInClauseColumns = new HashSet<>();

    /** Set of TObjectName nodes that are UNPIVOT definition columns (value and FOR columns).
     *  These are column DEFINITIONS that create new output columns, NOT column references.
     *  Example: UNPIVOT (yearly_total FOR order_mode IN (...))
     *  - yearly_total is a value column definition
     *  - order_mode is a FOR column definition
     *  Both should NOT be collected as column references. */
    private final Set<TObjectName> unpivotDefinitionColumns = new HashSet<>();

    /** Variable declaration names (from DECLARE statements) - these are NOT column references */
    private final Set<TObjectName> variableDeclarationNames = new HashSet<>();

    /** Lambda parameter names - these are NOT column references but local function parameters
     *  e.g., in "transform(array, x -> x + 1)", x is a lambda parameter, not a table column */
    private final Set<TObjectName> lambdaParameters = new HashSet<>();

    /** DDL target object names - these are NOT column references but object names in DDL statements.
     *  Examples: file format name in CREATE FILE FORMAT, stage name in CREATE STAGE, pipe name in CREATE PIPE.
     *  These should be skipped during column collection. */
    private final Set<TObjectName> ddlTargetNames = new HashSet<>();

    /** Stack of lambda parameter name sets - used to track current lambda context during traversal.
     *  When inside a lambda expression, the parameter names are pushed onto this stack.
     *  This allows checking if a TObjectName is a lambda parameter without walking up the AST. */
    private final Stack<Set<String>> lambdaParameterStack = new Stack<>();

    /** Map of TSelectSqlStatement -> Set of lateral column alias names defined in its SELECT list.
     *  Used to detect lateral column aliases (Snowflake, BigQuery) where aliases defined earlier
     *  in the SELECT list can be referenced by later columns. */
    private final Map<TSelectSqlStatement, Set<String>> selectLateralAliases = new LinkedHashMap<>();

    /** The alias of the current result column being processed (normalized, lowercase).
     *  Used to exclude the current result column's own alias from lateral alias matching,
     *  since a column reference inside the expression that DEFINES an alias cannot be
     *  a reference TO that alias - it must be a reference to the source table column.
     *  e.g., in "CASE WHEN Model_ID = '' THEN NULL ELSE TRIM(Model_ID) END AS Model_ID",
     *  the Model_ID references inside CASE are source table columns, not lateral alias references. */
    private String currentResultColumnAlias = null;

    /** Flag indicating if we're currently inside a result column context.
     *  Lateral alias matching should ONLY apply inside result columns (SELECT list),
     *  NOT in FROM clause, WHERE clause, etc. Column references in those places
     *  are source table columns, not lateral alias references. */
    private boolean inResultColumnContext = false;

    /** Map of TTable to its SubqueryNamespace for deferred validation */
    private final Map<TTable, SubqueryNamespace> pendingSubqueryValidation = new LinkedHashMap<>();

    /** Map of TTable to its INamespace - used for legacy compatibility to fill TTable.getAttributes() */
    private final Map<TTable, INamespace> tableToNamespaceMap = new LinkedHashMap<>();

    /** Map of USING column -> right-side TTable for JOIN...USING resolution priority */
    private final Map<TObjectName, TTable> usingColumnToRightTable = new LinkedHashMap<>();

    /** Map of USING column -> left-side TTable for JOIN...USING (both tables should be reported) */
    private final Map<TObjectName, TTable> usingColumnToLeftTable = new LinkedHashMap<>();

    /** Current right-side table of a JOIN...USING clause being processed */
    private TTable currentUsingJoinRightTable = null;

    /** Current trigger target table (for SQL Server deleted/inserted virtual table resolution) */
    private TTable currentTriggerTargetTable = null;

    /** Current PL/SQL block scope being built */
    private PlsqlBlockScope currentPlsqlBlockScope = null;

    /** Stack of PL/SQL block scopes for nested blocks */
    private final Stack<PlsqlBlockScope> plsqlBlockScopeStack = new Stack<>();

    /** Stack to save/restore trigger target table for nested triggers */
    private final Stack<TTable> triggerTargetTableStack = new Stack<>();

    /** Set of TTable objects that are virtual trigger tables (deleted/inserted) that should be skipped in output */
    private final Set<TTable> virtualTriggerTables = new HashSet<>();

    /** Set of TFunctionCall objects that are table-valued functions (from FROM clause).
     *  These should NOT be treated as column method calls in preVisit(TFunctionCall).
     *  For example, [exce].[sampleTable]() is a table function, not column.method(). */
    private final Set<TFunctionCall> tableValuedFunctionCalls = new HashSet<>();

    /** Last table processed in the current FROM clause - used to find left side of JOIN...USING */
    private TTable lastProcessedFromTable = null;

    /** All tables processed so far in the current FROM clause - used for chained USING joins.
     *  In a query like "t1 JOIN t2 USING (c1) JOIN t3 USING (c2)", when processing USING (c2),
     *  both t1 and t2 should be considered as left-side tables, not just t2.
     *  This list is reset when entering a new FROM clause. */
    private List<TTable> currentJoinChainTables = new ArrayList<>();

    /** Current CTAS target table - set when processing CREATE TABLE AS SELECT */
    private TTable currentCTASTargetTable = null;

    /** The main SELECT scope for CTAS - only result columns at this level become CTAS target columns.
     *  This prevents subquery result columns from being incorrectly registered as CTAS target columns. */
    private SelectScope ctasMainSelectScope = null;

    /** Current UPDATE target table - set when processing UPDATE statement */
    private TTable currentUpdateTargetTable = null;
    /** @see #preVisit(TUpdateSqlStatement) — gates direct trace certification. */
    private boolean currentUpdateHasSingleTable = true;

    /** Current MERGE target table - set when processing MERGE statement */
    private TTable currentMergeTargetTable = null;

    /** Current INSERT target table - set when processing INSERT statement */
    private TTable currentInsertTargetTable = null;

    /** Current DELETE target table - set when processing DELETE statement */
    private TTable currentDeleteTargetTable = null;

    /** All CTAS target tables collected during scope building */
    private Set<TTable> allCtasTargetTables = new HashSet<>();

    /** Flag to track when we're inside EXECUTE IMMEDIATE dynamic string expression */
    private boolean insideExecuteImmediateDynamicExpr = false;

    /** Counter to track when we're processing PIVOT/UNPIVOT source relations.
     *  When > 0, subqueries should NOT be added to FromScope because they are
     *  source tables for PIVOT/UNPIVOT, not directly visible in the outer query.
     *  PIVOT/UNPIVOT transforms the source data and only the PIVOT/UNPIVOT table
     *  should be visible, not the underlying source subquery. */
    private int pivotSourceProcessingDepth = 0;

    /** Set of cursor FOR loop record names (e.g., "rec" in "for rec in (SELECT ...)") */
    private final Set<String> cursorForLoopRecordNames = new HashSet<>();

    // ========== Oracle Package Support ==========

    /** Registry of Oracle packages for cross-package resolution */
    private OraclePackageRegistry packageRegistry;

    /** Current package scope (when inside package body) */
    private OraclePackageScope currentPackageScope = null;

    /** Stack of package scopes for nested package handling */
    private final Stack<OraclePackageScope> packageScopeStack = new Stack<>();

    // ========== Cursor Variable Tracking ==========

    /** Set of known cursor variable names (lowercase) in current scope chain */
    private final Set<String> cursorVariableNames = new HashSet<>();

    // ========== Constructor ==========

    /**
     * Binding-trace capture sink (dynamic-SQL publication proof, R4 step 3);
     * {@code null} unless opted in. Direct {@code setSourceTable} bindings
     * bypass NameResolver entirely, so the typed clusters below register their
     * traces here. Uninstrumented direct sites simply produce NO trace, which
     * the proof treats as unprovable — fail-closed, never wrong.
     */
    private gudusoft.gsqlparser.resolver2.binding.BindingTraceRegistry bindingTraceRegistry;

    public void setBindingTraceRegistry(
            gudusoft.gsqlparser.resolver2.binding.BindingTraceRegistry registry) {
        this.bindingTraceRegistry = registry;
    }

    /** Register a typed direct-binding trace (observation-only; null-safe). */
    private void traceDirectBinding(TObjectName reference,
            gudusoft.gsqlparser.resolver2.binding.BindingTrace.BinderKind kind, TTable target) {
        if (bindingTraceRegistry != null) {
            bindingTraceRegistry.register(gudusoft.gsqlparser.resolver2.binding.BindingTrace
                    .direct(reference, kind, target));
        }
    }

    public ScopeBuilder(TContext globalContext, INameMatcher nameMatcher) {
        this.globalContext = globalContext;
        this.nameMatcher = nameMatcher != null ? nameMatcher : new DefaultNameMatcher();
        // Get TSQLEnv from global context if available
        if (globalContext != null) {
            this.sqlEnv = globalContext.getSqlEnv();
        }
    }

    public ScopeBuilder(TContext globalContext) {
        this(globalContext, new DefaultNameMatcher());
    }

    /**
     * Set the TSQLEnv for table metadata lookup.
     * This can be used to override the TSQLEnv from globalContext.
     *
     * @param sqlEnv the SQL environment containing table metadata
     */
    public void setSqlEnv(TSQLEnv sqlEnv) {
        this.sqlEnv = sqlEnv;
    }

    /**
     * Get the TSQLEnv used for table metadata lookup.
     *
     * @return the SQL environment, or null if not set
     */
    public TSQLEnv getSqlEnv() {
        return sqlEnv;
    }

    /**
     * Set the strategy for handling ambiguous columns.
     * This value will be passed to namespaces for config-based isolation.
     *
     * @param strategy One of TBaseType.GUESS_COLUMN_STRATEGY_* constants, or -1 to use global default
     */
    public void setGuessColumnStrategy(int strategy) {
        this.guessColumnStrategy = strategy;
    }

    /**
     * Get the strategy for handling ambiguous columns.
     *
     * @return The strategy constant, or -1 if not set (use global default)
     */
    public int getGuessColumnStrategy() {
        return guessColumnStrategy;
    }

    // ========== Main Entry Point ==========

    /**
     * Build scope tree for the given SQL statements.
     *
     * @param statements SQL statements to process
     * @return Build result containing scope tree and column mappings
     */
    public ScopeBuildResult build(TStatementList statements) {
        // Initialize
        reset();

        // Create global scope
        globalScope = new GlobalScope(globalContext, nameMatcher);
        scopeStack.push(globalScope);

        // Detect database vendor
        if (statements != null && statements.size() > 0) {
            dbVendor = statements.get(0).dbvendor;
        }

        // Pre-traversal: Build package registry for Oracle
        if (dbVendor == EDbVendor.dbvoracle && statements != null) {
            packageRegistry = new OraclePackageRegistry();
            packageRegistry.setDebug(DEBUG_SCOPE_BUILD);
            packageRegistry.buildFromStatements(statements);
            if (DEBUG_SCOPE_BUILD && packageRegistry.size() > 0) {
                System.out.println("[DEBUG] Built package registry with " +
                    packageRegistry.size() + " packages");
            }
        }

        // Process each statement
        if (statements != null) {
            for (int i = 0; i < statements.size(); i++) {
                Object stmt = statements.get(i);
                if (DEBUG_SCOPE_BUILD) {
                    System.out.println("[DEBUG] build(): Processing statement " + i + " of type " + stmt.getClass().getName());
                }
                if (stmt instanceof TParseTreeNode) {
                    // For certain statement types, we need to call accept() to trigger preVisit()
                    // - TCommonBlock: to set up the PL/SQL block scope
                    // - TDb2CreateFunction: to set up the function scope and handle parameters/variables
                    // - TPlsqlCreatePackage: to set up the package scope for package body
                    // For other statements, use acceptChildren() to maintain original behavior
                    if (stmt instanceof gudusoft.gsqlparser.stmt.TCommonBlock ||
                        stmt instanceof TDb2CreateFunction ||
                        stmt instanceof TPlsqlCreatePackage) {
                        ((TParseTreeNode) stmt).accept(this);
                    } else {
                        ((TParseTreeNode) stmt).acceptChildren(this);
                    }
                }
            }
        }

        // Post-process: remove function keyword arguments that were marked during traversal
        // This is necessary because TFunctionCall is visited AFTER its child TObjectName nodes
        if (!functionKeywordArguments.isEmpty()) {
            allColumnReferences.removeAll(functionKeywordArguments);
            for (TObjectName keywordArg : functionKeywordArguments) {
                columnToScopeMap.remove(keywordArg);
            }
            if (DEBUG_SCOPE_BUILD) {
                System.out.println("[DEBUG] Post-process: removed " + functionKeywordArguments.size() +
                    " function keyword arguments from column references");
            }
        }

        // Build result
        return new ScopeBuildResult(
            globalScope,
            columnToScopeMap,
            allColumnReferences,
            statementScopeMap,
            usingColumnToRightTable,
            usingColumnToLeftTable,
            tableToNamespaceMap,
            allCtasTargetTables
        );
    }

    /**
     * Reset all state for a new build
     */
    private void reset() {
        scopeStack.clear();
        columnToScopeMap.clear();
        allColumnReferences.clear();
        statementScopeMap.clear();
        updateScopeMap.clear();
        mergeScopeMap.clear();
        deleteScopeMap.clear();
        tableNameReferences.clear();
        tableValuedFunctionCalls.clear();
        tupleAliasColumns.clear();
        ctasTargetColumns.clear();
        valuesTableAliasColumns.clear();
        resultColumnAliasNames.clear();
        functionKeywordArguments.clear();
        namedArgumentParameters.clear();
        pivotInClauseColumns.clear();
        insertAllTargetColumns.clear();
        mergeInsertValuesUnboundColumns.clear();
        ddlTargetNames.clear();
        selectLateralAliases.clear();
        fromScopeStack.clear();
        pendingSubqueryValidation.clear();
        tableToNamespaceMap.clear();
        currentSelectScope = null;
        currentUpdateScope = null;
        currentMergeScope = null;
        currentDeleteScope = null;
        currentFromScope = null;
        currentCTEScope = null;
        cteDefinitionDepth = 0;
        currentMergeTargetTable = null;
        currentCTASTargetTable = null;
        ctasMainSelectScope = null;
        allCtasTargetTables.clear();
        currentPlsqlBlockScope = null;
        plsqlBlockScopeStack.clear();
        cursorForLoopRecordNames.clear();
        // Package support
        if (packageRegistry != null) {
            packageRegistry.clear();
        }
        packageRegistry = null;
        currentPackageScope = null;
        packageScopeStack.clear();
        // Cursor variable tracking
        cursorVariableNames.clear();
        globalScope = null;
    }

    // ========== CREATE TABLE AS SELECT Statement ==========

    @Override
    public void preVisit(TCreateTableSqlStatement stmt) {
        // Track CTAS target table for registering output columns
        if (stmt.getSubQuery() != null && stmt.getTargetTable() != null) {
            currentCTASTargetTable = stmt.getTargetTable();
            // Also add to the set of all CTAS target tables for filtering in formatter
            allCtasTargetTables.add(currentCTASTargetTable);
        }
    }

    @Override
    public void postVisit(TCreateTableSqlStatement stmt) {
        // Clear CTAS context after processing
        currentCTASTargetTable = null;
        ctasMainSelectScope = null;
    }

    // ========== Constraint Columns ==========

    @Override
    public void preVisit(TConstraint constraint) {
        // Collect FOREIGN KEY constraint column list as column references
        // These columns belong to the table being created/altered
        // Example: FOREIGN KEY (ProductID, SpecialOfferID) REFERENCES ...
        // The columns ProductID, SpecialOfferID in the FK list are references to the current table
        //
        // NOTE: We do NOT collect the referencedColumnList (columns from REFERENCES clause)
        // because those are already added to the referenced table's linkedColumns during
        // TConstraint.doParse() and will be output correctly from there.
        if (constraint.getConstraint_type() == EConstraintType.foreign_key ||
            constraint.getConstraint_type() == EConstraintType.reference) {

            TPTNodeList<TColumnWithSortOrder> columnList = constraint.getColumnList();
            if (columnList != null) {
                for (int i = 0; i < columnList.size(); i++) {
                    TColumnWithSortOrder col = columnList.getElement(i);
                    if (col != null && col.getColumnName() != null) {
                        TObjectName colName = col.getColumnName();
                        // Add to column references - the ownerTable is set by TConstraint.doParse()
                        // We need to also set sourceTable for proper output
                        if (colName.getSourceTable() == null && col.getOwnerTable() != null) {
                            colName.setSourceTable(col.getOwnerTable());
                        }
                        allColumnReferences.add(colName);
                    }
                }
            }
        }
    }

    // ========== SELECT Statement ==========

    // Debug flag
    private static final boolean DEBUG_SCOPE_BUILD = false;

    // Stack to save/restore pivotSourceProcessingDepth when entering subqueries
    // This ensures subquery's own tables are added to its FromScope even when inside PIVOT source
    private java.util.Deque<Integer> pivotSourceDepthStack = new java.util.ArrayDeque<>();

    @Override
    public void preVisit(TSelectSqlStatement stmt) {
        // Save and reset pivotSourceProcessingDepth for subqueries inside PIVOT source.
        // This ensures that when a PIVOT source contains a subquery, the subquery's own tables
        // (like #sample in: SELECT * FROM (SELECT col1 FROM #sample) p UNPIVOT ...)
        // are added to the subquery's FromScope, not filtered out by pivotSourceProcessingDepth.
        // The depth will be restored in postVisit(TSelectSqlStatement).
        pivotSourceDepthStack.push(pivotSourceProcessingDepth);
        pivotSourceProcessingDepth = 0;

        // Determine parent scope
        IScope parentScope = determineParentScopeForSelect(stmt);

        // Create SelectScope
        SelectScope selectScope = new SelectScope(parentScope, stmt);
        statementScopeMap.put(stmt, selectScope);

        // Push to stack
        scopeStack.push(selectScope);
        currentSelectScope = selectScope;

        // Track the main SELECT scope for CTAS - only the first SELECT in CTAS context
        // Subqueries within CTAS should NOT register their result columns as CTAS target columns
        if (currentCTASTargetTable != null && ctasMainSelectScope == null) {
            ctasMainSelectScope = selectScope;
        }

        if (DEBUG_SCOPE_BUILD) {
            String stmtPreview = stmt.toString().length() > 50
                ? stmt.toString().substring(0, 50) + "..."
                : stmt.toString();
            System.out.println("[DEBUG] preVisit(SELECT): " + stmtPreview.replace("\n", " "));
        }

        // Collect lateral column aliases from the SELECT list (for Snowflake, BigQuery lateral alias support)
        // These are aliases that can be referenced by later columns in the same SELECT list
        collectLateralAliases(stmt);

        // Note: FROM scope is created in preVisit(TFromClause)
        // TSelectSqlStatement.acceptChildren() DOES visit TFromClause when
        // TBaseType.USE_JOINEXPR_INSTEAD_OF_JOIN is true (which is the default)
    }

    @Override
    public void postVisit(TSelectSqlStatement stmt) {
        // Pop CTEScope if present (it was left on stack in postVisit(TCTEList))
        if (!scopeStack.isEmpty() && scopeStack.peek() instanceof CTEScope) {
            scopeStack.pop();
            currentCTEScope = findEnclosingCTEScope();
        }

        // Handle Teradata implicit derived tables for SELECT with no explicit FROM clause
        // According to teradata_implicit_derived_tables_zh.md:
        // When there are NO explicit tables AND exactly 1 implicit derived table,
        // unqualified columns should be linked to that implicit derived table
        SelectScope selectScope = statementScopeMap.get(stmt);
        // Check if FROM scope is null OR empty (no children)
        // The parser may create an empty FROM scope for implicit derived tables
        boolean fromScopeEmpty = selectScope == null ||
                                  selectScope.getFromScope() == null ||
                                  selectScope.getFromScope().getChildren().isEmpty();
        if (selectScope != null && fromScopeEmpty &&
            dbVendor == EDbVendor.dbvteradata && stmt.tables != null) {

            // Collect implicit derived tables (created by Phase 1 old resolver)
            List<TTable> implicitDerivedTables = new ArrayList<>();
            for (int i = 0; i < stmt.tables.size(); i++) {
                TTable table = stmt.tables.getTable(i);
                if (table.getEffectType() == ETableEffectType.tetImplicitLateralDerivedTable) {
                    implicitDerivedTables.add(table);
                }
            }

            // If there are implicit derived tables and FROM scope is empty,
            // add them to the FROM scope so unqualified columns can resolve
            if (!implicitDerivedTables.isEmpty()) {
                // Use existing FROM scope if present, otherwise create new one
                FromScope fromScope = selectScope.getFromScope();
                if (fromScope == null) {
                    fromScope = new FromScope(selectScope, stmt);
                    selectScope.setFromScope(fromScope);
                }

                // Use a Set to avoid adding duplicate tables (same name).
                // S2: key by vendor-aware identifier so quoted-sensitive
                // dialects (Oracle / Postgres quoted) and BigQuery's
                // case-sensitive table rule do not collapse distinct names.
                Set<String> addedTableNames = new HashSet<>();
                for (TTable implicitTable : implicitDerivedTables) {
                    String tableName = implicitTable.getName();
                    String tableKey = keyForTable(tableName);
                    if (addedTableNames.contains(tableKey)) {
                        continue; // Skip duplicate table
                    }
                    addedTableNames.add(tableKey);

                    // Create TableNamespace for the implicit derived table
                    TableNamespace tableNs = new TableNamespace(implicitTable, nameMatcher, sqlEnv);
                    tableNs.validate();
                    String alias = implicitTable.getAliasName();
                    if (alias == null || alias.isEmpty()) {
                        alias = implicitTable.getName();
                    }
                    fromScope.addChild(tableNs, alias, false);
                    tableToNamespaceMap.put(implicitTable, tableNs);

                    if (DEBUG_SCOPE_BUILD) {
                        System.out.println("[DEBUG] Added Teradata implicit derived table: " + implicitTable.getName());
                    }
                }
            }
        }

        // Pop SelectScope
        if (!scopeStack.isEmpty() && scopeStack.peek() instanceof SelectScope) {
            scopeStack.pop();
        }

        // Restore current SelectScope
        currentSelectScope = findEnclosingSelectScope();

        // Restore pivotSourceProcessingDepth (saved in preVisit)
        // This ensures that after exiting a subquery, we return to the correct PIVOT processing state
        if (!pivotSourceDepthStack.isEmpty()) {
            pivotSourceProcessingDepth = pivotSourceDepthStack.pop();
        }

        // Clear currentFromScope when exiting a truly top-level SELECT statement.
        // This prevents the FROM scope from leaking into subsequent statements like INSERT.
        // A truly top-level SELECT is one where:
        // 1. The fromScopeStack is empty (no nested subquery to restore)
        // 2. The currentSelectScope is null (no enclosing SELECT to reference)
        // 3. We're not inside an UPDATE, DELETE, or MERGE statement that has its own FROM scope
        // For subqueries, the FROM scope is restored via fromScopeStack in postVisit(TFromClause).
        if (fromScopeStack.isEmpty() && currentSelectScope == null &&
            currentUpdateScope == null && currentDeleteScope == null && currentMergeScope == null) {
            currentFromScope = null;
        }

        // Clean up lateral aliases for this statement
        selectLateralAliases.remove(stmt);
    }

    /**
     * Collect lateral column aliases from a SELECT statement's result column list.
     * Lateral column aliases are aliases that can be referenced by later columns
     * in the same SELECT list (supported by Snowflake, BigQuery, etc.)
     */
    private void collectLateralAliases(TSelectSqlStatement stmt) {
        TResultColumnList resultCols = stmt.getResultColumnList();
        if (resultCols == null || resultCols.size() == 0) {
            return;
        }

        Set<String> aliases = new HashSet<>();
        for (int i = 0; i < resultCols.size(); i++) {
            TResultColumn rc = resultCols.getResultColumn(i);
            if (rc == null || rc.getAliasClause() == null) {
                continue;
            }

            // Get the alias name
            TAliasClause aliasClause = rc.getAliasClause();
            if (aliasClause.getAliasName() != null) {
                String aliasName = aliasClause.getAliasName().toString();
                // Normalize the alias name (strip quotes for matching)
                aliasName = normalizeAliasName(aliasName);
                if (aliasName != null && !aliasName.isEmpty()) {
                    // S2: vendor-aware key for the lateral alias set so
                    // case rules match the lookup site below.
                    aliases.add(keyForColumn(aliasName));
                    if (DEBUG_SCOPE_BUILD) {
                        System.out.println("[DEBUG] Collected lateral alias: " + aliasName);
                    }
                }
            }
        }

        if (!aliases.isEmpty()) {
            selectLateralAliases.put(stmt, aliases);
        }
    }

    /**
     * Slice S2: produce a vendor-aware key for table identifier sets / maps.
     * Quote-aware: identifiers like Oracle {@code "MyTbl"} keep their case
     * (quoted-sensitive) while unquoted ones fold per vendor rules. This is
     * what raw {@code String#toLowerCase()} cannot do.
     */
    private String keyForTable(String name) {
        if (name == null || name.isEmpty()) return name;
        return gudusoft.gsqlparser.sqlenv.IdentifierService.normalizeStatic(
                dbVendor,
                gudusoft.gsqlparser.sqlenv.ESQLDataObjectType.dotTable,
                name);
    }

    /**
     * Slice S2: produce a vendor-aware key for column identifier sets / maps.
     */
    private String keyForColumn(String name) {
        if (name == null || name.isEmpty()) return name;
        return gudusoft.gsqlparser.sqlenv.IdentifierService.normalizeStatic(
                dbVendor,
                gudusoft.gsqlparser.sqlenv.ESQLDataObjectType.dotColumn,
                name);
    }

    /**
     * Normalize an alias name by stripping surrounding quotes.
     */
    private String normalizeAliasName(String name) {
        if (name == null || name.isEmpty()) return name;
        // Remove surrounding double quotes
        if (name.startsWith("\"") && name.endsWith("\"") && name.length() > 2) {
            return name.substring(1, name.length() - 1);
        }
        // Remove surrounding backticks
        if (name.startsWith("`") && name.endsWith("`") && name.length() > 2) {
            return name.substring(1, name.length() - 1);
        }
        // Remove surrounding square brackets
        if (name.startsWith("[") && name.endsWith("]") && name.length() > 2) {
            return name.substring(1, name.length() - 1);
        }
        return name;
    }

    /**
     * Check if a column name matches a lateral alias in the current SELECT scope.
     * This is used to filter out references to lateral column aliases.
     */
    private boolean isLateralColumnAlias(String columnName) {
        if (columnName == null || columnName.isEmpty()) {
            return false;
        }

        // Lateral aliases should ONLY apply inside result column context (SELECT list).
        // Column references in FROM clause, WHERE clause, etc. are source table columns,
        // not lateral alias references.
        if (!inResultColumnContext) {
            return false;
        }

        // Only check for lateral aliases in vendors that support them
        // and where we want to filter them out from column references.
        // Note: Redshift supports lateral aliases but test expects them to be reported as columns
        if (dbVendor != EDbVendor.dbvsnowflake &&
            dbVendor != EDbVendor.dbvbigquery &&
            dbVendor != EDbVendor.dbvdatabricks &&
            dbVendor != EDbVendor.dbvsparksql) {
            return false;
        }

        // Check if current SELECT has this alias
        if (currentSelectScope != null && currentSelectScope.getNode() instanceof TSelectSqlStatement) {
            TSelectSqlStatement stmt = (TSelectSqlStatement) currentSelectScope.getNode();
            Set<String> aliases = selectLateralAliases.get(stmt);
            if (aliases != null) {
                // S2: same vendor-aware key as the storage site above.
                String normalizedName = keyForColumn(normalizeAliasName(columnName));
                if (aliases.contains(normalizedName)) {
                    // IMPORTANT: Exclude the current result column's own alias from lateral alias matching.
                    // A column reference inside the expression that DEFINES an alias cannot be
                    // a reference TO that alias - it must be a reference to the source table column.
                    // e.g., in "CASE WHEN Model_ID = '' THEN NULL ELSE TRIM(Model_ID) END AS Model_ID",
                    // Model_ID inside the CASE is a source table column, not a lateral alias reference.
                    if (currentResultColumnAlias != null && normalizedName.equals(currentResultColumnAlias)) {
                        if (DEBUG_SCOPE_BUILD) {
                            System.out.println("[DEBUG] Skipping lateral alias check for current result column alias: " + columnName);
                        }
                        return false;
                    }
                    if (DEBUG_SCOPE_BUILD) {
                        System.out.println("[DEBUG] Found lateral alias reference: " + columnName);
                    }
                    return true;
                }
            }
        }

        return false;
    }

    /**
     * Determine the parent scope for a SELECT statement.
     *
     * <p>Rules:
     * <ul>
     *   <li>CTE subquery: parent is CTEScope</li>
     *   <li>FROM subquery: parent is enclosing SelectScope</li>
     *   <li>Scalar subquery: parent is enclosing SelectScope</li>
     *   <li>Top-level: parent is GlobalScope</li>
     * </ul>
     */
    private IScope determineParentScopeForSelect(TSelectSqlStatement stmt) {
        // If we have a CTE scope on the stack and this is a CTE subquery,
        // use the CTE scope as parent
        if (currentCTEScope != null && isQueryOfCTE(stmt)) {
            return currentCTEScope;
        }

        // Otherwise, find appropriate parent from stack
        // Skip any non-SELECT scopes (FromScope, etc.)
        for (int i = scopeStack.size() - 1; i >= 0; i--) {
            IScope scope = scopeStack.get(i);
            if (scope instanceof SelectScope || scope instanceof CTEScope ||
                scope instanceof PlsqlBlockScope || scope instanceof GlobalScope) {
                return scope;
            }
        }

        return scopeStack.isEmpty() ? globalScope : scopeStack.peek();
    }

    /**
     * Check if a SELECT statement is the query of a CTE
     */
    private boolean isQueryOfCTE(TSelectSqlStatement stmt) {
        TParseTreeNode parent = stmt.getParentStmt();
        return parent instanceof TCTE;
    }

    /**
     * Find the enclosing SelectScope in the stack
     */
    private SelectScope findEnclosingSelectScope() {
        for (int i = scopeStack.size() - 1; i >= 0; i--) {
            IScope scope = scopeStack.get(i);
            if (scope instanceof SelectScope) {
                return (SelectScope) scope;
            }
        }
        return null;
    }

    // ========== UPDATE Statement ==========

    @Override
    public void preVisit(TUpdateSqlStatement stmt) {
        // Determine parent scope
        IScope parentScope = determineParentScopeForUpdate(stmt);

        // Create UpdateScope
        UpdateScope updateScope = new UpdateScope(parentScope, stmt);
        updateScopeMap.put(stmt, updateScope);

        // Push to stack
        scopeStack.push(updateScope);
        currentUpdateScope = updateScope;

        // Set the current UPDATE target table for SET clause column linking
        currentUpdateTargetTable = stmt.getTargetTable();
        // A multi-table UPDATE ("UPDATE t1 JOIN t2 ... SET only_t2 = 1") has no
        // grammar-guaranteed single target: an unqualified LHS may legitimately
        // bind to a non-target table. The legacy sourceTable assignment below
        // still points at the target, but that must not be CERTIFIED as a proof
        // trace, so binding traces are issued only for the single-table form.
        currentUpdateHasSingleTable = stmt.tables == null || stmt.tables.size() <= 1;

        if (DEBUG_SCOPE_BUILD) {
            String stmtPreview = stmt.toString().length() > 50
                ? stmt.toString().substring(0, 50) + "..."
                : stmt.toString();
            System.out.println("[DEBUG] preVisit(UPDATE): " + stmtPreview.replace("\n", " ") + ", parentScope=" + parentScope);
        }

        // Create FromScope for UPDATE's tables (target table + FROM clause tables)
        // The tables will be added when the visitor visits TTable nodes via acceptChildren()
        if (stmt.tables != null && stmt.tables.size() > 0) {
            // Save current FROM scope if any
            if (currentFromScope != null) {
                fromScopeStack.push(currentFromScope);
            }

            // Create FromScope for UPDATE's tables
            FromScope fromScope = new FromScope(updateScope, stmt.tables);
            updateScope.setFromScope(fromScope);
            currentFromScope = fromScope;

            // Tables will be processed when acceptChildren() visits TTable nodes
            // via preVisit(TTable) which checks currentFromScope
        }

        // Visit JOIN ON conditions by traversing relations with type ETableSource.join
        // This ensures columns in ON clauses are collected into allColumnReferences
        // (Similar to DELETE statement handling)
        for (TTable relation : stmt.getRelations()) {
            if (relation.getTableType() == ETableSource.join && relation.getJoinExpr() != null) {
                visitJoinExprConditions(relation.getJoinExpr());
            }
        }
    }

    @Override
    public void postVisit(TUpdateSqlStatement stmt) {
        // Pop scope
        if (!scopeStack.isEmpty() && scopeStack.peek() instanceof UpdateScope) {
            scopeStack.pop();
        }

        // Restore current UpdateScope
        currentUpdateScope = findEnclosingUpdateScope();

        // Clear current UPDATE target table
        currentUpdateTargetTable = null;
        currentUpdateHasSingleTable = true;

        // Restore FROM scope
        if (!fromScopeStack.isEmpty()) {
            currentFromScope = fromScopeStack.pop();
        } else {
            currentFromScope = null;
        }
    }

    // ========== INSERT Statement ==========

    /** Tracks the SelectScope for INSERT ALL subquery, so VALUES columns can resolve to it */
    private SelectScope currentInsertAllSubqueryScope = null;

    @Override
    public void preVisit(TInsertSqlStatement stmt) {
        // Set the current INSERT target table for OUTPUT clause column linking
        currentInsertTargetTable = stmt.getTargetTable();

        // Explicit INSERT target column list: these are bound to the target
        // table by Phase 1 (linkColumnToTable) before resolver2 runs, so the
        // scope machinery never produces a complete trace for them. Record the
        // typed direct binding here (the binder IS the INSERT target).
        if (bindingTraceRegistry != null && currentInsertTargetTable != null
                && stmt.getColumnList() != null) {
            for (int i = 0; i < stmt.getColumnList().size(); i++) {
                TObjectName col = stmt.getColumnList().getObjectName(i);
                // Unqualified only: a qualifier that disagrees with the INSERT
                // target must not be certified (see the UPDATE SET note).
                if (col != null && col.getTableToken() == null
                        && col.getSourceTable() == currentInsertTargetTable) {
                    traceDirectBinding(col,
                            gudusoft.gsqlparser.resolver2.binding.BindingTrace.BinderKind.DML_TARGET,
                            currentInsertTargetTable);
                }
            }
        }

        // Handle INSERT ALL (Oracle multi-table insert)
        // The subquery provides source columns that are referenced in VALUES clauses
        // We need to pre-build the subquery scope so VALUES columns can resolve
        if (stmt.isInsertAll() && stmt.getSubQuery() != null) {
            TSelectSqlStatement subQuery = stmt.getSubQuery();

            // Determine parent scope
            IScope parentScope = scopeStack.isEmpty() ? globalScope : scopeStack.peek();

            // Create SelectScope for the subquery
            SelectScope subqueryScope = new SelectScope(parentScope, subQuery);
            currentInsertAllSubqueryScope = subqueryScope;

            // Build FromScope with the subquery's tables
            FromScope fromScope = new FromScope(subqueryScope, subQuery);
            buildInsertAllFromScope(fromScope, subQuery);
            subqueryScope.setFromScope(fromScope);

            // Push the scope so VALUES columns can resolve against it
            scopeStack.push(subqueryScope);
            currentSelectScope = subqueryScope;

            if (DEBUG_SCOPE_BUILD) {
                System.out.println("[DEBUG] preVisit(INSERT ALL): Created subquery scope with " +
                    fromScope.getChildren().size() + " tables");
            }
        }

        if (DEBUG_SCOPE_BUILD) {
            String stmtPreview = stmt.toString().length() > 50
                ? stmt.toString().substring(0, 50) + "..."
                : stmt.toString();
            System.out.println("[DEBUG] preVisit(INSERT): " + stmtPreview.replace("\n", " ") +
                ", targetTable=" + (currentInsertTargetTable != null ? currentInsertTargetTable.getName() : "null") +
                ", isInsertAll=" + stmt.isInsertAll());
        }
    }

    @Override
    public void postVisit(TInsertSqlStatement stmt) {
        // Pop INSERT ALL subquery scope if we pushed one
        if (stmt.isInsertAll() && currentInsertAllSubqueryScope != null) {
            if (!scopeStack.isEmpty() && scopeStack.peek() == currentInsertAllSubqueryScope) {
                scopeStack.pop();
            }
            currentInsertAllSubqueryScope = null;
            currentSelectScope = findEnclosingSelectScope();
        }

        // Clear current INSERT target table
        currentInsertTargetTable = null;
    }

    /**
     * Build FromScope for INSERT ALL subquery.
     * This adds the subquery's FROM tables to the scope so VALUES columns can resolve.
     */
    private void buildInsertAllFromScope(FromScope fromScope, TSelectSqlStatement select) {
        if (select == null || select.tables == null) {
            return;
        }

        // Add namespace for each table in the FROM clause
        for (int i = 0; i < select.tables.size(); i++) {
            TTable table = select.tables.getTable(i);
            if (table == null) {
                continue;
            }

            // Skip INSERT target tables (they're in the tables list but not part of FROM)
            if (table.getEffectType() == ETableEffectType.tetInsert) {
                continue;
            }

            // Create TableNamespace for this table
            TableNamespace tableNs = new TableNamespace(table, nameMatcher, sqlEnv);
            tableNs.validate();

            // Determine alias - use table alias if available, otherwise table name
            String alias = table.getAliasName();
            if (alias == null || alias.isEmpty()) {
                alias = table.getName();
            }

            fromScope.addChild(tableNs, alias, false);
            tableToNamespaceMap.put(table, tableNs);

            if (DEBUG_SCOPE_BUILD) {
                System.out.println("[DEBUG] buildInsertAllFromScope: Added table " +
                    table.getName() + " (alias: " + alias + ") to INSERT ALL subquery scope");
            }
        }
    }

    // ========== INSERT ALL Target Columns - Track columns that already have sourceTable ==========

    @Override
    public void preVisit(TInsertIntoValue insertIntoValue) {
        // Track INSERT ALL target columns (from columnList) that already have sourceTable set
        // These should NOT be re-resolved against the subquery scope
        TObjectNameList columnList = insertIntoValue.getColumnList();
        if (columnList != null) {
            for (int i = 0; i < columnList.size(); i++) {
                TObjectName column = columnList.getObjectName(i);
                if (column != null && column.getSourceTable() != null) {
                    insertAllTargetColumns.add(column);
                    if (DEBUG_SCOPE_BUILD) {
                        System.out.println("[DEBUG] preVisit(TInsertIntoValue): Tracked INSERT ALL target column: " +
                            column.toString() + " -> " + column.getSourceTable().getName());
                    }
                }
            }
        }
    }

    /**
     * Determine the parent scope for an UPDATE statement.
     */
    private IScope determineParentScopeForUpdate(TUpdateSqlStatement stmt) {
        // If we have a CTE scope on the stack, use it
        if (currentCTEScope != null) {
            return currentCTEScope;
        }

        // Otherwise, find appropriate parent from stack
        for (int i = scopeStack.size() - 1; i >= 0; i--) {
            IScope scope = scopeStack.get(i);
            if (scope instanceof SelectScope || scope instanceof UpdateScope ||
                scope instanceof CTEScope || scope instanceof PlsqlBlockScope ||
                scope instanceof GlobalScope) {
                return scope;
            }
        }

        return scopeStack.isEmpty() ? globalScope : scopeStack.peek();
    }

    /**
     * Find the enclosing UpdateScope in the stack
     */
    private UpdateScope findEnclosingUpdateScope() {
        for (int i = scopeStack.size() - 1; i >= 0; i--) {
            IScope scope = scopeStack.get(i);
            if (scope instanceof UpdateScope) {
                return (UpdateScope) scope;
            }
        }
        return null;
    }

    // ========== DELETE Statement ==========

    @Override
    public void preVisit(TDeleteSqlStatement stmt) {
        // Determine parent scope
        IScope parentScope = determineParentScopeForDelete(stmt);

        // Create DeleteScope
        DeleteScope deleteScope = new DeleteScope(parentScope, stmt);
        deleteScopeMap.put(stmt, deleteScope);

        // Push to stack
        scopeStack.push(deleteScope);
        currentDeleteScope = deleteScope;

        // Set the current DELETE target table for OUTPUT clause column linking
        currentDeleteTargetTable = stmt.getTargetTable();

        if (DEBUG_SCOPE_BUILD) {
            String stmtPreview = stmt.toString().length() > 50
                ? stmt.toString().substring(0, 50) + "..."
                : stmt.toString();
            System.out.println("[DEBUG] preVisit(DELETE): " + stmtPreview.replace("\n", " ") +
                ", targetTable=" + (currentDeleteTargetTable != null ? currentDeleteTargetTable.getName() : "null"));
        }

        // Create FromScope for DELETE's tables (target table + FROM clause tables)
        // The tables will be added when the visitor visits TTable nodes via acceptChildren()
        if (stmt.tables != null && stmt.tables.size() > 0) {
            // Save current FROM scope if any
            if (currentFromScope != null) {
                fromScopeStack.push(currentFromScope);
            }

            // Create FromScope for DELETE's tables
            FromScope fromScope = new FromScope(deleteScope, stmt.tables);
            deleteScope.setFromScope(fromScope);
            currentFromScope = fromScope;

            // Tables will be processed when acceptChildren() visits TTable nodes
            // via preVisit(TTable) which checks currentFromScope.
            //
            // Slice 84 — joined DELETE FROM-side tables (in
            // {@code referenceJoins}) are NOT visited by
            // {@code TDeleteSqlStatement.acceptChildren}, which only
            // walks the inherited {@code joins} list. As a result the
            // FromScope's children would be missing the joined-DELETE
            // read sources (e.g. PG `DELETE FROM e USING d` →
            // `departments` would never reach `preVisit(TTable)`),
            // and WHERE / ON refs against them would resolve to
            // NOT_FOUND.
            //
            // Walk referenceJoins explicitly here so the tables are
            // registered before the rest of acceptChildren walks
            // WHERE / ON / etc. Drivers and JoinItem right-side
            // tables are visited via their own acceptChildren; ON
            // conditions are intentionally NOT walked here — line
            // 1219's `visitJoinExprConditions` already collects them
            // through the join-typed wrapper in
            // {@code stmt.getRelations()} (verified for PG USING-with-
            // JOIN and MSSQL FROM-FROM via parser probes). Walking
            // them here would double-collect ON refs.
            TJoinList refJoins = stmt.getReferenceJoins();
            if (refJoins != null && refJoins.size() > 0) {
                for (int ji = 0; ji < refJoins.size(); ji++) {
                    TJoin rj = refJoins.getJoin(ji);
                    if (rj == null) continue;
                    if (rj.getTable() != null) {
                        rj.getTable().acceptChildren(this);
                    }
                    TJoinItemList items = rj.getJoinItems();
                    if (items == null) continue;
                    for (int k = 0; k < items.size(); k++) {
                        TJoinItem item = items.getJoinItem(k);
                        if (item == null || item.getTable() == null) continue;
                        item.getTable().acceptChildren(this);
                    }
                }
            }
        }

        // Visit JOIN ON conditions by traversing relations with type ETableSource.join
        // Use getRelations() and getJoinExpr() instead of deprecated getReferenceJoins()/TJoin
        for (TTable relation : stmt.getRelations()) {
            if (relation.getTableType() == ETableSource.join && relation.getJoinExpr() != null) {
                visitJoinExprConditions(relation.getJoinExpr());
            }
        }
    }

    /**
     * Recursively visit a TJoinExpr tree to collect column references from ON conditions.
     * This handles nested joins where left/right tables can themselves be join expressions.
     */
    private void visitJoinExprConditions(TJoinExpr joinExpr) {
        if (joinExpr == null) {
            return;
        }

        // Visit the ON condition if present
        if (joinExpr.getOnCondition() != null) {
            joinExpr.getOnCondition().acceptChildren(this);
        }

        // Recursively handle left table if it's a join
        TTable leftTable = joinExpr.getLeftTable();
        if (leftTable != null && leftTable.getTableType() == ETableSource.join && leftTable.getJoinExpr() != null) {
            visitJoinExprConditions(leftTable.getJoinExpr());
        }

        // Recursively handle right table if it's a join
        TTable rightTable = joinExpr.getRightTable();
        if (rightTable != null && rightTable.getTableType() == ETableSource.join && rightTable.getJoinExpr() != null) {
            visitJoinExprConditions(rightTable.getJoinExpr());
        }
    }

    @Override
    public void postVisit(TDeleteSqlStatement stmt) {
        // Pop scope
        if (!scopeStack.isEmpty() && scopeStack.peek() instanceof DeleteScope) {
            scopeStack.pop();
        }

        // Restore current DeleteScope
        currentDeleteScope = findEnclosingDeleteScope();

        // Clear current DELETE target table
        currentDeleteTargetTable = null;

        // Restore FROM scope
        if (!fromScopeStack.isEmpty()) {
            currentFromScope = fromScopeStack.pop();
        } else {
            currentFromScope = null;
        }
    }

    // ========== OUTPUT Clause ==========

    @Override
    public void preVisit(TOutputClause outputClause) {
        if (outputClause == null || outputClause.getSelectItemList() == null) {
            return;
        }

        // Only process for SQL Server / Azure SQL
        if (dbVendor != EDbVendor.dbvmssql && dbVendor != EDbVendor.dbvazuresql) {
            return;
        }

        // Process each column in the OUTPUT clause
        // These columns may reference inserted/deleted pseudo-tables
        // which need to be resolved to the DML statement's target table
        //
        // Phase 1 (TOutputClause.doParse) already swaps tokens and sets pseudoTableType.
        // Phase 2 here sets the correct sourceTable (which may differ in trigger context)
        // and adds to allColumnReferences for the resolver.
        TResultColumnList selectList = outputClause.getSelectItemList();
        for (int i = 0; i < selectList.size(); i++) {
            TResultColumn resultColumn = selectList.getResultColumn(i);
            if (resultColumn != null && resultColumn.getFieldAttr() != null) {
                TObjectName columnRef = resultColumn.getFieldAttr();

                boolean isPseudoTableColumn = false;

                if (columnRef.getPseudoTableType() != EPseudoTableType.none) {
                    // Phase 1 already set pseudoTableType — just need to set sourceTable
                    isPseudoTableColumn = true;
                } else {
                    // Fallback: check raw tokens in case Phase 1 didn't run
                    TSourceToken objectToken = columnRef.getObjectToken();
                    TSourceToken partToken = columnRef.getPartToken();
                    TSourceToken propertyToken = columnRef.getPropertyToken();

                    if (objectToken != null && propertyToken == null) {
                        // Common case: objectToken=inserted/deleted, partToken=columnName
                        String objName = objectToken.toString().toUpperCase();
                        if ("INSERTED".equals(objName) || "DELETED".equals(objName)) {
                            isPseudoTableColumn = true;
                            columnRef.setPseudoTableType("INSERTED".equals(objName)
                                    ? EPseudoTableType.inserted : EPseudoTableType.deleted);
                        }
                    } else if (partToken != null && propertyToken != null) {
                        // Edge case: partToken=inserted/deleted, propertyToken=columnName (needs swap)
                        String partName = partToken.toString().toUpperCase();
                        if ("INSERTED".equals(partName) || "DELETED".equals(partName)) {
                            isPseudoTableColumn = true;
                            columnRef.setPseudoTableType("INSERTED".equals(partName)
                                    ? EPseudoTableType.inserted : EPseudoTableType.deleted);
                            columnRef.setObjectToken(partToken);
                            columnRef.setPartToken(propertyToken);
                            columnRef.setPropertyToken(null);
                        }
                    }
                }

                // Determine which DML target table to use.
                // Priority: trigger > merge > insert/update/delete
                // The MERGE target takes priority over enclosing DML statements because
                // the OUTPUT clause belongs to the MERGE itself, and inserted/deleted
                // pseudo-tables refer to MERGE target rows, not the enclosing INSERT/UPDATE/DELETE target.
                TTable targetTable = null;
                if (currentTriggerTargetTable != null) {
                    targetTable = currentTriggerTargetTable;
                } else if (currentMergeTargetTable != null) {
                    targetTable = currentMergeTargetTable;
                } else if (currentInsertTargetTable != null) {
                    targetTable = currentInsertTargetTable;
                } else if (currentUpdateTargetTable != null) {
                    targetTable = currentUpdateTargetTable;
                } else if (currentDeleteTargetTable != null) {
                    targetTable = currentDeleteTargetTable;
                }

                if (isPseudoTableColumn) {
                    if (targetTable != null) {
                        columnRef.setSourceTable(targetTable);
                        traceDirectBinding(columnRef,
                                gudusoft.gsqlparser.resolver2.binding.BindingTrace.BinderKind.DML_TARGET,
                                targetTable);
                        allColumnReferences.add(columnRef);

                        if (DEBUG_SCOPE_BUILD) {
                            System.out.println("[DEBUG] OUTPUT clause column '" + columnRef.toString() +
                                "' (column=" + columnRef.getColumnNameOnly() + ") linked to target table '" +
                                targetTable.getName() + "'");
                        }
                    }
                } else if (targetTable != null && "$action".equalsIgnoreCase(columnRef.getColumnNameOnly())) {
                    // $action is a MERGE-specific pseudo-column that returns 'INSERT', 'UPDATE', or 'DELETE'.
                    // Link it to the target table and add to allColumnReferences to maintain SQL text order
                    // with neighboring inserted/deleted pseudo-table columns.
                    // Preserve dbObjectType (constant) since setSourceTable changes it to column.
                    EDbObjectType savedType = columnRef.getDbObjectType();
                    columnRef.setSourceTable(targetTable);
                    columnRef.setDbObjectTypeDirectly(savedType);
                    traceDirectBinding(columnRef,
                            gudusoft.gsqlparser.resolver2.binding.BindingTrace.BinderKind.DML_TARGET,
                            targetTable);
                    allColumnReferences.add(columnRef);

                    if (DEBUG_SCOPE_BUILD) {
                        System.out.println("[DEBUG] OUTPUT clause $action column linked to target table '" +
                            targetTable.getName() + "'");
                    }
                }
            }
        }
    }

    /**
     * Determine the parent scope for a DELETE statement.
     */
    private IScope determineParentScopeForDelete(TDeleteSqlStatement stmt) {
        // If we have a CTE scope on the stack, use it
        if (currentCTEScope != null) {
            return currentCTEScope;
        }

        // Otherwise, find appropriate parent from stack
        for (int i = scopeStack.size() - 1; i >= 0; i--) {
            IScope scope = scopeStack.get(i);
            if (scope instanceof SelectScope || scope instanceof UpdateScope ||
                scope instanceof DeleteScope || scope instanceof CTEScope ||
                scope instanceof PlsqlBlockScope ||
                scope instanceof GlobalScope) {
                return scope;
            }
        }

        return scopeStack.isEmpty() ? globalScope : scopeStack.peek();
    }

    /**
     * Find the enclosing DeleteScope in the stack
     */
    private DeleteScope findEnclosingDeleteScope() {
        for (int i = scopeStack.size() - 1; i >= 0; i--) {
            IScope scope = scopeStack.get(i);
            if (scope instanceof DeleteScope) {
                return (DeleteScope) scope;
            }
        }
        return null;
    }

    // ========== CREATE TRIGGER Statement ==========

    @Override
    public void preVisit(TCreateTriggerStmt stmt) {
        // For SQL Server triggers, track the target table so we can resolve
        // deleted/inserted virtual tables to the actual trigger target table
        if (dbVendor == EDbVendor.dbvmssql || dbVendor == EDbVendor.dbvazuresql) {
            TTable targetTable = stmt.getOnTable();
            if (targetTable != null) {
                // Save current trigger target if any (for nested triggers, though rare)
                if (currentTriggerTargetTable != null) {
                    triggerTargetTableStack.push(currentTriggerTargetTable);
                }
                currentTriggerTargetTable = targetTable;

                if (DEBUG_SCOPE_BUILD) {
                    System.out.println("[DEBUG] preVisit(CREATE TRIGGER): target table = " + targetTable.getName());
                }
            }
        }
    }

    @Override
    public void postVisit(TCreateTriggerStmt stmt) {
        // Restore previous trigger target table
        if (dbVendor == EDbVendor.dbvmssql || dbVendor == EDbVendor.dbvazuresql) {
            if (!triggerTargetTableStack.isEmpty()) {
                currentTriggerTargetTable = triggerTargetTableStack.pop();
            } else {
                currentTriggerTargetTable = null;
            }
        }
    }

    @Override
    public void preVisit(TPlsqlCreateTrigger stmt) {
        // Oracle trigger: track FOLLOWS trigger list names to avoid collecting as column references
        // These are trigger names, not column references
        if (stmt.getFollowsTriggerList() != null) {
            TObjectNameList followsList = stmt.getFollowsTriggerList();
            for (int i = 0; i < followsList.size(); i++) {
                TObjectName triggerName = followsList.getObjectName(i);
                if (triggerName != null) {
                    ddlTargetNames.add(triggerName);
                    if (DEBUG_SCOPE_BUILD) {
                        System.out.println("[DEBUG] preVisit(TPlsqlCreateTrigger): marked FOLLOWS trigger = " + triggerName);
                    }
                }
            }
        }
    }

    // ========== CREATE INDEX Statement ==========

    @Override
    public void preVisit(TCreateIndexSqlStatement stmt) {
        // Mark the table name as a table reference (not column)
        TObjectName tableName = stmt.getTableName();
        if (tableName != null) {
            ddlTargetNames.add(tableName);
            if (DEBUG_SCOPE_BUILD) {
                System.out.println("[DEBUG] preVisit(CREATE INDEX): marked table reference = " + tableName);
            }
        }

        // Handle the columns in the index - these should be linked to the table
        if (stmt.tables != null && stmt.tables.size() > 0) {
            TTable targetTable = stmt.tables.getTable(0);
            TOrderByItemList columnList = stmt.getColumnNameList();
            if (columnList != null && targetTable != null) {
                for (int i = 0; i < columnList.size(); i++) {
                    TOrderByItem orderByItem = columnList.getOrderByItem(i);
                    if (orderByItem != null && orderByItem.getSortKey() != null) {
                        TExpression sortKey = orderByItem.getSortKey();
                        if (sortKey.getExpressionType() == EExpressionType.simple_object_name_t) {
                            TObjectName columnName = sortKey.getObjectOperand();
                            if (columnName != null) {
                                columnName.setSourceTable(targetTable);
                                allColumnReferences.add(columnName);
                                if (DEBUG_SCOPE_BUILD) {
                                    System.out.println("[DEBUG] CREATE INDEX column '" + columnName +
                                        "' linked to table '" + targetTable.getName() + "'");
                                }
                            }
                        }
                    }
                }
            }
        }
    }

    // ========== DROP INDEX Statement ==========

    @Override
    public void preVisit(TDropIndexSqlStatement stmt) {
        // For dialects such as SQLite, the standalone index name is the
        // principal child visited by TDropIndexSqlStatement.
        TObjectName indexName = stmt.getIndexName();
        if (indexName != null) {
            ddlTargetNames.add(indexName);
        }

        TObjectNameList indexNames = stmt.getIndexNameList();
        if (indexNames != null) {
            for (int i = 0; i < indexNames.size(); i++) {
                TObjectName listedIndexName = indexNames.getObjectName(i);
                if (listedIndexName != null) {
                    ddlTargetNames.add(listedIndexName);
                }
            }
        }

        // Mark the table name as a table reference (not column)
        TObjectName tableName = stmt.getTableName();
        if (tableName != null) {
            ddlTargetNames.add(tableName);
            if (DEBUG_SCOPE_BUILD) {
                System.out.println("[DEBUG] preVisit(DROP INDEX): marked table reference = " + tableName);
            }
        }

        // For SQL Server, also handle TDropIndexItem list
        TDropIndexItemList dropIndexItems = stmt.getDropIndexItemList();
        if (dropIndexItems != null) {
            for (int i = 0; i < dropIndexItems.size(); i++) {
                TDropIndexItem item = dropIndexItems.getDropIndexItem(i);
                if (item != null) {
                    // Mark index name to avoid being collected as column
                    TObjectName itemIndexName = item.getIndexName();
                    if (itemIndexName != null) {
                        ddlTargetNames.add(itemIndexName);
                    }
                    // Mark table name (objectName in TDropIndexItem)
                    TObjectName objectName = item.getObjectName();
                    if (objectName != null) {
                        ddlTargetNames.add(objectName);
                        if (DEBUG_SCOPE_BUILD) {
                            System.out.println("[DEBUG] preVisit(DROP INDEX): marked table reference from item = " + objectName);
                        }
                    }
                }
            }
        }
    }

    // ========== EXECUTE IMMEDIATE - Skip variable references in dynamic SQL expression ==========

    @Override
    public void preVisit(TExecImmeStmt stmt) {
        // Set flag to indicate we're inside EXECUTE IMMEDIATE
        // This prevents the dynamic SQL variable from being collected as a column reference
        insideExecuteImmediateDynamicExpr = true;
        if (DEBUG_SCOPE_BUILD) {
            System.out.println("[DEBUG] preVisit(TExecImmeStmt): entering EXECUTE IMMEDIATE");
        }
    }

    @Override
    public void postVisit(TExecImmeStmt stmt) {
        // Clear the flag when leaving EXECUTE IMMEDIATE
        insideExecuteImmediateDynamicExpr = false;
        if (DEBUG_SCOPE_BUILD) {
            System.out.println("[DEBUG] postVisit(TExecImmeStmt): leaving EXECUTE IMMEDIATE");
        }
    }

    // ========== Cursor FOR Loop - Track record names to avoid false column detection ==========

    @Override
    public void preVisit(TLoopStmt stmt) {
        // Track cursor FOR loop record names (e.g., "rec" in "for rec in (SELECT ...)")
        // These are implicitly declared record variables, and their field access like "rec.field"
        // should not be collected as column references
        if (stmt.getKind() == TLoopStmt.cursor_for_loop) {
            TObjectName recordName = stmt.getRecordName();
            if (recordName != null) {
                String recNameStr = recordName.toString();
                if (recNameStr != null && !recNameStr.isEmpty()) {
                    cursorForLoopRecordNames.add(recNameStr.toLowerCase(Locale.ROOT));
                    if (DEBUG_SCOPE_BUILD) {
                        System.out.println("[DEBUG] preVisit(TLoopStmt): registered cursor FOR loop record = " + recNameStr);
                    }
                }
            }
        }
    }

    @Override
    public void postVisit(TLoopStmt stmt) {
        // Remove cursor FOR loop record name when leaving the loop scope
        if (stmt.getKind() == TLoopStmt.cursor_for_loop) {
            TObjectName recordName = stmt.getRecordName();
            if (recordName != null) {
                String recNameStr = recordName.toString();
                if (recNameStr != null && !recNameStr.isEmpty()) {
                    cursorForLoopRecordNames.remove(recNameStr.toLowerCase(Locale.ROOT));
                    if (DEBUG_SCOPE_BUILD) {
                        System.out.println("[DEBUG] postVisit(TLoopStmt): removed cursor FOR loop record = " + recNameStr);
                    }
                }
            }
        }
    }

    // ========== Snowflake DDL Statements - Track target names to avoid false column detection ==========

    @Override
    public void preVisit(TCreateFileFormatStmt stmt) {
        // Track file format name to avoid collecting it as a column reference
        if (stmt.getFileFormatName() != null) {
            ddlTargetNames.add(stmt.getFileFormatName());
            if (DEBUG_SCOPE_BUILD) {
                System.out.println("[DEBUG] preVisit(TCreateFileFormatStmt): marked DDL target = " + stmt.getFileFormatName());
            }
        }
    }

    @Override
    public void preVisit(TCreateStageStmt stmt) {
        // Track stage name to avoid collecting it as a column reference
        if (stmt.getStageName() != null) {
            ddlTargetNames.add(stmt.getStageName());
            if (DEBUG_SCOPE_BUILD) {
                System.out.println("[DEBUG] preVisit(TCreateStageStmt): marked DDL target = " + stmt.getStageName());
            }
        }
    }

    @Override
    public void preVisit(TCreatePipeStmt stmt) {
        // Track pipe name to avoid collecting it as a column reference
        if (stmt.getPipeName() != null) {
            ddlTargetNames.add(stmt.getPipeName());
            if (DEBUG_SCOPE_BUILD) {
                System.out.println("[DEBUG] preVisit(TCreatePipeStmt): marked DDL target = " + stmt.getPipeName());
            }
        }
    }

    @Override
    public void preVisit(TAlterTableStatement stmt) {
        if (DEBUG_SCOPE_BUILD) {
            System.out.println("[DEBUG] preVisit(TAlterTableStatement): " + stmt.sqlstatementtype);
        }
        // Track columns being modified in ALTER TABLE as DDL targets
        // These are not column references - they're column definitions/targets
        if (stmt.getAlterTableOptionList() != null) {
            for (int i = 0; i < stmt.getAlterTableOptionList().size(); i++) {
                TAlterTableOption opt = stmt.getAlterTableOptionList().getAlterTableOption(i);
                trackAlterTableOptionColumns(opt);
            }
        }
    }

    /**
     * Track column names in ALTER TABLE options as DDL targets.
     * These include: ALTER COLUMN, DROP COLUMN, CHANGE COLUMN, RENAME COLUMN, etc.
     */
    private void trackAlterTableOptionColumns(TAlterTableOption opt) {
        if (opt == null) return;

        // Single column name (ALTER COLUMN, RENAME COLUMN, etc.)
        if (opt.getColumnName() != null) {
            ddlTargetNames.add(opt.getColumnName());
            if (DEBUG_SCOPE_BUILD) {
                System.out.println("[DEBUG] trackAlterTableOptionColumns: marked DDL target = " + opt.getColumnName());
            }
        }

        // Column name list (DROP COLUMN, SET UNUSED, etc.)
        if (opt.getColumnNameList() != null) {
            for (int i = 0; i < opt.getColumnNameList().size(); i++) {
                TObjectName colName = opt.getColumnNameList().getObjectName(i);
                ddlTargetNames.add(colName);
                if (DEBUG_SCOPE_BUILD) {
                    System.out.println("[DEBUG] trackAlterTableOptionColumns: marked DDL target (list) = " + colName);
                }
            }
        }

        // New column name in RENAME COLUMN (rename TO new_name)
        if (opt.getNewColumnName() != null) {
            ddlTargetNames.add(opt.getNewColumnName());
            if (DEBUG_SCOPE_BUILD) {
                System.out.println("[DEBUG] trackAlterTableOptionColumns: marked DDL target (new) = " + opt.getNewColumnName());
            }
        }

        // Column definitions (ADD COLUMN, MODIFY COLUMN, etc.)
        if (opt.getColumnDefinitionList() != null) {
            for (int i = 0; i < opt.getColumnDefinitionList().size(); i++) {
                TColumnDefinition colDef = opt.getColumnDefinitionList().getColumn(i);
                if (colDef.getColumnName() != null) {
                    ddlTargetNames.add(colDef.getColumnName());
                    if (DEBUG_SCOPE_BUILD) {
                        System.out.println("[DEBUG] trackAlterTableOptionColumns: marked DDL target (def) = " + colDef.getColumnName());
                    }
                }
            }
        }
    }

    // ========== SQL Server Trigger UPDATE(column) Function ==========

    /**
     * Handle SQL Server trigger UPDATE(column) function.
     * The column inside UPDATE() should be resolved to the trigger target table.
     * Example: IF UPDATE(Zip) - Zip column belongs to the trigger's ON table.
     */
    @Override
    public void preVisit(TMssqlCreateTriggerUpdateColumn node) {
        if (currentTriggerTargetTable == null) {
            return; // Not inside a trigger context
        }

        TObjectName columnName = node.getColumnName();
        if (columnName != null) {
            // Link the column to the trigger target table
            columnName.setSourceTable(currentTriggerTargetTable);
            traceDirectBinding(columnName,
                    gudusoft.gsqlparser.resolver2.binding.BindingTrace.BinderKind.DML_TARGET,
                    currentTriggerTargetTable);

            // Add to allColumnReferences if not already there
            if (!allColumnReferences.contains(columnName)) {
                allColumnReferences.add(columnName);
            }

            // Map the column to the current scope
            IScope currentScope = scopeStack.isEmpty() ? globalScope : scopeStack.peek();
            columnToScopeMap.put(columnName, currentScope);

            if (DEBUG_SCOPE_BUILD) {
                System.out.println("[DEBUG] preVisit(TMssqlCreateTriggerUpdateColumn): " +
                    columnName + " -> " + currentTriggerTargetTable.getFullName());
            }
        }
    }

    // ========== PL/SQL Block Statement ==========

    @Override
    public void preVisit(TCommonBlock stmt) {
        // TCommonBlock wraps TBlockSqlNode - we need to explicitly visit it
        TBlockSqlNode blockBody = stmt.getBlockBody();
        if (blockBody != null) {
            blockBody.accept(this);
        }
    }

    // ========== Oracle Package Handling ==========

    @Override
    public void preVisit(TPlsqlCreatePackage pkg) {
        // Only create scope for package body (kind_create_body)
        if (pkg.getKind() == TBaseType.kind_create_body) {
            String pkgName = pkg.getPackageName() != null
                ? pkg.getPackageName().getObjectString()
                : null;
            if (pkgName == null && pkg.getPackageName() != null) {
                pkgName = pkg.getPackageName().toString();
            }

            if (pkgName != null && packageRegistry != null) {
                OraclePackageNamespace pkgNs = packageRegistry.getPackage(pkgName);
                if (pkgNs != null) {
                    // Determine parent scope
                    IScope parentScope = scopeStack.isEmpty() ? globalScope : scopeStack.peek();

                    // Create and push package scope
                    OraclePackageScope pkgScope = new OraclePackageScope(parentScope, pkg, pkgNs);
                    scopeStack.push(pkgScope);
                    currentPackageScope = pkgScope;
                    packageScopeStack.push(pkgScope);

                    if (DEBUG_SCOPE_BUILD) {
                        System.out.println("[DEBUG] preVisit(TPlsqlCreatePackage): Entered package body: " + pkgName +
                            ", members=" + pkgNs.getMembers().size());
                    }
                }
            }
        }

        // Manually traverse child elements to avoid recursive preVisit call
        // (TPlsqlCreatePackage.acceptChildren calls preVisit again)
        if (pkg.getDeclareStatements() != null) {
            for (int i = 0; i < pkg.getDeclareStatements().size(); i++) {
                TCustomSqlStatement decl = pkg.getDeclareStatements().get(i);
                if (decl != null) {
                    decl.acceptChildren(this);
                }
            }
        }
        if (pkg.getBodyStatements() != null) {
            for (int i = 0; i < pkg.getBodyStatements().size(); i++) {
                TCustomSqlStatement bodyStmt = pkg.getBodyStatements().get(i);
                if (bodyStmt != null) {
                    bodyStmt.acceptChildren(this);
                }
            }
        }
    }

    @Override
    public void postVisit(TPlsqlCreatePackage pkg) {
        if (pkg.getKind() == TBaseType.kind_create_body) {
            if (!packageScopeStack.isEmpty() &&
                !scopeStack.isEmpty() &&
                scopeStack.peek() == packageScopeStack.peek()) {
                scopeStack.pop();
                packageScopeStack.pop();
                currentPackageScope = packageScopeStack.isEmpty() ? null : packageScopeStack.peek();

                if (DEBUG_SCOPE_BUILD) {
                    String pkgName = pkg.getPackageName() != null
                        ? pkg.getPackageName().getObjectString()
                        : "unknown";
                    if (pkgName == null && pkg.getPackageName() != null) {
                        pkgName = pkg.getPackageName().toString();
                    }
                    System.out.println("[DEBUG] postVisit(TPlsqlCreatePackage): Exited package body: " + pkgName);
                }
            }
        }
    }

    @Override
    public void preVisit(TBlockSqlNode node) {
        // Save current PL/SQL block scope if nested
        if (currentPlsqlBlockScope != null) {
            plsqlBlockScopeStack.push(currentPlsqlBlockScope);
        }

        // Determine parent scope
        IScope parentScope = scopeStack.isEmpty() ? globalScope : scopeStack.peek();

        // Create PL/SQL block scope
        PlsqlBlockScope blockScope = new PlsqlBlockScope(parentScope, node);
        currentPlsqlBlockScope = blockScope;

        // Push to scope stack
        scopeStack.push(blockScope);

        if (DEBUG_SCOPE_BUILD) {
            String label = blockScope.getBlockLabel();
            System.out.println("[DEBUG] preVisit(TBlockSqlNode): label=" +
                (label != null ? label : "(anonymous)") +
                ", parent=" + parentScope);
        }

        // Process declare statements to collect variables
        // Use acceptChildren to traverse into statements like cursor declarations
        // that have nested SELECT statements
        for (TCustomSqlStatement decl : node.getDeclareStatements()) {
            decl.acceptChildren(this);
        }

        // Process body statements
        for (TCustomSqlStatement bodyStmt : node.getBodyStatements()) {
            // Use acceptChildren to traverse into the statement and collect column references
            bodyStmt.acceptChildren(this);
        }
    }

    @Override
    public void postVisit(TBlockSqlNode node) {
        // Pop from scope stack
        if (!scopeStack.isEmpty() && scopeStack.peek() instanceof PlsqlBlockScope) {
            scopeStack.pop();
        }

        // Restore previous PL/SQL block scope
        if (!plsqlBlockScopeStack.isEmpty()) {
            currentPlsqlBlockScope = plsqlBlockScopeStack.pop();
        } else {
            currentPlsqlBlockScope = null;
        }

        if (DEBUG_SCOPE_BUILD) {
            System.out.println("[DEBUG] postVisit(TBlockSqlNode): restored scope");
        }
    }

    @Override
    public void preVisit(TVarDeclStmt stmt) {
        if (DEBUG_SCOPE_BUILD) {
            String varName = stmt.getElementName() != null ? stmt.getElementName().toString() : "(unnamed)";
            System.out.println("[DEBUG] preVisit(TVarDeclStmt): var=" + varName +
                ", currentPlsqlBlockScope=" + (currentPlsqlBlockScope != null ? "exists" : "null"));
        }

        // Add variable to current PL/SQL block's variable namespace
        if (currentPlsqlBlockScope != null) {
            currentPlsqlBlockScope.getVariableNamespace().addVariable(stmt);

            // Mark the element name TObjectName as a variable declaration (not a column reference)
            // This prevents it from being collected in allColumnReferences
            if (stmt.getElementName() != null) {
                variableDeclarationNames.add(stmt.getElementName());
            }
        }
    }

    // ========== Oracle Cursor Variable Tracking ==========

    @Override
    public void preVisit(TCursorDeclStmt cursorDecl) {
        // Track cursor variable name for filtering during column resolution
        TObjectName cursorName = cursorDecl.getCursorName();
        if (cursorName != null) {
            String name = cursorName.toString();
            if (name != null && !name.isEmpty()) {
                cursorVariableNames.add(name.toLowerCase(Locale.ROOT));

                // Also add to current PlsqlBlockScope's namespace if available
                if (currentPlsqlBlockScope != null) {
                    PlsqlVariableNamespace varNs = currentPlsqlBlockScope.getVariableNamespace();
                    if (varNs != null) {
                        // Add cursor as a parameter-like entry (not a regular variable)
                        varNs.addParameter(name);
                    }
                }

                // Mark the cursor name TObjectName as not a column reference
                variableDeclarationNames.add(cursorName);

                if (DEBUG_SCOPE_BUILD) {
                    System.out.println("[DEBUG] preVisit(TCursorDeclStmt): Registered cursor variable: " + name);
                }
            }
        }

        // Process nested SELECT statement in cursor declaration
        if (cursorDecl.getSubquery() != null) {
            cursorDecl.getSubquery().acceptChildren(this);
        }
    }

    @Override
    public void preVisit(TOpenforStmt openFor) {
        // Track the cursor variable in OPEN...FOR
        TObjectName cursorVar = openFor.getCursorVariableName();
        if (cursorVar != null) {
            String name = cursorVar.toString();
            if (name != null && !name.isEmpty()) {
                cursorVariableNames.add(name.toLowerCase(Locale.ROOT));
                if (DEBUG_SCOPE_BUILD) {
                    System.out.println("[DEBUG] preVisit(TOpenforStmt): OPEN FOR cursor variable: " + name);
                }
            }
        }

        // Process the FOR subquery
        if (openFor.getSubquery() != null) {
            openFor.getSubquery().acceptChildren(this);
        }
    }

    // ========== MySQL/MSSQL DECLARE Statement ==========

    @Override
    public void preVisit(TMssqlDeclare stmt) {
        // Handle DECLARE statements for MySQL/MSSQL
        // These are in bodyStatements (not declareStatements) for MySQL procedures
        if (currentPlsqlBlockScope != null && stmt.getVariables() != null) {
            for (int i = 0; i < stmt.getVariables().size(); i++) {
                TDeclareVariable declVar = stmt.getVariables().getDeclareVariable(i);
                if (declVar != null && declVar.getVariableName() != null) {
                    // Mark the variable name as a declaration so it won't be collected as a column reference
                    variableDeclarationNames.add(declVar.getVariableName());
                    // Also add the variable name to the namespace
                    currentPlsqlBlockScope.getVariableNamespace().addParameter(declVar.getVariableName().toString());

                    if (DEBUG_SCOPE_BUILD) {
                        System.out.println("[DEBUG] preVisit(TMssqlDeclare): added var=" + declVar.getVariableName().toString());
                    }
                }
            }
        }
    }

    // ========== DB2 DECLARE Statement ==========

    @Override
    public void preVisit(TDb2SqlVariableDeclaration stmt) {
        // Handle DECLARE statements for DB2 procedures
        // These are in declareStatements for DB2 procedures
        if (currentPlsqlBlockScope != null && stmt.getVariables() != null) {
            for (int i = 0; i < stmt.getVariables().size(); i++) {
                TDeclareVariable declVar = stmt.getVariables().getDeclareVariable(i);
                if (declVar != null && declVar.getVariableName() != null) {
                    // Mark the variable name as a declaration so it won't be collected as a column reference
                    variableDeclarationNames.add(declVar.getVariableName());
                    // Also add the variable name to the namespace
                    currentPlsqlBlockScope.getVariableNamespace().addParameter(declVar.getVariableName().toString());

                    if (DEBUG_SCOPE_BUILD) {
                        System.out.println("[DEBUG] preVisit(TDb2SqlVariableDeclaration): added var=" + declVar.getVariableName().toString());
                    }
                }
            }
        }
    }

    // ========== DB2 DECLARE CURSOR Statement ==========

    @Override
    public void preVisit(TDb2DeclareCursorStatement stmt) {
        // DB2 DECLARE CURSOR statements contain a SELECT subquery
        // The default acceptChildren only calls subquery.accept() which doesn't traverse the SELECT's children
        // We need to manually traverse the subquery's children to collect column references
        if (stmt.getSubquery() != null) {
            if (DEBUG_SCOPE_BUILD) {
                System.out.println("[DEBUG] preVisit(TDb2DeclareCursorStatement): traversing subquery");
            }
            stmt.getSubquery().acceptChildren(this);
        }
    }

    // ========== DB2 CREATE FUNCTION Statement ==========

    @Override
    public void preVisit(TDb2CreateFunction stmt) {
        // Save current PL/SQL block scope if nested
        if (currentPlsqlBlockScope != null) {
            plsqlBlockScopeStack.push(currentPlsqlBlockScope);
        }

        // Determine parent scope
        IScope parentScope = scopeStack.isEmpty() ? globalScope : scopeStack.peek();

        // Get function name for the scope label
        String functionName = null;
        if (stmt.getFunctionName() != null) {
            functionName = stmt.getFunctionName().toString();
        }

        // Create PL/SQL block scope using the function name as the label
        PlsqlBlockScope blockScope = new PlsqlBlockScope(parentScope, stmt, functionName);
        currentPlsqlBlockScope = blockScope;

        // Push to scope stack
        scopeStack.push(blockScope);

        // Add function parameters to the variable namespace
        if (stmt.getParameterDeclarations() != null) {
            for (int i = 0; i < stmt.getParameterDeclarations().size(); i++) {
                TParameterDeclaration param = stmt.getParameterDeclarations().getParameterDeclarationItem(i);
                if (param != null && param.getParameterName() != null) {
                    variableDeclarationNames.add(param.getParameterName());
                    blockScope.getVariableNamespace().addParameter(param.getParameterName().toString());
                }
            }
        }

        if (DEBUG_SCOPE_BUILD) {
            System.out.println("[DEBUG] preVisit(TDb2CreateFunction): name=" +
                (functionName != null ? functionName : "anonymous"));
        }

        // Note: We do NOT manually process declareStatements and bodyStatements here.
        // The natural visitor flow (acceptChildren) will visit them after preVisit returns.
        // When TDb2SqlVariableDeclaration nodes are visited, preVisit(TDb2SqlVariableDeclaration)
        // will add them to currentPlsqlBlockScope's namespace.
    }

    @Override
    public void postVisit(TDb2CreateFunction stmt) {
        // Pop from scope stack
        if (!scopeStack.isEmpty() && scopeStack.peek() instanceof PlsqlBlockScope) {
            scopeStack.pop();
        }

        // Restore parent PL/SQL block scope
        if (!plsqlBlockScopeStack.isEmpty()) {
            currentPlsqlBlockScope = plsqlBlockScopeStack.pop();
        } else {
            currentPlsqlBlockScope = null;
        }

        if (DEBUG_SCOPE_BUILD) {
            System.out.println("[DEBUG] postVisit(TDb2CreateFunction)");
        }
    }

    // ========== Generic CREATE FUNCTION Statement ==========

    @Override
    public void preVisit(TCreateFunctionStmt stmt) {
        // Save current PL/SQL block scope if nested
        if (currentPlsqlBlockScope != null) {
            plsqlBlockScopeStack.push(currentPlsqlBlockScope);
        }

        // Determine parent scope
        IScope parentScope = scopeStack.isEmpty() ? globalScope : scopeStack.peek();

        // Get function name for the scope label
        String functionName = null;
        if (stmt.getFunctionName() != null) {
            functionName = stmt.getFunctionName().toString();

            // Register the function in SQLEnv so it can be looked up later
            // This allows distinguishing schema.function() calls from column.method() calls
            if (sqlEnv != null) {
                sqlEnv.addFunction(stmt.getFunctionName(), true);
                if (DEBUG_SCOPE_BUILD) {
                    System.out.println("[DEBUG] preVisit(TCreateFunctionStmt): Registered function in SQLEnv: " + functionName);
                }
            }
        }

        // Create PL/SQL block scope using the function name as the label
        PlsqlBlockScope blockScope = new PlsqlBlockScope(parentScope, stmt, functionName);
        currentPlsqlBlockScope = blockScope;

        // Push to scope stack
        scopeStack.push(blockScope);

        // Add function parameters to the variable namespace
        if (stmt.getParameterDeclarations() != null) {
            for (int i = 0; i < stmt.getParameterDeclarations().size(); i++) {
                TParameterDeclaration param = stmt.getParameterDeclarations().getParameterDeclarationItem(i);
                if (param != null && param.getParameterName() != null) {
                    variableDeclarationNames.add(param.getParameterName());
                    blockScope.getVariableNamespace().addParameter(param.getParameterName().toString());
                }
            }
        }

        // Handle variable declarations in the function body
        // TCreateFunctionStmt.acceptChildren() doesn't visit declareStatements, so we need to do it manually
        if (stmt.getDeclareStatements() != null && stmt.getDeclareStatements().size() > 0) {
            for (int i = 0; i < stmt.getDeclareStatements().size(); i++) {
                TCustomSqlStatement decl = stmt.getDeclareStatements().get(i);
                if (decl instanceof TDb2SqlVariableDeclaration) {
                    TDb2SqlVariableDeclaration db2VarDecl = (TDb2SqlVariableDeclaration) decl;
                    if (db2VarDecl.getVariables() != null) {
                        for (int j = 0; j < db2VarDecl.getVariables().size(); j++) {
                            TDeclareVariable declVar = db2VarDecl.getVariables().getDeclareVariable(j);
                            if (declVar != null && declVar.getVariableName() != null) {
                                variableDeclarationNames.add(declVar.getVariableName());
                                blockScope.getVariableNamespace().addParameter(declVar.getVariableName().toString());
                                if (DEBUG_SCOPE_BUILD) {
                                    System.out.println("[DEBUG] preVisit(TCreateFunctionStmt): added var=" + declVar.getVariableName().toString());
                                }
                            }
                        }
                    }
                }
            }
        }

        if (DEBUG_SCOPE_BUILD) {
            System.out.println("[DEBUG] preVisit(TCreateFunctionStmt): name=" +
                (functionName != null ? functionName : "anonymous") +
                ", bodyStatements=" + stmt.getBodyStatements().size() +
                ", blockBody=" + (stmt.getBlockBody() != null) +
                ", declareStatements=" + (stmt.getDeclareStatements() != null ? stmt.getDeclareStatements().size() : 0) +
                ", returnStmt=" + (stmt.getReturnStmt() != null));
        }
    }

    @Override
    public void postVisit(TCreateFunctionStmt stmt) {
        // Pop from scope stack
        if (!scopeStack.isEmpty() && scopeStack.peek() instanceof PlsqlBlockScope) {
            scopeStack.pop();
        }

        // Restore parent PL/SQL block scope
        if (!plsqlBlockScopeStack.isEmpty()) {
            currentPlsqlBlockScope = plsqlBlockScopeStack.pop();
        } else {
            currentPlsqlBlockScope = null;
        }

        if (DEBUG_SCOPE_BUILD) {
            System.out.println("[DEBUG] postVisit(TCreateFunctionStmt)");
        }
    }

    // ========== DB2 RETURN Statement ==========

    @Override
    public void preVisit(TDb2ReturnStmt stmt) {
        // DB2 RETURN statements can contain a SELECT subquery (for table-valued functions)
        // The default accept only calls subquery.accept() which doesn't traverse the SELECT's children
        // We need to manually traverse the subquery's children to collect column references
        if (stmt.getSubquery() != null) {
            if (DEBUG_SCOPE_BUILD) {
                System.out.println("[DEBUG] preVisit(TDb2ReturnStmt): traversing subquery");
            }
            stmt.getSubquery().acceptChildren(this);
        }
    }

    // ========== MSSQL RETURN Statement (also used for DB2) ==========

    @Override
    public void preVisit(TMssqlReturn stmt) {
        // TMssqlReturn can contain a SELECT subquery (used for DB2 table-valued functions too)
        // We need to traverse the subquery's children to collect column references
        if (stmt.getSubquery() != null) {
            if (DEBUG_SCOPE_BUILD) {
                System.out.println("[DEBUG] preVisit(TMssqlReturn): traversing subquery");
            }
            stmt.getSubquery().acceptChildren(this);
        }
    }

    // ========== PL/SQL CREATE PROCEDURE Statement ==========

    @Override
    public void preVisit(TPlsqlCreateProcedure stmt) {
        // Save current PL/SQL block scope if nested
        if (currentPlsqlBlockScope != null) {
            plsqlBlockScopeStack.push(currentPlsqlBlockScope);
        }

        // Determine parent scope
        IScope parentScope = scopeStack.isEmpty() ? globalScope : scopeStack.peek();

        // Get procedure name for the scope label
        String procedureName = null;
        if (stmt.getProcedureName() != null) {
            procedureName = stmt.getProcedureName().toString();
        }

        // Create PL/SQL block scope using the procedure name as the label
        PlsqlBlockScope blockScope = new PlsqlBlockScope(parentScope, stmt, procedureName);
        currentPlsqlBlockScope = blockScope;

        // Push to scope stack
        scopeStack.push(blockScope);

        // Register procedure parameters in the variable namespace
        // This allows ScopeBuilder to filter them out during column reference collection
        TParameterDeclarationList params = stmt.getParameterDeclarations();
        if (params != null) {
            for (int i = 0; i < params.size(); i++) {
                TParameterDeclaration param = params.getParameterDeclarationItem(i);
                if (param != null && param.getParameterName() != null) {
                    blockScope.getVariableNamespace().addParameter(param.getParameterName().toString());
                }
            }
        }

        if (DEBUG_SCOPE_BUILD) {
            System.out.println("[DEBUG] preVisit(TPlsqlCreateProcedure): name=" +
                (procedureName != null ? procedureName : "(unnamed)") +
                ", parent=" + parentScope +
                ", params=" + (params != null ? params.size() : 0));
        }

        // Note: We do NOT manually process declareStatements and bodyStatements here.
        // The natural visitor flow (acceptChildren) will visit them after preVisit returns.
        // When TVarDeclStmt nodes are visited, preVisit(TVarDeclStmt) will add them
        // to currentPlsqlBlockScope's namespace.
    }

    @Override
    public void postVisit(TPlsqlCreateProcedure stmt) {
        // Pop from scope stack
        if (!scopeStack.isEmpty() && scopeStack.peek() instanceof PlsqlBlockScope) {
            scopeStack.pop();
        }

        // Restore previous PL/SQL block scope
        if (!plsqlBlockScopeStack.isEmpty()) {
            currentPlsqlBlockScope = plsqlBlockScopeStack.pop();
        } else {
            currentPlsqlBlockScope = null;
        }

        if (DEBUG_SCOPE_BUILD) {
            System.out.println("[DEBUG] postVisit(TPlsqlCreateProcedure): restored scope");
        }
    }

    // ========== PL/SQL CREATE FUNCTION Statement ==========

    @Override
    public void preVisit(TPlsqlCreateFunction stmt) {
        // Save current PL/SQL block scope if nested
        if (currentPlsqlBlockScope != null) {
            plsqlBlockScopeStack.push(currentPlsqlBlockScope);
        }

        // Determine parent scope
        IScope parentScope = scopeStack.isEmpty() ? globalScope : scopeStack.peek();

        // Get function name for the scope label
        String functionName = null;
        if (stmt.getFunctionName() != null) {
            functionName = stmt.getFunctionName().toString();
        }

        // Create PL/SQL block scope using the function name as the label
        PlsqlBlockScope blockScope = new PlsqlBlockScope(parentScope, stmt, functionName);
        currentPlsqlBlockScope = blockScope;

        // Push to scope stack
        scopeStack.push(blockScope);

        // Register function parameters in the variable namespace
        // This allows ScopeBuilder to filter them out during column reference collection
        TParameterDeclarationList params = stmt.getParameterDeclarations();
        if (params != null) {
            for (int i = 0; i < params.size(); i++) {
                TParameterDeclaration param = params.getParameterDeclarationItem(i);
                if (param != null && param.getParameterName() != null) {
                    blockScope.getVariableNamespace().addParameter(param.getParameterName().toString());
                }
            }
        }

        if (DEBUG_SCOPE_BUILD) {
            System.out.println("[DEBUG] preVisit(TPlsqlCreateFunction): name=" +
                (functionName != null ? functionName : "(unnamed)") +
                ", parent=" + parentScope +
                ", params=" + (params != null ? params.size() : 0));
        }

        // Note: We do NOT manually process declareStatements and bodyStatements here.
        // The natural visitor flow (acceptChildren) will visit them after preVisit returns.
        // When TVarDeclStmt nodes are visited, preVisit(TVarDeclStmt) will add them
        // to currentPlsqlBlockScope's namespace.
    }

    @Override
    public void postVisit(TPlsqlCreateFunction stmt) {
        // Pop from scope stack
        if (!scopeStack.isEmpty() && scopeStack.peek() instanceof PlsqlBlockScope) {
            scopeStack.pop();
        }

        // Restore previous PL/SQL block scope
        if (!plsqlBlockScopeStack.isEmpty()) {
            currentPlsqlBlockScope = plsqlBlockScopeStack.pop();
        } else {
            currentPlsqlBlockScope = null;
        }

        if (DEBUG_SCOPE_BUILD) {
            System.out.println("[DEBUG] postVisit(TPlsqlCreateFunction): restored scope");
        }
    }

    // ========== CREATE PROCEDURE Statement (generic, including MySQL) ==========

    @Override
    public void preVisit(TCreateProcedureStmt stmt) {
        // Save current PL/SQL block scope if nested
        if (currentPlsqlBlockScope != null) {
            plsqlBlockScopeStack.push(currentPlsqlBlockScope);
        }

        // Determine parent scope
        IScope parentScope = scopeStack.isEmpty() ? globalScope : scopeStack.peek();

        // Get procedure name for the scope label
        String procedureName = null;
        if (stmt.getProcedureName() != null) {
            procedureName = stmt.getProcedureName().toString();
        }

        // Create PL/SQL block scope using the procedure name as the label
        PlsqlBlockScope blockScope = new PlsqlBlockScope(parentScope, stmt, procedureName);
        currentPlsqlBlockScope = blockScope;

        // Push to scope stack
        scopeStack.push(blockScope);

        // Register procedure parameters in the variable namespace
        // This allows ScopeBuilder to filter them out during column reference collection
        TParameterDeclarationList params = stmt.getParameterDeclarations();
        if (params != null) {
            for (int i = 0; i < params.size(); i++) {
                TParameterDeclaration param = params.getParameterDeclarationItem(i);
                if (param != null && param.getParameterName() != null) {
                    blockScope.getVariableNamespace().addParameter(param.getParameterName().toString());
                }
            }
        }

        if (DEBUG_SCOPE_BUILD) {
            System.out.println("[DEBUG] preVisit(TCreateProcedureStmt): name=" +
                (procedureName != null ? procedureName : "(unnamed)") +
                ", parent=" + parentScope +
                ", params=" + (params != null ? params.size() : 0));
        }

        // Process declareStatements manually since TCreateProcedureStmt.acceptChildren()
        // doesn't traverse them. This adds variable declarations to the namespace
        // and marks their element names so they won't be collected as column references.
        for (TCustomSqlStatement decl : stmt.getDeclareStatements()) {
            if (decl instanceof TVarDeclStmt) {
                TVarDeclStmt varDecl = (TVarDeclStmt) decl;
                blockScope.getVariableNamespace().addVariable(varDecl);
                if (varDecl.getElementName() != null) {
                    variableDeclarationNames.add(varDecl.getElementName());
                }
                if (DEBUG_SCOPE_BUILD) {
                    String varName = varDecl.getElementName() != null ? varDecl.getElementName().toString() : "(unnamed)";
                    System.out.println("[DEBUG] TCreateProcedureStmt: added declare var=" + varName);
                }
            } else if (decl instanceof TDb2SqlVariableDeclaration) {
                // Handle DB2 variable declarations (DECLARE var_name TYPE)
                TDb2SqlVariableDeclaration db2VarDecl = (TDb2SqlVariableDeclaration) decl;
                if (db2VarDecl.getVariables() != null) {
                    for (int i = 0; i < db2VarDecl.getVariables().size(); i++) {
                        TDeclareVariable declVar = db2VarDecl.getVariables().getDeclareVariable(i);
                        if (declVar != null && declVar.getVariableName() != null) {
                            variableDeclarationNames.add(declVar.getVariableName());
                            blockScope.getVariableNamespace().addParameter(declVar.getVariableName().toString());
                            if (DEBUG_SCOPE_BUILD) {
                                System.out.println("[DEBUG] TCreateProcedureStmt (DB2): added declare var=" + declVar.getVariableName().toString());
                            }
                        }
                    }
                }
            }
            // For any declaration that might contain embedded statements (like cursor declarations),
            // traverse them so that column references inside are collected
            decl.acceptChildren(this);
        }
    }

    @Override
    public void postVisit(TCreateProcedureStmt stmt) {
        // Pop from scope stack
        if (!scopeStack.isEmpty() && scopeStack.peek() instanceof PlsqlBlockScope) {
            scopeStack.pop();
        }

        // Restore previous PL/SQL block scope
        if (!plsqlBlockScopeStack.isEmpty()) {
            currentPlsqlBlockScope = plsqlBlockScopeStack.pop();
        } else {
            currentPlsqlBlockScope = null;
        }

        if (DEBUG_SCOPE_BUILD) {
            System.out.println("[DEBUG] postVisit(TCreateProcedureStmt): restored scope");
        }
    }

    // ========== MySQL CREATE PROCEDURE Statement (deprecated, but still in use) ==========

    @Override
    public void preVisit(TMySQLCreateProcedure stmt) {
        // Save current PL/SQL block scope if nested
        if (currentPlsqlBlockScope != null) {
            plsqlBlockScopeStack.push(currentPlsqlBlockScope);
        }

        // Determine parent scope
        IScope parentScope = scopeStack.isEmpty() ? globalScope : scopeStack.peek();

        // Get procedure name for the scope label
        String procedureName = null;
        if (stmt.getProcedureName() != null) {
            procedureName = stmt.getProcedureName().toString();
        }

        // Create PL/SQL block scope using the procedure name as the label
        PlsqlBlockScope blockScope = new PlsqlBlockScope(parentScope, stmt, procedureName);
        currentPlsqlBlockScope = blockScope;

        // Push to scope stack
        scopeStack.push(blockScope);

        // Register procedure parameters in the variable namespace
        TParameterDeclarationList params = stmt.getParameterDeclarations();
        if (params != null) {
            for (int i = 0; i < params.size(); i++) {
                TParameterDeclaration param = params.getParameterDeclarationItem(i);
                if (param != null && param.getParameterName() != null) {
                    blockScope.getVariableNamespace().addParameter(param.getParameterName().toString());
                }
            }
        }

        if (DEBUG_SCOPE_BUILD) {
            System.out.println("[DEBUG] preVisit(TMySQLCreateProcedure): name=" +
                (procedureName != null ? procedureName : "(unnamed)") +
                ", parent=" + parentScope +
                ", params=" + (params != null ? params.size() : 0));
        }
    }

    @Override
    public void postVisit(TMySQLCreateProcedure stmt) {
        // Pop from scope stack
        if (!scopeStack.isEmpty() && scopeStack.peek() instanceof PlsqlBlockScope) {
            scopeStack.pop();
        }

        // Restore previous PL/SQL block scope
        if (!plsqlBlockScopeStack.isEmpty()) {
            currentPlsqlBlockScope = plsqlBlockScopeStack.pop();
        } else {
            currentPlsqlBlockScope = null;
        }

        if (DEBUG_SCOPE_BUILD) {
            System.out.println("[DEBUG] postVisit(TMySQLCreateProcedure): restored scope");
        }
    }

    // ========== Nested BEGIN...END Block (TBlockSqlStatement) ==========
    // This handles nested BEGIN blocks within stored procedures.
    // The nested block inherits the parent's variable namespace.

    @Override
    public void preVisit(TBlockSqlStatement stmt) {
        // For nested blocks, we don't create a new PlsqlBlockScope.
        // The nested block inherits the enclosing PlsqlBlockScope's variable namespace.
        // This ensures variables declared in the parent block are visible in nested blocks.
        if (DEBUG_SCOPE_BUILD) {
            System.out.println("[DEBUG] preVisit(TBlockSqlStatement): nested block, " +
                "currentPlsqlBlockScope=" + (currentPlsqlBlockScope != null ? "exists" : "null"));
        }
        // No new scope is created - we just inherit the parent's scope
    }

    @Override
    public void postVisit(TBlockSqlStatement stmt) {
        // Nothing to pop since we didn't push a new scope
        if (DEBUG_SCOPE_BUILD) {
            System.out.println("[DEBUG] postVisit(TBlockSqlStatement): exiting nested block");
        }
    }

    // ========== FOR Loop Statement (DB2, PL/SQL) ==========
    // FOR loop statements have a cursor subquery that needs explicit traversal.
    // The TForStmt.acceptChildren() calls subquery.accept() which only calls preVisit/postVisit
    // but doesn't traverse the SELECT statement's children. We need to explicitly traverse it.

    @Override
    public void preVisit(TForStmt stmt) {
        // Explicitly traverse the FOR loop's cursor subquery
        // This is needed because TForStmt.acceptChildren() calls subquery.accept()
        // which doesn't traverse the SELECT's children (tables, columns, etc.)
        if (stmt.getSubquery() != null) {
            stmt.getSubquery().acceptChildren(this);
        }

        if (DEBUG_SCOPE_BUILD) {
            System.out.println("[DEBUG] preVisit(TForStmt): traversed cursor subquery");
        }
    }

    // ========== MERGE Statement ==========

    @Override
    public void preVisit(TMergeSqlStatement stmt) {
        // Determine parent scope
        IScope parentScope = determineParentScopeForMerge(stmt);

        // Create MergeScope
        MergeScope mergeScope = new MergeScope(parentScope, stmt);
        mergeScopeMap.put(stmt, mergeScope);

        // Push to stack
        scopeStack.push(mergeScope);
        currentMergeScope = mergeScope;

        // Set the current MERGE target table for UPDATE SET and INSERT column linking
        currentMergeTargetTable = stmt.getTargetTable();

        if (DEBUG_SCOPE_BUILD) {
            String stmtPreview = stmt.toString().length() > 50
                ? stmt.toString().substring(0, 50) + "..."
                : stmt.toString();
            System.out.println("[DEBUG] preVisit(MERGE): " + stmtPreview.replace("\n", " ") +
                ", targetTable=" + (currentMergeTargetTable != null ? currentMergeTargetTable.getName() : "null"));
        }

        // Create FromScope for MERGE's tables (target table + using table)
        if (stmt.tables != null && stmt.tables.size() > 0) {
            // Save current FROM scope if any
            if (currentFromScope != null) {
                fromScopeStack.push(currentFromScope);
            }

            // Create FromScope for MERGE's tables
            FromScope fromScope = new FromScope(mergeScope, stmt.tables);
            mergeScope.setFromScope(fromScope);
            currentFromScope = fromScope;

            // Tables will be processed when acceptChildren() visits TTable nodes
        }

        // Process MERGE ON clause condition for Teradata only
        // In Teradata, unqualified columns on the left side of MERGE ON clause comparisons
        // should be linked to the target table (not the source subquery)
        if (dbVendor == EDbVendor.dbvteradata && stmt.getCondition() != null && currentMergeTargetTable != null) {
            processMergeOnCondition(stmt.getCondition());
        }
    }

    /**
     * Process MERGE ON clause condition for Teradata.
     * For comparison expressions like "x1=10" or "x1=s.col", if the left operand
     * is an unqualified column (no table prefix), link it to the MERGE target table.
     *
     * This implements the Teradata-specific rule: in MERGE/USING/ON clause, unqualified columns
     * on the left side of comparisons should be linked to the target table.
     * This behavior is NOT applied to other databases as their column resolution rules differ.
     */
    private void processMergeOnCondition(TExpression condition) {
        if (condition == null) {
            return;
        }

        // Use iterative DFS to avoid StackOverflowError for deeply nested AND/OR chains
        Deque<TExpression> stack = new ArrayDeque<>();
        stack.push(condition);
        while (!stack.isEmpty()) {
            TExpression current = stack.pop();
            if (current == null) continue;

            if (DEBUG_SCOPE_BUILD) {
                System.out.println("[DEBUG] processMergeOnCondition: type=" + current.getExpressionType() +
                        ", expr=" + current.toString().replace("\n", " "));
            }

            // Handle comparison expressions (e.g., x1=10, x1=s.col)
            if (current.getExpressionType() == EExpressionType.simple_comparison_t) {
                TExpression leftOperand = current.getLeftOperand();
                if (leftOperand != null &&
                    leftOperand.getExpressionType() == EExpressionType.simple_object_name_t &&
                    leftOperand.getObjectOperand() != null) {

                    TObjectName leftColumn = leftOperand.getObjectOperand();
                    // Check if column is unqualified (no table prefix)
                    if (leftColumn.getTableToken() == null) {
                        // Link to MERGE target table
                        leftColumn.setSourceTable(currentMergeTargetTable);
                        traceDirectBinding(leftColumn,
                                gudusoft.gsqlparser.resolver2.binding.BindingTrace.BinderKind.MERGE_TARGET,
                                currentMergeTargetTable);
                        // Add to target table's linked columns directly
                        currentMergeTargetTable.getLinkedColumns().addObjectName(leftColumn);
                        allColumnReferences.add(leftColumn);
                        // Mark as ON clause target column - should NOT be re-resolved through name resolution
                        // This prevents the column from being incorrectly linked to the USING subquery
                        setClauseTargetColumns.add(leftColumn);
                        // Add to columnToScopeMap with the current MergeScope
                        if (currentMergeScope != null) {
                            columnToScopeMap.put(leftColumn, currentMergeScope);
                        }
                        if (DEBUG_SCOPE_BUILD) {
                            System.out.println("[DEBUG] Linked MERGE ON clause left-side column: " +
                                    leftColumn.toString() + " -> " + currentMergeTargetTable.getFullName());
                        }
                    }
                }
            }

            // Iteratively process compound conditions (AND, OR, parenthesis)
            if (current.getExpressionType() == EExpressionType.logical_and_t ||
                current.getExpressionType() == EExpressionType.logical_or_t ||
                current.getExpressionType() == EExpressionType.parenthesis_t) {
                if (current.getRightOperand() != null) stack.push(current.getRightOperand());
                if (current.getLeftOperand() != null) stack.push(current.getLeftOperand());
            }
        }
    }

    @Override
    public void postVisit(TMergeSqlStatement stmt) {
        // Pop CTEScope if present (left on the stack by postVisit(TCTEList)
        // when MERGE has a WITH clause; the parent statement is responsible
        // for cleanup — mirrors postVisit(TSelectSqlStatement) lines 649-653).
        if (!scopeStack.isEmpty() && scopeStack.peek() instanceof CTEScope) {
            scopeStack.pop();
            currentCTEScope = findEnclosingCTEScope();
        }

        // Pop scope
        if (!scopeStack.isEmpty() && scopeStack.peek() instanceof MergeScope) {
            scopeStack.pop();
        }

        // Restore current MergeScope
        currentMergeScope = findEnclosingMergeScope();

        // Clear MERGE target table
        currentMergeTargetTable = null;

        // Restore FROM scope
        if (!fromScopeStack.isEmpty()) {
            currentFromScope = fromScopeStack.pop();
        } else {
            currentFromScope = null;
        }
    }

    /**
     * Determine the parent scope for a MERGE statement.
     */
    private IScope determineParentScopeForMerge(TMergeSqlStatement stmt) {
        // If we have a CTE scope on the stack, use it
        if (currentCTEScope != null) {
            return currentCTEScope;
        }

        // Otherwise, find appropriate parent from stack
        for (int i = scopeStack.size() - 1; i >= 0; i--) {
            IScope scope = scopeStack.get(i);
            if (scope instanceof SelectScope || scope instanceof UpdateScope ||
                scope instanceof MergeScope || scope instanceof CTEScope ||
                scope instanceof PlsqlBlockScope ||
                scope instanceof GlobalScope) {
                return scope;
            }
        }

        return scopeStack.isEmpty() ? globalScope : scopeStack.peek();
    }

    /**
     * Find the enclosing MergeScope in the stack
     */
    private MergeScope findEnclosingMergeScope() {
        for (int i = scopeStack.size() - 1; i >= 0; i--) {
            IScope scope = scopeStack.get(i);
            if (scope instanceof MergeScope) {
                return (MergeScope) scope;
            }
        }
        return null;
    }

    // ========== MERGE UPDATE Clause ==========

    @Override
    public void preVisit(TMergeUpdateClause updateClause) {
        // Handle MERGE UPDATE SET clause columns
        // The left-hand side of SET assignments (e.g., SET col = expr)
        // should be linked to the MERGE target table
        if (currentMergeTargetTable != null && updateClause.getUpdateColumnList() != null) {
            TResultColumnList updateColumns = updateClause.getUpdateColumnList();
            for (int i = 0; i < updateColumns.size(); i++) {
                TResultColumn rc = updateColumns.getResultColumn(i);
                if (rc != null && rc.getExpr() != null) {
                    TExpression expr = rc.getExpr();
                    // SET clause uses assignment_t for "column = value" assignments
                    // or simple_comparison_t in some databases
                    if ((expr.getExpressionType() == EExpressionType.assignment_t ||
                         expr.getExpressionType() == EExpressionType.simple_comparison_t) &&
                        expr.getLeftOperand() != null &&
                        expr.getLeftOperand().getExpressionType() == EExpressionType.simple_object_name_t &&
                        expr.getLeftOperand().getObjectOperand() != null) {
                        TObjectName leftColumn = expr.getLeftOperand().getObjectOperand();
                        // Link the SET clause column to the MERGE target table
                        leftColumn.setSourceTable(currentMergeTargetTable);
                        traceDirectBinding(leftColumn,
                                gudusoft.gsqlparser.resolver2.binding.BindingTrace.BinderKind.MERGE_TARGET,
                                currentMergeTargetTable);
                        allColumnReferences.add(leftColumn);
                        // Mark as SET clause target - should NOT be re-resolved through star column
                        setClauseTargetColumns.add(leftColumn);
                        // Add to columnToScopeMap with the current MergeScope
                        if (currentMergeScope != null) {
                            columnToScopeMap.put(leftColumn, currentMergeScope);
                        }
                        if (DEBUG_SCOPE_BUILD) {
                            System.out.println("[DEBUG] Linked MERGE UPDATE SET column: " +
                                    leftColumn.toString() + " -> " + currentMergeTargetTable.getFullName());
                        }
                    }
                }
            }
        }
    }

    // ========== MERGE INSERT Clause ==========

    @Override
    public void preVisit(TMergeInsertClause insertClause) {
        // Handle MERGE INSERT clause columns
        // The column list in INSERT (column_list) should be linked to the MERGE target table
        if (currentMergeTargetTable != null && insertClause.getColumnList() != null) {
            TObjectNameList columnList = insertClause.getColumnList();
            for (int i = 0; i < columnList.size(); i++) {
                TObjectName column = columnList.getObjectName(i);
                if (column != null) {
                    // Link the INSERT column to the MERGE target table
                    column.setSourceTable(currentMergeTargetTable);
                    traceDirectBinding(column,
                            gudusoft.gsqlparser.resolver2.binding.BindingTrace.BinderKind.MERGE_TARGET,
                            currentMergeTargetTable);
                    allColumnReferences.add(column);
                    // Mark as target column - should NOT be re-resolved through name resolution
                    // (same as UPDATE SET clause left-side columns)
                    setClauseTargetColumns.add(column);
                    // Add to columnToScopeMap with the current MergeScope
                    if (currentMergeScope != null) {
                        columnToScopeMap.put(column, currentMergeScope);
                    }
                    if (DEBUG_SCOPE_BUILD) {
                        System.out.println("[DEBUG] Linked MERGE INSERT column: " +
                                column.toString() + " -> " + currentMergeTargetTable.getFullName());
                    }
                }
            }
        }

        // Handle MERGE INSERT VALUES clause columns
        // The VALUES list columns (e.g., VALUES(product, quantity)) should be linked to the USING table (source table)
        // In MERGE semantics, WHEN NOT MATCHED means the row exists in the source but not in the target,
        // so unqualified column references in VALUES refer to the source (USING) table.
        if (currentMergeScope != null && insertClause.getValuelist() != null) {
            TTable usingTable = currentMergeScope.getMergeStatement().getUsingTable();
            if (usingTable != null) {
                TResultColumnList valueList = insertClause.getValuelist();
                for (int i = 0; i < valueList.size(); i++) {
                    TResultColumn rc = valueList.getResultColumn(i);
                    if (rc != null && rc.getExpr() != null) {
                        TExpression expr = rc.getExpr();
                        // Handle simple column references in VALUES clause
                        if (expr.getExpressionType() == EExpressionType.simple_object_name_t &&
                            expr.getObjectOperand() != null) {
                            TObjectName valueColumn = expr.getObjectOperand();
                            // An unqualified name that the USING source provably does not project
                            // is not a column of anything visible here: the target row does not
                            // exist yet in a WHEN NOT MATCHED branch, so the source is the only
                            // relation in scope. Leave it unresolved instead of fabricating a link
                            // to the USING table.
                            if (!valueColumn.isQualified() &&
                                usingSourceProvablyLacksColumn(usingTable, valueColumn)) {
                                mergeInsertValuesUnboundColumns.add(valueColumn);
                                if (DEBUG_SCOPE_BUILD) {
                                    System.out.println("[DEBUG] MERGE VALUES column not projected by USING source, " +
                                            "left unresolved: " + valueColumn.toString());
                                }
                                continue;
                            }
                            // Link the VALUES column to the USING table (source)
                            valueColumn.setSourceTable(usingTable);
                            traceDirectBinding(valueColumn,
                                    gudusoft.gsqlparser.resolver2.binding.BindingTrace.BinderKind.MERGE_USING,
                                    usingTable);
                            allColumnReferences.add(valueColumn);
                            // Only track UNQUALIFIED columns for resolution restoration.
                            // Qualified columns (e.g., v.id, s.s_a) are correctly resolved by
                            // name resolution through their table prefix. Unqualified columns
                            // may get an AMBIGUOUS resolution when the column name exists in
                            // both target and source tables. For these, we need to clear the
                            // AMBIGUOUS resolution and force sourceTable to the USING table.
                            if (!valueColumn.isQualified()) {
                                mergeInsertValuesColumns.put(valueColumn, usingTable);
                            }
                            columnToScopeMap.put(valueColumn, currentMergeScope);
                            if (DEBUG_SCOPE_BUILD) {
                                System.out.println("[DEBUG] Linked MERGE VALUES column: " +
                                        valueColumn.toString() + " -> " + usingTable.getFullName());
                            }
                        }
                    }
                }
            }
        }
    }

    /**
     * Answers whether the MERGE USING source <b>provably</b> does not expose a column named
     * <code>column</code>.
     *
     * <p>Absence can only be proven when EVERY name the source exposes is enumerable from the
     * AST. That holds for a plain derived table — {@code USING (SELECT a, b FROM t) SRC} — each
     * of whose select-list items is either aliased or a simple column reference. Every other
     * shape has names this method cannot enumerate, and each one makes it return {@code false}
     * so the caller keeps its existing binding and no provable link is ever dropped:</p>
     *
     * <ul>
     *   <li>a physical table, CTE reference or table function — no projection in the AST at all;</li>
     *   <li>a star, which hides both the names and the arity;</li>
     *   <li>a set operation, whose result schema depends on how branches are matched
     *       ({@code UNION ALL BY NAME} exposes names present only on the right);</li>
     *   <li>a computed item, which several vendors expose under an implicit name derived from
     *       the expression ({@code SELECT lower(name)} is referenceable as {@code lower});</li>
     *   <li>a tuple alias ({@code posexplode(x) AS (i, a)}), which contributes several names;</li>
     *   <li>a struct path ({@code s.nested.field}), whose exposed name is the last segment.</li>
     * </ul>
     */
    private boolean usingSourceProvablyLacksColumn(TTable usingTable, TObjectName column) {
        if (usingTable == null || column == null) {
            return false;
        }
        TSelectSqlStatement subquery = usingTable.getSubquery();
        if (subquery == null) {
            return false;
        }
        if (subquery.getSetOperatorType() != ESetOperatorType.none) {
            return false;
        }
        TResultColumnList projection = subquery.getResultColumnList();
        if (projection == null || projection.size() == 0) {
            return false;
        }
        String columnName = referenceableName(column);
        if (columnName == null) {
            return false;
        }

        // A derived table may rename its projection — (SELECT ...) AS s(x, y) — and those names
        // replace the select list's position by position. A list shorter than the projection
        // leaves the remaining columns named by the select list itself.
        TObjectNameList renames = usingTable.getAliasClause() != null
                ? usingTable.getAliasClause().getColumns() : null;
        int renameCount = renames == null ? 0 : renames.size();
        if (renameCount > projection.size()) {
            return false;   // more names than columns: not a shape we can reason about
        }

        for (int i = 0; i < projection.size(); i++) {
            TResultColumn rc = projection.getResultColumn(i);
            if (rc == null || rc.getExpr() == null) {
                return false;   // cannot describe this item -> projection is not fully known
            }

            // Work out the item's own exposed name first. It is needed even for renamed
            // positions, because a shape whose name cannot be enumerated (a star, a tuple
            // alias, a computed item) also leaves the arity in doubt, and then the rename
            // list may cover only a prefix of the real columns.
            String ownName = null;
            if (rc.getAliasClause() != null) {
                TObjectNameList tupleColumns = rc.getAliasClause().getColumns();
                if (tupleColumns != null && tupleColumns.size() > 0) {
                    return false;   // one item, several names
                }
                if (rc.getAliasClause().getAliasName() != null) {
                    ownName = referenceableName(rc.getAliasClause().getAliasName());
                    if (ownName == null) {
                        // An alias replaces the item's own name, so an alias we cannot read
                        // leaves this position unknown — reading through to the expression
                        // underneath would name the column something it is not. A quoted
                        // alias containing a period, "a.b", lands here.
                        return false;
                    }
                }
            }
            if (ownName == null) {
                if (rc.getExpr().getExpressionType() != EExpressionType.simple_object_name_t ||
                    rc.getExpr().getObjectOperand() == null) {
                    return false;   // computed item: the implicit name is vendor-defined
                }
                TObjectName projectedName = rc.getExpr().getObjectOperand();
                // Detect the wildcard structurally: the printed form carries whatever trivia sat
                // around the dot, so "s . *" never matches a text test for a trailing ".*".
                if ("*".equals(projectedName.getColumnNameOnly())) {
                    return false;   // star: names and arity both unknown
                }
                String text = projectedName.toString();
                if (text != null && (text.equals("*") || text.endsWith(".*"))) {
                    return false;
                }
                if (projectedName.getPropertyToken() != null) {
                    return false;   // struct path: exposed under its last segment
                }
                ownName = referenceableName(projectedName);
                if (ownName == null) {
                    return false;
                }
            }

            String projected = i < renameCount
                    ? referenceableName(renames.getObjectName(i))
                    : ownName;
            if (projected == null) {
                return false;   // renamed to something we cannot read -> not fully known
            }
            if (SQLUtil.sameName(dbVendor, ESQLDataObjectType.dotColumn, projected, columnName)) {
                return false;
            }
        }
        return true;
    }

    /**
     * The single-segment name an object can be referenced by, or {@code null} when it cannot be
     * determined. Alias names carry no column part token, so they fall back to their source text;
     * anything that still looks qualified is reported as undeterminable rather than guessed at.
     */
    private static String referenceableName(TObjectName name) {
        if (name == null) {
            return null;
        }
        String part = name.getColumnNameOnly();
        if (part != null && part.length() > 0) {
            return part;
        }
        String text = name.toString();
        if (text == null || text.length() == 0 || text.indexOf('.') >= 0) {
            return null;
        }
        return text;
    }

    // ========== CTE (WITH Clause) ==========

    @Override
    public void preVisit(TCTEList cteList) {
        // Create CTEScope
        IScope parentScope = scopeStack.peek();
        CTEScope cteScope = new CTEScope(parentScope, cteList);

        // Push to stack
        scopeStack.push(cteScope);
        currentCTEScope = cteScope;
    }

    @Override
    public void postVisit(TCTEList cteList) {
        // DON'T pop CTEScope here - leave it on stack so the main SELECT
        // can reference CTEs in its FROM clause. CTEScope will be popped
        // in postVisit(TSelectSqlStatement) after the entire SELECT is processed.
        //
        // Only clear currentCTEScope so new CTEs aren't added to it
        // (but it remains accessible via the stack for CTE lookups)
    }

    @Override
    public void preVisit(TCTE cte) {
        // Track CTE definition depth for CTAS handling
        cteDefinitionDepth++;

        if (currentCTEScope == null) {
            return;
        }

        // Get CTE name
        String cteName = cte.getTableName() != null ? cte.getTableName().toString() : null;
        if (cteName == null) {
            return;
        }

        // Mark CTE table name as a table reference (not column)
        if (cte.getTableName() != null) {
            tableNameReferences.add(cte.getTableName());
        }

        // Create CTENamespace and add to CTEScope BEFORE processing subquery
        // This allows later CTEs to reference earlier ones
        TSelectSqlStatement subquery = cte.getSubquery();
        CTENamespace cteNamespace = new CTENamespace(cte, cteName, subquery, nameMatcher);

        // Add to CTE scope immediately (enables forward references)
        currentCTEScope.addCTE(cteName, cteNamespace);

        // Note: The subquery will be processed when acceptChildren traverses into it
        // At that point, preVisit(TSelectSqlStatement) will be called with currentCTEScope set
    }

    @Override
    public void postVisit(TCTE cte) {
        // Track CTE definition depth for CTAS handling
        if (cteDefinitionDepth > 0) {
            cteDefinitionDepth--;
        }

        if (currentCTEScope == null) {
            return;
        }

        // Validate the CTENamespace after subquery processing is complete
        String cteName = cte.getTableName() != null ? cte.getTableName().toString() : null;
        if (cteName != null) {
            CTENamespace cteNamespace = currentCTEScope.getCTE(cteName);
            if (cteNamespace != null) {
                cteNamespace.validate();
            }
        }
    }

    /**
     * Find the enclosing CTEScope in the stack
     */
    private CTEScope findEnclosingCTEScope() {
        for (int i = scopeStack.size() - 1; i >= 0; i--) {
            IScope scope = scopeStack.get(i);
            if (scope instanceof CTEScope) {
                return (CTEScope) scope;
            }
        }
        return null;
    }

    // ========== FROM Clause ==========

    @Override
    public void preVisit(TFromClause fromClause) {
        if (DEBUG_SCOPE_BUILD) {
            System.out.println("[DEBUG] preVisit(TFromClause): currentSelectScope=" +
                (currentSelectScope != null ? "exists" : "NULL"));
        }

        if (currentSelectScope == null) {
            return;
        }

        // Save current FROM scope for nested subqueries (e.g., in JOINs)
        // This is critical: when processing a JOIN, the left subquery's FROM clause
        // will be visited before the right subquery. We need to restore the outer
        // FROM scope after processing each inner subquery.
        if (currentFromScope != null) {
            fromScopeStack.push(currentFromScope);
        }

        // Reset join chain tables for this FROM clause
        // This tracks ALL tables in chained JOINs for proper USING column resolution
        currentJoinChainTables.clear();

        // Create FromScope
        FromScope fromScope = new FromScope(currentSelectScope, fromClause);
        currentSelectScope.setFromScope(fromScope);

        // Track current FromScope
        currentFromScope = fromScope;

        if (DEBUG_SCOPE_BUILD) {
            System.out.println("[DEBUG]   Created FromScope, linked to SelectScope");
        }
    }

    @Override
    public void postVisit(TFromClause fromClause) {
        // Restore previous FROM scope (for nested subqueries in JOINs)
        // IMPORTANT: Do NOT clear currentFromScope if stack is empty!
        // We need to keep the FROM scope available for the SELECT list expressions
        // (e.g., function calls, column references) which are visited after FROM clause.
        // The FROM scope will be cleared when the SELECT statement ends.
        if (!fromScopeStack.isEmpty()) {
            currentFromScope = fromScopeStack.pop();
        }
        // Note: If stack is empty, we keep currentFromScope as is - it will be cleared
        // in postVisit(TSelectSqlStatement) or when the enclosing statement ends.
    }

    // ========== Table ==========

    @Override
    public void preVisit(TTable table) {
        // Mark table name as a table reference (not column)
        if (table.getTableName() != null) {
            tableNameReferences.add(table.getTableName());
        }

        if (DEBUG_SCOPE_BUILD) {
            System.out.println("[DEBUG] preVisit(TTable): " + table.getDisplayName() +
                " type=" + table.getTableType() +
                " currentFromScope=" + (currentFromScope != null ? "exists" : "NULL"));
        }

        // Only process if we have a FROM scope
        if (currentFromScope == null) {
            return;
        }

        // Handle based on table type
        ETableSource tableType = table.getTableType();

        switch (tableType) {
            case objectname:
                processPhysicalTable(table);
                break;

            case subquery:
                processSubqueryTable(table);
                break;

            case join:
                // JOIN is handled via TJoinExpr
                // Left and right tables will be visited separately
                break;

            case function:
                // Table-valued function - treat similar to table
                processTableFunction(table);
                break;

            case pivoted_table:
                // PIVOT table - creates new columns from IN clause
                processPivotTable(table);
                break;

            case unnest:
                // UNNEST table - creates virtual table from array
                processUnnestTable(table);
                break;

            case rowList:
                // VALUES table - inline data with optional column aliases
                // e.g., VALUES (1, 'a'), (2, 'b') AS t(id, name)
                processValuesTable(table);
                break;

            case stageReference:
                // Snowflake stage file reference (e.g., @stage/path)
                // Treat similar to a regular table but without metadata
                processStageTable(table);
                break;

            case td_unpivot:
                // Teradata TD_UNPIVOT table function - collect columns from parameters
                processTDUnpivotTable(table);
                break;

            default:
                // Other types (CTE reference, etc.)
                processCTEReference(table);
                break;
        }
    }

    @Override
    public void postVisit(TTable table) {
        // Decrement the PIVOT source processing depth when exiting a pivot table.
        // This must happen BEFORE SubqueryNamespace validation so the flag is correctly
        // restored for any subsequent tables.
        if (table.getTableType() == ETableSource.pivoted_table) {
            if (pivotSourceProcessingDepth > 0) {
                pivotSourceProcessingDepth--;
            }
        }

        // Validate SubqueryNamespace after subquery content is fully processed
        // This is critical because SubqueryNamespace.doValidate() needs to read
        // the subquery's SELECT list, which is only complete after traversal
        SubqueryNamespace subNs = pendingSubqueryValidation.remove(table);
        if (subNs != null) {
            subNs.validate();
        }
    }

    /**
     * Process a physical table reference
     */
    private void processPhysicalTable(TTable table) {
        // Check if this table references a CTE
        String tableName = table.getName();
        CTENamespace cteNamespace = findCTEByName(tableName);

        // A bare-name match to an enclosing CTE is not always a CTE reference.
        // Skip the match when:
        //   1. The table has a schema/database/server prefix (e.g.
        //      "ZZZ_DEV.FOTC_BB_PRODUCT_INTER") — CTE names are unqualified.
        //   2. The table is inside the CTE's own definition and the CTE is
        //      non-recursive — non-recursive CTEs are not visible to themselves
        //      (Mantis #4412).
        if (cteNamespace != null && shouldTreatAsPhysicalTableNotCTE(table, cteNamespace)) {
            cteNamespace = null;
        }

        if (cteNamespace != null) {
            // This is a CTE reference, use the existing CTENamespace
            String alias = getTableAlias(table);

            // When the same CTE is referenced more than once in a FROM clause
            // with different aliases (e.g. FROM cte a, cte b), each reference
            // needs its own CTENamespace so getSourceTable() reports the right
            // alias. The single definition instance can only carry one
            // referencingTable, so reusing it makes every reference resolve to
            // the LAST reference's table (Mantis #4545).
            //
            // Reuse the definition instance for the FIRST outer reference (and
            // for self-references inside the still-unvalidated definition body,
            // to keep recursive-CTE behavior unchanged). Subsequent outer
            // references get an independent per-reference copy.
            CTENamespace refNamespace;
            if (!cteNamespace.isValidated() || !cteNamespace.isBoundToOuterReference()) {
                refNamespace = cteNamespace;
                if (cteNamespace.isValidated()) {
                    cteNamespace.setBoundToOuterReference(true);
                }
            } else {
                refNamespace = cteNamespace.createReference();
                refNamespace.validate();
            }
            refNamespace.setReferencingTable(table);  // Set the referencing TTable for getFinalTable() fallback
            currentFromScope.addChild(refNamespace, alias, false);
            lastProcessedFromTable = table;  // Track for JOIN...USING left table detection
            currentJoinChainTables.add(table);  // Track ALL tables in join chain for chained USING
            if (DEBUG_SCOPE_BUILD) {
                System.out.println("[DEBUG] Added CTE to FromScope: alias=" + alias);
            }
        } else {
            // Check if this is a SQL Server virtual table (deleted/inserted)
            // These can appear in:
            // 1. CREATE TRIGGER bodies - should reference the trigger's target table
            // 2. OUTPUT clauses of INSERT/UPDATE/DELETE - handled by preVisit(TOutputClause)
            //
            // IMPORTANT: Only substitute deleted/inserted when inside a TRIGGER context.
            // In DML (INSERT/UPDATE/DELETE) context, deleted/inserted in FROM clause
            // are regular table references (could be trigger pseudo-tables from an outer trigger).
            // The OUTPUT clause pseudo-columns are handled separately in preVisit(TOutputClause).
            TTable effectiveTable = table;
            if (dbVendor == EDbVendor.dbvmssql || dbVendor == EDbVendor.dbvazuresql) {
                String upperName = tableName != null ? tableName.toUpperCase() : "";
                if ("DELETED".equals(upperName) || "INSERTED".equals(upperName)) {
                    // Only substitute when inside a TRIGGER (not just any DML statement)
                    if (currentTriggerTargetTable != null) {
                        effectiveTable = currentTriggerTargetTable;
                        // Track this table as a virtual trigger table (to be skipped in table output)
                        virtualTriggerTables.add(table);
                        if (DEBUG_SCOPE_BUILD) {
                            System.out.println("[DEBUG] Substituting virtual table '" + tableName +
                                "' with trigger target table '" + currentTriggerTargetTable.getName() + "'");
                        }
                    }
                }
            }

            // Regular physical table - pass TSQLEnv for metadata lookup
            TableNamespace tableNs = new TableNamespace(effectiveTable, nameMatcher, sqlEnv);
            tableNs.validate();
            String alias = getTableAlias(table);

            // Add to FROM scope ONLY if not inside a PIVOT/UNPIVOT source processing context.
            // When a table is the source of a PIVOT/UNPIVOT, only the PIVOT/UNPIVOT table
            // should be visible in the outer query, not the source table itself.
            if (pivotSourceProcessingDepth == 0) {
                currentFromScope.addChild(tableNs, alias, false);
                if (DEBUG_SCOPE_BUILD) {
                    System.out.println("[DEBUG] Added table to FromScope: alias=" + alias + " tableName=" + tableName +
                        " hasMetadata=" + (tableNs.getResolvedTable() != null));
                }
            } else {
                if (DEBUG_SCOPE_BUILD) {
                    System.out.println("[DEBUG] Skipping table from FromScope (inside PIVOT source): alias=" + alias);
                }
            }

            lastProcessedFromTable = table;  // Track for JOIN...USING left table detection
            currentJoinChainTables.add(table);  // Track ALL tables in join chain for chained USING
            tableToNamespaceMap.put(table, tableNs);  // Store for legacy compatibility
        }
    }

    /**
     * Process a subquery in FROM clause
     */
    private void processSubqueryTable(TTable table) {
        TSelectSqlStatement subquery = table.getSubquery();
        if (subquery == null) {
            return;
        }

        // Track column name definitions from the alias clause
        // These are column DEFINITIONS, not references - should NOT be collected as column refs
        // e.g., in "FROM (SELECT ...) AS t(id, name)", 'id' and 'name' are definitions
        TAliasClause aliasClause = table.getAliasClause();
        if (aliasClause != null) {
            TObjectNameList columns = aliasClause.getColumns();
            if (columns != null && columns.size() > 0) {
                for (int i = 0; i < columns.size(); i++) {
                    TObjectName colName = columns.getObjectName(i);
                    if (colName != null) {
                        valuesTableAliasColumns.add(colName);
                        if (DEBUG_SCOPE_BUILD) {
                            System.out.println("[DEBUG] Tracked subquery alias column definition (will skip): " + colName.toString());
                        }
                    }
                }
            }
        }

        String alias = table.getAliasName();
        INamespace namespace;

        // Check if this is a TABLE function (Oracle TABLE(SELECT ...) syntax)
        // When isTableKeyword() is true, the subquery is wrapped in a TABLE() function
        boolean isTableFunction = table.isTableKeyword();

        // Check if this is a UNION/INTERSECT/EXCEPT query
        if (subquery.isCombinedQuery()) {
            // Create UnionNamespace for set operations
            UnionNamespace unionNs = new UnionNamespace(subquery, alias, nameMatcher);
            namespace = unionNs;

            if (DEBUG_SCOPE_BUILD) {
                System.out.println("[DEBUG]   Detected UNION query with " +
                    unionNs.getBranchCount() + " branches");
            }
        } else {
            // Regular subquery - create SubqueryNamespace
            // Pass isTableFunction to mark TABLE function subqueries for expression alias filtering
            SubqueryNamespace subNs = new SubqueryNamespace(subquery, alias, nameMatcher, isTableFunction);
            // Pass guessColumnStrategy for config-based isolation (prevents test side effects)
            if (guessColumnStrategy >= 0) {
                subNs.setGuessColumnStrategy(guessColumnStrategy);
            }
            // Pass sqlEnv for metadata lookup during star column resolution
            if (sqlEnv != null) {
                subNs.setSqlEnv(sqlEnv);
            }
            // Set the owning TTable for legacy sync support
            subNs.setSourceTable(table);
            namespace = subNs;

            // Register for deferred validation
            // SubqueryNamespace needs to be validated AFTER its subquery's SELECT list is processed
            // because the column names come from the SELECT list
            pendingSubqueryValidation.put(table, subNs);
        }

        // Add to FROM scope ONLY if not inside a PIVOT/UNPIVOT source processing context.
        // When a subquery is the source of a PIVOT/UNPIVOT, only the PIVOT/UNPIVOT table
        // should be visible in the outer query, not the source subquery itself.
        // Example: FROM (SELECT ...) p UNPIVOT (...) AS unpvt
        //   - Only 'unpvt' should be visible, not 'p'
        //   - Column references in outer SELECT should resolve to 'unpvt', not ambiguously to both
        if (pivotSourceProcessingDepth == 0) {
            currentFromScope.addChild(namespace, alias != null ? alias : "<subquery>", false);
            if (DEBUG_SCOPE_BUILD) {
                System.out.println("[DEBUG] Added subquery to FromScope: alias=" + alias);
            }
        } else {
            if (DEBUG_SCOPE_BUILD) {
                System.out.println("[DEBUG] Skipping subquery from FromScope (inside PIVOT source): alias=" + alias);
            }
        }
        tableToNamespaceMap.put(table, namespace);  // Store for legacy compatibility

        // Note: The subquery SELECT will be processed when acceptChildren traverses into it
        // For UnionNamespace, validation happens during construction
    }

    /**
     * Process a table-valued function
     *
     * TABLE functions can contain subqueries as arguments, e.g.:
     * TABLE (SELECT AVG(E.SALARY) AS AVGSAL, COUNT(*) AS EMPCOUNT FROM EMP E) AS EMPINFO
     *
     * In this case, we create a SubqueryNamespace to expose the subquery's SELECT list
     * columns (AVGSAL, EMPCOUNT) to the outer query.
     */
    private void processTableFunction(TTable table) {
        // Track this function call as a table-valued function (not a column method call)
        if (table.getFuncCall() != null) {
            tableValuedFunctionCalls.add(table.getFuncCall());
        }

        String alias = getTableAlias(table);

        // Check if the TABLE function has a subquery argument
        TFunctionCall funcCall = table.getFuncCall();
        if (funcCall != null && funcCall.getArgs() != null && funcCall.getArgs().size() > 0) {
            TExpression firstArg = funcCall.getArgs().getExpression(0);
            if (firstArg != null && firstArg.getSubQuery() != null) {
                // TABLE function contains a subquery - create SubqueryNamespace
                TSelectSqlStatement subquery = firstArg.getSubQuery();

                // Check if this is a UNION/INTERSECT/EXCEPT query
                INamespace namespace;
                if (subquery.isCombinedQuery()) {
                    // Create UnionNamespace for set operations
                    UnionNamespace unionNs = new UnionNamespace(subquery, alias, nameMatcher);
                    namespace = unionNs;
                } else {
                    // Create SubqueryNamespace for regular subquery, marked as from TABLE function
                    SubqueryNamespace subNs = new SubqueryNamespace(subquery, alias, nameMatcher, true);
                    // Pass guessColumnStrategy for config-based isolation (prevents test side effects)
                    if (guessColumnStrategy >= 0) {
                        subNs.setGuessColumnStrategy(guessColumnStrategy);
                    }
                    // Pass sqlEnv for metadata lookup during star column resolution
                    if (sqlEnv != null) {
                        subNs.setSqlEnv(sqlEnv);
                    }
                    // Set the owning TTable for legacy sync support
                    subNs.setSourceTable(table);
                    namespace = subNs;
                    // Defer validation until after children are visited
                    pendingSubqueryValidation.put(table, subNs);
                }

                currentFromScope.addChild(namespace, alias, false);
                tableToNamespaceMap.put(table, namespace);  // Store for legacy compatibility

                if (DEBUG_SCOPE_BUILD) {
                    System.out.println("[DEBUG] Added TABLE function with subquery to FromScope: alias=" + alias);
                }
                return;
            }
        }

        // Fallback: treat as a regular table-valued function (e.g., UDF)
        TableNamespace tableNs = new TableNamespace(table, nameMatcher, sqlEnv);
        tableNs.validate();
        currentFromScope.addChild(tableNs, alias, false);
        tableToNamespaceMap.put(table, tableNs);  // Store for legacy compatibility
    }

    /**
     * Process a PIVOT table
     *
     * PIVOT tables are created from a source table and a PIVOT clause:
     * <pre>
     * FROM source_table
     * PIVOT (aggregate_function(value) FOR column IN (val1, val2, ...)) AS alias
     * </pre>
     *
     * The PIVOT produces new columns (val1, val2, ...) while maintaining
     * some pass-through columns from the source table.
     */
    private void processPivotTable(TTable table) {
        // Get the source table of the pivot (the table being pivoted)
        // Note: For SQL Server, getSourceTableOfPivot() may return null, so we also check
        // getPivotedTable().getTableSource() which is set during parsing.
        // However, for BigQuery, using this fallback can break resolution because BigQuery's
        // AST structure adds the source table to FROM scope separately during traversal.
        // For SQL Server, we need the fallback to properly resolve pass-through columns.
        TTable sourceTable = table.getSourceTableOfPivot();

        // Get PIVOT clause from the table's pivot table reference
        TPivotClause pivotClause = null;
        TPivotedTable pivotedTable = table.getPivotedTable();

        // SQL Server UNPIVOT issue: When UNPIVOT is used on a subquery, the table from
        // statement.tables may have tableType=pivoted_table but getPivotedTable()=null.
        // The actual pivot clause is on a different TTable object from statement.joins.
        // We need to search for it there.
        if (pivotedTable == null && (dbVendor == EDbVendor.dbvmssql || dbVendor == EDbVendor.dbvazuresql)) {
            // Try to find the actual pivot table from joins
            TTable pivotTableFromJoins = findPivotTableInJoins(table);
            if (pivotTableFromJoins != null && pivotTableFromJoins.getPivotedTable() != null) {
                pivotedTable = pivotTableFromJoins.getPivotedTable();
            }
        }

        if (pivotedTable != null) {
            pivotClause = pivotedTable.getPivotClause();
            // Also try to get source table from the pivoted table if not found yet
            if (sourceTable == null) {
                TTable potentialSourceTable = pivotedTable.getTableSource();
                // Use the fallback to get the source table for vendors that need it.
                // This is required for pass-through column resolution in PIVOT tables.
                // Note: For BigQuery, the source table (especially subqueries) needs this
                // fallback to properly resolve pass-through columns.
                if (potentialSourceTable != null) {
                    sourceTable = potentialSourceTable;
                }
            }
        }

        // Get the alias - for PIVOT tables, the alias is in the PIVOT clause
        String alias = getTableAlias(table);

        // If table alias is null/empty, try to get from pivot clause's alias clause
        if ((alias == null || alias.isEmpty() || alias.startsWith("null")) && pivotClause != null) {
            if (pivotClause.getAliasClause() != null &&
                pivotClause.getAliasClause().getAliasName() != null) {
                alias = pivotClause.getAliasClause().getAliasName().toString();
            }
        }

        // Fallback to appropriate default alias if still no alias
        if (alias == null || alias.isEmpty() || alias.startsWith("null")) {
            // Use different default for PIVOT vs UNPIVOT to match TPivotClause.doParse()
            if (pivotClause != null && pivotClause.getType() == TPivotClause.unpivot) {
                alias = "unpivot_alias";
            } else {
                alias = "pivot_alias";
            }
        }

        // IMPORTANT: The visitor traverses through getRelations() which may contain
        // different TTable objects than statement.tables. The formatter matches
        // sourceTable against statement.tables using object identity. We need to
        // find the matching pivot table in statement.tables to ensure proper matching.
        TTable pivotTableForNamespace = findMatchingPivotTableInStatement(table, alias);

        // Create PivotNamespace with the table from statement.tables (if found)
        PivotNamespace pivotNs = new PivotNamespace(pivotTableForNamespace, pivotClause, sourceTable, alias, nameMatcher);
        pivotNs.validate();

        // Wire source namespace for pass-through column resolution (Delta 2)
        if (sourceTable != null) {
            INamespace sourceNamespace = resolveSourceNamespaceForPivot(sourceTable);
            if (sourceNamespace != null) {
                pivotNs.setSourceNamespace(sourceNamespace);
            }
        }

        // Add to FROM scope with the pivot table alias
        currentFromScope.addChild(pivotNs, alias, false);
        tableToNamespaceMap.put(table, pivotNs);  // Store for legacy compatibility
        if (pivotTableForNamespace != null && pivotTableForNamespace != table) {
            tableToNamespaceMap.put(pivotTableForNamespace, pivotNs);  // Also map the matched table
        }

        // Add all PIVOT/UNPIVOT columns to allColumnReferences
        // Per CLAUDE.md, this resolution logic MUST be in ScopeBuilder, not in the formatter
        if (pivotClause != null) {
            if (pivotClause.getType() == TPivotClause.unpivot) {
                // UNPIVOT case: add generated columns and IN clause source columns
                addUnpivotColumns(pivotClause, pivotTableForNamespace, sourceTable);
            } else {
                // PIVOT case: Check if there's an alias column list (e.g., AS p (col1, col2, col3))
                // If so, use the alias columns as they REPLACE the IN clause column names
                boolean hasAliasColumnList = pivotClause.getAliasClause() != null &&
                    pivotClause.getAliasClause().getColumns() != null &&
                    pivotClause.getAliasClause().getColumns().size() > 0;

                if (hasAliasColumnList) {
                    // Use alias column list - these replace the default pivot column names
                    addPivotAliasColumns(pivotClause.getAliasClause().getColumns(), pivotTableForNamespace);
                } else {
                    // No alias column list - use IN clause columns as pivot column names
                    TPivotInClause inClause = pivotClause.getPivotInClause();
                    if (inClause != null) {
                        addPivotInClauseColumns(inClause, pivotTableForNamespace);
                    }
                }
            }
        }

        if (DEBUG_SCOPE_BUILD) {
            System.out.println("[DEBUG] Added PIVOT table to FromScope: alias=" + alias +
                " sourceTable=" + (sourceTable != null ? sourceTable.getName() : "null") +
                " pivotColumns=" + pivotNs.getPivotColumns().size() +
                " pivotTable=" + (pivotTableForNamespace == table ? "same" : "from-stmt-tables"));
        }

        // Mark that we're now processing PIVOT/UNPIVOT source relations.
        // This prevents the source subquery from being added to FromScope
        // when the visitor traverses the TPivotedTable's children.
        // Will be decremented in postVisit(TTable) for pivot tables.
        pivotSourceProcessingDepth++;
    }

    /**
     * Add all columns from PIVOT IN clause to allColumnReferences.
     * This ensures all pivot columns appear in the output, not just the ones referenced in SELECT.
     *
     * @param inClause The PIVOT IN clause
     * @param pivotTable The pivot table to set as sourceTable
     */
    private void addPivotInClauseColumns(TPivotInClause inClause, TTable pivotTable) {
        if (inClause == null || pivotTable == null) {
            return;
        }

        // Case 1: IN clause has items (e.g., IN ([1], [2]) or IN ("SINGAPORE","LONDON","HOUSTON"))
        TResultColumnList items = inClause.getItems();
        if (items != null) {
            for (int i = 0; i < items.size(); i++) {
                TResultColumn resultColumn = items.getResultColumn(i);
                if (resultColumn == null || resultColumn.getExpr() == null) {
                    continue;
                }
                TExpression expr = resultColumn.getExpr();

                // An explicit alias names the generated column outright, whatever the
                // IN-list value is: Oracle/Snowflake/BigQuery/Teradata all accept
                // IN ('direct' AS Store) and call the output column Store.
                String itemAlias = pivotInItemAlias(resultColumn);

                if (expr.getExpressionType() == EExpressionType.simple_object_name_t) {
                    // Column reference (e.g., [Sammich], [Apple], "HOUSTON" in BigQuery)
                    // These are pivot column DEFINITIONS, not references to source table columns.
                    TObjectName objName = expr.getObjectOperand();
                    if (objName != null) {
                        objName.setSourceTable(pivotTable);
                        // Mark as pivot IN clause column so preVisit(TObjectName) won't re-process it
                        // and NameResolver won't overwrite the sourceTable with the source table
                        pivotInClauseColumns.add(objName);
                        // IMPORTANT: Do NOT add to columnToScopeMap - these are column DEFINITIONS,
                        // not references that need resolution. Adding to the map would cause the
                        // NameResolver to resolve them as source table columns, overwriting the
                        // sourceTable we set above.
                        if (itemAlias == null) {
                            allColumnReferences.add(objName);
                        } else {
                            // The alias, not the value, is the generated column. Publish it
                            // instead so exactly one column is exposed per IN-list item.
                            allColumnReferences.add(
                                newPivotOutputColumn(inClause.dbvendor, itemAlias, pivotTable));
                        }
                    }
                } else if (expr.getExpressionType() == EExpressionType.simple_constant_t) {
                    // Constant value (e.g., "HOUSTON", 'value')
                    // These are pivot column DEFINITIONS, not references that need resolution.
                    TConstant constant = expr.getConstantOperand();
                    if (constant != null && constant.getValueToken() != null) {
                        String columnName = itemAlias != null
                            ? itemAlias
                            : pivotOutputColumnName(inClause.dbvendor,
                                                    constant.getValueToken().toString());
                        allColumnReferences.add(
                            newPivotOutputColumn(inClause.dbvendor, columnName, pivotTable));
                        // IMPORTANT: Do NOT add to columnToScopeMap - these are column DEFINITIONS,
                        // not references that need resolution. Adding to the map would cause the
                        // NameResolver to resolve them and overwrite the sourceTable we set above.
                    }
                }
            }
        }

        // Case 2: IN clause has a subquery (e.g., IN (SELECT DISTINCT col FROM table))
        if (inClause.getSubQuery() != null) {
            TResultColumnList subqueryColumns = inClause.getSubQuery().getResultColumnList();
            if (subqueryColumns != null) {
                for (int i = 0; i < subqueryColumns.size(); i++) {
                    TResultColumn resultColumn = subqueryColumns.getResultColumn(i);
                    if (resultColumn != null) {
                        TObjectName pivotColumn = TObjectName.createObjectName(
                            inClause.dbvendor,
                            EDbObjectType.column,
                            new TSourceToken(resultColumn.getDisplayName())
                        );
                        pivotColumn.setSourceTable(pivotTable);
                        allColumnReferences.add(pivotColumn);
                        // IMPORTANT: Do NOT add to columnToScopeMap.
                        // These are synthetic PIVOT output column DEFINITIONS (derived from IN-subquery result),
                        // not references that should be name-resolved. Adding them to the map would allow
                        // NameResolver to overwrite pivotColumn.sourceTable to some source table.
                    }
                }
            }
        }
    }

    /**
     * Add PIVOT alias columns to allColumnReferences.
     * When PIVOT has an alias clause with column list (e.g., AS p (empid_renamed, Q1, Q2, Q3, Q4)),
     * the alias columns REPLACE the IN clause column names in the output.
     *
     * @param aliasColumns The column list from the alias clause
     * @param pivotTable The pivot table to set as sourceTable
     */
    private void addPivotAliasColumns(TObjectNameList aliasColumns, TTable pivotTable) {
        if (aliasColumns == null || pivotTable == null) {
            return;
        }

        for (int i = 0; i < aliasColumns.size(); i++) {
            TObjectName aliasCol = aliasColumns.getObjectName(i);
            if (aliasCol != null) {
                aliasCol.setSourceTable(pivotTable);
                allColumnReferences.add(aliasCol);
                // IMPORTANT: Do NOT add to columnToScopeMap.
                // These are PIVOT output column DEFINITIONS from the alias list,
                // not references that should be name-resolved.
            }
        }
    }

    /**
     * Add UNPIVOT source columns (IN clause) to allColumnReferences and mark definition columns.
     *
     * UNPIVOT (yearly_total FOR order_mode IN (store AS 'direct', internet AS 'online'))
     * - yearly_total is the value column (DEFINITION - creates a new column, NOT a reference)
     * - order_mode is the FOR column (DEFINITION - creates a new column, NOT a reference)
     * - store, internet are source columns (REFERENCES - belong to source table)
     *
     * IMPORTANT: Value and FOR columns are DEFINITIONS that create new columns in the UNPIVOT
     * output. They should NOT be added to allColumnReferences (which tracks references).
     * The PivotNamespace already tracks these generated columns for resolution purposes.
     *
     * @param pivotClause The UNPIVOT clause
     * @param unpivotTable The UNPIVOT table for generated columns
     * @param sourceTable The source table for IN clause columns
     */
    private void addUnpivotColumns(TPivotClause pivotClause, TTable unpivotTable, TTable sourceTable) {
        if (pivotClause == null || unpivotTable == null) {
            return;
        }

        // Mark value columns as UNPIVOT definitions (NOT column references)
        // These define new output columns like "yearly_total" in UNPIVOT (yearly_total FOR ...)
        // We still set sourceTable for resolution purposes, but mark them so they're not
        // collected as column references by isColumnReference().
        // Note: For single value column UNPIVOT (like Oracle), use getValueColumn() (deprecated singular)
        TObjectNameList valueColumns = pivotClause.getValueColumnList();
        if (valueColumns != null && valueColumns.size() > 0) {
            for (int i = 0; i < valueColumns.size(); i++) {
                TObjectName valueCol = valueColumns.getObjectName(i);
                if (valueCol != null) {
                    valueCol.setSourceTable(unpivotTable);
                    unpivotDefinitionColumns.add(valueCol);
                    // Add to output completeness list as a DEFINITION (no name resolution)
                    allColumnReferences.add(valueCol);
                }
            }
        } else {
            // Fallback to deprecated singular method for Oracle compatibility
            @SuppressWarnings("deprecation")
            TObjectName valueCol = pivotClause.getValueColumn();
            if (valueCol != null) {
                valueCol.setSourceTable(unpivotTable);
                unpivotDefinitionColumns.add(valueCol);
                // Add to output completeness list as a DEFINITION (no name resolution)
                allColumnReferences.add(valueCol);
            }
        }

        // Mark FOR columns as UNPIVOT definitions (NOT column references)
        // These define new output columns like "order_mode" in UNPIVOT (... FOR order_mode IN ...)
        // We still set sourceTable for resolution purposes, but mark them so they're not
        // collected as column references by isColumnReference().
        // Note: For single FOR column UNPIVOT (like Oracle), use getPivotColumn() (deprecated singular)
        TObjectNameList pivotColumnList = pivotClause.getPivotColumnList();
        if (pivotColumnList != null && pivotColumnList.size() > 0) {
            for (int i = 0; i < pivotColumnList.size(); i++) {
                TObjectName forCol = pivotColumnList.getObjectName(i);
                if (forCol != null) {
                    forCol.setSourceTable(unpivotTable);
                    unpivotDefinitionColumns.add(forCol);
                    // Add to output completeness list as a DEFINITION (no name resolution)
                    allColumnReferences.add(forCol);
                }
            }
        } else {
            // Fallback to deprecated singular method for Oracle compatibility
            @SuppressWarnings("deprecation")
            TObjectName forCol = pivotClause.getPivotColumn();
            if (forCol != null) {
                forCol.setSourceTable(unpivotTable);
                unpivotDefinitionColumns.add(forCol);
                // Add to output completeness list as a DEFINITION (no name resolution)
                allColumnReferences.add(forCol);
            }
        }

        // IN clause columns (e.g., store, internet in "IN (store AS 'direct', internet AS 'online')")
        // are references to columns in the source table. They should be added to allColumnReferences
        // so they appear in the output with source table attribution (e.g., pivot_table.store).
        //
        // We set their sourceTable to the source table and add them to allColumnReferences.
        // We also mark them as unpivotDefinitionColumns so they're not collected again by isColumnReference().
        // S2: vendor-aware key set so quoted-vs-unquoted UNPIVOT consumed
        // columns are correctly distinguished on Oracle / Postgres quoted
        // and BigQuery (columns insensitive). Lookup site below uses the
        // same keyForColumn() helper.
        Set<String> consumedColumns = new HashSet<>();  // Track consumed column names
        TUnpivotInClause unpivotInClause = pivotClause.getUnpivotInClause();
        if (unpivotInClause != null && unpivotInClause.getItems() != null && sourceTable != null) {
            for (int i = 0; i < unpivotInClause.getItems().size(); i++) {
                TUnpivotInClauseItem item = unpivotInClause.getItems().getElement(i);
                if (item != null) {
                    // Single column case
                    if (item.getColumn() != null) {
                        TObjectName col = item.getColumn();
                        col.setSourceTable(sourceTable);
                        // Mark as definition so it's not collected again in isColumnReference()
                        unpivotDefinitionColumns.add(col);
                        // Add to allColumnReferences - this IS a reference to a source table column
                        allColumnReferences.add(col);
                        // Track consumed column name (strip table prefix if present)
                        String colName = col.getColumnNameOnly();
                        if (colName != null) consumedColumns.add(keyForColumn(colName));
                    }
                    // Multi-column case
                    if (item.getColumnList() != null) {
                        for (int j = 0; j < item.getColumnList().size(); j++) {
                            TObjectName col = item.getColumnList().getObjectName(j);
                            if (col != null) {
                                col.setSourceTable(sourceTable);
                                // Mark as definition so it's not collected again in isColumnReference()
                                unpivotDefinitionColumns.add(col);
                                // Add to allColumnReferences - this IS a reference to a source table column
                                allColumnReferences.add(col);
                                // Track consumed column name
                                String colName = col.getColumnNameOnly();
                                if (colName != null) consumedColumns.add(keyForColumn(colName));
                            }
                        }
                    }
                }
            }
        }

        // Collect value and FOR column names for exclusion
        // (reusing valueColumns and pivotColumnList already defined above)
        if (valueColumns != null) {
            for (int i = 0; i < valueColumns.size(); i++) {
                TObjectName vc = valueColumns.getObjectName(i);
                if (vc != null && vc.getColumnNameOnly() != null) {
                    consumedColumns.add(keyForColumn(vc.getColumnNameOnly()));
                }
            }
        }
        if (pivotColumnList != null) {
            for (int i = 0; i < pivotColumnList.size(); i++) {
                TObjectName fc = pivotColumnList.getObjectName(i);
                if (fc != null && fc.getColumnNameOnly() != null) {
                    consumedColumns.add(keyForColumn(fc.getColumnNameOnly()));
                }
            }
        }

        // Add pass-through columns as part of the UNPIVOT virtual table's output schema.
        // Pass-through columns are source columns that are NOT consumed by UNPIVOT:
        // - NOT in the IN clause (consumed columns)
        // - NOT the value column (generated by UNPIVOT)
        // - NOT the FOR column (generated by UNPIVOT)
        //
        // This ensures pass-through columns appear in the output even when not explicitly
        // referenced in the outer SELECT, similar to how value and FOR columns are added.
        //
        // NOTE: The source subquery's own columns will ALSO be collected during normal
        // traversal (with pivotSourceProcessingDepth reset), so they'll appear with
        // source table attribution (e.g., #sample.col1). This gives us dual attribution:
        // - #sample.col1 (from source subquery)
        // - (pivot-table:unpvt).col1 (as part of UNPIVOT output schema)
        if (sourceTable != null && sourceTable.getSubquery() != null && unpivotTable != null) {
            TSelectSqlStatement sourceSubquery = sourceTable.getSubquery();
            TResultColumnList resultCols = sourceSubquery.getResultColumnList();
            if (resultCols != null) {
                for (int i = 0; i < resultCols.size(); i++) {
                    TResultColumn rc = resultCols.getResultColumn(i);
                    if (rc == null) continue;

                    // Get the column name from the result column
                    // Handle both simple columns and aliased expressions
                    String columnName = null;
                    if (rc.getAliasClause() != null && rc.getAliasClause().getAliasName() != null) {
                        columnName = rc.getAliasClause().getAliasName().toString();
                    } else if (rc.getExpr() != null) {
                        TExpression expr = rc.getExpr();
                        if (expr.getExpressionType() == EExpressionType.simple_object_name_t &&
                            expr.getObjectOperand() != null) {
                            columnName = expr.getObjectOperand().getColumnNameOnly();
                        }
                    }

                    if (columnName == null || columnName.isEmpty()) continue;

                    // Check if this is a pass-through column (not consumed).
                    // S2: route through the same vendor-aware keyForColumn()
                    // used at the storage sites above. IdentifierService
                    // strips quotes per vendor (so the manual "[...]" / "\"...\""
                    // strip is no longer needed here).
                    String normalizedName = keyForColumn(columnName);
                    if (!consumedColumns.contains(normalizedName)) {
                        // This is a pass-through column - create a synthetic entry
                        // We use TObjectName.createObjectName() which properly initializes tokens
                        // so getColumnNameOnly() returns the correct value
                        TObjectName passthroughCol = TObjectName.createObjectName(
                            dbVendor,
                            EDbObjectType.column,
                            new TSourceToken(columnName)
                        );
                        passthroughCol.setSourceTable(unpivotTable);

                        // Mark as definition column so it's not processed as a reference in isColumnReference()
                        unpivotDefinitionColumns.add(passthroughCol);

                        // Add to output
                        allColumnReferences.add(passthroughCol);

                        if (DEBUG_SCOPE_BUILD) {
                            System.out.println("[DEBUG] Added UNPIVOT pass-through column: " + columnName);
                        }
                    }
                }
            }
        }
    }

    /**
     * Find the matching pivot table in the current statement's tables collection.
     *
     * The visitor traverses through getRelations() which may contain TTable objects
     * that are different from those in statement.tables. Since the formatter uses
     * object identity to match sourceTable against statement.tables, we need to
     * return the TTable from statement.tables.
     *
     * @param visitedTable The TTable from visitor traversal
     * @param alias The alias to match
     * @return The matching TTable from statement.tables, or visitedTable if not found
     */
    private TTable findMatchingPivotTableInStatement(TTable visitedTable, String alias) {
        // Get the current statement from the scope
        if (currentSelectScope == null || !(currentSelectScope.getNode() instanceof TSelectSqlStatement)) {
            return visitedTable;
        }

        TSelectSqlStatement stmt = (TSelectSqlStatement) currentSelectScope.getNode();
        if (stmt.tables == null) {
            return visitedTable;
        }

        // Search for a pivot table with matching alias in statement.tables
        for (int i = 0; i < stmt.tables.size(); i++) {
            TTable stmtTable = stmt.tables.getTable(i);
            if (stmtTable == null) continue;

            // Check if this is a pivot table with matching alias
            if (stmtTable.getTableType() == ETableSource.pivoted_table) {
                String stmtAlias = getTableAlias(stmtTable);
                // Try to get alias from pivot clause if not found
                if ((stmtAlias == null || stmtAlias.isEmpty() || stmtAlias.startsWith("null"))
                    && stmtTable.getPivotedTable() != null
                    && stmtTable.getPivotedTable().getPivotClause() != null) {
                    TPivotClause pc = stmtTable.getPivotedTable().getPivotClause();
                    if (pc.getAliasClause() != null && pc.getAliasClause().getAliasName() != null) {
                        stmtAlias = pc.getAliasClause().getAliasName().toString();
                    }
                }

                // Match by alias
                if (alias != null && stmtAlias != null && SQLUtil.sameName(dbVendor, ESQLDataObjectType.dotTable, alias, stmtAlias)) {
                    return stmtTable;
                }
            }
        }

        // Not found in statement.tables, return the original visited table
        return visitedTable;
    }

    /**
     * Find the actual pivot table with PivotedTable info from the statement's joins.
     *
     * SQL Server UNPIVOT issue: When UNPIVOT is used on a subquery, the table from
     * statement.tables may have tableType=pivoted_table but getPivotedTable()=null.
     * The actual pivot clause is on a different TTable object from statement.joins.
     *
     * @param table The pivot table from statement.tables (may have getPivotedTable()=null)
     * @return The matching TTable from joins with getPivotedTable() populated, or null if not found
     */
    private TTable findPivotTableInJoins(TTable table) {
        // Get the current statement from the scope
        if (currentSelectScope == null || !(currentSelectScope.getNode() instanceof TSelectSqlStatement)) {
            return null;
        }

        TSelectSqlStatement stmt = (TSelectSqlStatement) currentSelectScope.getNode();

        // Search in joins for a pivot table with getPivotedTable() != null
        TJoinList joins = stmt.joins;
        if (joins != null) {
            for (int i = 0; i < joins.size(); i++) {
                TJoin join = joins.getJoin(i);
                if (join == null) continue;

                TTable joinTable = join.getTable();
                if (joinTable != null &&
                    joinTable.getTableType() == ETableSource.pivoted_table &&
                    joinTable.getPivotedTable() != null) {
                    // Found a pivot table with the actual PivotedTable info
                    // Match by alias if available
                    String tableAlias = getTableAlias(table);
                    String joinTableAlias = getTableAlias(joinTable);

                    // If the table from statement.tables has an alias, try to match
                    if (tableAlias != null && !tableAlias.isEmpty()) {
                        // Try to get alias from pivot clause if joinTableAlias is null or has the
                        // placeholder pattern "null(piviot_table)" or similar
                        if ((joinTableAlias == null || joinTableAlias.isEmpty() ||
                             joinTableAlias.startsWith("null")) &&
                            joinTable.getPivotedTable().getPivotClause() != null) {
                            TPivotClause pc = joinTable.getPivotedTable().getPivotClause();
                            if (pc.getAliasClause() != null && pc.getAliasClause().getAliasName() != null) {
                                joinTableAlias = pc.getAliasClause().getAliasName().toString();
                            }
                        }
                        if (SQLUtil.sameName(dbVendor, ESQLDataObjectType.dotTable, tableAlias, joinTableAlias)) {
                            return joinTable;
                        }
                    } else {
                        // No alias to match, return the first pivot table found
                        return joinTable;
                    }
                }
            }
        }

        return null;
    }

    /**
     * Find a table by alias or name in the current SELECT statement's FROM clause.
     * Used for linking EXCEPT columns to the star column's source table.
     *
     * @param aliasOrName The table alias or name to find
     * @return The matching TTable, or null if not found
     */
    private TTable findTableByAliasInCurrentScope(String aliasOrName) {
        if (aliasOrName == null || aliasOrName.isEmpty()) {
            return null;
        }

        // Get the current statement from the scope
        if (currentSelectScope == null || !(currentSelectScope.getNode() instanceof TSelectSqlStatement)) {
            return null;
        }

        TSelectSqlStatement stmt = (TSelectSqlStatement) currentSelectScope.getNode();
        if (stmt.tables == null) {
            return null;
        }

        // Search for a table with matching alias or name
        for (int i = 0; i < stmt.tables.size(); i++) {
            TTable table = stmt.tables.getTable(i);
            if (table == null) continue;

            // Check alias first
            String tableAlias = getTableAlias(table);
            if (tableAlias != null && !tableAlias.isEmpty() &&
                SQLUtil.sameName(dbVendor, ESQLDataObjectType.dotTable, aliasOrName, tableAlias)) {
                return table;
            }

            // Check table name
            String tableName = table.getTableName() != null ? table.getTableName().toString() : null;
            if (tableName != null && SQLUtil.compareIdentifier(dbVendor, ESQLDataObjectType.dotTable, aliasOrName, tableName)) {
                return table;
            }

            // For subqueries without explicit alias, check the full name
            String fullName = table.getFullName();
            if (fullName != null && SQLUtil.compareIdentifier(dbVendor, ESQLDataObjectType.dotTable, aliasOrName, fullName)) {
                return table;
            }
        }

        return null;
    }

    /**
     * Resolve the source namespace for a PIVOT table (Delta 2 - pass-through column resolution).
     *
     * The source namespace is used to resolve pass-through columns that are not
     * part of the PIVOT IN clause (e.g., ADDRESS_ID in "SELECT p.ADDRESS_ID, p.[1] FROM CTE PIVOT(...) p").
     *
     * @param sourceTable The source table of the PIVOT
     * @return The namespace for the source table, or null if not found
     */
    private INamespace resolveSourceNamespaceForPivot(TTable sourceTable) {
        if (sourceTable == null) {
            return null;
        }

        String sourceName = sourceTable.getName();

        // Case 1: Source is a CTE reference. Apply the same Mantis #4412
        // guard so a schema-qualified PIVOT source, or a self-reference
        // inside its own non-recursive CTE definition, falls through to
        // the physical-table branch below.
        CTENamespace cteNamespace = findCTEByName(sourceName);
        if (cteNamespace != null && !shouldTreatAsPhysicalTableNotCTE(sourceTable, cteNamespace)) {
            return cteNamespace;
        }

        // Case 2: Source is a subquery
        if (sourceTable.getSubquery() != null) {
            // Create a SubqueryNamespace for the subquery
            SubqueryNamespace subqueryNs = new SubqueryNamespace(
                sourceTable.getSubquery(),
                getTableAlias(sourceTable),
                nameMatcher
            );
            subqueryNs.validate();
            return subqueryNs;
        }

        // Case 3: Source is a physical table - create TableNamespace
        TableNamespace tableNs = new TableNamespace(sourceTable, nameMatcher, sqlEnv);
        tableNs.validate();
        return tableNs;
    }

    /**
     * Process an UNNEST table expression.
     *
     * UNNEST flattens an array into rows, creating a virtual table:
     * <pre>
     * SELECT value FROM UNNEST(array_column)
     * SELECT element FROM UNNEST(['a', 'b', 'c']) AS element
     * SELECT * FROM UNNEST(array_column) WITH OFFSET
     * </pre>
     *
     * The UNNEST table provides:
     * 1. An implicit column for the unnested elements (named by alias or 'value')
     * 2. Optional WITH OFFSET column for array indices
     * 3. STRUCT field columns when unnesting ARRAY<STRUCT<...>>
     */
    private void processUnnestTable(TTable table) {
        String alias = getTableAlias(table);

        // Create UnnestNamespace
        UnnestNamespace unnestNs = new UnnestNamespace(table, alias, nameMatcher);
        unnestNs.validate();

        // Add to FROM scope
        currentFromScope.addChild(unnestNs, alias, false);
        tableToNamespaceMap.put(table, unnestNs);  // Store for legacy compatibility

        // Process the array expression inside UNNEST to capture correlated references
        // e.g., UNNEST(nested_attribute) - nested_attribute should link to outer table
        TUnnestClause unnestClause = table.getUnnestClause();
        if (unnestClause != null && unnestClause.getArrayExpr() != null) {
            // Visit the array expression to collect column references
            // This will be handled by the expression visitor
            traverseExpressionForColumns(unnestClause.getArrayExpr());
        }

        if (DEBUG_SCOPE_BUILD) {
            System.out.println("[DEBUG] Added UNNEST table to FromScope: alias=" + alias +
                " implicitColumn=" + unnestNs.getImplicitColumnName());
        }
    }

    /**
     * Process a Snowflake stage table reference.
     * Stage tables reference files in storage (e.g., @stage/path/file.parquet).
     * They're treated as tables but without schema metadata - columns are accessed
     * via positional references ($1, $2) or JSON path access ($1:field).
     */
    private void processStageTable(TTable table) {
        String alias = getTableAlias(table);
        String tableName = table.getFullName();

        // Create a TableNamespace for the stage table
        // Stage tables don't have metadata, so we use null for sqlEnv
        TableNamespace stageNs = new TableNamespace(table, nameMatcher, null);
        stageNs.validate();

        // Add to FROM scope
        currentFromScope.addChild(stageNs, alias, false);
        lastProcessedFromTable = table;
        currentJoinChainTables.add(table);  // Track ALL tables in join chain for chained USING
        tableToNamespaceMap.put(table, stageNs);

        if (DEBUG_SCOPE_BUILD) {
            System.out.println("[DEBUG] Added stage table to FromScope: alias=" + alias +
                " tableName=" + tableName);
        }
    }

    /**
     * Process a Teradata TD_UNPIVOT table function.
     * TD_UNPIVOT transforms columns into rows. The columns are created during parsing
     * in TTDUnpivot.doParse() and linked to either the output table (VALUE_COLUMNS,
     * UNPIVOT_COLUMN) or the source table (COLUMN_LIST).
     *
     * This method collects those columns into allColumnReferences as definition columns
     * (they don't need name resolution - their sourceTable is already set).
     *
     * @see gudusoft.gsqlparser.nodes.teradata.TTDUnpivot
     */
    private void processTDUnpivotTable(TTable table) {
        TTDUnpivot tdUnpivot = table.getTdUnpivot();
        if (tdUnpivot == null) {
            return;
        }

        // VALUE_COLUMNS: Output value columns of TD_UNPIVOT
        // These columns are created from string literals and linked to the output table
        TObjectNameList valueColumns = tdUnpivot.getValueColumns();
        if (valueColumns != null) {
            for (int i = 0; i < valueColumns.size(); i++) {
                TObjectName col = valueColumns.getObjectName(i);
                if (col != null) {
                    // Mark as definition column (already has sourceTable set during parsing)
                    unpivotDefinitionColumns.add(col);
                    // Add to output list
                    allColumnReferences.add(col);
                    if (DEBUG_SCOPE_BUILD) {
                        System.out.println("[DEBUG] TD_UNPIVOT valueColumn: " + col.getColumnNameOnly() +
                            " -> " + (col.getSourceTable() != null ? col.getSourceTable().getTableName() : "null"));
                    }
                }
            }
        }

        // UNPIVOT_COLUMN: Output label column of TD_UNPIVOT (contains original column names)
        TObjectNameList unpivotColumns = tdUnpivot.getUnpivotColumns();
        if (unpivotColumns != null) {
            for (int i = 0; i < unpivotColumns.size(); i++) {
                TObjectName col = unpivotColumns.getObjectName(i);
                if (col != null) {
                    // Mark as definition column
                    unpivotDefinitionColumns.add(col);
                    // Add to output list
                    allColumnReferences.add(col);
                    if (DEBUG_SCOPE_BUILD) {
                        System.out.println("[DEBUG] TD_UNPIVOT unpivotColumn: " + col.getColumnNameOnly() +
                            " -> " + (col.getSourceTable() != null ? col.getSourceTable().getTableName() : "null"));
                    }
                }
            }
        }

        // COLUMN_LIST: Source columns being unpivoted
        // These columns are linked to the source table (the table in the ON clause)
        TObjectNameList columnList = tdUnpivot.getColumnList();
        if (columnList != null) {
            for (int i = 0; i < columnList.size(); i++) {
                TObjectName col = columnList.getObjectName(i);
                if (col != null) {
                    // Mark as definition column
                    unpivotDefinitionColumns.add(col);
                    // Add to output list
                    allColumnReferences.add(col);
                    if (DEBUG_SCOPE_BUILD) {
                        System.out.println("[DEBUG] TD_UNPIVOT columnList: " + col.getColumnNameOnly() +
                            " -> " + (col.getSourceTable() != null ? col.getSourceTable().getTableName() : "null"));
                    }
                }
            }
        }
    }

    /**
     * Process a VALUES table (inline data with column aliases).
     * Example: VALUES (1, 'a'), (2, 'b') AS t(id, name)
     * Used in Teradata MERGE: USING VALUES (:empno, :name, :salary) AS s(empno, name, salary)
     */
    private void processValuesTable(TTable table) {
        String alias = getTableAlias(table);

        // Track column name definitions from the alias clause
        // These are column DEFINITIONS, not references - should NOT be collected as column refs
        // e.g., in "VALUES (1, 'a') AS t(id, name)", 'id' and 'name' are definitions
        TAliasClause aliasClause = table.getAliasClause();
        if (aliasClause != null) {
            TObjectNameList columns = aliasClause.getColumns();
            if (columns != null && columns.size() > 0) {
                for (int i = 0; i < columns.size(); i++) {
                    TObjectName colName = columns.getObjectName(i);
                    if (colName != null) {
                        valuesTableAliasColumns.add(colName);
                        if (DEBUG_SCOPE_BUILD) {
                            System.out.println("[DEBUG] Tracked VALUES alias column definition (will skip): " + colName.toString());
                        }
                    }
                }
            }
        }

        // Create ValuesNamespace - columns are extracted from alias clause
        ValuesNamespace valuesNs = new ValuesNamespace(table, alias, nameMatcher);
        valuesNs.validate();

        // Add to FROM scope with the table alias
        currentFromScope.addChild(valuesNs, alias, false);
        tableToNamespaceMap.put(table, valuesNs);  // Store for legacy compatibility
        lastProcessedFromTable = table;
        currentJoinChainTables.add(table);  // Track ALL tables in join chain for chained USING

        if (DEBUG_SCOPE_BUILD) {
            System.out.println("[DEBUG] Added VALUES table to FromScope: alias=" + alias +
                ", columns=" + valuesNs.getAllColumnSources().keySet());
        }
    }

    /**
     * Process a potential CTE reference
     */
    private void processCTEReference(TTable table) {
        String tableName = table.getName();
        CTENamespace cteNamespace = findCTEByName(tableName);

        if (cteNamespace != null) {
            String alias = getTableAlias(table);
            currentFromScope.addChild(cteNamespace, alias, false);
        }
    }

    /**
     * Decide whether a table that name-matches an enclosing CTE should still be
     * treated as a physical table rather than as a CTE reference.
     *
     * <p>Two situations trigger this guard:
     *
     * <ol>
     *   <li>The table reference carries a schema, database, or server prefix
     *       (e.g. {@code ZZZ_DEV.FOTC_BB_PRODUCT_INTER}). CTE names are
     *       unqualified across every supported dialect, so a qualified name
     *       cannot be a CTE reference.</li>
     *   <li>The table appears inside the CTE's own definition and we can be
     *       <em>certain</em> the CTE is non-recursive. Non-recursive CTEs are
     *       not visible to themselves, so a same-named table inside the body
     *       is the underlying physical table, not a self-reference. See
     *       Mantis #4412.</li>
     * </ol>
     *
     * <p>The non-recursive determination is intentionally conservative because
     * {@code TCTE.isRecursive()} is unreliable across dialects:
     * <ul>
     *   <li>BigQuery's grammar accepts {@code WITH RECURSIVE} but never sets
     *       the flag.</li>
     *   <li>PostgreSQL/Snowflake/Redshift/Hive/Teradata only mark
     *       {@code getCTE(0)} as recursive even when {@code WITH RECURSIVE}
     *       applies to the whole list.</li>
     *   <li>SQL Server allows recursive CTEs without any keyword.</li>
     * </ul>
     * To stay safe we treat a CTE as "potentially recursive" — and therefore
     * do not reroute its self-references — whenever any sibling in the same
     * {@code TCTEList} is marked recursive, or whenever the CTE body is a
     * combined query (the typical recursive shape).
     */
    private boolean shouldTreatAsPhysicalTableNotCTE(TTable table, CTENamespace cteNamespace) {
        if (table == null || cteNamespace == null) {
            return false;
        }

        // Case 1: schema/database/server-qualified name cannot match a CTE.
        if (hasSchemaOrDatabaseQualifier(table)) {
            return true;
        }

        // Case 2: definitely-non-recursive CTE self-reference inside its body.
        return isNonRecursiveSelfReference(table, cteNamespace);
    }

    private boolean isNonRecursiveSelfReference(TTable table, CTENamespace cteNamespace) {
        TCTE cte = cteNamespace.getCTE();
        if (cte == null || cte.getSubquery() == null) {
            return false;
        }

        // Don't reroute when there's any sign the CTE could be recursive.
        if (isPotentiallyRecursive(cte)) {
            return false;
        }

        TSelectSqlStatement cteSubquery = cte.getSubquery();
        return gudusoft.gsqlparser.nodes.TParseTreeNode.subNodeInNode(table, cteSubquery);
    }

    /**
     * A CTE is treated as potentially recursive whenever
     * {@link TCTE#isRecursive()} is true on this CTE, on any sibling in the
     * same {@link TCTEList} (covers the
     * "{@code WITH RECURSIVE a AS (...), b AS (...)}" case where dialect
     * grammars mark only the first CTE), or whenever the CTE body is a
     * combined query — the standard recursive shape used by SQL Server,
     * which has no {@code RECURSIVE} keyword.
     */
    private boolean isPotentiallyRecursive(TCTE cte) {
        if (cte == null) {
            return false;
        }
        if (cte.isRecursive()) {
            return true;
        }

        TCTEList list = findEnclosingCTEList(cte);
        if (list != null) {
            for (int i = 0; i < list.size(); i++) {
                TCTE sibling = list.getCTE(i);
                if (sibling != null && sibling.isRecursive()) {
                    return true;
                }
            }
        }

        TSelectSqlStatement body = cte.getSubquery();
        if (body != null && body.isCombinedQuery()) {
            return true;
        }

        return false;
    }

    /**
     * Walk the live scope stack to find the {@link TCTEList} that contains
     * {@code cte}. We avoid using {@link gudusoft.gsqlparser.nodes.TParseTreeNode#getParent()}
     * because TCTE does not always carry a parent pointer back to its list.
     */
    private TCTEList findEnclosingCTEList(TCTE cte) {
        if (cte == null) {
            return null;
        }
        for (int i = scopeStack.size() - 1; i >= 0; i--) {
            IScope scope = scopeStack.get(i);
            if (scope instanceof CTEScope) {
                TCTEList list = ((CTEScope) scope).getCTEList();
                if (list == null) {
                    continue;
                }
                for (int j = 0; j < list.size(); j++) {
                    if (list.getCTE(j) == cte) {
                        return list;
                    }
                }
            }
        }
        return null;
    }

    /**
     * Returns true when the table reference has any non-empty
     * server/database/schema prefix, e.g. {@code db.schema.t} or
     * {@code schema.t}.
     */
    private boolean hasSchemaOrDatabaseQualifier(TTable table) {
        if (table == null) {
            return false;
        }
        String schema = table.getPrefixSchema();
        if (schema != null && !schema.isEmpty()) {
            return true;
        }
        String database = table.getPrefixDatabase();
        if (database != null && !database.isEmpty()) {
            return true;
        }
        String server = table.getPrefixServer();
        if (server != null && !server.isEmpty()) {
            return true;
        }
        return false;
    }

    /**
     * Find a CTE by name in all enclosing CTE scopes
     */
    private CTENamespace findCTEByName(String name) {
        if (name == null) {
            return null;
        }

        // Normalize name by stripping SQL Server bracket delimiters [name] -> name
        String normalizedName = stripBrackets(name);

        // Search through scope stack for CTE scopes
        for (int i = scopeStack.size() - 1; i >= 0; i--) {
            IScope scope = scopeStack.get(i);
            if (scope instanceof CTEScope) {
                CTEScope cteScope = (CTEScope) scope;
                CTENamespace cte = cteScope.getCTE(normalizedName);
                if (cte != null) {
                    return cte;
                }
            }
        }

        return null;
    }

    /**
     * Strip SQL Server bracket delimiters from a name.
     * Converts "[name]" to "name", leaves unbracketed names unchanged.
     */
    private String stripBrackets(String name) {
        if (name == null) {
            return null;
        }
        if (name.startsWith("[") && name.endsWith("]") && name.length() > 2) {
            return name.substring(1, name.length() - 1);
        }
        return name;
    }

    /**
     * Strip string delimiters (double quotes and single quotes) from a constant value.
     * Used for PIVOT IN clause constant values like "HOUSTON" or 'value'.
     * SQL Server brackets are preserved as they're often needed for special names.
     */
    /**
     * The explicit alias of one PIVOT IN-list item, or null when it has none.
     *
     * <p>Delegates to {@link PivotNamespace#inListItemAlias} deliberately: the name
     * a pivot column is published under here and the name
     * {@code PivotNamespace} lets it be resolved by must come from the same code.
     * When they drifted apart, a reference to the real column reported NOT_FOUND
     * while a stale value-derived name still matched.</p>
     */
    private String pivotInItemAlias(TResultColumn resultColumn) {
        return PivotNamespace.inListItemAlias(resultColumn);
    }

    /** Build a pivot-generated output column already bound to the pivot table. */
    private TObjectName newPivotOutputColumn(EDbVendor vendor, String name, TTable pivotTable) {
        TObjectName column = TObjectName.createObjectName(
            vendor, EDbObjectType.column, new TSourceToken(name));
        column.setSourceTable(pivotTable);
        return column;
    }

    /**
     * The name a PIVOT gives to the output column generated by one IN-list value,
     * when the item carries no explicit alias.
     *
     * <p>This is vendor-specific and the difference is not cosmetic. Oracle and
     * Snowflake name the column after the literal <em>as written</em>, quotes
     * included, so {@code FOR metrics IN ('Revenue')} produces a column whose name
     * really is {@code 'Revenue'} and which must later be referenced as
     * {@code "'Revenue'"}. Stripping the quotes there yields a name that matches
     * nothing in the query (Mantis 4662). BigQuery does the opposite — its IN-list
     * values have to form valid identifiers and the generated column is named
     * {@code Revenue} — so the quotes must still be stripped for it, and for every
     * other vendor the previous behaviour is retained.</p>
     *
     * <p>Phase 1 ({@code TPivotInClause.linkColumnToTable}) builds the name from the
     * literal token, so keeping the quotes here makes resolver2 agree with it
     * instead of overwriting it with a different spelling. Delegates to
     * {@link PivotNamespace#inListValueColumnName} so the published name and the
     * resolvable name are produced by one rule.</p>
     */
    private String pivotOutputColumnName(EDbVendor vendor, String rawValue) {
        return PivotNamespace.inListValueColumnName(vendor, rawValue);
    }

    private String stripStringDelimiters(String value) {
        if (value == null || value.isEmpty()) {
            return value;
        }
        // Strip double quotes (BigQuery style identifier)
        if (value.startsWith("\"") && value.endsWith("\"") && value.length() > 2) {
            return value.substring(1, value.length() - 1);
        }
        // Strip single quotes (string literal)
        if (value.startsWith("'") && value.endsWith("'") && value.length() > 2) {
            return value.substring(1, value.length() - 1);
        }
        // SQL Server brackets [] are preserved as they're part of the column identity
        return value;
    }

    /**
     * Get the alias for a table, or the table name if no alias
     */
    private String getTableAlias(TTable table) {
        if (table.getAliasName() != null && !table.getAliasName().isEmpty()) {
            return table.getAliasName();
        }
        return table.getName();
    }

    // ========== JOIN ==========

    @Override
    public void preVisit(TJoinExpr joinExpr) {
        // JOIN expressions are traversed automatically
        // Left and right tables will trigger preVisit(TTable)
        // ON condition columns will trigger preVisit(TObjectName)
        if (DEBUG_SCOPE_BUILD) {
            System.out.println("[DEBUG] preVisit(TJoinExpr): " + joinExpr +
                               ", usingColumns=" + (joinExpr.getUsingColumns() != null ? joinExpr.getUsingColumns().size() : "null") +
                               ", leftTable=" + joinExpr.getLeftTable() +
                               ", rightTable=" + joinExpr.getRightTable() +
                               ", joinChainTables=" + currentJoinChainTables.size());
        }

        // Handle USING columns in TJoinExpr (used when USE_JOINEXPR_INSTEAD_OF_JOIN is true)
        if (joinExpr.getUsingColumns() != null && joinExpr.getUsingColumns().size() > 0) {
            TTable rightTable = joinExpr.getRightTable();

            // For TJoinExpr, the left side may be another TJoinExpr (nested joins) or a single table.
            // We need to collect ALL tables on the left side recursively.
            List<TTable> leftSideTables = collectTablesFromJoinExpr(joinExpr.getLeftTable());

            if (DEBUG_SCOPE_BUILD) {
                System.out.println("[DEBUG] preVisit(TJoinExpr) USING: leftSideTables=" + leftSideTables.size());
                for (TTable t : leftSideTables) {
                    System.out.println("[DEBUG]   - " + t.getFullName());
                }
            }

            if (rightTable != null) {
                currentUsingJoinRightTable = rightTable;
                // USING clause semantic: For chained joins like "t1 JOIN t2 USING (c1) JOIN t3 USING (c2)",
                // the USING column c2 should be linked to ALL tables on the left side (t1 and t2), not just one.
                // This is because the left side of the second join is the result of (t1 JOIN t2).
                for (int i = 0; i < joinExpr.getUsingColumns().size(); i++) {
                    TObjectName usingCol = joinExpr.getUsingColumns().getObjectName(i);
                    if (usingCol != null) {
                        // Create synthetic columns for ALL tables on the left side
                        // The first table gets the original USING column, the rest get clones
                        boolean isFirstTable = true;
                        for (TTable leftTable : leftSideTables) {
                            if (isFirstTable) {
                                // Original USING column -> first left table
                                usingColumnToLeftTable.put(usingCol, leftTable);
                                isFirstTable = false;
                            } else {
                                // Create synthetic column for additional left tables
                                TObjectName chainTableCol = usingCol.clone();
                                chainTableCol.setSourceTable(leftTable);

                                // Add the synthetic chain table column to references
                                if (currentSelectScope != null) {
                                    columnToScopeMap.put(chainTableCol, currentSelectScope);
                                }
                                allColumnReferences.add(chainTableCol);

                                // Track in USING map for resolution
                                usingColumnToLeftTable.put(chainTableCol, leftTable);

                                if (DEBUG_SCOPE_BUILD) {
                                    System.out.println("[DEBUG] Created synthetic USING column for left table: " +
                                                       usingCol.getColumnNameOnly() + " -> " + leftTable.getFullName());
                                }
                            }
                        }

                        // Create a synthetic column reference for the right table
                        // Clone it and set the clone's sourceTable to right table
                        TObjectName rightTableCol = usingCol.clone();
                        rightTableCol.setSourceTable(rightTable);

                        // Add the synthetic right table column to references
                        if (currentSelectScope != null) {
                            columnToScopeMap.put(rightTableCol, currentSelectScope);
                        }
                        allColumnReferences.add(rightTableCol);

                        // ONLY track the synthetic column in USING map for right table resolution
                        usingColumnToRightTable.put(rightTableCol, rightTable);
                    }
                }
            }
        }
    }

    /**
     * Collect all tables from a TTable that might be a join structure.
     * If the table is a join (type=join), recursively collect tables from the join tree.
     * If it's a simple table (objectname), return just that table.
     */
    private List<TTable> collectTablesFromJoinExpr(TTable table) {
        List<TTable> tables = new ArrayList<>();
        if (table == null) {
            return tables;
        }

        if (table.getTableType() == ETableSource.join && table.getJoinExpr() != null) {
            // This is a join structure - recursively collect from both sides
            TJoinExpr joinExpr = table.getJoinExpr();
            tables.addAll(collectTablesFromJoinExpr(joinExpr.getLeftTable()));
            tables.addAll(collectTablesFromJoinExpr(joinExpr.getRightTable()));
        } else {
            // Simple table - add it
            tables.add(table);
        }

        return tables;
    }

    @Override
    public void preVisit(TJoinItem joinItem) {
        // Track the right-side table for JOIN...USING column resolution priority
        // In "a JOIN table2 USING (id)", joinItem.getTable() is table2 (the right side)
        if (DEBUG_SCOPE_BUILD) {
            System.out.println("[DEBUG] preVisit(TJoinItem): " + joinItem +
                               ", usingColumns=" + (joinItem.getUsingColumns() != null ? joinItem.getUsingColumns().size() : "null") +
                               ", lastProcessedFromTable=" + lastProcessedFromTable +
                               ", joinChainTables=" + currentJoinChainTables.size());
        }
        if (joinItem.getUsingColumns() != null && joinItem.getUsingColumns().size() > 0) {
            TTable rightTable = joinItem.getTable();
            TTable leftTable = lastProcessedFromTable;  // The table processed before this JOIN
            if (rightTable != null) {
                currentUsingJoinRightTable = rightTable;
                // USING clause semantic: For chained joins like "t1 JOIN t2 USING (c1) JOIN t3 USING (c2)",
                // the USING column c2 should be linked to ALL tables on the left side (t1 and t2), not just t2.
                // This is because the left side of the second join is the result of (t1 JOIN t2).
                for (int i = 0; i < joinItem.getUsingColumns().size(); i++) {
                    TObjectName usingCol = joinItem.getUsingColumns().getObjectName(i);
                    if (usingCol != null) {
                        // Track original USING column -> immediate left table (for reference only)
                        // This is the primary left table association
                        if (leftTable != null) {
                            usingColumnToLeftTable.put(usingCol, leftTable);
                        }

                        // Create synthetic columns for ALL tables in the join chain (left side of this join)
                        // This ensures that in "t1 JOIN t2 USING (c1) JOIN t3 USING (c2)", column c2
                        // is linked to both t1 and t2, not just t2.
                        for (TTable chainTable : currentJoinChainTables) {
                            if (chainTable != leftTable) {  // Skip leftTable - handled by original usingCol
                                TObjectName chainTableCol = usingCol.clone();
                                chainTableCol.setSourceTable(chainTable);

                                // Add the synthetic chain table column to references
                                if (currentSelectScope != null) {
                                    columnToScopeMap.put(chainTableCol, currentSelectScope);
                                }
                                allColumnReferences.add(chainTableCol);

                                // Track in USING map for resolution
                                usingColumnToLeftTable.put(chainTableCol, chainTable);

                                if (DEBUG_SCOPE_BUILD) {
                                    System.out.println("[DEBUG] Created synthetic USING column for chain table: " +
                                                       usingCol.getColumnNameOnly() + " -> " + chainTable.getFullName());
                                }
                            }
                        }

                        // Create a synthetic column reference for the right table
                        // The original usingCol has sourceTable = left table (set by parser)
                        // Clone it and set the clone's sourceTable to right table
                        TObjectName rightTableCol = usingCol.clone();
                        rightTableCol.setSourceTable(rightTable);

                        // Add the synthetic right table column to references
                        if (currentSelectScope != null) {
                            columnToScopeMap.put(rightTableCol, currentSelectScope);
                        }
                        allColumnReferences.add(rightTableCol);

                        // ONLY track the synthetic column in USING map for right table resolution
                        // Do NOT add the original usingCol - it should keep its left table resolution
                        usingColumnToRightTable.put(rightTableCol, rightTable);
                    }
                }
            }
        }
    }

    @Override
    public void postVisit(TJoinItem joinItem) {
        // Clear the current USING join right table after processing
        if (joinItem.getUsingColumns() != null && joinItem.getUsingColumns().size() > 0) {
            currentUsingJoinRightTable = null;
        }
    }

    // ========== Expressions ==========

    @Override
    public void preVisit(TExpression expression) {
        // Handle function expressions (type function_t) - the visitor may not automatically
        // traverse to getFunctionCall() and its arguments
        if (expression.getExpressionType() == EExpressionType.function_t &&
            expression.getFunctionCall() != null) {
            TFunctionCall func = expression.getFunctionCall();

            // Handle STRUCT and similar functions that store field values in getFieldValues()
            if (func.getFieldValues() != null && func.getFieldValues().size() > 0) {
                for (int i = 0; i < func.getFieldValues().size(); i++) {
                    TResultColumn fieldValue = func.getFieldValues().getResultColumn(i);
                    if (fieldValue != null && fieldValue.getExpr() != null) {
                        traverseExpressionForColumns(fieldValue.getExpr());
                    }
                }
            }

            // Handle regular functions with getArgs() (e.g., TO_JSON_STRING, ARRAY_LENGTH, etc.)
            if (func.getArgs() != null && func.getArgs().size() > 0) {
                for (int i = 0; i < func.getArgs().size(); i++) {
                    TExpression argExpr = func.getArgs().getExpression(i);
                    if (argExpr != null) {
                        traverseExpressionForColumns(argExpr);
                    }
                }
            }

            // Handle special function expressions (CAST, CONVERT, EXTRACT, etc.)
            // These functions store their arguments in expr1/expr2/expr3 instead of args
            if (func.getExpr1() != null) {
                traverseExpressionForColumns(func.getExpr1());
            }
            if (func.getExpr2() != null) {
                traverseExpressionForColumns(func.getExpr2());
            }
            if (func.getExpr3() != null) {
                traverseExpressionForColumns(func.getExpr3());
            }
        }

        // Handle array expressions - objectOperand contains the column reference
        if (expression.getExpressionType() == EExpressionType.array_t &&
            expression.getObjectOperand() != null) {
            preVisit(expression.getObjectOperand());
        }

        // Handle array access expressions (e.g., str2['ptype'] in SparkSQL/Hive)
        // The column reference is in the LeftOperand
        if (expression.getExpressionType() == EExpressionType.array_access_expr_t) {
            if (expression.getLeftOperand() != null) {
                traverseExpressionForColumns(expression.getLeftOperand());
            }
        }

        // Handle CASE expressions - traverse all sub-expressions to collect column references
        if (expression.getExpressionType() == EExpressionType.case_t &&
            expression.getCaseExpression() != null) {
            if (DEBUG_SCOPE_BUILD) {
                System.out.println("[DEBUG] preVisit(TExpression): Found CASE expression, currentSelectScope=" +
                    (currentSelectScope != null ? "set" : "null"));
            }
            traverseExpressionForColumns(expression);
        }

        // Handle lambda expressions - mark parameters as NOT column references
        // Lambda parameters are local function parameters, not table column references
        // e.g., in "aggregate(array, 0, (acc, x) -> acc + x)", acc and x are lambda parameters
        if (expression.getExpressionType() == EExpressionType.lambda_t) {
            TExpression paramExpr = expression.getLeftOperand();
            TExpression bodyExpr = expression.getRightOperand();
            if (paramExpr != null) {
                // Collect parameter names first
                Set<String> paramNames = new HashSet<>();
                collectLambdaParameterNames(paramExpr, paramNames);

                // Push parameter names onto the stack for use in preVisit(TObjectName)
                lambdaParameterStack.push(paramNames);

                // Mark the parameter definition TObjectNames
                collectLambdaParameterObjects(paramExpr);

                // Mark all usages in the body that match parameter names
                if (bodyExpr != null && !paramNames.isEmpty()) {
                    markLambdaParameterUsages(bodyExpr, paramNames);
                }
            }
        }

        // Handle typecast expressions - the visitor may not automatically traverse the left operand
        // e.g., for "$1:apMac::string", we need to traverse "$1:apMac" to collect the column reference
        if (expression.getExpressionType() == EExpressionType.typecast_t) {
            if (expression.getLeftOperand() != null) {
                traverseExpressionForColumns(expression.getLeftOperand());
            }
        }

        // Handle named argument expressions (e.g., "INPUT => value" in Snowflake FLATTEN)
        // The left operand is the parameter name, NOT a column reference.
        // Mark it with ttobjNamedArgParameter objectType so all downstream consumers skip it.
        if (expression.getExpressionType() == EExpressionType.assignment_t) {
            TExpression leftOp = expression.getLeftOperand();
            if (leftOp != null &&
                leftOp.getExpressionType() == EExpressionType.simple_object_name_t &&
                leftOp.getObjectOperand() != null) {
                TObjectName paramName = leftOp.getObjectOperand();
                // Set the objectType to mark this as a named argument parameter
                // This marking persists on the AST node and will be respected by
                // all downstream consumers (resolver, data lineage analyzer, etc.)
                paramName.setObjectType(TObjectName.ttobjNamedArgParameter);
                namedArgumentParameters.add(paramName);
                if (DEBUG_SCOPE_BUILD) {
                    System.out.println("[DEBUG] Marked named argument parameter: " +
                        paramName.toString() + " with objectType=" + TObjectName.ttobjNamedArgParameter);
                }
            }
        }
    }

    @Override
    public void postVisit(TExpression expression) {
        // Pop lambda parameter context when exiting a lambda expression
        if (expression.getExpressionType() == EExpressionType.lambda_t) {
            TExpression paramExpr = expression.getLeftOperand();
            if (paramExpr != null && !lambdaParameterStack.isEmpty()) {
                lambdaParameterStack.pop();
            }
        }
    }

    /**
     * Recursively collect lambda parameter NAMES as strings.
     */
    private void collectLambdaParameterNames(TExpression paramExpr, Set<String> paramNames) {
        if (paramExpr == null) return;

        // Single parameter: expression has objectOperand
        if (paramExpr.getObjectOperand() != null) {
            String name = paramExpr.getObjectOperand().toString();
            if (name != null && !name.isEmpty()) {
                paramNames.add(name.toLowerCase());
            }
            return;
        }

        // Multiple parameters: expression has exprList
        if (paramExpr.getExprList() != null) {
            for (int i = 0; i < paramExpr.getExprList().size(); i++) {
                TExpression e = paramExpr.getExprList().getExpression(i);
                collectLambdaParameterNames(e, paramNames);
            }
        }
    }

    /**
     * Recursively collect all TObjectName nodes from lambda parameter definitions.
     */
    private void collectLambdaParameterObjects(TExpression paramExpr) {
        if (paramExpr == null) return;

        if (paramExpr.getObjectOperand() != null) {
            lambdaParameters.add(paramExpr.getObjectOperand());
            return;
        }

        if (paramExpr.getExprList() != null) {
            for (int i = 0; i < paramExpr.getExprList().size(); i++) {
                TExpression e = paramExpr.getExprList().getExpression(i);
                collectLambdaParameterObjects(e);
            }
        }
    }

    /**
     * Recursively find and mark all TObjectName usages in a lambda body that match parameter names.
     */
    private void markLambdaParameterUsages(TExpression bodyExpr, Set<String> paramNames) {
        if (bodyExpr == null) return;

        // Use iterative DFS to avoid StackOverflowError for deeply nested expression chains
        Deque<TExpression> stack = new ArrayDeque<>();
        stack.push(bodyExpr);
        while (!stack.isEmpty()) {
            TExpression current = stack.pop();
            if (current == null) continue;

            // Check if this expression is a simple column reference matching a parameter name
            if (current.getObjectOperand() != null) {
                TObjectName objName = current.getObjectOperand();
                String name = objName.toString();
                if (name != null && paramNames.contains(name.toLowerCase())) {
                    lambdaParameters.add(objName);
                }
            }

            // Push sub-expressions onto stack (right first so left is processed first)
            if (current.getRightOperand() != null) {
                stack.push(current.getRightOperand());
            }
            if (current.getLeftOperand() != null) {
                stack.push(current.getLeftOperand());
            }
            if (current.getExprList() != null) {
                for (int i = current.getExprList().size() - 1; i >= 0; i--) {
                    stack.push(current.getExprList().getExpression(i));
                }
            }

            // Handle CASE expressions
            if (current.getCaseExpression() != null) {
                TCaseExpression caseExpr = current.getCaseExpression();
                if (caseExpr.getElse_expr() != null) {
                    stack.push(caseExpr.getElse_expr());
                }
                if (caseExpr.getWhenClauseItemList() != null) {
                    for (int i = caseExpr.getWhenClauseItemList().size() - 1; i >= 0; i--) {
                        TWhenClauseItem item = caseExpr.getWhenClauseItemList().getWhenClauseItem(i);
                        if (item.getReturn_expr() != null) {
                            stack.push(item.getReturn_expr());
                        }
                        if (item.getComparison_expr() != null) {
                            stack.push(item.getComparison_expr());
                        }
                    }
                }
                if (caseExpr.getInput_expr() != null) {
                    stack.push(caseExpr.getInput_expr());
                }
            }

            // Handle function calls
            if (current.getFunctionCall() != null) {
                TFunctionCall func = current.getFunctionCall();
                if (func.getArgs() != null) {
                    for (int i = func.getArgs().size() - 1; i >= 0; i--) {
                        stack.push(func.getArgs().getExpression(i));
                    }
                }
            }
        }
    }

    // ========== Function Calls ==========

    @Override
    public void preVisit(TFunctionCall functionCall) {
        // Handle SQL Server UPDATE() function in trigger context
        // UPDATE(column_name) is used in triggers to check if a column was updated
        // The column argument should be resolved to the trigger target table
        if ((dbVendor == EDbVendor.dbvmssql || dbVendor == EDbVendor.dbvazuresql) &&
            currentTriggerTargetTable != null &&
            functionCall.getFunctionName() != null) {
            String funcName = functionCall.getFunctionName().toString();
            if ("update".equalsIgnoreCase(funcName) || "columns_updated".equalsIgnoreCase(funcName)) {
                // UPDATE(column) - link the column argument to trigger target table
                if (functionCall.getArgs() != null && functionCall.getArgs().size() == 1) {
                    TExpression argExpr = functionCall.getArgs().getExpression(0);
                    if (argExpr != null && argExpr.getObjectOperand() != null) {
                        TObjectName columnName = argExpr.getObjectOperand();
                        columnName.setSourceTable(currentTriggerTargetTable);

                        // Add to allColumnReferences if not already there
                        if (!allColumnReferences.contains(columnName)) {
                            allColumnReferences.add(columnName);
                        }

                        // Map the column to the current scope
                        IScope currentScope = scopeStack.isEmpty() ? globalScope : scopeStack.peek();
                        columnToScopeMap.put(columnName, currentScope);

                        if (DEBUG_SCOPE_BUILD) {
                            System.out.println("[DEBUG] preVisit(TFunctionCall/update): " +
                                columnName + " -> " + currentTriggerTargetTable.getFullName());
                        }
                    }
                }
            }
        }

        // Mark keyword arguments in built-in functions so they are not treated as column references.
        // For example, SECOND in TIMESTAMP_DIFF(ts1, ts2, SECOND) should not be collected as a column.
        // We do this in preVisit because TObjectName nodes are visited after TFunctionCall.
        markFunctionKeywordArguments(functionCall);

        // Handle special functions like STRUCT that store field values in getFieldValues()
        // instead of getArgs(). The visitor pattern may not automatically traverse these.
        if (functionCall.getFieldValues() != null && functionCall.getFieldValues().size() > 0) {
            // STRUCT and similar functions - traverse the field values to collect column references
            for (int i = 0; i < functionCall.getFieldValues().size(); i++) {
                TResultColumn fieldValue = functionCall.getFieldValues().getResultColumn(i);
                if (fieldValue != null && fieldValue.getExpr() != null) {
                    // Manually traverse the field value expression
                    traverseExpressionForColumns(fieldValue.getExpr());
                }
            }
        }

        // Handle special function expressions (CAST, CONVERT, EXTRACT, etc.)
        // These functions store their arguments in expr1/expr2/expr3 instead of args
        // The visitor pattern may not automatically traverse these expressions.
        if (functionCall.getExpr1() != null) {
            traverseExpressionForColumns(functionCall.getExpr1());
        }
        if (functionCall.getExpr2() != null) {
            traverseExpressionForColumns(functionCall.getExpr2());
        }
        if (functionCall.getExpr3() != null) {
            traverseExpressionForColumns(functionCall.getExpr3());
        }

        // Handle XML functions that store their arguments in special properties
        // These functions don't use getArgs() but have dedicated value expression lists
        // XMLELEMENT: getXMLElementValueExprList() contains the value expressions
        // XMLFOREST: getXMLForestValueList() contains the value expressions
        // XMLQUERY/XMLEXISTS: getXmlPassingClause().getPassingList() contains column refs
        // XMLAttributes: getXMLAttributesClause().getValueExprList() contains attributes
        if (functionCall.getXMLElementValueExprList() != null) {
            TResultColumnList xmlValueList = functionCall.getXMLElementValueExprList();
            for (int i = 0; i < xmlValueList.size(); i++) {
                TResultColumn rc = xmlValueList.getResultColumn(i);
                if (rc != null && rc.getExpr() != null) {
                    traverseExpressionForColumns(rc.getExpr());
                }
            }
        }
        if (functionCall.getXMLForestValueList() != null) {
            TResultColumnList xmlForestList = functionCall.getXMLForestValueList();
            for (int i = 0; i < xmlForestList.size(); i++) {
                TResultColumn rc = xmlForestList.getResultColumn(i);
                if (rc != null && rc.getExpr() != null) {
                    traverseExpressionForColumns(rc.getExpr());
                }
            }
        }
        if (functionCall.getXmlPassingClause() != null &&
            functionCall.getXmlPassingClause().getPassingList() != null) {
            TResultColumnList passingList = functionCall.getXmlPassingClause().getPassingList();
            for (int i = 0; i < passingList.size(); i++) {
                TResultColumn rc = passingList.getResultColumn(i);
                if (rc != null && rc.getExpr() != null) {
                    traverseExpressionForColumns(rc.getExpr());
                }
            }
        }
        if (functionCall.getXMLAttributesClause() != null &&
            functionCall.getXMLAttributesClause().getValueExprList() != null) {
            TResultColumnList attrList = functionCall.getXMLAttributesClause().getValueExprList();
            for (int i = 0; i < attrList.size(); i++) {
                TResultColumn rc = attrList.getResultColumn(i);
                if (rc != null && rc.getExpr() != null) {
                    traverseExpressionForColumns(rc.getExpr());
                }
            }
        }
        // Handle XMLCAST/XMLQUERY typeExpression - stores the inner expression to cast
        // For XMLCAST(expr AS type), the expr is stored in typeExpression
        if (functionCall.getTypeExpression() != null) {
            traverseExpressionForColumns(functionCall.getTypeExpression());
        }

        // Skip if this is a table-valued function (from FROM clause)
        // Table functions like [exce].[sampleTable]() should not be treated as column.method()
        if (tableValuedFunctionCalls.contains(functionCall)) {
            return;
        }

        // Handle OGC/spatial/CLR method calls on columns (SQL Server specific)
        // These can be in two forms:
        // 1. table.column.method() - 3-part name where:
        //    - databaseToken = table alias (e.g., "ad")
        //    - schemaToken = column name (e.g., "SpatialLocation")
        //    - objectToken = method name (e.g., "STDistance")
        //
        // 2. column.method() - 2-part name where:
        //    - schemaToken = column name (e.g., "SpatialLocation")
        //    - objectToken = method name (e.g., "STDistance")
        //    - databaseToken = null
        //    In this case, if there's only one table in FROM, infer the column belongs to it
        //
        // NOTE: This is SQL Server specific because Oracle uses schema.function() syntax
        // for package calls (e.g., DBMS_OUTPUT.PUT_LINE, ERRLOG.LOAD_ERR_DTL).
        //
        // NOTE: We must skip static type methods like "geography::STGeomFromText()"
        // These use the :: syntax and the "schemaToken" is actually a type name, not a column.
        //
        // We extract the column reference and link it to the source table
        // Only apply column method handling for SQL Server (not Oracle, etc.)
        if (dbVendor == EDbVendor.dbvmssql || dbVendor == EDbVendor.dbvazuresql) {
            TObjectName funcName = functionCall.getFunctionName();

            if (DEBUG_SCOPE_BUILD) {
                System.out.println("[DEBUG] preVisit(TFunctionCall): " + functionCall);
                System.out.println("[DEBUG]   funcName: " + funcName);
                if (funcName != null) {
                    System.out.println("[DEBUG]   schemaToken: " + funcName.getSchemaToken());
                    System.out.println("[DEBUG]   databaseToken: " + funcName.getDatabaseToken());
                    System.out.println("[DEBUG]   objectToken: " + funcName.getObjectToken());
                    System.out.println("[DEBUG]   currentFromScope: " + (currentFromScope != null ? "exists" : "null"));
                }
            }

            if (funcName != null) {
                String funcNameStr = funcName.toString();

                // Skip static type methods like "geography::STGeomFromText()"
                // These are identified by the "::" in the function name string
                if (funcNameStr != null && funcNameStr.contains("::")) {
                    if (DEBUG_SCOPE_BUILD) {
                        System.out.println("[DEBUG]   Skipping static type method: " + funcNameStr);
                    }
                    return; // Don't process static type methods as column references
                }

                if (funcName.getSchemaToken() != null) {
                    // schemaToken might be a column name (column.method()) or a schema name (schema.function())
                    // We distinguish by:
                    // 1. First checking SQLEnv if the full function name exists as a registered function
                    // 2. Then checking if the first part is a known SQL Server system schema name
                    String possibleColumnOrSchema = funcName.getSchemaToken().toString();

                    // Check SQLEnv first - if the function is registered, this is schema.function()
                    // This handles user-defined functions with custom schema names (e.g., dbo1.ufnGetInventoryStock)
                    if (sqlEnv != null && sqlEnv.searchFunction(funcNameStr) != null) {
                        if (DEBUG_SCOPE_BUILD) {
                            System.out.println("[DEBUG]   Skipping schema.function() call (found in SQLEnv): " + funcNameStr);
                        }
                        return; // Don't treat as column.method()
                    }

                    // Also check for known SQL Server system schema names as a fallback
                    // (for functions not explicitly created in this batch but are system/built-in)
                    if (isSqlServerSchemaName(possibleColumnOrSchema)) {
                        if (DEBUG_SCOPE_BUILD) {
                            System.out.println("[DEBUG]   Skipping schema.function() call (system schema): " + funcNameStr);
                        }
                        return; // Don't treat as column.method()
                    }

                    if (funcName.getDatabaseToken() != null) {
                        // Case 1: 3-part name (table.column.method)
                        String tableAlias = funcName.getDatabaseToken().toString();
                        if (DEBUG_SCOPE_BUILD) {
                            System.out.println("[DEBUG]   Detected 3-part name: " + tableAlias + "." + possibleColumnOrSchema + ".method");
                        }
                        handleMethodCallOnColumn(tableAlias, possibleColumnOrSchema);
                    } else if (currentFromScope != null) {
                        // Case 2: 2-part name (column.method) with schemaToken set
                        if (DEBUG_SCOPE_BUILD) {
                            System.out.println("[DEBUG]   Detected 2-part name (schemaToken): " + possibleColumnOrSchema + ".method");
                        }
                        handleUnqualifiedMethodCall(possibleColumnOrSchema);
                    }
                } else if (funcNameStr != null && funcNameStr.contains(".") && currentFromScope != null) {
                    // Alternative case: function name contains dots but schemaToken is null
                    // This happens in UPDATE SET clause: Location.SetXY(...)
                    // Or in SELECT with 3-part names: p.Demographics.value(...)
                    //
                    // We need to distinguish between:
                    // - 2-part: column.method() - first part is a column name
                    // - 3-part: table.column.method() - first part is a table alias
                    //
                    // We check if the first part matches a table alias in the current FROM scope
                    int firstDotPos = funcNameStr.indexOf('.');
                    if (firstDotPos > 0) {
                        String firstPart = funcNameStr.substring(0, firstDotPos);
                        String remainder = funcNameStr.substring(firstDotPos + 1);

                        // Check if first part is a table alias
                        boolean firstPartIsTable = false;
                        for (ScopeChild child : currentFromScope.getChildren()) {
                            if (nameMatcher.matches(child.getAlias(), firstPart)) {
                                firstPartIsTable = true;
                                break;
                            }
                        }

                        if (firstPartIsTable) {
                            // 3-part name: table.column.method()
                            // Extract column name from remainder (before the next dot, if any)
                            int secondDotPos = remainder.indexOf('.');
                            if (secondDotPos > 0) {
                                String columnName = remainder.substring(0, secondDotPos);
                                if (DEBUG_SCOPE_BUILD) {
                                    System.out.println("[DEBUG]   Detected 3-part name (parsed): " + firstPart + "." + columnName + ".method");
                                }
                                handleMethodCallOnColumn(firstPart, columnName);
                            }
                            // If no second dot, the structure is ambiguous (table.method?) - skip it
                        } else {
                            // 2-part name: column.method()
                            if (DEBUG_SCOPE_BUILD) {
                                System.out.println("[DEBUG]   Detected 2-part name (parsed): " + firstPart + ".method");
                            }
                            handleUnqualifiedMethodCall(firstPart);
                        }
                    }
                }
            }
        }
    }

    /**
     * Mark keyword arguments in a function call so they are not treated as column references.
     * Uses TBuiltFunctionUtil to check which argument positions contain keywords.
     */
    private void markFunctionKeywordArguments(TFunctionCall functionCall) {
        if (functionCall.getArgs() == null || functionCall.getArgs().size() == 0) {
            return;
        }
        if (functionCall.getFunctionName() == null) {
            return;
        }

        String functionName = functionCall.getFunctionName().toString();
        Set<Integer> keywordPositions = TBuiltFunctionUtil.argumentsIncludeKeyword(dbVendor, functionName);

        if (keywordPositions == null || keywordPositions.isEmpty()) {
            return;
        }

        TExpressionList args = functionCall.getArgs();
        for (Integer pos : keywordPositions) {
            int index = pos - 1; // TBuiltFunctionUtil uses 1-based positions
            if (index >= 0 && index < args.size()) {
                TExpression argExpr = args.getExpression(index);
                // Mark the objectOperand if it's a simple object name or constant
                if (argExpr != null) {
                    TObjectName objectName = argExpr.getObjectOperand();
                    if (objectName != null) {
                        functionKeywordArguments.add(objectName);
                        if (DEBUG_SCOPE_BUILD) {
                            System.out.println("[DEBUG] Marked function keyword argument: " +
                                objectName.toString() + " at position " + pos +
                                " in function " + functionName);
                        }
                    }
                }
            }
        }
    }

    /**
     * Handle a qualified method call on a column: table.column.method()
     * Creates a synthetic column reference and links it to the source table.
     *
     * @param tableAlias the table alias or name
     * @param columnName the column name
     */
    private void handleMethodCallOnColumn(String tableAlias, String columnName) {
        if (currentFromScope == null) {
            return;
        }

        for (ScopeChild child : currentFromScope.getChildren()) {
            if (nameMatcher.matches(child.getAlias(), tableAlias)) {
                // Found matching table - create column reference
                createAndRegisterColumnReference(tableAlias, columnName, child);
                break;
            }
        }
    }

    /**
     * Handle an unqualified method call on a column: column.method()
     * Attempts to infer the table when there's only one table in FROM,
     * or when the column name uniquely identifies the source table.
     *
     * @param columnName the column name
     */
    private void handleUnqualifiedMethodCall(String columnName) {
        if (currentFromScope == null) {
            return;
        }

        List<ScopeChild> children = currentFromScope.getChildren();

        // Case 1: Only one table in FROM - column must belong to it
        if (children.size() == 1) {
            ScopeChild child = children.get(0);
            createAndRegisterColumnReference(child.getAlias(), columnName, child);
            return;
        }

        // Case 2: Multiple tables - try to find which table has this column
        // This requires metadata from TableNamespace or SQLEnv
        ScopeChild matchedChild = null;
        int matchCount = 0;

        for (ScopeChild child : children) {
            INamespace ns = child.getNamespace();
            if (ns != null) {
                // Check if this namespace has the column
                ColumnLevel level = ns.hasColumn(columnName);
                if (level == ColumnLevel.EXISTS) {
                    matchedChild = child;
                    matchCount++;
                } else if (level == ColumnLevel.MAYBE && matchedChild == null) {
                    // MAYBE means the table has no metadata, so column might exist
                    // Only use as fallback if no definite match found
                    matchedChild = child;
                }
            }
        }

        // If exactly one table definitely has the column, use it
        // If no definite match but one MAYBE, use that as fallback
        if (matchedChild != null && (matchCount <= 1)) {
            createAndRegisterColumnReference(matchedChild.getAlias(), columnName, matchedChild);
        }
    }

    /**
     * Create and register a synthetic column reference for a method call on a column.
     *
     * @param tableAlias the table alias or name
     * @param columnName the column name
     * @param scopeChild the ScopeChild containing the namespace
     */
    private void createAndRegisterColumnReference(String tableAlias, String columnName, ScopeChild scopeChild) {
        // Create TObjectName with proper tokens for table.column
        // Use TObjectName.createObjectName() which properly initializes objectToken and partToken
        TSourceToken tableToken = new TSourceToken(tableAlias);
        TSourceToken columnToken = new TSourceToken(columnName);
        TObjectName columnRef = TObjectName.createObjectName(
            dbVendor,
            EDbObjectType.column,
            tableToken,
            columnToken
        );

        // Get the TTable from the namespace
        INamespace ns = scopeChild.getNamespace();
        TTable sourceTable = null;
        if (ns instanceof TableNamespace) {
            sourceTable = ((TableNamespace) ns).getTable();
        } else if (ns instanceof CTENamespace) {
            sourceTable = ((CTENamespace) ns).getReferencingTable();
        } else if (ns != null) {
            // For other namespace types (SubqueryNamespace, etc.), try getFinalTable()
            sourceTable = ns.getFinalTable();
        }

        if (sourceTable != null) {
            columnRef.setSourceTable(sourceTable);
        }

        // Determine the scope for this column
        IScope columnScope = determineColumnScope(columnRef);
        if (columnScope != null) {
            columnToScopeMap.put(columnRef, columnScope);
        }
        allColumnReferences.add(columnRef);

        if (DEBUG_SCOPE_BUILD) {
            System.out.println("[DEBUG] Created synthetic column reference for method call: " +
                    tableAlias + "." + columnName + " -> " +
                    (sourceTable != null ? sourceTable.getFullName() : "unknown"));
        }
    }

    /**
     * Traverse an expression to collect column references.
     * Uses iterative left-chain descent for pure binary expression chains
     * to avoid StackOverflowError for deeply nested AND/OR/arithmetic chains.
     */
    private void traverseExpressionForColumns(TExpression expr) {
        if (expr == null) return;

        // For pure binary expression chains (AND/OR/arithmetic), use iterative descent
        // to avoid StackOverflowError. Binary expressions don't have objectOperand,
        // functionCall, exprList, subQuery, or caseExpression - only left/right operands.
        if (TExpression.isPureBinaryForDoParse(expr.getExpressionType())) {
            Deque<TExpression> rightChildren = new ArrayDeque<>();
            TExpression current = expr;
            while (current != null && TExpression.isPureBinaryForDoParse(current.getExpressionType())) {
                if (current.getRightOperand() != null) {
                    rightChildren.push(current.getRightOperand());
                }
                current = current.getLeftOperand();
            }
            // Process leftmost leaf (not a pure binary type, safe to recurse)
            if (current != null) {
                traverseExpressionForColumns(current);
            }
            // Process right children bottom-up (preserves left-to-right order)
            while (!rightChildren.isEmpty()) {
                traverseExpressionForColumns(rightChildren.pop());
            }
            return;
        }

        // Handle lambda expressions - push parameter names before traversing body
        boolean isLambda = (expr.getExpressionType() == EExpressionType.lambda_t);
        if (isLambda && expr.getLeftOperand() != null) {
            Set<String> paramNames = new HashSet<>();
            collectLambdaParameterNames(expr.getLeftOperand(), paramNames);
            lambdaParameterStack.push(paramNames);
            // Also collect the parameter objects
            collectLambdaParameterObjects(expr.getLeftOperand());
        }

        // Check for column reference in objectOperand (common in array access, simple names)
        // Skip constants (e.g., DAY in DATEDIFF(DAY, ...) is parsed as simple_constant_t)
        if (expr.getObjectOperand() != null &&
            expr.getExpressionType() != EExpressionType.simple_constant_t) {
            if (DEBUG_SCOPE_BUILD) {
                System.out.println("[DEBUG] traverseExpressionForColumns: Found objectOperand=" +
                    expr.getObjectOperand().toString() + " in expr type=" + expr.getExpressionType());
            }
            // This will trigger preVisit(TObjectName) if not a table reference
            preVisit(expr.getObjectOperand());
        }

        // Traverse sub-expressions
        // For assignment_t expressions (named arguments like "INPUT => value" in Snowflake FLATTEN),
        // the left operand is the parameter name, NOT a column reference.
        // Only traverse the right operand (the value) for assignment_t expressions.
        boolean isNamedArgument = (expr.getExpressionType() == EExpressionType.assignment_t);
        if (expr.getLeftOperand() != null && !isNamedArgument) {
            traverseExpressionForColumns(expr.getLeftOperand());
        }
        if (expr.getRightOperand() != null) {
            traverseExpressionForColumns(expr.getRightOperand());
        }

        // Pop lambda parameter context after traversing
        if (isLambda && expr.getLeftOperand() != null && !lambdaParameterStack.isEmpty()) {
            lambdaParameterStack.pop();
        }

        // Traverse function call arguments
        if (expr.getFunctionCall() != null) {
            TFunctionCall func = expr.getFunctionCall();
            if (func.getArgs() != null) {
                for (int i = 0; i < func.getArgs().size(); i++) {
                    traverseExpressionForColumns(func.getArgs().getExpression(i));
                }
            }
            // Handle STRUCT field values recursively
            if (func.getFieldValues() != null) {
                for (int i = 0; i < func.getFieldValues().size(); i++) {
                    TResultColumn rc = func.getFieldValues().getResultColumn(i);
                    if (rc != null && rc.getExpr() != null) {
                        traverseExpressionForColumns(rc.getExpr());
                    }
                }
            }
            // Handle special function expressions (CAST, CONVERT, EXTRACT, etc.)
            // These functions store their arguments in expr1/expr2/expr3 instead of args
            if (func.getExpr1() != null) {
                traverseExpressionForColumns(func.getExpr1());
            }
            if (func.getExpr2() != null) {
                traverseExpressionForColumns(func.getExpr2());
            }
            if (func.getExpr3() != null) {
                traverseExpressionForColumns(func.getExpr3());
            }
            // Handle XML functions that store their arguments in special properties
            if (func.getXMLElementValueExprList() != null) {
                TResultColumnList xmlValueList = func.getXMLElementValueExprList();
                for (int j = 0; j < xmlValueList.size(); j++) {
                    TResultColumn rc = xmlValueList.getResultColumn(j);
                    if (rc != null && rc.getExpr() != null) {
                        traverseExpressionForColumns(rc.getExpr());
                    }
                }
            }
            if (func.getXMLForestValueList() != null) {
                TResultColumnList xmlForestList = func.getXMLForestValueList();
                for (int j = 0; j < xmlForestList.size(); j++) {
                    TResultColumn rc = xmlForestList.getResultColumn(j);
                    if (rc != null && rc.getExpr() != null) {
                        traverseExpressionForColumns(rc.getExpr());
                    }
                }
            }
            if (func.getXmlPassingClause() != null &&
                func.getXmlPassingClause().getPassingList() != null) {
                TResultColumnList passingList = func.getXmlPassingClause().getPassingList();
                for (int j = 0; j < passingList.size(); j++) {
                    TResultColumn rc = passingList.getResultColumn(j);
                    if (rc != null && rc.getExpr() != null) {
                        traverseExpressionForColumns(rc.getExpr());
                    }
                }
            }
            if (func.getXMLAttributesClause() != null &&
                func.getXMLAttributesClause().getValueExprList() != null) {
                TResultColumnList attrList = func.getXMLAttributesClause().getValueExprList();
                for (int j = 0; j < attrList.size(); j++) {
                    TResultColumn rc = attrList.getResultColumn(j);
                    if (rc != null && rc.getExpr() != null) {
                        traverseExpressionForColumns(rc.getExpr());
                    }
                }
            }
            // Handle XMLCAST typeExpression
            if (func.getTypeExpression() != null) {
                traverseExpressionForColumns(func.getTypeExpression());
            }
        }

        // Traverse expression list (e.g., IN clause)
        if (expr.getExprList() != null) {
            for (int i = 0; i < expr.getExprList().size(); i++) {
                traverseExpressionForColumns(expr.getExprList().getExpression(i));
            }
        }

        // Traverse subquery if present
        if (expr.getSubQuery() != null) {
            expr.getSubQuery().acceptChildren(this);
        }

        // Traverse CASE expression
        if (expr.getExpressionType() == EExpressionType.case_t && expr.getCaseExpression() != null) {
            TCaseExpression caseExpr = expr.getCaseExpression();

            // Traverse input expression (for simple CASE: CASE input_expr WHEN ...)
            if (caseExpr.getInput_expr() != null) {
                traverseExpressionForColumns(caseExpr.getInput_expr());
            }

            // Traverse each WHEN...THEN clause
            if (caseExpr.getWhenClauseItemList() != null) {
                for (int i = 0; i < caseExpr.getWhenClauseItemList().size(); i++) {
                    TWhenClauseItem whenItem = caseExpr.getWhenClauseItemList().getWhenClauseItem(i);
                    if (whenItem != null) {
                        // Traverse WHEN condition
                        if (whenItem.getComparison_expr() != null) {
                            traverseExpressionForColumns(whenItem.getComparison_expr());
                        }
                        // Traverse PostgreSQL condition list
                        if (whenItem.getConditionList() != null) {
                            for (int j = 0; j < whenItem.getConditionList().size(); j++) {
                                traverseExpressionForColumns(whenItem.getConditionList().getExpression(j));
                            }
                        }
                        // Traverse THEN result
                        if (whenItem.getReturn_expr() != null) {
                            traverseExpressionForColumns(whenItem.getReturn_expr());
                        }
                    }
                }
            }

            // Traverse ELSE expression
            if (caseExpr.getElse_expr() != null) {
                traverseExpressionForColumns(caseExpr.getElse_expr());
            }
        }
    }

    // ========== Result Columns ==========

    @Override
    public void preVisit(TResultColumn resultColumn) {
        // Mark that we're inside a result column context.
        // Lateral alias matching should ONLY apply inside result columns.
        inResultColumnContext = true;

        // Track the current result column's alias to exclude from lateral alias matching.
        // A column reference inside the expression that DEFINES an alias cannot be
        // a reference TO that alias - it must be a reference to the source table column.
        // S2: must use the same vendor-aware key as the lateral alias set so the
        // exclusion check at isLateralColumnAlias() compares like-with-like (e.g.
        // Snowflake folds unquoted identifiers to UPPER; if this stayed
        // lowercase, the equals() check below would fail and a column reference
        // inside its own alias-defining expression would be wrongly treated as a
        // lateral alias reference, dropping it from the column-reference set).
        if (resultColumn.getAliasClause() != null && resultColumn.getAliasClause().getAliasName() != null) {
            currentResultColumnAlias = keyForColumn(normalizeAliasName(
                resultColumn.getAliasClause().getAliasName().toString()));
        } else {
            currentResultColumnAlias = null;
        }

        // Collect SQL Server proprietary column aliases (column_alias = expression)
        // These should not be treated as column references
        if (resultColumn.getExpr() != null &&
            resultColumn.getExpr().getExpressionType() == EExpressionType.sqlserver_proprietary_column_alias_t) {
            TExpression leftOperand = resultColumn.getExpr().getLeftOperand();
            if (leftOperand != null &&
                leftOperand.getExpressionType() == EExpressionType.simple_object_name_t &&
                leftOperand.getObjectOperand() != null) {
                sqlServerProprietaryAliases.add(leftOperand.getObjectOperand());
                if (DEBUG_SCOPE_BUILD) {
                    System.out.println("[DEBUG] Collected SQL Server proprietary alias: " +
                            leftOperand.getObjectOperand().toString());
                }
            }
        }

        // Handle BigQuery EXCEPT columns: SELECT * EXCEPT (column1, column2)
        // EXCEPT columns are added to allColumnReferences for DDL verification and lineage tracking,
        // but WITHOUT scope mapping to avoid triggering auto-inference in inner namespaces.
        // Star column expansion in TSQLResolver2 handles EXCEPT filtering directly.
        TObjectNameList exceptColumns = resultColumn.getExceptColumnList();
        if (exceptColumns != null && exceptColumns.size() > 0) {
            // Get the star column's source table from the expression
            TTable starSourceTable = null;
            if (resultColumn.getExpr() != null &&
                resultColumn.getExpr().getExpressionType() == EExpressionType.simple_object_name_t &&
                resultColumn.getExpr().getObjectOperand() != null) {
                TObjectName starColumn = resultColumn.getExpr().getObjectOperand();
                String starStr = starColumn.toString();
                if (starStr != null && starStr.endsWith("*")) {
                    // Get the table qualifier (e.g., "COMMON" from "COMMON.*")
                    String tableQualifier = starColumn.getTableString();
                    if (tableQualifier != null && !tableQualifier.isEmpty()) {
                        // Find the table by alias in the current scope
                        starSourceTable = findTableByAliasInCurrentScope(tableQualifier);
                    }
                }
            }

            for (int i = 0; i < exceptColumns.size(); i++) {
                TObjectName exceptCol = exceptColumns.getObjectName(i);
                if (exceptCol != null) {
                    if (starSourceTable != null) {
                        // Qualified star (e.g., COMMON.*): Link EXCEPT column directly to source table
                        exceptCol.setSourceTable(starSourceTable);
                    }
                    // IMPORTANT: Add to allColumnReferences for tracking, but do NOT add to
                    // columnToScopeMap - this prevents triggering auto-inference in inner namespaces
                    allColumnReferences.add(exceptCol);
                    if (DEBUG_SCOPE_BUILD) {
                        System.out.println("[DEBUG] EXCEPT column added for tracking (no scope mapping): " +
                            exceptCol.toString() + (starSourceTable != null ? " -> " + starSourceTable.getFullName() : ""));
                    }
                }
            }
        }

        // Handle BigQuery REPLACE columns: SELECT * REPLACE (expr AS identifier)
        // REPLACE columns create new columns that replace existing ones in star expansion.
        // Link them directly to the star's source table.
        java.util.ArrayList<gudusoft.gsqlparser.nodes.TReplaceExprAsIdentifier> replaceColumns =
            resultColumn.getReplaceExprAsIdentifiers();
        if (replaceColumns != null && replaceColumns.size() > 0) {
            // Get the star column's source table (similar to EXCEPT handling)
            TTable starSourceTable = null;
            if (resultColumn.getExpr() != null &&
                resultColumn.getExpr().getExpressionType() == EExpressionType.simple_object_name_t &&
                resultColumn.getExpr().getObjectOperand() != null) {
                TObjectName starColumn = resultColumn.getExpr().getObjectOperand();
                String starStr = starColumn.toString();
                if (starStr != null && starStr.endsWith("*")) {
                    String tableQualifier = starColumn.getTableString();
                    if (tableQualifier != null && !tableQualifier.isEmpty()) {
                        starSourceTable = findTableByAliasInCurrentScope(tableQualifier);
                    }
                }
            }

            for (int i = 0; i < replaceColumns.size(); i++) {
                gudusoft.gsqlparser.nodes.TReplaceExprAsIdentifier replaceCol = replaceColumns.get(i);
                if (replaceCol != null && replaceCol.getIdentifier() != null) {
                    TObjectName replaceId = replaceCol.getIdentifier();
                    if (starSourceTable != null) {
                        // Qualified star: Link REPLACE identifier to the star's source table
                        replaceId.setSourceTable(starSourceTable);
                        allColumnReferences.add(replaceId);
                        if (DEBUG_SCOPE_BUILD) {
                            System.out.println("[DEBUG] REPLACE column linked to star source table: " +
                                replaceId.toString() + " -> " + starSourceTable.getFullName());
                        }
                    } else {
                        // Unqualified star: Add with scope mapping for normal resolution
                        if (currentSelectScope != null) {
                            columnToScopeMap.put(replaceId, currentSelectScope);
                        }
                        allColumnReferences.add(replaceId);
                        if (DEBUG_SCOPE_BUILD) {
                            System.out.println("[DEBUG] REPLACE column added for resolution (unqualified star): " +
                                replaceId.toString());
                        }
                    }
                }
            }
        }

        // Handle CTAS target columns (CREATE TABLE AS SELECT)
        // In CTAS context, result columns become target table column definitions.
        // These are registered as "definition columns" (not reference columns):
        // - Added to allColumnReferences (for output)
        // - Added to ctasTargetColumns/tupleAliasColumns (definition set - prevents re-resolution)
        // - NOT added to columnToScopeMap (prevents NameResolver from overwriting sourceTable)
        //
        // IMPORTANT: Only handle CTAS target columns for the main SELECT of CTAS,
        // not for result columns inside CTEs or subqueries within the CTAS.
        // When inside a CTE definition (cteDefinitionDepth > 0), skip CTAS handling because
        // those result columns define CTE output, not CTAS target table columns.
        // Also check currentSelectScope == ctasMainSelectScope to exclude subqueries.
        if (currentCTASTargetTable != null && cteDefinitionDepth == 0 && currentSelectScope == ctasMainSelectScope) {
            boolean ctasColumnHandled = false;

            if (resultColumn.getAliasClause() != null) {
                TObjectNameList tupleColumns = resultColumn.getAliasClause().getColumns();

                // Case 1: Tuple aliases (e.g., AS (b1, b2, b3) in SparkSQL/Hive)
                if (tupleColumns != null && tupleColumns.size() > 0) {
                    for (int i = 0; i < tupleColumns.size(); i++) {
                        TObjectName tupleCol = tupleColumns.getObjectName(i);
                        if (tupleCol != null) {
                            // Mark as tuple alias column to skip in preVisit(TObjectName)
                            tupleAliasColumns.add(tupleCol);
                            // Set the source table to the CTAS target table
                            tupleCol.setSourceTable(currentCTASTargetTable);
                            // Add to all column references so it appears in output
                            allColumnReferences.add(tupleCol);
                            if (DEBUG_SCOPE_BUILD) {
                                System.out.println("[DEBUG] Registered CTAS tuple alias column: " +
                                        tupleCol.toString() + " -> " + currentCTASTargetTable.getFullName());
                            }
                        }
                    }
                    ctasColumnHandled = true;
                }
                // Case 2: Standard alias (AS alias / Teradata NAMED alias)
                else {
                    TObjectName aliasName = resultColumn.getAliasClause().getAliasName();
                    if (aliasName != null) {
                        // For alias names, partToken may be null but startToken has the actual text
                        // We need to set partToken so getColumnNameOnly() works correctly in the formatter
                        // This is done on a clone to avoid modifying the original AST node
                        if (aliasName.getPartToken() == null && aliasName.getStartToken() != null) {
                            // Clone the aliasName to avoid modifying the original AST
                            TObjectName ctasCol = aliasName.clone();
                            ctasCol.setPartToken(ctasCol.getStartToken());
                            ctasCol.setSourceTable(currentCTASTargetTable);
                            ctasTargetColumns.add(ctasCol);
                            allColumnReferences.add(ctasCol);
                            if (DEBUG_SCOPE_BUILD) {
                                System.out.println("[DEBUG] Registered CTAS target column (standard alias clone): " +
                                        ctasCol.getColumnNameOnly() + " -> " + currentCTASTargetTable.getFullName());
                            }
                            ctasColumnHandled = true;
                        } else {
                            String colName = aliasName.getColumnNameOnly();
                            if (colName != null && !colName.isEmpty()) {
                                // Register aliasName as CTAS target column DEFINITION
                                aliasName.setSourceTable(currentCTASTargetTable);
                                ctasTargetColumns.add(aliasName);
                                allColumnReferences.add(aliasName);
                                if (DEBUG_SCOPE_BUILD) {
                                    System.out.println("[DEBUG] Registered CTAS target column (standard alias): " +
                                            colName + " -> " + currentCTASTargetTable.getFullName());
                                }
                                ctasColumnHandled = true;
                            }
                        }
                    }
                }
            }

            // Case 3: No alias, simple column reference or star (e.g., SELECT a FROM s, SELECT * FROM s)
            // The target column inherits the source column name.
            // Use clone pattern (like JOIN...USING) to avoid polluting source column's sourceTable.
            if (!ctasColumnHandled && resultColumn.getExpr() != null &&
                resultColumn.getExpr().getExpressionType() == EExpressionType.simple_object_name_t &&
                resultColumn.getExpr().getObjectOperand() != null) {
                TObjectName sourceCol = resultColumn.getExpr().getObjectOperand();
                // Get column name - use getColumnNameOnly() first, fall back to toString()
                String colName = sourceCol.getColumnNameOnly();
                if (colName == null || colName.isEmpty()) {
                    colName = sourceCol.toString();
                }
                if (colName != null && !colName.isEmpty()) {
                    // Clone the source column to create a synthetic CTAS target column
                    // The clone refers to original start/end tokens for proper name extraction
                    // This includes star columns (SELECT * FROM s) which should create t.*
                    TObjectName ctasCol = sourceCol.clone();
                    ctasCol.setSourceTable(currentCTASTargetTable);
                    ctasTargetColumns.add(ctasCol);
                    allColumnReferences.add(ctasCol);
                    if (DEBUG_SCOPE_BUILD) {
                        System.out.println("[DEBUG] Registered CTAS target column (simple ref clone): " +
                                colName + " -> " + currentCTASTargetTable.getFullName());
                    }
                }
            }
        } else {
            // NOT in CTAS context - track result column alias names to skip them
            // These are NOT column references - they're alias names given to expressions.
            // This includes standard "AS alias" and Teradata "NAMED alias" syntax.
            if (resultColumn.getAliasClause() != null) {
                TObjectName aliasName = resultColumn.getAliasClause().getAliasName();
                if (aliasName != null) {
                    resultColumnAliasNames.add(aliasName);
                    if (DEBUG_SCOPE_BUILD) {
                        System.out.println("[DEBUG] Tracked result column alias name (will skip): " + aliasName.toString());
                    }
                }
            }
        }

        // Handle UPDATE SET clause columns
        // When inside an UPDATE statement, the left-hand side of SET assignments
        // (e.g., SET col = expr) should be linked to the target table
        if (currentUpdateTargetTable != null && resultColumn.getExpr() != null) {
            TExpression expr = resultColumn.getExpr();
            // SET clause uses assignment_t for "column = value" assignments in Teradata
            // or simple_comparison_t in some other databases
            if ((expr.getExpressionType() == EExpressionType.assignment_t ||
                 expr.getExpressionType() == EExpressionType.simple_comparison_t) &&
                expr.getLeftOperand() != null &&
                expr.getLeftOperand().getExpressionType() == EExpressionType.simple_object_name_t &&
                expr.getLeftOperand().getObjectOperand() != null) {
                TObjectName leftColumn = expr.getLeftOperand().getObjectOperand();
                // Link the SET clause column to the UPDATE target table
                leftColumn.setSourceTable(currentUpdateTargetTable);
                // Certify ONLY an unqualified SET target. A qualified LHS may name
                // a different table than the UPDATE target (valid multi-table
                // UPDATE: "UPDATE t1 JOIN t2 ON ... SET t2.a = 1"), and the
                // sourceTable assignment above would then be pointing at t1 —
                // whatever that legacy behavior is worth, it must never become a
                // COMPLETE proof trace.
                if (leftColumn.getTableToken() == null && currentUpdateHasSingleTable) {
                    traceDirectBinding(leftColumn,
                            gudusoft.gsqlparser.resolver2.binding.BindingTrace.BinderKind.DML_TARGET,
                            currentUpdateTargetTable);
                }
                allColumnReferences.add(leftColumn);
                // Mark as SET clause target - should NOT be re-resolved through star column
                setClauseTargetColumns.add(leftColumn);
                // Also add to columnToScopeMap with the current UpdateScope
                if (currentUpdateScope != null) {
                    columnToScopeMap.put(leftColumn, currentUpdateScope);
                }
                if (DEBUG_SCOPE_BUILD) {
                    System.out.println("[DEBUG] Linked UPDATE SET column: " +
                            leftColumn.toString() + " -> " + currentUpdateTargetTable.getFullName());
                }
            }
        }

        // Explicitly traverse typecast expressions in result columns
        // The visitor pattern may not automatically traverse nested expressions in typecast
        // This is important for Snowflake stage file columns like "$1:apMac::string"
        if (resultColumn.getExpr() != null &&
            resultColumn.getExpr().getExpressionType() == EExpressionType.typecast_t) {
            TExpression typecastExpr = resultColumn.getExpr();
            if (typecastExpr.getLeftOperand() != null) {
                traverseExpressionForColumns(typecastExpr.getLeftOperand());
            }
        }
    }

    @Override
    public void postVisit(TResultColumn resultColumn) {
        // Clear the current result column alias when we leave the result column
        currentResultColumnAlias = null;
        // Mark that we're leaving the result column context
        inResultColumnContext = false;
    }

    // ========== Column References ==========

    @Override
    public void preVisit(TObjectName objectName) {
        // Skip if this is a table name reference
        if (tableNameReferences.contains(objectName)) {
            return;
        }

        // Skip if this is a tuple alias column (already handled in preVisit(TResultColumn))
        if (tupleAliasColumns.contains(objectName)) {
            return;
        }

        // Skip if this is a CTAS target column (already handled in preVisit(TResultColumn))
        // These are definition columns for the CTAS target table, not column references
        if (ctasTargetColumns.contains(objectName)) {
            return;
        }

        // Skip if this is a VALUES table alias column definition (already handled in processValuesTable)
        // These are column NAME definitions like 'id', 'name' in "VALUES (...) AS t(id, name)"
        if (valuesTableAliasColumns.contains(objectName)) {
            return;
        }

        // Skip if this is a PIVOT IN clause column (already handled in addPivotInClauseColumns)
        // These are pivot column DEFINITIONS, not references to source table columns.
        if (pivotInClauseColumns.contains(objectName)) {
            return;
        }

        // Skip if this is a result column alias name (tracked in preVisit(TResultColumn))
        // These are NOT column references - they're alias names for expressions
        // e.g., "COUNT(1) AS cnt" or Teradata "COUNT(1)(NAMED cnt)"
        if (resultColumnAliasNames.contains(objectName)) {
            return;
        }

        // Skip if this is a lambda parameter
        // Lambda parameters are local function parameters, not table column references
        // e.g., in "transform(array, x -> x + 1)", x is a lambda parameter
        if (lambdaParameters.contains(objectName) || isLambdaParameter(objectName)) {
            return;
        }

        // Skip if this is a DDL target object name (file format, stage, pipe, etc.)
        // These are object names in DDL statements, not column references
        if (ddlTargetNames.contains(objectName)) {
            if (DEBUG_SCOPE_BUILD) {
                System.out.println("[DEBUG] Skipping DDL target name: " + objectName);
            }
            return;
        }
        if (DEBUG_SCOPE_BUILD && !ddlTargetNames.isEmpty()) {
            System.out.println("[DEBUG] DDL target check for " + objectName +
                " (hashCode=" + System.identityHashCode(objectName) +
                "): ddlTargetNames has " + ddlTargetNames.size() + " entries");
            for (TObjectName t : ddlTargetNames) {
                System.out.println("[DEBUG]   DDL target: " + t + " (hashCode=" + System.identityHashCode(t) + ")");
            }
        }

        // Skip if this is clearly not a column reference
        if (!isColumnReference(objectName)) {
            return;
        }

        // MERGE INSERT VALUES names that the USING source provably does not project stay in the
        // resolver's own tracking — consumers still need to see them, as unresolved — but get no
        // scope, which is what keeps every later resolution pass from binding them. Same shape as
        // the CTAS target columns below.
        if (mergeInsertValuesUnboundColumns.contains(objectName)) {
            allColumnReferences.add(objectName);
            return;
        }

        // Special handling: Link Snowflake stage positional columns to the stage table
        // These columns ($1, $2, $1:path) need to be linked to the stage table in the FROM clause
        if (dbVendor == EDbVendor.dbvsnowflake &&
            objectName.getSourceTable() == null &&
            isSnowflakeStagePositionalColumn(objectName)) {
            TTable stageTable = findSnowflakeStageTableInScope();
            if (DEBUG_SCOPE_BUILD) {
                System.out.println("[DEBUG] findSnowflakeStageTableInScope returned: " +
                    (stageTable != null ? stageTable.getTableName() : "null") +
                    " for column " + objectName);
            }
            if (stageTable != null) {
                objectName.setSourceTable(stageTable);
                if (DEBUG_SCOPE_BUILD) {
                    System.out.println("[DEBUG] Linked Snowflake stage column " + objectName +
                        " to stage table " + stageTable.getTableName());
                }
            }
        }

        // Determine the scope for this column
        IScope scope = determineColumnScope(objectName);

        if (DEBUG_SCOPE_BUILD) {
            System.out.println("[DEBUG] preVisit(TObjectName): " + objectName.toString() +
                " scope=" + (scope != null ? scope.getScopeType() : "null") +
                " currentSelectScope=" + (currentSelectScope != null ? "exists" : "null") +
                " currentUpdateScope=" + (currentUpdateScope != null ? "exists" : "null"));
        }

        // Record the mapping
        if (scope != null) {
            columnToScopeMap.put(objectName, scope);
            allColumnReferences.add(objectName);
        }
    }

    /**
     * Check if a TObjectName is a column reference (not a table/schema/etc.)
     */
    private boolean isColumnReference(TObjectName objectName) {
        if (objectName == null) {
            return false;
        }

        // reuse result from TCustomsqlstatement.isValidColumnName(EDbVendor pDBVendor)
        if (objectName.getObjectType() == TObjectName.ttobjNotAObject) return false;
        if (objectName.getDbObjectType() == EDbObjectType.hint) return false;

        // Numeric literals (e.g., "5" in LIMIT 5, "10" in TOP 10) are not column references.
        // Some grammars wrap Number tokens in createObjectName(), making them look like TObjectName
        // with dbObjectType=column. Check the token text to filter these out.
        if (objectName.getPartToken() != null) {
            TSourceToken pt = objectName.getPartToken();
            if (pt.tokentype == ETokenType.ttnumber) return false;
            // Some lexers (e.g., Hive) assign ttkeyword to Number tokens
            String tokenText = pt.toString();
            if (tokenText.length() > 0 && isNumericLiteral(tokenText)) return false;
        }

        // Skip if this is marked as a variable (e.g., DECLARE statement element name)
        if (objectName.getObjectType() == TObjectName.ttobjVariable) {
            return false;
        }

        // Skip if it's already marked as a table reference
        if (tableNameReferences.contains(objectName)) {
            return false;
        }

        // Skip if this is a variable declaration name (from DECLARE statement)
        if (variableDeclarationNames.contains(objectName)) {
            return false;
        }

        // Skip if this is an UNPIVOT definition column (value or FOR column)
        // These are column DEFINITIONS that create new output columns, not references
        if (unpivotDefinitionColumns.contains(objectName)) {
            return false;
        }

        // Skip if we're inside EXECUTE IMMEDIATE dynamic string expression
        // The variable name used for dynamic SQL is not a column reference
        if (insideExecuteImmediateDynamicExpr) {
            if (DEBUG_SCOPE_BUILD) {
                System.out.println("[DEBUG] Skipping identifier inside EXECUTE IMMEDIATE: " + objectName.toString());
            }
            return false;
        }

        // Skip if column name is empty or null - this indicates a table alias or similar
        String columnName = objectName.getColumnNameOnly();
        if (columnName == null || columnName.isEmpty()) {
            return false;
        }

        // Check object type
        // Column references typically have objectType that indicates column usage
        // or appear in contexts where columns are expected

        // Skip if this is part of a CREATE TABLE column definition
        // Note: getParentObjectName() returns TObjectName (for qualified names), not the AST parent
        TParseTreeNode parent = objectName.getParentObjectName();
        if (parent instanceof TColumnDefinition) {
            return false;
        }

        // Skip if this looks like a table name in FROM clause
        if (parent instanceof TTable) {
            return false;
        }

        // Skip if this is a table alias (parent is TAliasClause)
        if (parent instanceof gudusoft.gsqlparser.nodes.TAliasClause) {
            return false;
        }

        // Skip if this is a cursor name in cursor-related statements (DECLARE CURSOR, OPEN, FETCH, CLOSE, DEALLOCATE)
        if (isCursorName(objectName)) {
            return false;
        }

        // Skip if this is a datepart keyword in a date function (e.g., DAY in DATEDIFF)
        // These have null parent but are known date/time keywords used in function arguments
        // We need to verify it's actually in a date function context by checking surrounding tokens
        if (parent == null && objectName.getTableToken() == null &&
            isSqlServerDatepartKeyword(columnName) &&
            isInDateFunctionContext(objectName)) {
            return false;
        }

        // Skip if this was pre-marked as a function keyword argument in preVisit(TFunctionCall)
        // This handles keywords like SECOND in TIMESTAMP_DIFF(ts1, ts2, SECOND) for BigQuery/Snowflake
        if (functionKeywordArguments.contains(objectName)) {
            if (DEBUG_SCOPE_BUILD) {
                System.out.println("[DEBUG] Skipping pre-marked function keyword: " + objectName.toString());
            }
            return false;
        }

        // Skip if this is a named argument parameter name (e.g., INPUT in "INPUT => value")
        // These are parameter names in named argument syntax, NOT column references.
        // Examples: Snowflake FLATTEN(INPUT => parse_json(col), outer => TRUE)
        // Check both the Set (for current ScopeBuilder run) and the objectType (for AST-level marking)
        if (namedArgumentParameters.contains(objectName) ||
            objectName.getObjectType() == TObjectName.ttobjNamedArgParameter) {
            if (DEBUG_SCOPE_BUILD) {
                System.out.println("[DEBUG] Skipping named argument parameter: " + objectName.toString());
            }
            return false;
        }

        // Skip if this is a keyword argument in a built-in function (e.g., DAY in DATEDIFF)
        // This is a fallback using parent traversal (may not work if parent is null)
        if (isFunctionKeywordArgument(objectName)) {
            return false;
        }

        // Skip if this is a variable or function parameter (e.g., p_date in CREATE FUNCTION)
        // EXCEPTION: In PL/SQL blocks, we need to collect variable references so TSQLResolver2
        // can distinguish between table columns and block variables during name resolution
        if (objectName.getLinkedVariable() != null) {
            if (currentPlsqlBlockScope == null) {  // Not in PL/SQL block
                return false;
            }
        }
        EDbObjectType dbObjType = objectName.getDbObjectType();
        if (dbObjType == EDbObjectType.variable || dbObjType == EDbObjectType.parameter) {
            // Special case: Snowflake stage file positional columns ($1, $2, $1:path, etc.)
            // These are parsed as "parameter" but are actually column references to stage files
            boolean isStagePositional = (dbVendor == EDbVendor.dbvsnowflake && isSnowflakeStagePositionalColumn(objectName));
            if (DEBUG_SCOPE_BUILD) {
                System.out.println("[DEBUG] dbObjType check: dbObjType=" + dbObjType +
                    " colNameOnly=" + objectName.getColumnNameOnly() +
                    " objStr=" + objectName.getObjectString() +
                    " isSnowflakeStagePositional=" + isStagePositional);
            }
            if (isStagePositional) {
                // Allow collection - will be linked to stage table during name resolution
                // Fall through to return true
            } else if (currentPlsqlBlockScope == null) {  // Not in PL/SQL block
                return false;
            } else {
                return false;
                // In PL/SQL block - allow collection so name resolution can distinguish
                // between table columns and block variables
            }
        }

        // Skip if this name matches a registered parameter in the current PL/SQL block scope
        // BUT ONLY if we're NOT in a DML statement context (SELECT/INSERT/UPDATE/DELETE/MERGE)
        // This handles cases where the parser doesn't link the reference to the parameter declaration
        // (e.g., EXECUTE IMMEDIATE ddl_in where ddl_in is a procedure parameter)
        //
        // When inside a DML statement, we MUST allow collection so name resolution can distinguish
        // between table columns and block variables (e.g., "DELETE FROM emp WHERE ename = main.ename")
        if (currentPlsqlBlockScope != null) {
            // Check if we're inside any DML statement context
            // Note: currentInsertTargetTable is set when inside an INSERT statement
            boolean inDmlContext = (currentSelectScope != null || currentUpdateScope != null ||
                                    currentDeleteScope != null || currentMergeScope != null ||
                                    currentInsertTargetTable != null);

            if (!inDmlContext) {
                // Not in DML context - this is likely a standalone expression like EXECUTE IMMEDIATE param
                // or a WHILE condition, etc.
                // Check if the name is a variable in the current scope OR any parent PL/SQL block scope.
                String nameOnly = objectName.getColumnNameOnly();
                if (nameOnly != null && isVariableInPlsqlScopeChain(nameOnly)) {
                    if (DEBUG_SCOPE_BUILD) {
                        System.out.println("[DEBUG] Skipping registered PL/SQL parameter/variable (not in DML): " + nameOnly);
                    }
                    return false;
                }

                // Also skip qualified references (like TEMP1.M1) when not in DML context
                // BUT only if the prefix is NOT a trigger correlation variable (:new, :old, new, old)
                // These are likely PL/SQL object/record field accesses, not table columns
                if (objectName.getTableToken() != null) {
                    String prefix = objectName.getTableToken().toString().toLowerCase();
                    // Skip filtering for trigger correlation variables
                    if (!":new".equals(prefix) && !":old".equals(prefix) &&
                        !"new".equals(prefix) && !"old".equals(prefix)) {
                        if (DEBUG_SCOPE_BUILD) {
                            System.out.println("[DEBUG] Skipping qualified reference in non-DML PL/SQL context: " + objectName.toString());
                        }
                        return false;
                    }
                }
            }
        }

        // Skip if this is a bind variable (e.g., :project_id in Oracle, @param in SQL Server)
        // BUT skip this check for Snowflake stage positional columns with JSON paths like $1:apMac
        // which are tokenized as bind variables due to the colon syntax
        if (objectName.getPartToken() != null && objectName.getPartToken().tokentype == ETokenType.ttbindvar) {
            // Check if this is a Snowflake stage JSON path column - these are NOT bind variables
            if (!(dbVendor == EDbVendor.dbvsnowflake && isSnowflakeStagePositionalColumn(objectName))) {
                if (DEBUG_SCOPE_BUILD) {
                    System.out.println("[DEBUG] partToken bindvar check: " + objectName.toString() +
                        " tokentype=" + objectName.getPartToken().tokentype);
                }
                return false;
            }
        }
        // Also check by column name pattern for bind variables
        // BUT skip this check for Snowflake stage positional columns with JSON paths like $1:apMac
        // where getColumnNameOnly() returns ":apMac" - this is NOT a bind variable
        String colName = objectName.getColumnNameOnly();
        if (colName != null && (colName.startsWith(":") || colName.startsWith("@"))) {
            // Check if this is a Snowflake stage JSON path column (e.g., $1:apMac)
            // In this case, colName is ":apMac" but it's a JSON path, not a bind variable
            boolean isStageCol = (dbVendor == EDbVendor.dbvsnowflake && isSnowflakeStagePositionalColumn(objectName));
            if (DEBUG_SCOPE_BUILD) {
                System.out.println("[DEBUG] bind variable check: colName=" + colName +
                    " objStr=" + objectName.getObjectString() +
                    " isSnowflakeStageCol=" + isStageCol);
            }
            if (!isStageCol) {
                return false;
            }
        }

        // Skip built-in functions without parentheses (niladic functions)
        // These look like column references but are actually function calls
        // Examples: CURRENT_USER (SQL Server), CURRENT_DATETIME (BigQuery), etc.
        // Only check unqualified names - qualified names like "table.column" are real column references
        if (objectName.getTableToken() == null && isBuiltInFunctionName(colName)) {
            return false;
        }

        // Skip Snowflake procedure system variables (e.g., sqlrowcount, sqlerrm, sqlstate)
        // These are special variables available in Snowflake stored procedures
        if (dbVendor == EDbVendor.dbvsnowflake && objectName.getTableToken() == null &&
            isSnowflakeProcedureSystemVariable(colName)) {
            if (DEBUG_SCOPE_BUILD) {
                System.out.println("[DEBUG] Skipping Snowflake procedure system variable: " + colName);
            }
            return false;
        }

        // Skip if this is a double-quoted string literal in MySQL
        // In MySQL, "Z" is a string literal by default (unless ANSI_QUOTES mode)
        if (dbVendor == EDbVendor.dbvmysql && objectName.getPartToken() != null) {
            if (objectName.getPartToken().tokentype == ETokenType.ttdqstring) {
                return false;
            }
        }

        // Skip if this is the alias part of SQL Server's proprietary column alias syntax
        // e.g., in "column_alias = expression", column_alias is an alias, not a column reference
        if (isSqlServerProprietaryColumnAlias(objectName, parent)) {
            return false;
        }

        // Skip if this is a lateral column alias reference (Snowflake, BigQuery, etc.)
        // e.g., in "SELECT col as x, x + 1 as y", x is a lateral alias reference, not a source column
        // Only check unqualified names (no table prefix) - qualified names like "t.x" are not lateral aliases
        if (objectName.getTableToken() == null && isLateralColumnAlias(columnName)) {
            return false;
        }

        // Handle PL/SQL package constants (e.g., sch.pk_constv2.c_cdsl in VALUES clause)
        // These are not resolvable as table columns, but we still collect them so they can
        // be output as "missed." columns when linkOrphanColumnToFirstTable=false, or linked
        // to the first physical table when linkOrphanColumnToFirstTable=true.
        // Note: The qualified prefix (schema.table) is preserved in the TObjectName tokens
        // (schemaToken, tableToken) for DataFlowAnalyzer to use when creating relationships.
        if (isPlsqlPackageConstant(objectName, parent)) {
            // Clear sourceTable since this is not a real table column
            // Don't set dbObjectType to variable so that populateOrphanColumns() in TSQLResolver2
            // will process it and set ownStmt, enabling linkOrphanColumnToFirstTable to work
            objectName.setSourceTable(null);
            if (DEBUG_SCOPE_BUILD) {
                System.out.println("[DEBUG] Collected PL/SQL package constant as orphan: " + objectName.toString());
            }
            // Return true to collect as orphan column
            return true;
        }

        // Oracle PL/SQL special identifiers (pseudo-columns, implicit vars, exception handlers, cursor attrs)
        // Best practice: filter in ScopeBuilder (early), with strict gating:
        // - Oracle vendor only
        // - Quoted identifiers override keywords (e.g., "ROWNUM" is a user identifier)
        if (dbVendor == EDbVendor.dbvoracle && objectName.getQuoteType() == EQuoteType.notQuoted) {
            String nameOnly = objectName.getColumnNameOnly();

            // 1) Pseudo-columns whose names are Oracle reserved words
            // (ROWNUM, LEVEL, ROWID): an unquoted occurrence can never be a
            // user column, so no statement context is needed to rule it out.
            // The name list is shared with the Phase 1 publish path in
            // TCustomSqlStatement so the two cannot drift apart (Mantis #4675).
            // Context-gated pseudo-columns (CONNECT_BY_*, NEXTVAL/CURRVAL,
            // VERSIONS_*) are classified in Phase 1, which has the statement
            // context this method lacks; the mark it leaves behind is honoured
            // by the isColumnReference() guard below.
            if (OraclePseudoColumnUtil.isDetachedReservedPseudoColumn(nameOnly)) {
                markNotAColumn(objectName, EDbObjectType.constant);
                return false;
            }

            // 2) PL/SQL inquiry directives: $$PLSQL_UNIT, $$PLSQL_LINE, $$PLSQL_UNIT_OWNER, etc.
            // These are compile-time constants, not column references
            if (nameOnly != null && nameOnly.startsWith("$$")) {
                markNotAColumn(objectName, EDbObjectType.constant);
                return false;
            }

            // 3) Inside PL/SQL blocks: filter implicit identifiers & cursor attributes
            if (currentPlsqlBlockScope != null) {
                if (nameOnly != null) {
                    String lower = nameOnly.toLowerCase(Locale.ROOT);
                    // SQLCODE (implicit variable) / SQLERRM (built-in; often written like a variable)
                    if ("sqlcode".equals(lower) || "sqlerrm".equals(lower)) {
                        markNotAColumn(objectName, EDbObjectType.variable);
                        return false;
                    }
                }

                // Cursor attributes: SQL%NOTFOUND, cursor%ROWCOUNT, etc.
                if (isOraclePlsqlCursorAttribute(objectName)) {
                    markNotAColumn(objectName, EDbObjectType.variable);
                    return false;
                }

                // Boolean literals: TRUE, FALSE (case-insensitive)
                // These are PL/SQL boolean constants, not column references
                if (nameOnly != null) {
                    String lower = nameOnly.toLowerCase(Locale.ROOT);
                    if ("true".equals(lower) || "false".equals(lower)) {
                        markNotAColumn(objectName, EDbObjectType.constant);
                        return false;
                    }
                }

                // Oracle predefined exceptions (unqualified names in RAISE/WHEN clauses)
                // Examples: NO_DATA_FOUND, TOO_MANY_ROWS, CONFIGURATION_MISMATCH, etc.
                if (nameOnly != null && isOraclePredefinedException(nameOnly)) {
                    markNotAColumn(objectName, EDbObjectType.variable);
                    return false;
                }

                // Collection methods: .COUNT, .LAST, .FIRST, .DELETE, .EXISTS, .PRIOR, .NEXT, .TRIM, .EXTEND
                // These appear as qualified names like "collection.COUNT" where COUNT is the method
                if (isOraclePlsqlCollectionMethod(objectName)) {
                    markNotAColumn(objectName, EDbObjectType.variable);
                    return false;
                }

                // Cursor variable references: check if this is a known cursor variable
                // Example: emp in "OPEN emp FOR SELECT * FROM employees"
                // This is based on actual TCursorDeclStmt/TOpenforStmt declarations tracked in scope
                if (nameOnly != null && cursorVariableNames.contains(nameOnly.toLowerCase(Locale.ROOT))) {
                    markNotAColumn(objectName, EDbObjectType.variable);
                    if (DEBUG_SCOPE_BUILD) {
                        System.out.println("[DEBUG] Skipping cursor variable: " + nameOnly);
                    }
                    return false;
                }

                // Record variable fields: when "table.column" refers to a record variable field
                // Example: rec.field_name where rec is declared as "rec record_type%ROWTYPE"
                // Check if the "table" part is a known variable in the current scope
                if (objectName.getTableToken() != null) {
                    String tablePrefix = objectName.getTableToken().toString();
                    if (tablePrefix != null && isVariableInPlsqlScopeChain(tablePrefix)) {
                        // The "table" part is actually a record variable, so this is a record field access
                        markNotAColumn(objectName, EDbObjectType.variable);
                        return false;
                    }
                    // Also check cursor FOR loop record names (e.g., "rec" in "for rec in (SELECT ...)")
                    if (tablePrefix != null && cursorForLoopRecordNames.contains(tablePrefix.toLowerCase(Locale.ROOT))) {
                        // The "table" part is a cursor FOR loop record, so this is a record field access
                        markNotAColumn(objectName, EDbObjectType.variable);
                        if (DEBUG_SCOPE_BUILD) {
                            System.out.println("[DEBUG] Skipping cursor FOR loop record field: " + objectName.toString());
                        }
                        return false;
                    }

                    // Package member references (pkg.member or schema.pkg.member)
                    // Check if the table prefix matches a known package
                    if (tablePrefix != null && packageRegistry != null && packageRegistry.isPackage(tablePrefix)) {
                        OraclePackageNamespace pkgNs = packageRegistry.getPackage(tablePrefix);
                        String memberName = objectName.getColumnNameOnly();
                        if (pkgNs != null && memberName != null && pkgNs.hasMember(memberName)) {
                            markNotAColumn(objectName, EDbObjectType.variable);
                            if (DEBUG_SCOPE_BUILD) {
                                System.out.println("[DEBUG] Skipping package member reference: " +
                                    tablePrefix + "." + memberName);
                            }
                            return false;
                        }
                    }
                }

                // Package-level variable (unqualified) when inside package body
                // Check if this is a known package member without qualification
                if (currentPackageScope != null && objectName.getTableToken() == null) {
                    OraclePackageNamespace pkgNs = currentPackageScope.getPackageNamespace();
                    if (pkgNs != null && nameOnly != null && pkgNs.hasMember(nameOnly)) {
                        markNotAColumn(objectName, EDbObjectType.variable);
                        if (DEBUG_SCOPE_BUILD) {
                            System.out.println("[DEBUG] Skipping unqualified package member: " + nameOnly);
                        }
                        return false;
                    }
                }
            }
        }

        // Accept if it appears in an expression context
        if (parent instanceof TExpression) {
            return true;
        }

        // Accept if it appears in a result column
        if (parent instanceof TResultColumn) {
            return true;
        }

        // Default: accept as column reference
        return true;
    }

    /**
     * Mark a TObjectName as "not a column" so downstream collectors/resolvers can skip it.
     */
    private void markNotAColumn(TObjectName objectName, EDbObjectType objType) {
        if (objectName == null) return;
        objectName.setValidate_column_status(TBaseType.MARKED_NOT_A_COLUMN_IN_COLUMN_RESOLVER);
        // IMPORTANT: setSourceTable(null) may set dbObjectType to column; override after
        objectName.setSourceTable(null);
        if (objType != null) {
            objectName.setDbObjectTypeDirectly(objType);
        }
    }

    /**
     * Oracle PL/SQL cursor attributes are syntactically identified by '%' (e.g., SQL%NOTFOUND, cur%ROWCOUNT).
     * These are never table columns.
     */
    private boolean isOraclePlsqlCursorAttribute(TObjectName objectName) {
        if (dbVendor != EDbVendor.dbvoracle) return false;
        if (currentPlsqlBlockScope == null) return false;
        if (objectName == null) return false;

        String text = objectName.toString();
        if (text == null) return false;
        int idx = text.lastIndexOf('%');
        if (idx < 0 || idx == text.length() - 1) return false;

        String attr = text.substring(idx + 1).trim().toUpperCase(Locale.ROOT);
        // Common PL/SQL cursor attributes
        switch (attr) {
            case "FOUND":
            case "NOTFOUND":
            case "ROWCOUNT":
            case "ISOPEN":
            case "BULK_ROWCOUNT":
            case "BULK_EXCEPTIONS":
                return true;
            default:
                return false;
        }
    }

    /**
     * Oracle predefined exceptions that should not be treated as column references.
     * These include standard PL/SQL exceptions and DBMS_* package exceptions.
     */
    private static final java.util.Set<String> ORACLE_PREDEFINED_EXCEPTIONS = new java.util.HashSet<>(java.util.Arrays.asList(
        // Standard PL/SQL exceptions
        "ACCESS_INTO_NULL", "CASE_NOT_FOUND", "COLLECTION_IS_NULL", "CURSOR_ALREADY_OPEN",
        "DUP_VAL_ON_INDEX", "INVALID_CURSOR", "INVALID_NUMBER", "LOGIN_DENIED",
        "NO_DATA_FOUND", "NO_DATA_NEEDED", "NOT_LOGGED_ON", "PROGRAM_ERROR",
        "ROWTYPE_MISMATCH", "SELF_IS_NULL", "STORAGE_ERROR", "SUBSCRIPT_BEYOND_COUNT",
        "SUBSCRIPT_OUTSIDE_LIMIT", "SYS_INVALID_ROWID", "TIMEOUT_ON_RESOURCE",
        "TOO_MANY_ROWS", "VALUE_ERROR", "ZERO_DIVIDE",
        // DBMS_STANDARD exceptions
        "CONFIGURATION_MISMATCH", "OTHERS"
    ));

    private boolean isOraclePredefinedException(String name) {
        if (name == null) return false;
        return ORACLE_PREDEFINED_EXCEPTIONS.contains(name.toUpperCase(Locale.ROOT));
    }

    /**
     * Oracle PL/SQL collection methods that should not be treated as column references.
     * Examples: my_collection.COUNT, my_array.LAST, my_table.DELETE
     */
    private boolean isOraclePlsqlCollectionMethod(TObjectName objectName) {
        if (dbVendor != EDbVendor.dbvoracle) return false;
        if (currentPlsqlBlockScope == null) return false;
        if (objectName == null) return false;

        // Check if this is a qualified name (has a table/object prefix)
        // Collection methods appear as "collection_name.METHOD"
        if (objectName.getTableToken() == null) return false;

        String methodName = objectName.getColumnNameOnly();
        if (methodName == null) return false;

        String upper = methodName.toUpperCase(Locale.ROOT);
        switch (upper) {
            case "COUNT":
            case "FIRST":
            case "LAST":
            case "NEXT":
            case "PRIOR":
            case "EXISTS":
            case "DELETE":
            case "TRIM":
            case "EXTEND":
                return true;
            default:
                return false;
        }
    }

    /**
     * Detect whether this TObjectName belongs to an Oracle exception handler condition.
     * Example: EXCEPTION WHEN no_data_found THEN ... / WHEN OTHERS THEN ...
     *
     * We use parent-chain context rather than a keyword list to avoid false positives.
     */
    private boolean isInsideOracleExceptionHandler(TObjectName objectName) {
        if (dbVendor != EDbVendor.dbvoracle) return false;
        if (currentPlsqlBlockScope == null) return false;
        if (objectName == null) return false;

        TParseTreeNode node = objectName.getParentObjectName();
        while (node != null) {
            if (node instanceof TExceptionHandler) {
                return true;
            }
            node = node.getParentObjectName();
        }
        return false;
    }

    /**
     * Check if a TObjectName is a keyword argument in a built-in function.
     * For example, DAY in DATEDIFF(DAY, start_date, end_date) is a keyword, not a column.
     * Uses TBuiltFunctionUtil to check against the configured keyword argument positions.
     */
    private boolean isFunctionKeywordArgument(TObjectName objectName) {
        // Traverse up to find the containing expression
        TParseTreeNode parent = objectName.getParentObjectName();

        // Debug output for function keyword detection
        if (DEBUG_SCOPE_BUILD) {
            System.out.println("[DEBUG] isFunctionKeywordArgument: objectName=" + objectName.toString() +
                " parent=" + (parent != null ? parent.getClass().getSimpleName() : "null"));
        }

        if (!(parent instanceof TExpression)) {
            return false;
        }

        TExpression expr = (TExpression) parent;

        // Check if the expression type indicates this could be a keyword argument
        // Keywords like DAY, MONTH, YEAR in DATEDIFF/DATEADD are parsed as simple_constant_t
        // but still have objectOperand set, so we need to check both types
        EExpressionType exprType = expr.getExpressionType();
        if (exprType != EExpressionType.simple_object_name_t &&
            exprType != EExpressionType.simple_constant_t) {
            return false;
        }

        // Traverse up to find the containing function call
        TParseTreeNode exprParent = expr.getParentObjectName();

        // The expression might be inside a TExpressionList (function args)
        if (exprParent instanceof TExpressionList) {
            TExpressionList argList = (TExpressionList) exprParent;
            TParseTreeNode argListParent = argList.getParentObjectName();

            if (argListParent instanceof TFunctionCall) {
                TFunctionCall functionCall = (TFunctionCall) argListParent;
                return checkFunctionKeywordPosition(functionCall, argList, expr, objectName);
            }
        }

        // Direct parent might be TFunctionCall in some cases
        if (exprParent instanceof TFunctionCall) {
            TFunctionCall functionCall = (TFunctionCall) exprParent;
            TExpressionList args = functionCall.getArgs();
            if (args != null) {
                return checkFunctionKeywordPosition(functionCall, args, expr, objectName);
            }
        }

        return false;
    }

    /**
     * Check if the expression is at a keyword argument position in the function call.
     */
    private boolean checkFunctionKeywordPosition(TFunctionCall functionCall,
                                                  TExpressionList argList,
                                                  TExpression expr,
                                                  TObjectName objectName) {
        // Find the position of this expression in the argument list
        int position = -1;
        for (int i = 0; i < argList.size(); i++) {
            if (argList.getExpression(i) == expr) {
                position = i + 1; // TBuiltFunctionUtil uses 1-based positions
                break;
            }
        }

        if (position < 0) {
            return false;
        }

        // Get function name
        String functionName = functionCall.getFunctionName() != null
                ? functionCall.getFunctionName().toString()
                : null;
        if (functionName == null || functionName.isEmpty()) {
            return false;
        }

        // Check against the configured keyword argument positions
        // Use the ScopeBuilder's dbVendor since TFunctionCall.dbvendor may not be set
        Set<Integer> keywordPositions = TBuiltFunctionUtil.argumentsIncludeKeyword(
                dbVendor, functionName);

        if (keywordPositions != null && keywordPositions.contains(position)) {
            if (DEBUG_SCOPE_BUILD) {
                System.out.println("[DEBUG] Skipping function keyword argument: " +
                        objectName.toString() + " at position " + position +
                        " in function " + functionName);
            }
            return true;
        }

        return false;
    }

    /**
     * Check if a TObjectName is a PL/SQL package constant (not a table column).
     *
     * This filter applies ONLY when all of the following are true:
     * - Vendor is Oracle
     * - We are inside a PL/SQL block (currentPlsqlBlockScope != null)
     * - The TObjectName is multi-part: schema.object.part (e.g., sch.pk_constv2.c_cdsl)
     * - The TObjectName is used in an expression/value context (not DDL/definition context)
     *
     * Decision rule (no naming heuristics):
     * - Try to resolve the prefix (schema.object) as a table/alias/CTE in the current scope
     * - If neither resolves -> it's a package constant, NOT a column reference
     * - If either resolves -> it's a real column reference
     *
     * @param objectName The TObjectName to check
     * @param parent The parent node (may be null for some TObjectName nodes)
     * @return true if this is a PL/SQL package constant (should NOT be collected as column)
     */
    private boolean isPlsqlPackageConstant(TObjectName objectName, TParseTreeNode parent) {
        // Gating condition 1: Oracle vendor only
        if (dbVendor != EDbVendor.dbvoracle) {
            return false;
        }

        // Gating condition 2: Must be inside a PL/SQL block
        if (currentPlsqlBlockScope == null) {
            return false;
        }

        // Gating condition 3: Must be multi-part name (schema.object.part)
        // e.g., sch.pk_constv2.c_cdsl where:
        //   - schemaToken = "sch"
        //   - tableToken = "pk_constv2"
        //   - partToken = "c_cdsl"
        if (objectName.getSchemaToken() == null ||
            objectName.getTableToken() == null ||
            objectName.getPartToken() == null) {
            return false;
        }

        // Gating condition 4: Should not be in DDL definition context
        // Skip if parent indicates a DDL context (these are already filtered earlier,
        // but check here for safety). For VALUES clause expressions, parent is often null.
        if (parent instanceof TColumnDefinition || parent instanceof TTable) {
            return false;
        }

        // Now check if the prefix is resolvable as a table/alias in the current scope
        IScope scope = determineColumnScope(objectName);
        if (scope == null) {
            // Conservative: if we can't determine scope, don't filter
            return false;
        }

        String schemaName = objectName.getSchemaString();   // "sch"
        String qualifier = objectName.getTableString();      // "pk_constv2"

        // Try to resolve as table alias or table name
        INamespace ns1 = scope.resolveTable(qualifier);

        // Try to resolve as schema-qualified table name
        INamespace ns2 = null;
        if (schemaName != null && !schemaName.isEmpty()) {
            ns2 = scope.resolveTable(schemaName + "." + qualifier);
        }

        if (ns1 == null && ns2 == null) {
            // Not resolvable as a table/alias in this scope
            // -> Treat as package constant, NOT a column reference
            if (DEBUG_SCOPE_BUILD) {
                System.out.println("[DEBUG] Filtered PL/SQL package constant: " +
                    objectName.toString() + " (prefix '" + schemaName + "." + qualifier +
                    "' not resolvable in scope)");
            }
            return true;
        }

        // Resolvable as a table/alias -> treat as real column reference
        return false;
    }


    /**
     * SQL Server datepart keywords - used in DATEDIFF, DATEADD, DATEPART, DATENAME functions.
     * These are parsed as TObjectName but are actually date/time keywords, not columns.
     */
    private static final Set<String> SQL_SERVER_DATEPART_KEYWORDS = new HashSet<>(Arrays.asList(
        // Standard datepart values
        "year", "yy", "yyyy",
        "quarter", "qq", "q",
        "month", "mm", "m",
        "dayofyear", "dy", "y",
        "day", "dd", "d",
        "week", "wk", "ww",
        "weekday", "dw", "w",
        "hour", "hh",
        "minute", "mi", "n",
        "second", "ss", "s",
        "millisecond", "ms",
        "microsecond", "mcs",
        "nanosecond", "ns",
        // ISO week
        "iso_week", "isowk", "isoww",
        // Timezone offset
        "tzoffset", "tz"
    ));

    /**
     * Check if a name is a niladic function (built-in function without parentheses)
     * for the current database vendor.
     *
     * Uses TNiladicFunctionUtil with builtinFunctions/niladicFunctions.properties file.
     *
     * Niladic functions are functions that can be called without parentheses and look like
     * column references but are actually function calls returning values.
     * Examples: CURRENT_USER (SQL Server), CURRENT_DATETIME (BigQuery), SYSDATE (Oracle)
     *
     * Note: Regular built-in functions that require parentheses (like DAY(date), COUNT(*))
     * are NOT filtered here because they would have parentheses in the SQL and thus be
     * parsed as TFunctionCall nodes, not TObjectName.
     *
     * @param name The identifier name to check
     * @return true if it's a known niladic function for the current vendor
     */
    private boolean isBuiltInFunctionName(String name) {
        if (name == null || name.isEmpty()) {
            return false;
        }

        boolean isNiladic = TNiladicFunctionUtil.isNiladicFunction(dbVendor, name);

        if (DEBUG_SCOPE_BUILD && isNiladic) {
            System.out.println("[DEBUG] Identified niladic function: " + name + " for vendor " + dbVendor);
        }

        return isNiladic;
    }

    /**
     * Check if the given name is a Snowflake procedure system variable.
     * These are special variables available in Snowflake stored procedures:
     * - SQLROWCOUNT: Number of rows affected by the last SQL statement
     * - SQLERRM: Error message of the last SQL statement
     * - SQLSTATE: SQL state code of the last SQL statement
     * - SQLCODE: Deprecated, replaced by SQLSTATE
     */
    private boolean isSnowflakeProcedureSystemVariable(String name) {
        if (name == null || name.isEmpty()) {
            return false;
        }
        String upperName = name.toUpperCase();
        return "SQLROWCOUNT".equals(upperName) ||
               "SQLERRM".equals(upperName) ||
               "SQLSTATE".equals(upperName) ||
               "SQLCODE".equals(upperName);
    }

    /**
     * Find a Snowflake stage table in the current scope.
     * Stage tables are identified by their table name starting with '@' or being a quoted
     * string starting with '@' (e.g., '@stage/path' or '@schema.stage_name').
     *
     * @return The stage table if found, null otherwise
     */
    private TTable findSnowflakeStageTableInScope() {
        // Check if we have a current select scope with a FROM scope
        if (currentSelectScope == null) {
            if (DEBUG_SCOPE_BUILD) {
                System.out.println("[DEBUG] findSnowflakeStageTableInScope: currentSelectScope is null");
            }
            return null;
        }

        FromScope fromScope = currentSelectScope.getFromScope();
        if (fromScope == null) {
            if (DEBUG_SCOPE_BUILD) {
                System.out.println("[DEBUG] findSnowflakeStageTableInScope: fromScope is null");
            }
            return null;
        }

        if (DEBUG_SCOPE_BUILD) {
            System.out.println("[DEBUG] findSnowflakeStageTableInScope: fromScope has " +
                fromScope.getChildren().size() + " children");
        }

        // Search for stage tables through the FromScope's children (namespaces)
        for (ScopeChild child : fromScope.getChildren()) {
            INamespace namespace = child.getNamespace();
            if (namespace != null) {
                TTable table = namespace.getFinalTable();
                if (DEBUG_SCOPE_BUILD) {
                    System.out.println("[DEBUG]   child: alias=" + child.getAlias() +
                        " table=" + (table != null ? table.getTableName() : "null") +
                        " isStage=" + (table != null ? isSnowflakeStageTable(table) : "N/A"));
                }
                if (table != null && isSnowflakeStageTable(table)) {
                    return table;
                }
            }
        }

        return null;
    }

    /**
     * Check if a TTable is a Snowflake stage table.
     * Stage tables can be identified by:
     * - Table type is stageReference
     * - Table name starting with '@' (internal stage)
     * - Quoted string starting with '@' (external stage with path)
     *
     * @param table The table to check
     * @return true if this is a stage table
     */
    private boolean isSnowflakeStageTable(TTable table) {
        if (table == null) {
            return false;
        }

        // Check for stageReference table type (e.g., @schema.stage_name/path)
        if (table.getTableType() == ETableSource.stageReference) {
            return true;
        }

        if (table.getTableName() == null) {
            return false;
        }

        String tableName = table.getTableName().toString();
        if (tableName == null || tableName.isEmpty()) {
            return false;
        }

        // Check for stage table patterns:
        // - @stage_name
        // - '@stage/path/'
        // - @schema.stage_name
        return tableName.startsWith("@") ||
               tableName.startsWith("'@") ||
               tableName.startsWith("\"@");
    }

    /**
     * Check if a TObjectName represents a Snowflake stage file positional column.
     * Snowflake stage files allow positional column references like $1, $2, etc.,
     * and JSON path access like $1:field.
     *
     * Patterns recognized:
     * - Simple positional: $1, $2, $10, etc. (columnNameOnly = "$1")
     * - JSON path: $1:fieldName (objectString = "$1", columnNameOnly = ":fieldName")
     *
     * @param objectName The object name to check
     * @return true if this is a Snowflake stage file positional column
     */
    private boolean isSnowflakeStagePositionalColumn(TObjectName objectName) {
        if (objectName == null) {
            return false;
        }

        String colName = objectName.getColumnNameOnly();
        String objStr = objectName.getObjectString();

        // Pattern 1: Simple positional column ($1, $2, etc.)
        // columnNameOnly = "$1", objectString = ""
        if (colName != null && colName.length() >= 2 && colName.startsWith("$")) {
            char secondChar = colName.charAt(1);
            if (Character.isDigit(secondChar)) {
                // Verify all remaining chars are digits
                int i = 2;
                while (i < colName.length() && Character.isDigit(colName.charAt(i))) {
                    i++;
                }
                if (i == colName.length()) {
                    return true;
                }
            }
        }

        // Pattern 2: JSON path access ($1:fieldName)
        // objectString = "$1", columnNameOnly = ":fieldName"
        if (objStr != null && objStr.length() >= 2 && objStr.startsWith("$")) {
            char secondChar = objStr.charAt(1);
            if (Character.isDigit(secondChar)) {
                // Verify remaining chars are digits
                int i = 2;
                while (i < objStr.length() && Character.isDigit(objStr.charAt(i))) {
                    i++;
                }
                // If objectString is pure positional ($1, $12, etc.) and columnNameOnly starts with ':'
                if (i == objStr.length() && colName != null && colName.startsWith(":")) {
                    return true;
                }
            }
        }

        return false;
    }

    /**
     * Check if a variable name exists in the current PL/SQL block scope chain.
     * This walks up the scope chain from the current scope to all parent PL/SQL scopes.
     * Used to filter out variable references that should not be collected as column references.
     *
     * @param variableName The variable name to check (case-insensitive)
     * @return true if the variable exists in any scope in the chain
     */
    private boolean isVariableInPlsqlScopeChain(String variableName) {
        // Check the current scope first
        if (currentPlsqlBlockScope != null &&
            currentPlsqlBlockScope.getVariableNamespace().hasColumn(variableName) == ColumnLevel.EXISTS) {
            return true;
        }

        // Check all parent scopes in the stack
        // The stack contains saved parent scopes when we enter nested blocks
        for (PlsqlBlockScope parentScope : plsqlBlockScopeStack) {
            if (parentScope.getVariableNamespace().hasColumn(variableName) == ColumnLevel.EXISTS) {
                return true;
            }
        }

        return false;
    }

    /**
     * Check if a TObjectName is a lambda expression parameter by examining the parent chain.
     * Lambda parameters (e.g., x in "x -> x + 1" or acc, x in "(acc, x) -> acc + x")
     * should not be treated as column references.
     *
     * This method is called when lambdaParameters set hasn't been populated yet
     * (because TObjectName is visited before TExpression for the lambda).
     *
     * @param objectName The object name to check
     * @return true if it's a lambda parameter
     */
    private boolean isLambdaParameter(TObjectName objectName) {
        if (objectName == null) return false;
        if (lambdaParameterStack.isEmpty()) return false;

        // Check if this objectName's name matches any parameter in the current lambda context
        String name = objectName.toString();
        if (name == null) return false;
        String nameLower = name.toLowerCase();

        // Check all lambda contexts on the stack (for nested lambdas)
        for (Set<String> paramNames : lambdaParameterStack) {
            if (paramNames.contains(nameLower)) {
                // Also add to lambdaParameters for future reference
                lambdaParameters.add(objectName);
                return true;
            }
        }

        return false;
    }

    /**
     * Check if a name is a known SQL Server schema name.
     * Schema names in SQL Server include system schemas and common user schemas.
     *
     * When a 2-part function name like "dbo.ufnGetInventoryStock" is encountered,
     * we need to distinguish between:
     * - schema.function() call (e.g., dbo.ufnGetInventoryStock) - NOT a column reference
     * - column.method() call (e.g., Demographics.value) - IS a column reference
     *
     * We use schema name detection to identify the former case.
     *
     * @param name The potential schema name to check
     * @return true if it's a known SQL Server schema name
     */
    private boolean isSqlServerSchemaName(String name) {
        if (name == null || name.isEmpty()) {
            return false;
        }

        String upperName = name.toUpperCase();

        // System schemas
        if (upperName.equals("DBO") ||
            upperName.equals("SYS") ||
            upperName.equals("INFORMATION_SCHEMA") ||
            upperName.equals("GUEST") ||
            upperName.equals("DB_OWNER") ||
            upperName.equals("DB_ACCESSADMIN") ||
            upperName.equals("DB_SECURITYADMIN") ||
            upperName.equals("DB_DDLADMIN") ||
            upperName.equals("DB_BACKUPOPERATOR") ||
            upperName.equals("DB_DATAREADER") ||
            upperName.equals("DB_DATAWRITER") ||
            upperName.equals("DB_DENYDATAREADER") ||
            upperName.equals("DB_DENYDATAWRITER")) {
            return true;
        }

        return false;
    }

    /**
     * Check if a TObjectName is a cursor name in cursor-related statements.
     * Cursor names appear in DECLARE CURSOR, OPEN, FETCH, CLOSE, DEALLOCATE statements
     * and should not be treated as column references.
     *
     * @param objectName The object name to check
     * @return true if it's a cursor name in a cursor-related statement
     */
    private static boolean isNumericLiteral(String text) {
        if (text == null || text.isEmpty()) return false;
        boolean hasDigit = false;
        boolean hasDot = false;
        for (int i = 0; i < text.length(); i++) {
            char c = text.charAt(i);
            if (c >= '0' && c <= '9') {
                hasDigit = true;
            } else if (c == '.' && !hasDot) {
                hasDot = true;
            } else {
                return false;
            }
        }
        return hasDigit;
    }

    private boolean isCursorName(TObjectName objectName) {
        // Traverse up the parent chain to find cursor-related statements
        if (objectName.getDbObjectType() == EDbObjectType.cursor) return true;

        TParseTreeNode node = objectName.getParentObjectName();
        while (node != null) {
            // SQL Server cursor statements
            if (node instanceof gudusoft.gsqlparser.stmt.mssql.TMssqlDeclare) {
                gudusoft.gsqlparser.stmt.mssql.TMssqlDeclare declare =
                    (gudusoft.gsqlparser.stmt.mssql.TMssqlDeclare) node;
                if (declare.getCursorName() == objectName) {
                    return true;
                }
            }
            if (node instanceof gudusoft.gsqlparser.stmt.mssql.TMssqlOpen) {
                gudusoft.gsqlparser.stmt.mssql.TMssqlOpen open =
                    (gudusoft.gsqlparser.stmt.mssql.TMssqlOpen) node;
                if (open.getCursorName() == objectName) {
                    return true;
                }
            }
            if (node instanceof gudusoft.gsqlparser.stmt.mssql.TMssqlFetch) {
                gudusoft.gsqlparser.stmt.mssql.TMssqlFetch fetch =
                    (gudusoft.gsqlparser.stmt.mssql.TMssqlFetch) node;
                if (fetch.getCursorName() == objectName) {
                    return true;
                }
            }
            if (node instanceof gudusoft.gsqlparser.stmt.mssql.TMssqlClose) {
                gudusoft.gsqlparser.stmt.mssql.TMssqlClose close =
                    (gudusoft.gsqlparser.stmt.mssql.TMssqlClose) node;
                if (close.getCursorName() == objectName) {
                    return true;
                }
            }
            if (node instanceof gudusoft.gsqlparser.stmt.mssql.TMssqlDeallocate) {
                gudusoft.gsqlparser.stmt.mssql.TMssqlDeallocate deallocate =
                    (gudusoft.gsqlparser.stmt.mssql.TMssqlDeallocate) node;
                if (deallocate.getCursorName() == objectName) {
                    return true;
                }
            }
            // Generic cursor statements (used by other databases)
            if (node instanceof gudusoft.gsqlparser.stmt.TDeclareCursorStmt) {
                gudusoft.gsqlparser.stmt.TDeclareCursorStmt declare =
                    (gudusoft.gsqlparser.stmt.TDeclareCursorStmt) node;
                if (declare.getCursorName() == objectName) {
                    return true;
                }
            }
            if (node instanceof gudusoft.gsqlparser.stmt.TOpenStmt) {
                gudusoft.gsqlparser.stmt.TOpenStmt open =
                    (gudusoft.gsqlparser.stmt.TOpenStmt) node;
                if (open.getCursorName() == objectName) {
                    return true;
                }
            }
            if (node instanceof gudusoft.gsqlparser.stmt.TFetchStmt) {
                gudusoft.gsqlparser.stmt.TFetchStmt fetch =
                    (gudusoft.gsqlparser.stmt.TFetchStmt) node;
                if (fetch.getCursorName() == objectName) {
                    return true;
                }
            }
            if (node instanceof gudusoft.gsqlparser.stmt.TCloseStmt) {
                gudusoft.gsqlparser.stmt.TCloseStmt close =
                    (gudusoft.gsqlparser.stmt.TCloseStmt) node;
                if (close.getCursorName() == objectName) {
                    return true;
                }
            }
            node = node.getParentObjectName();
        }
        return false;
    }

    /**
     * Check if a name is a SQL Server datepart keyword.
     * These keywords are used in DATEDIFF, DATEADD, DATEPART, DATENAME functions
     * and should not be treated as column references.
     *
     * @param name The identifier name to check
     * @return true if it's a known SQL Server datepart keyword
     */
    private boolean isSqlServerDatepartKeyword(String name) {
        if (name == null) {
            return false;
        }
        // Only apply this check for SQL Server and Azure SQL Database
        if (dbVendor != EDbVendor.dbvmssql && dbVendor != EDbVendor.dbvazuresql) {
            return false;
        }
        return SQL_SERVER_DATEPART_KEYWORDS.contains(name.toLowerCase());
    }

    /**
     * SQL Server date functions that take a datepart keyword as first argument.
     */
    private static final Set<String> SQL_SERVER_DATE_FUNCTIONS = new HashSet<>(Arrays.asList(
        "datediff", "dateadd", "datepart", "datename", "datetrunc",
        "datediff_big"  // SQL Server 2016+
    ));

    /**
     * Check if a TObjectName is in a date function context.
     * This verifies that the token is preceded by "FUNCTION_NAME(" pattern.
     *
     * @param objectName The object name to check
     * @return true if it appears to be a datepart argument in a date function
     */
    private boolean isInDateFunctionContext(TObjectName objectName) {
        TSourceToken startToken = objectName.getStartToken();
        if (startToken == null) {
            return false;
        }

        // Use the token's container to access the token list
        TCustomSqlStatement stmt = objectName.getGsqlparser() != null ?
            (objectName.getGsqlparser().sqlstatements != null &&
             objectName.getGsqlparser().sqlstatements.size() > 0 ?
             objectName.getGsqlparser().sqlstatements.get(0) : null) : null;
        if (stmt == null || stmt.sourcetokenlist == null) {
            return false;
        }
        TSourceTokenList tokenList = stmt.sourcetokenlist;

        // Find the position of our token
        int pos = startToken.posinlist;
        if (pos < 0) {
            return false;
        }

        // Look for opening paren before this token (skipping whitespace)
        int parenPos = pos - 1;
        while (parenPos >= 0 && tokenList.get(parenPos).tokentype == ETokenType.ttwhitespace) {
            parenPos--;
        }
        if (parenPos < 0) {
            return false;
        }

        TSourceToken parenToken = tokenList.get(parenPos);
        if (parenToken.tokentype != ETokenType.ttleftparenthesis) {
            return false;
        }

        // Look for function name before the opening paren (skipping whitespace)
        int funcPos = parenPos - 1;
        while (funcPos >= 0 && tokenList.get(funcPos).tokentype == ETokenType.ttwhitespace) {
            funcPos--;
        }
        if (funcPos < 0) {
            return false;
        }

        TSourceToken funcToken = tokenList.get(funcPos);
        String funcName = funcToken.toString().toLowerCase();
        return SQL_SERVER_DATE_FUNCTIONS.contains(funcName);
    }

    /**
     * Check if a TObjectName is the alias part of SQL Server's proprietary column alias syntax.
     * In SQL Server, "column_alias = expression" is a valid way to alias a column.
     * The left side (column_alias) should not be treated as a column reference.
     *
     * Example: SELECT day_diff = DATEDIFF(DAY, start_date, end_date)
     * Here "day_diff" is an alias, not a column from any table.
     *
     * This method checks against the set populated by preVisit(TResultColumn).
     */
    private boolean isSqlServerProprietaryColumnAlias(TObjectName objectName, TParseTreeNode parent) {
        if (sqlServerProprietaryAliases.contains(objectName)) {
            if (DEBUG_SCOPE_BUILD) {
                System.out.println("[DEBUG] Skipping SQL Server proprietary column alias: " +
                        objectName.toString());
            }
            return true;
        }
        return false;
    }

    /**
     * Determine which scope a column reference belongs to
     */
    private IScope determineColumnScope(TObjectName objectName) {
        // Special handling for ORDER BY columns in combined queries (UNION/INTERSECT/EXCEPT)
        // The parser moves ORDER BY from a branch to the combined query, but the column
        // should be resolved in the branch's scope where it originally appeared.
        if (currentSelectScope != null) {
            TSelectSqlStatement selectStmt = getStatementForScope(currentSelectScope);
            if (selectStmt != null && selectStmt.isCombinedQuery()) {
                // Check if column is in an ORDER BY clause
                if (isInOrderByClause(objectName, selectStmt)) {
                    // Find the branch that contains this column's position
                    SelectScope branchScope = findBranchScopeByPosition(selectStmt, objectName);
                    if (branchScope != null) {
                        return branchScope;
                    }
                }
            }
            return currentSelectScope;
        }

        // Or use current UpdateScope if processing UPDATE statement
        if (currentUpdateScope != null) {
            return currentUpdateScope;
        }

        // Or use current MergeScope if processing MERGE statement
        if (currentMergeScope != null) {
            return currentMergeScope;
        }

        // Or use current DeleteScope if processing DELETE statement
        if (currentDeleteScope != null) {
            return currentDeleteScope;
        }

        // Fallback to top of stack
        return scopeStack.isEmpty() ? globalScope : scopeStack.peek();
    }

    /**
     * Get the TSelectSqlStatement for a SelectScope
     */
    private TSelectSqlStatement getStatementForScope(SelectScope scope) {
        for (Map.Entry<TSelectSqlStatement, SelectScope> entry : statementScopeMap.entrySet()) {
            if (entry.getValue() == scope) {
                return entry.getKey();
            }
        }
        return null;
    }

    /**
     * Check if an object name is inside an ORDER BY clause
     */
    private boolean isInOrderByClause(TObjectName objectName, TSelectSqlStatement stmt) {
        TOrderBy orderBy = stmt.getOrderbyClause();
        if (orderBy == null) {
            return false;
        }
        // Check if objectName's position is within ORDER BY's position range
        long objOffset = objectName.getStartToken().posinlist;
        long orderByStart = orderBy.getStartToken().posinlist;
        long orderByEnd = orderBy.getEndToken().posinlist;
        return objOffset >= orderByStart && objOffset <= orderByEnd;
    }

    /**
     * Find the branch SelectScope that contains the given column's position.
     * Returns null if no matching branch is found.
     */
    private SelectScope findBranchScopeByPosition(TSelectSqlStatement combinedStmt, TObjectName objectName) {
        if (!combinedStmt.isCombinedQuery()) {
            return null;
        }

        long columnLine = objectName.getStartToken().lineNo;

        // Search through branches recursively
        return findBranchScopeByLineRecursive(combinedStmt, columnLine);
    }

    /**
     * Iteratively search for the branch that contains the given line number.
     * Uses explicit stack to avoid StackOverflow on deeply nested UNION chains.
     */
    private SelectScope findBranchScopeByLineRecursive(TSelectSqlStatement stmt, long targetLine) {
        Deque<TSelectSqlStatement> stack = new ArrayDeque<>();
        stack.push(stmt);

        while (!stack.isEmpty()) {
            TSelectSqlStatement current = stack.pop();

            if (!current.isCombinedQuery()) {
                // This is a leaf branch - check if it contains the target line
                if (current.tables != null && current.tables.size() > 0) {
                    for (int i = 0; i < current.tables.size(); i++) {
                        TTable table = current.tables.getTable(i);
                        if (table.getStartToken().lineNo == targetLine) {
                            return statementScopeMap.get(current);
                        }
                    }
                }
                // Alternative: check if statement's range includes the target line
                long stmtStartLine = current.getStartToken().lineNo;
                long stmtEndLine = current.getEndToken().lineNo;
                if (targetLine >= stmtStartLine && targetLine <= stmtEndLine) {
                    return statementScopeMap.get(current);
                }
            } else {
                // Combined query - push children (right first so left is processed first)
                if (current.getRightStmt() != null) {
                    stack.push(current.getRightStmt());
                }
                if (current.getLeftStmt() != null) {
                    stack.push(current.getLeftStmt());
                }
            }
        }
        return null;
    }

    // ========== Accessors ==========

    public GlobalScope getGlobalScope() {
        return globalScope;
    }

    public INameMatcher getNameMatcher() {
        return nameMatcher;
    }

    public Map<TUpdateSqlStatement, UpdateScope> getUpdateScopeMap() {
        return Collections.unmodifiableMap(updateScopeMap);
    }

    public Map<TDeleteSqlStatement, DeleteScope> getDeleteScopeMap() {
        return Collections.unmodifiableMap(deleteScopeMap);
    }

    /**
     * Get the mapping of USING columns to their right-side tables.
     * In JOIN...USING syntax, USING columns should preferentially resolve
     * to the right-side (physical) table for TGetTableColumn compatibility.
     *
     * @return Map of USING column TObjectName -> right-side TTable
     */
    public Map<TObjectName, TTable> getUsingColumnToRightTable() {
        return Collections.unmodifiableMap(usingColumnToRightTable);
    }

    /**
     * Get the set of virtual trigger tables (deleted/inserted in SQL Server triggers).
     * These tables should be excluded from table output since their columns are
     * resolved to the trigger's target table.
     *
     * @return Set of TTable objects that are virtual trigger tables
     */
    public Set<TTable> getVirtualTriggerTables() {
        return Collections.unmodifiableSet(virtualTriggerTables);
    }

    /**
     * Get the set of SET clause target columns (UPDATE SET left-side columns).
     * These columns already have sourceTable correctly set to the UPDATE target table
     * and should NOT be re-resolved through star column push-down.
     *
     * @return Set of TObjectName nodes that are SET clause target columns
     */
    public Set<TObjectName> getSetClauseTargetColumns() {
        return Collections.unmodifiableSet(setClauseTargetColumns);
    }

    /**
     * Get the set of INSERT ALL target columns (from TInsertIntoValue columnList).
     * These columns already have sourceTable correctly set to the INSERT target table
     * and should NOT be re-resolved against the subquery scope.
     *
     * @return Set of TObjectName nodes that are INSERT ALL target columns
     */
    public Set<TObjectName> getInsertAllTargetColumns() {
        return Collections.unmodifiableSet(insertAllTargetColumns);
    }

    /**
     * Get the map of MERGE INSERT VALUES columns to their USING (source) table.
     * After name resolution, the resolver should restore sourceTable for these columns
     * to ensure they correctly link to the USING table per MERGE semantics.
     *
     * @return Map of TObjectName to their USING table
     */
    public Map<TObjectName, TTable> getMergeInsertValuesColumns() {
        return Collections.unmodifiableMap(mergeInsertValuesColumns);
    }
}