package gudusoft.gsqlparser.dlineage.dataflow.model;

import gudusoft.gsqlparser.dlineage.routine.RoutineAliasKey;
import gudusoft.gsqlparser.dlineage.routine.RoutineAliasRegistry;
import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.resolver2.metadata.StatementMetadata.ProcedureEnvironment;
import gudusoft.gsqlparser.EExpressionType;
import gudusoft.gsqlparser.ESetOperatorType;
import gudusoft.gsqlparser.ETableEffectType;
import gudusoft.gsqlparser.TCustomSqlStatement;
import gudusoft.gsqlparser.dlineage.util.DlineageUtil;
import gudusoft.gsqlparser.dlineage.util.NormalNameCollisions;
import gudusoft.gsqlparser.dlineage.util.Pair;
import gudusoft.gsqlparser.dlineage.util.Pair3;
import gudusoft.gsqlparser.dlineage.util.SHA256;
import gudusoft.gsqlparser.dlineage.util.ScopedNameKey;
import gudusoft.gsqlparser.dlineage.util.TableIdentityKey;
import gudusoft.gsqlparser.nodes.*;
import gudusoft.gsqlparser.sqlenv.ESQLDataObjectType;
import gudusoft.gsqlparser.sqlenv.IdentifierInputForm;
import gudusoft.gsqlparser.sqlenv.QualifiedCanonKey;
import gudusoft.gsqlparser.sqlenv.TSQLEnv;
import gudusoft.gsqlparser.sqlenv.TSQLTable;
import gudusoft.gsqlparser.stmt.*;
import gudusoft.gsqlparser.stmt.mssql.TMssqlDeclare;
import gudusoft.gsqlparser.util.IndexedLinkedHashMap;
import gudusoft.gsqlparser.util.Logger;
import gudusoft.gsqlparser.util.LoggerFactory;
import gudusoft.gsqlparser.util.SQLUtil;

import java.util.*;

@SuppressWarnings({ "unchecked", "rawtypes" })
public class ModelBindingManager {

        private static final Logger logger = LoggerFactory.getLogger(ModelBindingManager.class);

        private final Map modelBindingMap = new LinkedHashMap();
        private final Map processModelBindingMap = new LinkedHashMap();
        private final Map viewModelBindingMap = new LinkedHashMap();
        private final Map insertModelBindingMap = new LinkedHashMap();
        private final Map createModelBindingMap = new LinkedHashMap();
        private final Map createModelQuickBindingMap = new LinkedHashMap();
        private final Map mergeModelBindingMap = new LinkedHashMap();
        private final Map updateModelBindingMap = new LinkedHashMap();
        private final Map cursorModelBindingMap = new LinkedHashMap();
        private final Map tableNamesMap = new LinkedHashMap();
        // Models bound by table identity: a canonical miss never falls back to their folded name.
        private final Set<Table> identityBoundTables = Collections.newSetFromMap(new IdentityHashMap<Table, Boolean>());
        // Legacy normal names that different names share in this analysis; see normalName.
        private EDbVendor contestedVendor;
        private Set<String> contestedNormalNames = Collections.emptySet();
        private Set<String> contestedLegacyNames = Collections.emptySet();
        private final Map<String, String> collisionFreeNames = new HashMap<String, String>();
        private boolean legacyNormalNames;
        // Metadata identity lets a proven caller/callee share one endpoint after name scopes close.
        private final Map<TSQLTable, Table> temporaryMetadataModels = new IdentityHashMap<>();
        private final Map<TSQLTable, TStoredProcedureSqlStatement> temporaryMetadataOwners = new IdentityHashMap<>();
        /** The scopes of the routine bodies being analyzed, innermost first; see enterTemporaryTableScope. */
        private final Deque<List<Map>> temporaryScopes = new ArrayDeque<List<Map>>();
        private final Set<Table> dropTables = new HashSet<Table>();
        // The routine model bound to each routine statement. The same statement is bound to other models later (a SQL
        // function's result set), which replace it in modelBindingMap; this keeps the routine's own.
        private final Map<TCustomSqlStatement, Procedure> routineModels = new IdentityHashMap<TCustomSqlStatement, Procedure>();
        private gudusoft.gsqlparser.dlineage.routine.RoutineShadow.State routineShadowState;
        // Routines and Oracle packages by the names as written (RoutineAliasRegistry keeps the legacy index's precedence).
        private final RoutineAliasRegistry<Procedure> procedureAliases = new RoutineAliasRegistry<Procedure>();
        private final RoutineAliasRegistry<OraclePackage> packageAliases = new RoutineAliasRegistry<OraclePackage>();
        // A routine's function results (the result sets of its body) by the routine's name as written.
        private final RoutineAliasRegistry<Set<Object>> functionTableAliases = new RoutineAliasRegistry<Set<Object>>();
        // The deprecated text-keyed API's own maps: exactly the entries bound through it, keyed by the text as given and
        // looked up as the legacy maps were, with no analysis context needed (see bindProcedureByName).
        private final Map<String, Procedure> legacyProcedureNames = new LinkedHashMap<String, Procedure>();
        private final Map<String, OraclePackage> legacyPackageNames = new LinkedHashMap<String, OraclePackage>();
        private final Map<Object, Set<Object>> legacyFunctionTables = new LinkedHashMap<Object, Set<Object>>();
        // Local symbols (variables, cursors, declared types, trigger correlation names, table variables) by scope and name
        // as written.
        private final gudusoft.gsqlparser.dlineage.symbol.LocalSymbolRegistry localSymbols =
                        new gudusoft.gsqlparser.dlineage.symbol.LocalSymbolRegistry();
        // The cursor models by cursor name as written, in the declaring scope.
        private final gudusoft.gsqlparser.dlineage.symbol.LocalSymbolRegistry localCursorModels =
                        new gudusoft.gsqlparser.dlineage.symbol.LocalSymbolRegistry();
        // The identifier rules the analysis keyed this manager's routines under, so the deprecated text API can read a
        // name the same way from a thread with no analysis on it.
        private gudusoft.gsqlparser.sqlenv.IdentifierService routineService;
        private final Set<Relationship> relationHolder = Collections.synchronizedSet(new LinkedHashSet<Relationship>());
        // A table alias is resolved inside one statement: keyed by the statement's hash and the alias's
        // identity as written, never by a folded string.
        private final Map<ScopedNameKey, TTable> tableAliasMap = new LinkedHashMap<ScopedNameKey, TTable>();
        private final Map<TCustomSqlStatement, String> tableHashMap = new LinkedHashMap();
        private final Map<TCustomSqlStatement, String> topStmtHashMap = new HashMap();
        private final Map hashSQLMap = new HashMap();
        private final Map dynamicSQLMap = new HashMap();
        private final Set tableSet = new LinkedHashSet();
        private final Set resultSetSet = new LinkedHashSet();
        private final Set<String> dblinkTableSet = new LinkedHashSet();

        // Pipelined function stitching state
        // Keyed by a type's name as written under the analysis's rules (PipelinedFunctionAnalyzer); the deprecated
        // String API keeps its own text keys in the same maps.
        private final Map<Object, List<String>> objectTypeIndex = new LinkedHashMap<>();
        private final Map<Object, String> collectionToElementTypeIndex = new LinkedHashMap<>();
        private final Map<Object, List<PipelinedFunctionSignature>> pipelinedSignatures = new LinkedHashMap<>();
        private final List<PendingPipelinedCallSite> pendingPipelinedCallSites = new ArrayList<>();
        private final Set<String> resolvingPipelinedFunctions = new HashSet<>();

        public Map<String, Long> DISPLAY_ID = new LinkedHashMap<String, Long>();
        public Map<Long, String> DISPLAY_NAME = new LinkedHashMap<Long, String>();
        public Map<String, String> virtualTableNames = new LinkedHashMap<String, String>();

        public long TABLE_COLUMN_ID = 0;
        public long RELATION_ID = 0;
        public int virtualTableIndex = -1;

        /** The SQL-LR observation recorder of this analysis, or null (plan 06; internal). */
        private SqllrObservations sqllrObservations;

        /** The SQL-LR observation recorder of this analysis, or null. Internal API of the SQL-LR producer. */
        public SqllrObservations getSqllrObservations() {
                return sqllrObservations;
        }

        /** Binds a SQL-LR observation recorder to this analysis. Internal API of the SQL-LR producer. */
        public void setSqllrObservations(SqllrObservations observations) {
                this.sqllrObservations = observations;
        }

        /**
         * The position in the script of the top-level statement being analyzed, as ordered by the analyzer: the unit,
         * then the statement in the unit; -1 when unknown. A read of a nested field is validated against the CREATE
         * TABLE in force at this position (plan rule R10, {@link Table#getActiveFieldDeclaration()}).
         */
        private long currentStatementOrdinal = -1;

        public long getCurrentStatementOrdinal() {
                return currentStatementOrdinal;
        }

        public void setCurrentStatementOrdinal(long currentStatementOrdinal) {
                this.currentStatementOrdinal = currentStatementOrdinal;
        }

        private final static ThreadLocal localManager = new ThreadLocal();
        private final static ThreadLocal globalDatabase = new ThreadLocal();
        private final static ThreadLocal globalSchema = new ThreadLocal();
        /**
         * The form the global database / schema text arrived in: absent for a SQL spelling (a {@code USE},
         * a session default, a search path), {@code CATALOG_STORED} for the stored name a metadata export
         * gives a query's group. The text stays the bare name, for display; lineage keys read it by its form.
         */
        private final static ThreadLocal<IdentifierInputForm> globalDatabaseForm = new ThreadLocal<IdentifierInputForm>();
        private final static ThreadLocal<IdentifierInputForm> globalSchemaForm = new ThreadLocal<IdentifierInputForm>();
        private final static ThreadLocal schemaUnsetStatements = new ThreadLocal();
        private final static ThreadLocal globalVendor = new ThreadLocal();
        private final static ThreadLocal globalSQLEnv = new ThreadLocal();
        private final static ThreadLocal globalHash = new ThreadLocal();
        private final static ThreadLocal globalStmtStack = new ThreadLocal();
        /**
         * Set while the statement on {@link #getGlobalStmtStack()} is a stand-in rather than the
         * statement the work belongs to — pipelined stitching runs after every pass and pushes the
         * script's LAST statement just to have one. Anything that reads the statement for provenance,
         * such as a comment, must not attribute that statement's text to these relationships.
         */
        private final static ThreadLocal syntheticStmtContext = new ThreadLocal();

        public static boolean isSyntheticStmtContext() {
                return Boolean.TRUE.equals(syntheticStmtContext.get());
        }

        public static void setSyntheticStmtContext(boolean synthetic) {
                syntheticStmtContext.set(Boolean.valueOf(synthetic));
        }
        private final static ThreadLocal globalSqlInfo = new ThreadLocal();
        private final static ThreadLocal globalOption = new ThreadLocal();
        private final static ThreadLocal globalOraclePackage = new ThreadLocal();
        private final static ThreadLocal globalProcedure = new ThreadLocal();

        public static void set(ModelBindingManager modelManager) {
                if (modelManager != null) {
                        localManager.set(modelManager);
                }
        }

        public static ModelBindingManager get() {
                return (ModelBindingManager) localManager.get();
        }

        public static void setGlobalDatabase(String database) {
                if (database != null) {
                        globalDatabase.set(database);
                        globalDatabaseForm.remove();
                }
        }

        /** {@link #setGlobalDatabase(String)} with the form the text arrived in; null is a SQL spelling. */
        public static void setGlobalDatabase(String database, IdentifierInputForm form) {
                if (database != null) {
                        globalDatabase.set(database);
                        if (form == IdentifierInputForm.CATALOG_STORED) {
                                globalDatabaseForm.set(form);
                        } else {
                                globalDatabaseForm.remove();
                        }
                }
        }

        /** {@code CATALOG_STORED} when the global database text is a stored name, else null. */
        public static IdentifierInputForm getGlobalDatabaseForm() {
                return globalDatabaseForm.get();
        }

        /** The global database as a SQL spelling: its text, delimited when it is a stored name that needs it. */
        public static String getGlobalDatabaseSpelling() {
                String database = getGlobalDatabase();
                return getGlobalDatabaseForm() == IdentifierInputForm.CATALOG_STORED
                                ? DlineageUtil.storedNameSpelling(ESQLDataObjectType.dotCatalog, database) : database;
        }

        public static String getGlobalDatabase() {
                return (String) globalDatabase.get();
        }

        public static void removeGlobalDatabase() {
                globalDatabase.remove();
                globalDatabaseForm.remove();
        }

        public static void setGlobalSchema(String schema) {
                if (schema != null) {
                        globalSchema.set(schema);
                        globalSchemaForm.remove();
                }
        }

        /** {@link #setGlobalSchema(String)} with the form the text arrived in; null is a SQL spelling. */
        public static void setGlobalSchema(String schema, IdentifierInputForm form) {
                if (schema != null) {
                        globalSchema.set(schema);
                        if (form == IdentifierInputForm.CATALOG_STORED) {
                                globalSchemaForm.set(form);
                        } else {
                                globalSchemaForm.remove();
                        }
                }
        }

        /** {@code CATALOG_STORED} when the global schema text is a stored name, else null. */
        public static IdentifierInputForm getGlobalSchemaForm() {
                return globalSchemaForm.get();
        }

        /** The global schema as a SQL spelling: its text, delimited when it is a stored name that needs it. */
        public static String getGlobalSchemaSpelling() {
                String schema = getGlobalSchema();
                return getGlobalSchemaForm() == IdentifierInputForm.CATALOG_STORED
                                ? DlineageUtil.storedNameSpelling(ESQLDataObjectType.dotSchema, schema) : schema;
        }

        public static void removeGlobalSchema() {
                globalSchema.remove();
                globalSchemaForm.remove();
        }

        public static String getGlobalSchema() {
                return (String) globalSchema.get();
        }

        /**
         * The statements that a Snowflake {@code USE <database>} left with NO current
         * schema, i.e. everything after such a switch up to the next schema switch.
         *
         * <p>Recorded as a set of statements rather than as a running flag on
         * purpose. The analyzer walks the statement list several times - one pass for
         * CREATE TABLE, another for views, another for procedures - replaying the
         * {@code USE} statements in each. A running flag set during one pass is still
         * set when a LATER pass reaches a statement that precedes the switch, so it
         * would apply the clearing backwards and strip an already-exact qualification
         * off a statement that ran while the old schema was still current. Keyed by
         * statement, the answer is the same no matter which pass asks.
         *
         * <p>See GitHub #715 / MantisBT 4677.
         */
        public static void setSchemaUnsetStatements(Set<TCustomSqlStatement> statements) {
                if (statements == null || statements.isEmpty()) {
                        schemaUnsetStatements.remove();
                } else {
                        schemaUnsetStatements.set(statements);
                }
        }

        public static void removeSchemaUnsetStatements() {
                schemaUnsetStatements.remove();
        }

        /**
         * Whether the statement being analyzed right now has no current schema
         * because a Snowflake {@code USE <database>} unset it.
         *
         * @see #setSchemaUnsetStatements(Set)
         */
        @SuppressWarnings("unchecked")
        public static boolean isGlobalSchemaUnset() {
                Set<TCustomSqlStatement> unset = (Set<TCustomSqlStatement>) schemaUnsetStatements.get();
                if (unset == null || unset.isEmpty()) {
                        return false;
                }
                Stack<TCustomSqlStatement> stack = getGlobalStmtStack();
                if (stack == null || stack.isEmpty()) {
                        return false;
                }
                return unset.contains(DlineageUtil.getTopStmt(stack.peek()));
        }

        public static void setGlobalHash(String hash) {
                if (hash != null) {
                        globalHash.set(hash);
                }
        }

        public static void removeGlobalHash() {
                globalHash.remove();
        }

        public static String getGlobalHash() {
                return (String) globalHash.get();
        }

        public static void setGlobalOraclePackage(OraclePackage currentOraclePackage) {
                if (currentOraclePackage != null) {
                        globalOraclePackage.set(currentOraclePackage);
                }
        }

        public static void removeGlobalOraclePackage() {
                globalOraclePackage.remove();
        }

        public static OraclePackage getGlobalOraclePackage() {
                return (OraclePackage) globalOraclePackage.get();
        }
        
        public static void setGlobalProcedure(TStoredProcedureSqlStatement procedureSqlStatement) {
                if (procedureSqlStatement != null) {
                        globalProcedure.set(procedureSqlStatement);
                }
        }

        public static void removeGlobalProcedure() {
                globalProcedure.remove();
                ModelBindingManager.get().cleanTempTable();
        }

        /**
         * Puts back the routine a statement was analyzed under, null for none. Unlike {@link #removeGlobalProcedure()}
         * this ends no routine: the temporary tables stay where they are.
         */
        public static void restoreGlobalProcedure(TStoredProcedureSqlStatement procedureSqlStatement) {
                if (procedureSqlStatement != null) {
                        globalProcedure.set(procedureSqlStatement);
                } else {
                        globalProcedure.remove();
                }
        }

        public static TStoredProcedureSqlStatement getGlobalProcedure() {
                return (TStoredProcedureSqlStatement) globalProcedure.get();
        }
        
        public static void setGlobalVendor(EDbVendor vendor) {
                if (vendor != null) {
                        globalVendor.set(vendor);
                }
        }

        public static void removeGlobalVendor() {
                globalVendor.remove();
        }

        public static EDbVendor getGlobalVendor() {
                return (EDbVendor) globalVendor.get();
        }

        /**
         * The frozen {@link gudusoft.gsqlparser.sqlenv.IdentifierService} of the analysis running on
         * this thread — one engine, configured once at the analyzer entry, used by every lineage
         * identity key, binding map and output merge in the run.
         *
         * <p>Carried the same way this class already carries the vendor, the SQL environment and the
         * option, so that two analyses with opposite configurations can run concurrently without
         * either seeing the other's rules. It is NOT consulted by the vendor-only static comparison
         * API in {@code SQLUtil} / {@code IdentifierService}: those keep their stated default
         * semantics for independent callers.
         */
        private final static ThreadLocal globalIdentifierService = new ThreadLocal();

        /**
         * Install the analysis's identifier service for this thread.
         *
         * <p>Callers save the previous value and restore it in a {@code finally} block; nesting on one
         * thread and thread-pool reuse both depend on that, and a leaked service would let the next
         * analysis on the same worker key its model under another run's rules.
         *
         * @param service the frozen service; null clears the binding
         */
        public static void setGlobalIdentifierService(gudusoft.gsqlparser.sqlenv.IdentifierService service) {
                if (service == null) {
                        globalIdentifierService.remove();
                } else {
                        globalIdentifierService.set(service);
                }
        }

        public static void removeGlobalIdentifierService() {
                globalIdentifierService.remove();
        }

        /**
         * The service bound to this thread with no vendor-default substitution — what
         * {@link #setGlobalIdentifierService} has to be handed back to restore the previous state.
         *
         * @return the bound service, or null when nothing is bound
         */
        /**
         * Publishes the legacy normal names that different names share in this analysis, as
         * {@link NormalNameCollisions#scan} found them; {@code null} clears them.
         */
        public void setContestedNormalNames(EDbVendor vendor, Set<String> contested) {
                boolean none = vendor == null || contested == null || contested.isEmpty();
                contestedVendor = none ? null : vendor;
                contestedNormalNames = none ? Collections.<String>emptySet() : contested;
                contestedLegacyNames = none ? Collections.<String>emptySet() : NormalNameCollisions.legacyNames(contested);
                collisionFreeNames.clear();
        }

        /**
         * Makes {@link #normalName} return legacy names, for a pass that only relabels finished output
         * (normalized display names are bare, as the legacy fold made them).
         *
         * @return the previous setting, to restore
         */
        public boolean useLegacyNormalNames(boolean legacy) {
                boolean previous = legacyNormalNames;
                legacyNormalNames = legacy;
                return previous;
        }

        /** Whether any two different names in this analysis share a legacy normal name. */
        public boolean hasContestedNormalNames() {
                return !contestedLegacyNames.isEmpty();
        }

        /**
         * The normal name of one identifier segment in this analysis: its legacy name, unless a
         * different name shares that string (see {@link NormalNameCollisions}).
         */
        public String normalName(EDbVendor vendor, ESQLDataObjectType type, String origin, String legacy) {
                if (contestedLegacyNames.isEmpty() || legacyNormalNames || legacy == null
                                || vendor != contestedVendor || type == null || origin == null
                                || !contestedLegacyNames.contains(legacy.toUpperCase(Locale.ROOT))) {
                        return legacy;
                }
                String memoKey = type.name() + '\u0000' + origin;
                String name = collisionFreeNames.get(memoKey);
                if (name == null) {
                        name = NormalNameCollisions.normalName(contestedNormalNames, identifierServiceFor(vendor), type,
                                        origin, legacy);
                        collisionFreeNames.put(memoKey, name);
                }
                return name;
        }

        /** The analysis's own identifier rules when they are for {@code vendor}, else the vendor's. */
        private static gudusoft.gsqlparser.sqlenv.IdentifierService identifierServiceFor(EDbVendor vendor) {
                gudusoft.gsqlparser.sqlenv.IdentifierService service = getGlobalIdentifierService();
                return service != null && service.getProfile().getVendor() == vendor ? service
                                : gudusoft.gsqlparser.sqlenv.IdentifierService.defaultServiceFor(vendor);
        }

        public static gudusoft.gsqlparser.sqlenv.IdentifierService getGlobalIdentifierServiceRaw() {
                return (gudusoft.gsqlparser.sqlenv.IdentifierService) globalIdentifierService.get();
        }

        /**
         * The analysis's identifier service, or the vendor default when no analysis configured one.
         *
         * @return the service, or null when not even a vendor is known on this thread
         */
        public static gudusoft.gsqlparser.sqlenv.IdentifierService getGlobalIdentifierService() {
                gudusoft.gsqlparser.sqlenv.IdentifierService service =
                        (gudusoft.gsqlparser.sqlenv.IdentifierService) globalIdentifierService.get();
                if (service != null) {
                        return service;
                }
                EDbVendor vendor = getGlobalVendor();
                return vendor == null ? null
                        : gudusoft.gsqlparser.sqlenv.IdentifierService.defaultServiceFor(vendor);
        }

        public static void setGlobalSQLEnv(TSQLEnv sqlenv) {
                if (sqlenv != null) {
                        globalSQLEnv.set(sqlenv);
                }
        }

        public static void removeGlobalSQLEnv() {
                globalSQLEnv.remove();
        }

        public static TSQLEnv getGlobalSQLEnv() {
                return (TSQLEnv) globalSQLEnv.get();
        }

        public static String getGlobalServer() {
                TSQLEnv sqlEnv = getGlobalSQLEnv();
                if (sqlEnv != null)
                        return TSQLEnv.DEFAULT_SERVER_NAME.equals(sqlEnv.getDefaultServerName()) ? null : sqlEnv.getDefaultServerName();
                return null;
        }

        /**
         * Resolve the effective default database (catalog) used to qualify
         * unqualified / partial object names, with a three-tier precedence:
         *
         * <ol>
         * <li>the active global database — an in-script {@code USE database}, or the
         * per-group database set by {@code DataFlowAnalyzer};</li>
         * <li>the per-analysis {@code Option.getDefaultDatabase()};</li>
         * <li>the attached {@code TSQLEnv} default catalog;</li>
         * <li>{@code TSQLEnv.DEFAULT_DB_NAME}.</li>
         * </ol>
         *
         * Each lower tier is consulted only when the higher tier is null/empty. This
         * lets a shared multi-catalog {@code TSQLEnv} be reused across analyses with
         * different per-analysis default databases (tier 2) without mutating the env,
         * while still honoring an in-script {@code USE database} (tier 1).
         */
        public static String getEffectiveDefaultDatabase() {
                // tier 1: active global database (USE database / per-group database)
                String database = getGlobalDatabase();
                if (!SQLUtil.isEmpty(database)) {
                        return database;
                }
                // tier 2: per-analysis Option default database
                Option option = getGlobalOption();
                if (option != null) {
                        String optionDatabase = option.getDefaultDatabase();
                        if (!SQLUtil.isEmpty(optionDatabase) && !TSQLEnv.DEFAULT_DB_NAME.equals(optionDatabase)) {
                                return optionDatabase;
                        }
                }
                // tier 3: attached TSQLEnv default catalog
                TSQLEnv sqlenv = getGlobalSQLEnv();
                if (sqlenv != null && !SQLUtil.isEmpty(sqlenv.getDefaultCatalogName())) {
                        return sqlenv.getDefaultCatalogName();
                }
                // tier 4: fallback
                return TSQLEnv.DEFAULT_DB_NAME;
        }

        /**
         * The schema an unqualified name defaults to right now.
         *
         * <p>Six model classes used to carry an identical copy of this fallback; it
         * lives here so the {@link #isGlobalSchemaUnset() unset} rule cannot be
         * applied to some of them and forgotten on the others. Returns
         * {@link TSQLEnv#DEFAULT_SCHEMA_NAME} when there is no schema to default to.
         *
         * @see #getEffectiveDefaultDatabase()
         */
        public static String getEffectiveDefaultSchema() {
                // A Snowflake USE <database> unset the current schema for this statement.
                // The attached env's default schema is batch-global -- TUseSchema writes
                // it while PARSING, so it holds the LAST USE SCHEMA of the whole script --
                // and falling back to it here would re-attach the previous database's
                // schema to names that follow the switch. See GitHub #715.
                if (isGlobalSchemaUnset()) {
                        // Unset, unless the attached catalog PROVES what the switch landed
                        // in. Snowflake makes PUBLIC current when the new database has one;
                        // when the catalog shows it does, that is a fact rather than an
                        // assumption, and discarding it would lose an exact resolution.
                        String afterSwitch = null;
                        if (getGlobalSQLEnv() != null) {
                                afterSwitch = getGlobalSQLEnv().findSchemaAfterDatabaseSwitch(getEffectiveDefaultDatabase());
                        }
                        return SQLUtil.isEmpty(afterSwitch) ? TSQLEnv.DEFAULT_SCHEMA_NAME : afterSwitch;
                }
                String defaultSchema = null;
                if (getGlobalSQLEnv() != null) {
                        defaultSchema = getGlobalSQLEnv().getDefaultSchemaName();
                }
                if (!SQLUtil.isEmpty(defaultSchema)) {
                        return defaultSchema;
                }
                return TSQLEnv.DEFAULT_SCHEMA_NAME;
        }

        public static void setGlobalStmtStack(Stack<TCustomSqlStatement> stack) {
                if (stack != null) {
                        globalStmtStack.set(stack);
                }
        }

        public static void removeGlobalStmtStack() {
                globalStmtStack.remove();
        }
        
        public static void setGlobalSqlInfo(IndexedLinkedHashMap<String, List<SqlInfo>> sqlInfoMap) {
                if (sqlInfoMap != null) {
                        globalSqlInfo.set(sqlInfoMap);
                }
        }

        public static void removeGlobalSqlInfo() {
                globalSqlInfo.remove();
        }

        public static IndexedLinkedHashMap<String, List<SqlInfo>> getGlobalSqlInfo() {
                return (IndexedLinkedHashMap<String, List<SqlInfo>>) globalSqlInfo.get();
        }

        public static void setGlobalOption(Option option) {
                if (option != null) {
                        globalOption.set(option);
                }
        }
        
        public static Option getGlobalOption() {
                return (Option) globalOption.get();
        }

        public static void removeGlobalOption() {
                globalOption.remove();
        }

        public static Stack<TCustomSqlStatement> getGlobalStmtStack() {
                return (Stack<TCustomSqlStatement>) globalStmtStack.get();
        }

        public static void remove() {
                localManager.remove();
                globalDatabase.remove();
                globalSchema.remove();
                globalDatabaseForm.remove();
                globalSchemaForm.remove();
                schemaUnsetStatements.remove();
                globalVendor.remove();
                globalSQLEnv.remove();
                globalHash.remove();
                globalStmtStack.remove();
                globalOption.remove();
                globalSqlInfo.remove();
                globalIdentifierService.remove();
        }

    private IdentityHashMap<Object,Object> commentOccurrenceBindings;

    /** Records the model actually selected by the factory, without changing its lookup maps. */
    public <T> T observeCommentOccurrence(Object ast, T model) {
        Option opt = getGlobalOption();
        if (opt != null && opt.isCollectCommentBindings() && ast != null && model != null) {
            if (commentOccurrenceBindings == null) commentOccurrenceBindings = new IdentityHashMap<Object,Object>();
            commentOccurrenceBindings.put(ast, model);
        }
        return model;
    }

    /** Read existing AST bindings without name fallback, allocation, or ID changes. */
    public void visitExactBindings(java.util.function.BiConsumer<Object, Object> visitor) {
        if (commentOccurrenceBindings != null) {
            try { commentOccurrenceBindings.forEach(visitor); }
            finally { commentOccurrenceBindings = null; }
        }
        for (Map map : new Map[] { modelBindingMap, processModelBindingMap, viewModelBindingMap,
                insertModelBindingMap, createModelBindingMap, mergeModelBindingMap, updateModelBindingMap }) {
            for (Object item : map.entrySet()) {
                Map.Entry entry = (Map.Entry) item;
                visitor.accept(entry.getKey(), entry.getValue());
            }
        }
    }

        public void bindModel(Object gspModel, Object relationModel) {
                if(gspModel == null) {
                        return;
                }
                modelBindingMap.put(gspModel, relationModel);
                if (gspModel instanceof TCustomSqlStatement && relationModel instanceof Procedure) {
                        routineModels.put((TCustomSqlStatement) gspModel, (Procedure) relationModel);
                }

                TTable table = null;
                if (gspModel instanceof TTable && !(gspModel instanceof TCTE)) {
                        table = ((TTable) gspModel);
                } else if (gspModel instanceof Table) {
                        table = ((Table) gspModel).getTableObject();
                } else if (gspModel instanceof QueryTable) {
                        table = ((QueryTable) gspModel).getTableObject();
                } else if (gspModel instanceof TCTE) {
                        TTableList tables = ((TCTE) gspModel).getPreparableStmt().tables;
                        for (int j = 0; j < tables.size(); j++) {
                                TTable item = tables.getTable(j);
                                if (item != null && !SQLUtil.isEmpty(item.getAliasName())) {
                                        TCustomSqlStatement stmt = ((TCTE) gspModel).getPreparableStmt();
                                        if (tableHashMap.containsKey(stmt)) {
                                                tableAliasMap.put(aliasKey(tableHashMap.get(stmt), item.getAliasName()), item);
                                        } else {
                                                String sql = stmt.toString();
                                                if(sql == null){
                                                        System.err.println("Current statement toString() returns null.");
                                                        continue;
                                                }
                                                String hash = SHA256.getMd5(sql);
                                                tableHashMap.put(stmt, hash);
                                                tableAliasMap.put(aliasKey(hash, item.getAliasName()), item);
                                        }
                                }

                                if (item != null) {
                                        tableSet.add(item);
                                }
                        }
                } else if (gspModel instanceof Pair && ((Pair) gspModel).first instanceof Table) {
                        table = ((Table) ((Pair) gspModel).first).getTableObject();
                }

                if (table == null && relationModel instanceof QueryTable) {
                        table = ((QueryTable) relationModel).getTableObject();
                }

                updateTableAliasMap(table);

                if (table != null) {
                        tableSet.add(table);
                }
                
                if(relationModel instanceof ResultSet) {
                        resultSetSet.add(relationModel);
                }
        }

        /** The alias map's key: the statement hash, and the alias (or the column's qualifier) as written. */
        private static ScopedNameKey aliasKey(String statementHash, String aliasAsWritten) {
                return new ScopedNameKey(statementHash, DlineageUtil.tableNameKey(aliasAsWritten));
        }

        protected void updateTableAliasMap(TTable table) {
                if (table != null && !SQLUtil.isEmpty(table.getAliasName())) {
                        TCustomSqlStatement stmt = ModelBindingManager.getGlobalStmtStack().peek();
                        if (tableHashMap.containsKey(stmt)) {
                                tableAliasMap.put(aliasKey(tableHashMap.get(stmt), table.getAliasName()), table);
                        } else {
                                String sql = stmt.toString();
                                if(sql == null){
                                        System.err.println("Current statement toString() returns null.");
                                }
                                else {
                                        String hash = SHA256.getMd5(sql);
                                        tableHashMap.put(stmt, hash);
                                        tableAliasMap.put(aliasKey(hash, table.getAliasName()), table);
                                }
                        }
                }
        }

        /**
         * The model bound to {@code gspModel} itself, never one found by its name: a relation such as a LATERAL VIEW
         * must not take the model of a table that has its name ({@link #getModel} falls back to the name of a TTable).
         */
        public Object getBoundModel(Object gspModel) {
                return gspModel == null ? null : modelBindingMap.get(gspModel);
        }

        public Object getModel(Object gspModel) {
                if (gspModel == null) {
                        return null;
                }

                if (gspModel instanceof TTable && !(gspModel instanceof TCTE)) {
                        TTable table = (TTable) gspModel;
                        if (table.getCTE() != null) {
                                Object result =  modelBindingMap.get(table.getCTE());
                                if (result != null) {
                                        return result;
                                }
                        }
                        if (table.getAliasClause() != null && table.getAliasClause().getColumns() != null) {
                                Object result = modelBindingMap.get(table.getAliasClause().getColumns());
                                if (result != null) {
                                        return result;
                                }
                        }
                        if (table.getSubquery() != null && !table.getSubquery().isCombinedQuery()) {
                                Object result =  modelBindingMap.get(table.getSubquery().getResultColumnList());
                                if (result != null) {
                                        return result;
                                }
                        }
                }
                if (gspModel instanceof TSelectSqlStatement) {
                        TSelectSqlStatement select = (TSelectSqlStatement) gspModel;
                        if (!select.isCombinedQuery()) {
                                if (select.getResultColumnList() != null) {
                                        Object result = modelBindingMap.get(select.getResultColumnList());
                                        if (result != null) {
                                                return result;
                                        }
                                }
                                else if (select.getTransformClause() != null) {
                                        Object result = modelBindingMap.get(select.getTransformClause());
                                        if (result != null) {
                                                return result;
                                        }
                                }
                        }
                }
                Object result = modelBindingMap.get(gspModel);
                if (result == null) {
                        result = createModelBindingMap.get(gspModel);
                }
                if (result == null) {
                        result = insertModelBindingMap.get(gspModel);
                }
                if (result == null) {
                        result = updateModelBindingMap.get(gspModel);
                }
                if (result == null) {
                        result = mergeModelBindingMap.get(gspModel);
                }
                if (result == null) {
                        result = viewModelBindingMap.get(gspModel);
                }
                if (result == null) {
                        result = cursorModelBindingMap.get(gspModel);
                }

                if (result == null && gspModel instanceof TTable) {
                        result = getCreateTable((TTable) gspModel);
                }

                if (result == null && gspModel instanceof TTable) {
                        result = (Table) getCreateModel((TTable) gspModel);
                }

                if (result == null && gspModel instanceof TTable) {
                        TTable table = (TTable) gspModel;
                        if (table.getLinkTable() != null) {
                                result = (Table) getTableByName(
                                                DlineageUtil.getTableIdentityKey(table.getLinkTable().getTableName().toString()));
                                if (result == null) {
                                        result = (Table) getTableByName(
                                                        DlineageUtil.getTableIdentityKeyWithDefaultSchema(table.getLinkTable().getTableName().toString()));
                                }
                        } else {
                                result = (Table) getTableByName(
                                                DlineageUtil.getTableIdentityKey(((TTable) gspModel).getTableName().toString()));
                                if (result == null) {
                                        result = (Table) getTableByName(
                                                        DlineageUtil.getTableIdentityKeyWithDefaultSchema(((TTable) gspModel).getTableName().toString()));
                                }
                        }
                        TObjectName written = table.getLinkTable() != null ? table.getLinkTable().getTableName() : table.getTableName();
                        // A table no FROM item or DML target declared (the qualifier of rec.field) names a local first; a FROM or
                        // DML relation (FROM @t) is the table path's, else a local relation.
                        boolean implicit = table.getEffectType() == null
                                        || table.getEffectType() == ETableEffectType.tetImplicitLateralDerivedTable;
                        result = resolveMixedRelation(written == null ? null : written.toString(),
                                        result instanceof Table ? (Table) result : null, implicit);
                }
                
                if (result == null && gspModel instanceof TTable) {
                        TTable table = (TTable) gspModel;
                        if(table.getFuncCall()!=null) {
                                result = getModel(table.getFuncCall());
                        }
                }
                
                if (result == null && gspModel instanceof TTable) {
                        TTable table = (TTable) gspModel;
                        Table tableModel = new Table(table);
                        result = (Table) getTableByName(tableModel.getBindingKey());
                }

                if (gspModel instanceof TTable && result instanceof Table) {
                        return visibleTemporaryModel((TTable) gspModel, (Table) result);
                }
                return result;
        }

        /** The named routine whose body holds a routine statement; an anonymous block is part of the one around it. */
        private static TStoredProcedureSqlStatement namedRoutine(TStoredProcedureSqlStatement routine) {
                for (TCustomSqlStatement current = routine; current != null; current = current.getParentStmt()) {
                        if (current instanceof TStoredProcedureSqlStatement
                                        && ((TStoredProcedureSqlStatement) current).getStoredProcedureName() != null) {
                                return (TStoredProcedureSqlStatement) current;
                        }
                }
                return routine;
        }

        /** Name-based caches must not override the metadata captured at a temporary reference. */
        Table visibleTemporaryModel(TTable reference, Table candidate) {
                if (candidate == null || !reference.isResolved()
                                || !(reference.getSqlEnv() instanceof ProcedureEnvironment)) return candidate;
                TTable origin = candidate.getTableObject();
                if (origin == reference) return candidate;
                if (origin != null && reference.getResolvedTable() == null && origin.getResolvedTable() != null
                                && getGlobalProcedure() != null
                                && namedRoutine(temporaryMetadataOwners.get(origin.getResolvedTable())) == namedRoutine(getGlobalProcedure())
                                && gudusoft.gsqlparser.sqlenv.TemporaryTableSemantics.ofName(reference.dbvendor, reference.getTableName())
                                                == gudusoft.gsqlparser.sqlenv.TemporaryTableSemantics.Scope.SESSION) {
                        // This routine created the session table in SQL resolver2 never saw (EXECUTE of a
                        // string). It outlives that statement, so the routine's later reference is to it.
                        return candidate;
                }
                if (origin == null || origin.getResolvedTable() != reference.getResolvedTable()) return null;
                if (reference.getResolvedTable() == null && origin.getSqlEnv() != reference.getSqlEnv()) return null;
                return candidate;
        }

        public List<Procedure> getProcedureModels(){
                List<Procedure> procedures = new ArrayList<Procedure>();
                for (Object obj : modelBindingMap.values()) {
                        if(obj instanceof Procedure && !procedures.contains(obj)){
                                procedures.add((Procedure)obj);
                        }
                }
                return procedures;
        }
        
        public List<OraclePackage> getOraclePackageModels(){
                List<OraclePackage> oraclePackages = new ArrayList<OraclePackage>();
                for (Object obj : modelBindingMap.values()) {
                        if(obj instanceof OraclePackage && !oraclePackages.contains(obj)){
                                oraclePackages.add((OraclePackage)obj);
                        }
                }
                return oraclePackages;
        }
        
        public List<Process> getProcessModels(){
                List<Process> processes = new ArrayList<Process>();
                for (Object obj : processModelBindingMap.values()) {
                        if(obj instanceof Process && !processes.contains(obj)){
                                processes.add((Process)obj);
                        }
                }
                return processes;
        }
        
        public void bindProcessModel(TParseTreeNode gspModel, Object relationModel) {
                processModelBindingMap.put(gspModel, relationModel);
        }

        public void unbindProcessModel(TParseTreeNode gspModel) {
                processModelBindingMap.remove(gspModel);
        }

        public Process getProcessModel(TParseTreeNode gspModel) {
                return (Process)processModelBindingMap.get(gspModel);
        }
        
        public void bindViewModel(Object gspModel, Object relationModel) {
                viewModelBindingMap.put(gspModel, relationModel);
        }
        
        public Object getViewModel(Object gspModel) {
                return viewModelBindingMap.get(gspModel);
        }

        public void bindUpdateModel(Object gspModel, Object relationModel) {
                updateModelBindingMap.put(gspModel, relationModel);
        }

        public Object getUpdateModel(Object gspModel) {
                return updateModelBindingMap.get(gspModel);
        }

        public void bindMergeModel(Object gspModel, Object relationModel) {
                mergeModelBindingMap.put(gspModel, relationModel);
        }

        public Object getMergeModel(Object gspModel) {
                return mergeModelBindingMap.get(gspModel);
        }

        public void bindInsertModel(Object gspModel, Object relationModel) {
                insertModelBindingMap.put(gspModel, relationModel);
        }

        public Object getInsertModel(Object gspModel) {
                return insertModelBindingMap.get(gspModel);
        }

        /** Adds one of a routine's function results under the routine's name as written. */
        public void bindFunctionResult(RoutineAliasKey key, Object functionTable) {
                if (key == null) return;
                noteRoutineService(key);
                Set<Object> tableSet = functionTableAliases.get(key);
                if (tableSet == null) {
                        tableSet = new LinkedHashSet<Object>();
                        functionTableAliases.put(key, tableSet);
                }
                tableSet.add(functionTable);
        }

        /** A routine's function results, by its name as written (the exact name, else the other shape's routine level). */
        public Set<Object> getFunctionResults(RoutineAliasKey key) {
                return functionTableAliases.lookupName(key);
        }

        /**
         * Adds a function result under a key of the deprecated text-keyed API: the key as given (any object), and, for text,
         * also the routine name the text reads as, so the analysis's own lookups see it.
         *
         * @deprecated function results are keyed by the routine's name as written: use
         *             {@link #bindFunctionResult(RoutineAliasKey, Object)}
         */
        @Deprecated
        public void bindTableFunction(Object gspModel, Object functionTable) {
                Set<Object> tableSet = legacyFunctionTables.get(gspModel);
                if (tableSet == null) {
                        tableSet = new LinkedHashSet<Object>();
                        legacyFunctionTables.put(gspModel, tableSet);
                }
                tableSet.add(functionTable);
                if (gspModel instanceof String) {
                        bindFunctionResult(legacyTextKey((String) gspModel), functionTable);
                }
        }

        /**
         * The function results under a key of the deprecated text-keyed API, looked up as the legacy map was (the key as
         * given; for text, a qualified key's last segment against an unqualified one, as stored names); then, for text,
         * under the routine name the text reads as.
         *
         * @deprecated use {@link #getFunctionResults(RoutineAliasKey)}
         */
        @Deprecated
        public Set<Object> getFunctionTable(Object gspModel) {
                Set<Object> result = legacyFunctionTables.get(gspModel);
                if (result == null && gspModel instanceof String) {
                        String modelString = (String) gspModel;
                        for (Map.Entry<Object, Set<Object>> entry : legacyFunctionTables.entrySet()) {
                                if (!(entry.getKey() instanceof String)) {
                                        continue;
                                }
                                String keyString = (String) entry.getKey();
                                if (keyString.indexOf(".") != -1 && modelString.indexOf(".") == -1
                                                && sameStoredBindingName(ESQLDataObjectType.dotTable,
                                                                keyString.substring(keyString.lastIndexOf(".") + 1), modelString)) {
                                        return entry.getValue();
                                }
                                if (keyString.indexOf(".") == -1 && modelString.indexOf(".") != -1
                                                && sameStoredBindingName(ESQLDataObjectType.dotTable, keyString,
                                                                modelString.substring(modelString.lastIndexOf(".") + 1))) {
                                        return entry.getValue();
                                }
                        }
                        result = getFunctionResults(legacyTextKey(modelString));
                }
                return result;
        }

        /** Stored-name equality under the analysis's rules, for the deprecated text-keyed API's legacy lookups. */
        private boolean sameStoredBindingName(ESQLDataObjectType type, String a, String b) {
                gudusoft.gsqlparser.sqlenv.IdentifierService service = getGlobalIdentifierService();
                if (service == null) return a.equalsIgnoreCase(b); // non-identifier-compare: no vendor or configuration is known on this thread, so no identifier rules apply; the legacy maps' last-resort fallback
                return service.canonKeyOf(a, type, gudusoft.gsqlparser.sqlenv.IdentifierInputForm.CATALOG_STORED)
                        .equals(service.canonKeyOf(b, type, gudusoft.gsqlparser.sqlenv.IdentifierInputForm.CATALOG_STORED));
        }

        public Table getCreateTable(TTable table) {
                Table scoped = getTemporaryMetadataModel(table);
                if (scoped != null && temporaryMetadataOwners.get(table.getResolvedTable()) != getGlobalProcedure()) return scoped;
                if (table != null && table.getFullName() != null) {
                        return visibleTemporaryModel(table, (Table) createModelQuickBindingMap.get(
                                        DlineageUtil.getTableIdentityKey(table.getTableName().toString())));
                }
                if(modelBindingMap.get(table) instanceof Table) {
                        return (Table)modelBindingMap.get(table);
                }
                return null;
        }

        public Table getCreateModel(TTable table) {
                return (Table) createModelBindingMap.get(table);
        }

        Table getTemporaryMetadataModel(TTable table) {
                return isScopedTemporary(table) ? temporaryMetadataModels.get(table.getResolvedTable()) : null;
        }

        /**
         * Whether a table reference names one routine body's temporary table rather than a shared
         * one: its name says so ({@code #t}), or resolver2 bound it to a table that a routine
         * declared temporary ({@code CREATE TEMP TABLE t}). See
         * {@link gudusoft.gsqlparser.sqlenv.TemporaryTableSemantics}.
         */
        public static boolean isScopedTemporary(TTable table) {
                return table != null && table.getTableName() != null
                                && (table.getSqlEnv() instanceof ProcedureEnvironment
                                || SQLUtil.isLocalTemporaryTable(table.dbvendor, table.getTableName()));
        }

        public void bindCreateModel(TTable table, Table tableModel) {
                createModelBindingMap.put(table, tableModel);
                Object key = DlineageUtil.getTableIdentityKey(table.getTableName().toString());
                if ((getGlobalProcedure() != null && isScopedTemporary(table)) || !createModelQuickBindingMap.containsKey(key)) {
                        displaceBinding(createModelQuickBindingMap, 1, key, tableModel);
                        createModelQuickBindingMap.put(key, tableModel);
                }
        }

        public void bindCreateModel(TObjectName tableName, Table tableModel) {
                if (!createModelQuickBindingMap.containsKey(DlineageUtil.getTableIdentityKey(tableName.toString()))) {
                        createModelQuickBindingMap.put(DlineageUtil.getTableIdentityKey(tableName.toString()), tableModel);
                }
        }
        
        public void bindCreateModel(String tableName, Table tableModel) {
                if (!createModelQuickBindingMap.containsKey(DlineageUtil.getTableIdentityKey(tableName))) {
                        createModelQuickBindingMap.put(DlineageUtil.getTableIdentityKey(tableName), tableModel);
                }
        }

        public TObjectName[] getTableColumns(TTable table) {
                Table createTable = getCreateTable(table);
                if (createTable != null) {
                        List<TableColumn> columnList = createTable.getColumns();
                        TObjectName[] columns = new TObjectName[columnList.size()];
                        for (int i = 0; i < columns.length; i++) {
                                columns[i] = columnList.get(i).getColumnObject();
                        }
                        Arrays.sort(columns, new Comparator<TObjectName>() {

                                @Override
                                public int compare(TObjectName o1, TObjectName o2) {
                                        if (o1 == null) {
                                                return -1;
                                        }
                                        if (o2 == null) {
                                                return 1;
                                        }
                                        return o1.getStartToken().posinlist - o2.getStartToken().posinlist;
                                }
                        });
                        return columns;
                }
                else if(modelBindingMap.get(table) instanceof QueryTable) {
                        QueryTable queryTable = (QueryTable)modelBindingMap.get(table);
                        List<TObjectName> columns = new ArrayList<TObjectName>();
                        for (ResultColumn resultColumn : queryTable.getColumns()) {
                                if(resultColumn.hasStarLinkColumn()) {
                                        for(TObjectName column: resultColumn.getStarLinkColumnList()) {
                                                columns.add(column);
                                        }
                                }
                                else if (resultColumn.getColumnObject() instanceof TResultColumn) {
                                        TResultColumn columnObject = ((TResultColumn) resultColumn.getColumnObject());
                                        TAliasClause alias = columnObject.getAliasClause();
                                        if (alias != null && alias.getAliasName() != null) {
                                                if(resultColumn.isStruct() && resultColumn.isStarColumn()) {
                                                        TObjectName structColumn = DlineageUtil.syntheticStarName();
                                                        columns.add(structColumn);
                                                }
                                                else {
                                                        columns.add(alias.getAliasName());
                                                }
                                        } else {
                                                if (columnObject.getFieldAttr() != null) {
                                                        columns.add(columnObject.getFieldAttr());
                                                } else {
                                                        TObjectName column = new TObjectName();
                                                        if (columnObject.getExpr().getExpressionType() == EExpressionType.typecast_t) {
                                                                column.setString(columnObject.getExpr().getLeftOperand().toString());
                                                        } else {
                                                                column.setString(columnObject.toString());
                                                        }
                                                        columns.add(column);
                                                }
                                        }
                                } else if (resultColumn.getColumnObject() instanceof TObjectName) {
                                        columns.add((TObjectName) resultColumn.getColumnObject());
                                }
                        }
                        return columns.toArray(new TObjectName[0]);
                }

                TObjectNameList list = table.getLinkedColumns();
                List<TObjectName> columns = new ArrayList<TObjectName>();

                if (table.getCTE() != null) {
                        ResultSet resultSet = (ResultSet) getModel(table.getCTE());
                        if (resultSet != null) {
                                List<ResultColumn> columnList = resultSet.getColumns();
                                for (int i = 0; i < columnList.size(); i++) {
                                        ResultColumn resultColumn = columnList.get(i);
                                        if (resultColumn.getColumnObject() instanceof TResultColumn) {
                                                TResultColumn columnObject = ((TResultColumn) resultColumn.getColumnObject());
                                                TAliasClause alias = columnObject.getAliasClause();
                                                if (alias != null && alias.getAliasName() != null) {
                                                        columns.add(alias.getAliasName());
                                                } else {
                                                        if (columnObject.getFieldAttr() != null) {
                                                                columns.add(columnObject.getFieldAttr());
                                                        } else {
                                                                continue;
                                                        }
                                                }
                                        } else if (resultColumn.getColumnObject() instanceof TObjectName) {
                                                columns.add((TObjectName) resultColumn.getColumnObject());
                                        }
                                }
                        }
                } else if (list.size() == 1 && DlineageUtil.isStarName(list.getObjectName(0)) && table.getSubquery() != null) {
                        addSubqueryColumns(table, columns);
                } else {
                        for (int i = 0; i < list.size(); i++) {
                                TObjectName object = list.getObjectName(i);
                                if (DlineageUtil.isStarName(object) && table.getSubquery() != null) {
                                        addSubqueryColumns(table, columns);
                                }
                                else 
                                        columns.add(object);
                        }
                }
                Collections.sort(columns, new Comparator<TObjectName>() {

                        @Override
                        public int compare(TObjectName o1, TObjectName o2) {
                                return o1.getStartToken().posinlist - o2.getStartToken().posinlist;
                        }
                });
                return columns.toArray(new TObjectName[0]);
        }

        private void addSubqueryColumns(TTable table, List<TObjectName> columns) {
                ResultSet resultSet = (ResultSet) getModel(table.getSubquery());
                if (resultSet != null) {
                        List<ResultColumn> columnList = resultSet.getColumns();
                        for (int i = 0; i < columnList.size(); i++) {
                                ResultColumn resultColumn = columnList.get(i);
                                if (resultColumn.getColumnObject() instanceof TResultColumn) {
                                        TResultColumn columnObject = ((TResultColumn) resultColumn.getColumnObject());
                                        TAliasClause alias = columnObject.getAliasClause();
                                        if (alias != null && alias.getAliasName() != null) {
                                                columns.add(alias.getAliasName());
                                        } else {
                                                if (columnObject.getFieldAttr() != null) {
                                                        columns.add(columnObject.getFieldAttr());
                                                } else {
                                                        TObjectName column = new TObjectName();
                                                        if (columnObject.getExpr().getExpressionType() == EExpressionType.typecast_t) {
                                                                column.setString(columnObject.getExpr().getLeftOperand().toString());
                                                        } else {
                                                                column.setString(columnObject.toString());
                                                        }
                                                        columns.add(column);
                                                }
                                        }
                                } else if (resultColumn.getColumnObject() instanceof TObjectName) {
                                        columns.add((TObjectName) resultColumn.getColumnObject());
                                }
                        }
                }
        }

        public TTable getTableFromColumn(TObjectName column) {
                if (column.getSourceTable() != null) {
                        return column.getSourceTable();
                }

                if (column.getTableString() != null && column.getTableString().trim().length() > 0) {
                        TCustomSqlStatement peekStmt = ModelBindingManager.getGlobalStmtStack().peek();
                        while (peekStmt != null) {
                                TTable table = null;
                                if (tableHashMap.containsKey(peekStmt)) {
                                        table = tableAliasMap.get(aliasKey(tableHashMap.get(peekStmt), column.getTableString()));
                                }
                                if (table != null) {
                                        return table;
                                } else {
                                        peekStmt = peekStmt.getParentStmt();
                                }
                        }
                }
                return null;
        }
        
        public TTable getTable(TCustomSqlStatement stmt, TObjectName column) {
                if (column.getSourceTable() != null) {
                        return column.getSourceTable();
                }

                if (column.getTableString() != null && column.getTableString().trim().length() > 0) {
                        TCustomSqlStatement peekStmt = ModelBindingManager.getGlobalStmtStack().peek();
                        while (peekStmt != null) {
                                TTable table = null;
                                if (tableHashMap.containsKey(peekStmt)) {
                                        table = tableAliasMap.get(aliasKey(tableHashMap.get(peekStmt), column.getTableString()));
                                }
                                if (table != null && table.getSubquery() != stmt)
                                        return table;
                                
                                if (peekStmt.getTables() != null) {
                                        for (TTable tableItem : peekStmt.getTables()) {
                                                if (DlineageUtil.sameQualifiedName(ESQLDataObjectType.dotTable, tableItem.getTableName().toString(),
                                                                column.getTableString())) {
                                                        return tableItem;
                                                }
                                        }
                                }
                                
                                peekStmt = peekStmt.getParentStmt();
                        }
                }

                if (stmt.getTables() != null) {
                        for (int j = 0; j < stmt.getTables().size(); j++) {
                                TTable table = (TTable) stmt.getTables().getTable(j);
                                if (table.getSubquery() == stmt)
                                        continue;

                                TObjectName[] columns = getTableColumns(table);
                                for (int i = 0; i < columns.length; i++) {
                                        TObjectName columnName = columns[i];
                                        if (columnName == null || DlineageUtil.isWildcard(columnName))
                                                continue;
                                        if (DlineageUtil.sameQualifiedName(ESQLDataObjectType.dotColumn, columnName.toString(), column.toString())) {
                                                if (columnName.getSourceTable() == null || columnName.getSourceTable() == table) {
                                                        return decided(SqllrObservations.DECISION_FIRST_TABLE_WITH_COLUMN, column, table);
                                                }
                                        }
                                        if (!SQLUtil.isEmpty(columnName.getColumnNameOnly())
                                                        && DlineageUtil.sameName(ESQLDataObjectType.dotColumn, columnName.getColumnNameOnly(),
                                                                        column.getColumnNameOnly())) {
                                                if (columnName.getSourceTable() == null || columnName.getSourceTable() == table) {
                                                        return decided(SqllrObservations.DECISION_FIRST_TABLE_WITH_COLUMN, column, table);
                                                }
                                        }
                                }
                        }
                }

                return null;
        }

        public TTable guessTable(TCustomSqlStatement stmt, TObjectName column) {
                if (column.getTableString() != null && column.getTableString().trim().length() > 0) {
                        TCustomSqlStatement peekStmt = ModelBindingManager.getGlobalStmtStack().peek();
                        TTable table = null;
                        if (tableHashMap.containsKey(peekStmt)) {
                                table = tableAliasMap.get(aliasKey(tableHashMap.get(peekStmt), column.getTableString()));
                        }
                        if (table != null && table.getSubquery() != stmt)
                                return table;
                }

                Iterator iter = tableSet.iterator();
                while (iter.hasNext()) {
                        TTable table = (TTable) iter.next();

                        if (table.getSubquery() == stmt)
                                continue;

                        TObjectName[] columns = getTableColumns(table);
                        for (int i = 0; i < columns.length; i++) {
                                TObjectName columnName = columns[i];
                                if (DlineageUtil.isWildcard(columnName))
                                        continue;
                                if (DlineageUtil.sameQualifiedName(ESQLDataObjectType.dotColumn, columnName.toString(), column.toString())) {
                                        if (columnName.getSourceTable() == null || columnName.getSourceTable() == table) {
                                                return decided(SqllrObservations.DECISION_GUESS_TABLE, column, table);
                                        }
                                }
                        }
                }
                return null;
        }

        /** Records a fallback binding for the SQL-LR producer's snapshot (observe-only) and returns the table. */
        private static TTable decided(String id, TObjectName column, TTable table) {
                SqllrObservations observations = SqllrObservations.current();
                if (observations != null) {
                        observations.decision(id, column, table, "a column-name scan over the FROM items");
                }
                return table;
        }

        public List<Table> getTablesByName() {
                // A table bound by identity is also bound under its legacy name; list it once, at that
                // name, as before. Only a table whose legacy name now belongs to another table (two
                // tables the analysis keeps apart but the vendor-default fold merges) is listed by its
                // canonical key.
                Set<Object> alsoBoundByName = Collections.newSetFromMap(new IdentityHashMap<Object, Boolean>());
                for (Object entry : tableNamesMap.entrySet()) {
                        Map.Entry binding = (Map.Entry) entry;
                        if (!(binding.getKey() instanceof QualifiedCanonKey)) {
                                alsoBoundByName.add(binding.getValue());
                        }
                }
                List<Table> tables = new ArrayList<Table>();
                for (Object entry : tableNamesMap.entrySet()) {
                        Map.Entry binding = (Map.Entry) entry;
                        if (binding.getKey() instanceof QualifiedCanonKey && getGlobalVendor() != EDbVendor.dbvbigquery
                                        && alsoBoundByName.contains(binding.getValue())) {
                                continue;
                        }
                        tables.add((Table) binding.getValue());
                }
                return tables;
        }

        public List<TTable> getBaseTables() {
                List<TTable> tables = new ArrayList<TTable>();

                Iterator iter = modelBindingMap.keySet().iterator();
                while (iter.hasNext()) {
                        Object key = iter.next();
                        if (!(key instanceof TTable)) {
                                continue;
                        }
                        TTable table = (TTable) key;
                        if (table.getSubquery() == null) {
                                tables.add(table);
                        }
                }

                iter = createModelBindingMap.keySet().iterator();
                while (iter.hasNext()) {
                        Object key = iter.next();
                        if (!(key instanceof TTable)) {
                                continue;
                        }
                        TTable table = (TTable) key;
                        tables.add(table);
                }

                iter = insertModelBindingMap.keySet().iterator();
                while (iter.hasNext()) {
                        Object key = iter.next();
                        if (!(key instanceof TTable)) {
                                continue;
                        }
                        TTable table = (TTable) key;
                        tables.add(table);
                }

                iter = mergeModelBindingMap.keySet().iterator();
                while (iter.hasNext()) {
                        Object key = iter.next();
                        if (!(key instanceof TTable)) {
                                continue;
                        }
                        TTable table = (TTable) key;
                        tables.add(table);
                }

                iter = updateModelBindingMap.keySet().iterator();
                while (iter.hasNext()) {
                        Object key = iter.next();
                        if (!(key instanceof TTable)) {
                                continue;
                        }
                        TTable table = (TTable) key;
                        if (!tables.contains(table)) {
                                tables.add(table);
                        }
                }

                return tables;
        }

        public List<TCustomSqlStatement> getViews() {
                List<TCustomSqlStatement> views = new ArrayList<TCustomSqlStatement>();

                Iterator iter = viewModelBindingMap.keySet().iterator();
                while (iter.hasNext()) {
                        Object key = iter.next();
                        if (!(key instanceof TCreateViewSqlStatement) && !(key instanceof TCreateMaterializedSqlStatement)) {
                                continue;
                        }
                        TCustomSqlStatement view = (TCustomSqlStatement) key;
                        if (!views.contains(view)) {
                                views.add(view);
                        }
                }
                return views;
        }

        public List<TResultColumnList> getSelectResultSets() {
                List<TResultColumnList> resultSets = new ArrayList<TResultColumnList>();

                Iterator iter = modelBindingMap.keySet().iterator();
                while (iter.hasNext()) {
                        Object key = iter.next();
                        if (!(key instanceof TResultColumnList)) {
                                continue;
                        }
                        TResultColumnList resultset = (TResultColumnList) key;
                        resultSets.add(resultset);
                }
                return resultSets;
        }

        public List<TObjectNameList> getQueryAliasTables() {
                List<TObjectNameList> resultSets = new ArrayList<TObjectNameList>();

                Iterator iter = modelBindingMap.keySet().iterator();
                while (iter.hasNext()) {
                        Object key = iter.next();
                        if (!(key instanceof TObjectNameList)) {
                                continue;
                        }
                        TObjectNameList resultset = (TObjectNameList) key;
                        resultSets.add(resultset);
                }
                return resultSets;
        }

        public List<TSelectSqlStatement> getSelectSetResultSets() {
                List<TSelectSqlStatement> resultSets = new ArrayList<TSelectSqlStatement>();

                Iterator iter = modelBindingMap.keySet().iterator();
                while (iter.hasNext()) {
                        Object key = iter.next();
                        if (!(key instanceof TSelectSqlStatement)) {
                                continue;
                        }

                        TSelectSqlStatement stmt = (TSelectSqlStatement) key;
                        if (stmt.getSetOperatorType() == ESetOperatorType.none)
                                continue;

                        resultSets.add(stmt);
                }
                return resultSets;
        }

        public List<TCTE> getCTEs() {
                List<TCTE> resultSets = new ArrayList<TCTE>();

                Iterator iter = modelBindingMap.keySet().iterator();
                while (iter.hasNext()) {
                        Object key = iter.next();
                        if (!(key instanceof TCTE)) {
                                continue;
                        }

                        TCTE cte = (TCTE) key;
                        resultSets.add(cte);
                }
                return resultSets;
        }

        public List<TTable> getTableWithSelectSetResultSets() {
                List<TTable> resultSets = new ArrayList<TTable>();

                Iterator iter = modelBindingMap.keySet().iterator();
                while (iter.hasNext()) {
                        Object key = iter.next();
                        if (!(key instanceof TTable)) {
                                continue;
                        }

                        if (((TTable) key).getSubquery() == null)
                                continue;
                        TSelectSqlStatement stmt = ((TTable) key).getSubquery();
                        if (stmt.getSetOperatorType() == ESetOperatorType.none)
                                continue;

                        resultSets.add((TTable) key);
                }
                return resultSets;
        }

        public List<TParseTreeNode> getMergeResultSets() {
                List<TParseTreeNode> resultSets = new ArrayList<TParseTreeNode>();

                Iterator iter = modelBindingMap.keySet().iterator();
                while (iter.hasNext()) {
                        Object key = iter.next();
                        if (!(key instanceof TMergeUpdateClause) && !(key instanceof TMergeInsertClause)) {
                                continue;
                        }
                        TParseTreeNode resultset = (TParseTreeNode) key;
                        resultSets.add(resultset);
                }
                return resultSets;
        }

        public List<TParseTreeNode> getOutputResultSets() {
                List<TParseTreeNode> resultSets = new ArrayList<TParseTreeNode>();

                Iterator iter = modelBindingMap.keySet().iterator();
                while (iter.hasNext()) {
                        Object key = iter.next();
                        if (!(key instanceof TOutputClause)) {
                                continue;
                        }
                        TParseTreeNode resultset = (TParseTreeNode) key;
                        resultSets.add(resultset);
                }
                return resultSets;
        }

        public List<TParseTreeNode> getUpdateResultSets() {
                List<TParseTreeNode> resultSets = new ArrayList<TParseTreeNode>();

                Iterator iter = modelBindingMap.keySet().iterator();
                while (iter.hasNext()) {
                        Object key = iter.next();
                        if (!(key instanceof TUpdateSqlStatement)) {
                                continue;
                        }
                        TParseTreeNode resultset = (TParseTreeNode) key;
                        resultSets.add(resultset);
                }
                return resultSets;
        }

        public List<TParseTreeNode> getFunctoinCalls() {
                List<TParseTreeNode> resultSets = new ArrayList<TParseTreeNode>();

                Iterator iter = modelBindingMap.keySet().iterator();
                while (iter.hasNext()) {
                        Object key = iter.next();
                        if (!(key instanceof TFunctionCall) && !(key instanceof TCaseExpression)) {
                                continue;
                        }
                        TParseTreeNode resultset = (TParseTreeNode) key;
                        resultSets.add(resultset);
                }
                return resultSets;
        }

        public List<TParseTreeNode> getAliases() {
                List<TParseTreeNode> resultSets = new ArrayList<TParseTreeNode>();

                Iterator iter = modelBindingMap.keySet().iterator();
                while (iter.hasNext()) {
                        Object key = iter.next();
                        if (!(key instanceof TAliasClause)) {
                                continue;
                        }
                        TParseTreeNode resultset = (TParseTreeNode) key;
                        resultSets.add(resultset);
                }
                return resultSets;
        }
        
        public List<TParseTreeNode> getCursors() {
                List<TParseTreeNode> resultSets = new ArrayList<TParseTreeNode>();

                Iterator iter = modelBindingMap.keySet().iterator();
                while (iter.hasNext()) {
                        Object key = iter.next();
                        if (!(key instanceof TCursorDeclStmt) && !(key instanceof TOpenforStmt)) {
                                continue;
                        }
                        TParseTreeNode resultset = (TParseTreeNode) key;
                        resultSets.add(resultset);
                }
                return resultSets;
        }
        
        public List<TParseTreeNode> getPivotdTables() {
                List<TParseTreeNode> resultSets = new ArrayList<TParseTreeNode>();

                Iterator iter = modelBindingMap.keySet().iterator();
                while (iter.hasNext()) {
                        Object key = iter.next();
                        if (!(key instanceof TPivotClause)) {
                                continue;
                        }
                        TParseTreeNode resultset = (TParseTreeNode) key;
                        resultSets.add(resultset);
                }
                return resultSets;
        }

        public void addRelation(Relationship relation) {
                if (relation != null && !relationHolder.contains(relation)) {
                        relationHolder.add(relation);
                }
        }
        
        public void removeRelation(ImpactRelationship relation) {
                if (relation != null) {
                        relationHolder.remove(relation);
                }
        }

        public Relationship[] getRelations() {
                return relationHolder.toArray(new Relationship[0]);
        }

        public void reset() {
        currentStatementOrdinal = -1;
        commentOccurrenceBindings = null;
                modelBindingMap.clear();
                processModelBindingMap.clear();
                viewModelBindingMap.clear();
                insertModelBindingMap.clear();
                createModelBindingMap.clear();
                createModelQuickBindingMap.clear();
                mergeModelBindingMap.clear();
                updateModelBindingMap.clear();
                cursorModelBindingMap.clear();
                tableNamesMap.clear();
                temporaryScopes.clear();
                identityBoundTables.clear();
                setContestedNormalNames(null, null);
                legacyNormalNames = false;
                dropTables.clear();
                routineModels.clear();
                routineShadowState = null;
                procedureAliases.clear();
                packageAliases.clear();
                functionTableAliases.clear();
                legacyProcedureNames.clear();
                legacyPackageNames.clear();
                legacyFunctionTables.clear();
                routineService = null;
                localSymbols.clear();
                localCursorModels.clear();
                poolStack.clear();
                relationHolder.clear();
                tableAliasMap.clear();
                tableHashMap.clear();
                topStmtHashMap.clear();
                hashSQLMap.clear();
                dynamicSQLMap.clear();
                tableSet.clear();
                resultSetSet.clear();
                dblinkTableSet.clear();
                objectTypeIndex.clear();
                collectionToElementTypeIndex.clear();
                pipelinedSignatures.clear();
                pendingPipelinedCallSites.clear();
                resolvingPipelinedFunctions.clear();
                DISPLAY_ID.clear();
                DISPLAY_NAME.clear();
                virtualTableNames.clear();
        }

        public void bindCursorModel(TCursorDeclStmt stmt, Variable resultSet) {
                bindCursorModel(stmt, stmt.getCursorName(), resultSet);
        }

        public void bindCursorModel(TMssqlDeclare stmt, Variable resultSet) {
                bindCursorModel(stmt, stmt.getCursorName(), resultSet);
        }

        public void bindCursorModel(TOpenforStmt stmt, Variable resultSet) {
                bindCursorModel(stmt, stmt.getCursorVariableName(), resultSet);
        }

        public void bindCursorModel(TForStmt stmt, Variable resultSet) {
                bindCursorModel(stmt, stmt.getCursorName(), resultSet);
        }

        public void bindCursorModel(TLoopStmt stmt, Variable resultSet) {
                bindCursorModel(stmt, stmt.getRecordName(), resultSet);
        }

        /** A cursor's model, by the cursor's name as written in the scope of the statement that declares or opens it. */
        private void bindCursorModel(TCustomSqlStatement stmt, TObjectName cursorName, Variable resultSet) {
                gudusoft.gsqlparser.dlineage.symbol.LocalSymbolKey key = cursorName == null ? null
                                : localCursorKey(stmt, cursorName.toString());
                if (key != null) {
                        localCursorModels.put(key, resultSet);
                }
        }

        /**
         * Binds a cursor FOR loop's index to the cursor the loop names: one declared in the loop's routine, an enclosing
         * routine or the package.
         */
        public void bindCursorIndex(TObjectName indexName, TObjectName cursorName) {
                TCustomSqlStatement stmt = getGlobalStmtStack().peek();
                gudusoft.gsqlparser.dlineage.symbol.LocalSymbolKey cursorKey = localCursorKey(stmt, cursorName.toString());
                Table cursor = cursorKey == null ? null : firstVisible(localCursorModels, cursorKey,
                                gudusoft.gsqlparser.dlineage.symbol.LocalScopes.chainOf(this, stmt), false);
                if (cursor instanceof Variable) {
                        publishLocalSymbol(gudusoft.gsqlparser.dlineage.symbol.LocalSymbolKey.of(cursorKey.getScope(),
                                        stripColon(indexName.toString()), gudusoft.gsqlparser.dlineage.symbol.LocalSymbolKey.Kind.VARIABLE),
                                        cursor);
                }
        }

        /** A cursor's key: its name as written, in the scope of the statement that names it. */
        private gudusoft.gsqlparser.dlineage.symbol.LocalSymbolKey localCursorKey(TCustomSqlStatement stmt, String cursorName) {
                return gudusoft.gsqlparser.dlineage.symbol.LocalSymbolKey.of(
                                gudusoft.gsqlparser.dlineage.symbol.LocalScopes.scopeOf(this, stmt), stripColon(cursorName),
                                gudusoft.gsqlparser.dlineage.symbol.LocalSymbolKey.Kind.CURSOR);
        }

        private static String stripColon(String name) {
                return name != null && name.startsWith(":") ? name.substring(1) : name;
        }

        public List<TStoredProcedureSqlStatement> getProcedures() {
                List<TStoredProcedureSqlStatement> procedures = new ArrayList();
                Iterator iter = this.modelBindingMap.keySet().iterator();

                while (iter.hasNext()) {
                        Object key = iter.next();
                        if (key instanceof TStoredProcedureSqlStatement) {
                                TStoredProcedureSqlStatement procedure = (TStoredProcedureSqlStatement) key;
                                procedures.add(procedure);
                        }
                }

                return procedures;
        }

        // public void bindTableByName(TObjectName tableName, Table tableModel) {
        // tableNamesMap.put(tableName, tableModel);
        //
        // }
        //
        public void bindTableByName(String tableName, Table tableModel) {
                bindTableByName((Object) tableName, tableModel);
        }

        /** Canonical physical-table keys share lifecycle/ordering with legacy bindings. */
        public void bindTableByName(Object tableName, Table tableModel) {
                if (tableName instanceof TableIdentityKey) {
                        TableIdentityKey key = (TableIdentityKey) tableName;
                        displaceBinding(tableNamesMap, 0, key.getCanonKey(), tableModel);
                        tableNamesMap.put(key.getCanonKey(), tableModel);
                        identityBoundTables.add(tableModel);
                        // Name-based lookups outside the table identity path (variables, cursors, qualifier
                        // strings) still ask by the legacy folded name, so it stays bound as before.
                        if (key.getLegacyKey() != null) {
                                displaceBinding(tableNamesMap, 0, key.getLegacyKey(), tableModel);
                                tableNamesMap.put(key.getLegacyKey(), tableModel);
                        }
                } else {
                        displaceBinding(tableNamesMap, 0, tableName, tableModel);
                        tableNamesMap.put(tableName, tableModel);
                }
                TTable origin = tableModel.getTableObject();
                if (origin != null && origin.getResolvedTable() != null && isScopedTemporary(origin)) {
                        temporaryMetadataModels.put(origin.getResolvedTable(), tableModel);
                        temporaryMetadataOwners.put(origin.getResolvedTable(), getGlobalProcedure());
                }

        }

        // public Table getTableByName(TObjectName tableName) {
        // return (Table)tableNamesMap.get(tableName);
        // }

        /**
         * B3 (routine-summary-scc-design §3): the overload pools of the routines whose bodies are being analyzed, active
         * ONLY under {@code Option.identityFirstVariablePools}. A pool is keyed by the routine's frozen scope and its
         * declaration identity ({@code IdentityScope}), so two same-named overloads keep separate formals and locals; a
         * name lookup in a body prefers its pool's variable. Empty in LEGACY by construction. The legacy identity text
         * rides along only for the deprecated {@link #peekIdentityScope()}.
         */
        private final java.util.ArrayDeque<Object[]> poolStack = new java.util.ArrayDeque<Object[]>();

        /** @deprecated an overload pool is keyed by its typed scope: use {@link #pushIdentityScope(String, Object)}. */
        @Deprecated
        public void pushIdentityScope(String identityScopeKey) {
                pushIdentityScope(identityScopeKey, null);
        }

        /**
         * Enters an overload's pool: its typed scope ({@code IdentityScope}) and its legacy identity text (metadata). Every
         * push is matched by a {@link #popIdentityScope()}; a pool without a typed scope is entered but never active.
         */
        public void pushIdentityScope(String identityScopeKey, Object poolScope) {
                if (identityScopeKey != null || poolScope != null) {
                        poolStack.push(new Object[] { poolScope, identityScopeKey });
                }
        }

        public void popIdentityScope() {
                if (!poolStack.isEmpty()) {
                        poolStack.pop();
                }
        }

        /** The active overload pool's typed scope, or null. */
        public Object peekPoolScope() {
                Object[] top = poolStack.peek();
                return top == null ? null : top[0];
        }

        public boolean hasIdentityScope() {
                return peekPoolScope() != null;
        }

        /** @deprecated the pool is keyed by {@link #peekPoolScope()}; this is its legacy text, never used to resolve. */
        @Deprecated
        public String peekIdentityScope() {
                Object[] top = poolStack.peek();
                return top == null ? null : (String) top[1];
        }

        /** Indexes a local symbol by its key without listing it again (an alias of a model already listed). */
        public void bindLocalSymbol(gudusoft.gsqlparser.dlineage.symbol.LocalSymbolKey key, Table symbol) {
                if (key != null) {
                        localSymbols.put(key, symbol);
                }
        }

        /**
         * Binds a local symbol by its key and lists it among the analysis's tables at this point (getTablesByName, and so
         * the output order), as every binding of a variable, cursor or correlation name has been listed.
         */
        public void publishLocalSymbol(gudusoft.gsqlparser.dlineage.symbol.LocalSymbolKey key, Table symbol) {
                if (key != null) {
                        localSymbols.put(key, symbol);
                        bindTableByName((Object) key, symbol);
                }
        }

        /**
         * The local symbol a reference in {@code stmt} sees under {@code key}'s name: the first scope of the statement's
         * lexical chain (routine, enclosing routines, package) that declares it; at top level, the top-level one.
         */
        public Table lookupVisibleLocalSymbol(gudusoft.gsqlparser.dlineage.symbol.LocalSymbolKey key, TCustomSqlStatement stmt) {
                return lookupVisibleLocalSymbol(key, stmt, false);
        }

        /**
         * As {@link #lookupVisibleLocalSymbol(gudusoft.gsqlparser.dlineage.symbol.LocalSymbolKey, TCustomSqlStatement)};
         * with {@code topLevel}, a declaration at top level is visible from inside a routine too (a declared type).
         */
        public Table lookupVisibleLocalSymbol(gudusoft.gsqlparser.dlineage.symbol.LocalSymbolKey key, TCustomSqlStatement stmt,
                        boolean topLevel) {
                if (key == null) {
                        return null;
                }
                Object poolScope = peekPoolScope();
                java.util.List<Object> chain = gudusoft.gsqlparser.dlineage.symbol.LocalScopes.chainOf(this, stmt);
                if (poolScope != null) {
                        Table pooled = localSymbols.get(key.inScope(poolScope));
                        if (pooled instanceof Variable) {
                                return pooled;
                        }
                        // Every declaration of the overload being analyzed is in its pool: a declared name the pool lacks is not
                        // this overload's, and the overload-blind scope of its routine may hold another overload's; so the
                        // enclosing routines and the package answer.
                        if (poolScope instanceof gudusoft.gsqlparser.dlineage.symbol.IdentityScope
                                        && key.getKind().getNamespace() == gudusoft.gsqlparser.dlineage.symbol.LocalSymbolKey.Namespace.DECLARED) {
                                chain = new java.util.ArrayList<Object>(chain);
                                chain.remove(((gudusoft.gsqlparser.dlineage.symbol.IdentityScope) poolScope).getScope());
                        }
                }
                Table found = firstVisible(localSymbols, key, chain, topLevel);
                if (found == null && key.getKind() != gudusoft.gsqlparser.dlineage.symbol.LocalSymbolKey.Kind.CORRELATION) {
                        // A bare correlation name (NEW.col) when no declared local of that name is visible.
                        found = firstVisible(localSymbols, key.asCorrelation(), chain, topLevel);
                }
                return found;
        }

        private static Table firstVisible(gudusoft.gsqlparser.dlineage.symbol.LocalSymbolRegistry symbols,
                        gudusoft.gsqlparser.dlineage.symbol.LocalSymbolKey key, java.util.List<Object> chain, boolean topLevel) {
                for (Object scope : chain) {
                        Table found = symbols.get(key.inScope(scope));
                        if (found != null) {
                                return found;
                        }
                }
                return chain.isEmpty() || topLevel ? symbols.get(key.inScope(null)) : null;
        }

        /** The local symbol visible from the current statement under a name as written (a leading ':' is a sigil). */
        public Table visibleLocal(String written, gudusoft.gsqlparser.dlineage.symbol.LocalSymbolKey.Kind kind) {
                if (SQLUtil.isEmpty(written)) {
                        return null;
                }
                boolean correlation = written.startsWith(":");
                Stack<TCustomSqlStatement> stack = getGlobalStmtStack();
                return lookupVisibleLocalSymbol(gudusoft.gsqlparser.dlineage.symbol.LocalSymbolKey.of(null,
                                correlation ? written.substring(1) : written,
                                correlation ? gudusoft.gsqlparser.dlineage.symbol.LocalSymbolKey.Kind.CORRELATION : kind),
                                stack == null || stack.isEmpty() ? null : stack.peek());
        }

        /**
         * A name that may denote a table or a local relation (table variable, cursor, record), by the site's precedence:
         * with {@code localFirst} (a %ROWTYPE or %TYPE anchor, a qualifier no FROM item declares) the local relation visible
         * from the current statement answers before the table path, as PL/SQL scoping does; otherwise (a FROM or DML
         * relation) the table path's answer stands and the local relation answers only when the table path has none.
         */
        public Table resolveMixedRelation(String written, Table tablePath, boolean localFirst) {
                if (tablePath != null && !localFirst) {
                        return tablePath;
                }
                // A local relation: a table variable, cursor or record, or a trigger correlation name (:NEW, the source table).
                Table local = visibleLocal(written, gudusoft.gsqlparser.dlineage.symbol.LocalSymbolKey.Kind.TABLE_VARIABLE);
                return local != null ? local : tablePath;
        }

        /** The local symbol under a typed key, or null. */
        public Table getLocalSymbol(gudusoft.gsqlparser.dlineage.symbol.LocalSymbolKey key) {
                return key == null ? null : localSymbols.get(key);
        }

        /** A canonical miss must not fall back to a case-folded display name. */
        public Table getTableByName(Object tableKey) {
                if (tableKey instanceof TableIdentityKey) {
                        TableIdentityKey key = (TableIdentityKey) tableKey;
                        Object bound = tableNamesMap.get(key.getCanonKey());
                        if (bound != null) {
                                return (Table) bound;
                        }
                        // The folded name of a table is exactly what merges two tables the analysis keeps
                        // apart, so it never answers for one. A binding that was never keyed by table
                        // identity (a stage, a stream) is still found by it, as it always was; a local
                        // symbol never is: the sites that may name one ask for it explicitly.
                        Table byName = key.getLegacyKey() == null ? null : getTableOnly(key.getLegacyKey());
                        return byName == null || identityBoundTables.contains(byName) ? null : byName;
                }
                return tableKey instanceof String ? getTableByName((String) tableKey)
                                : (Table) tableNamesMap.get(tableKey);
        }

        /** A table or other named object bound under a name; never a local symbol. */
        private Table getTableOnly(String tableName) {
                Table table = (Table) tableNamesMap.get(tableName);
                return table != null ? table : (Table) tableNamesMap.get(DlineageUtil.getTableFullName(tableName));
        }

        /**
         * A table or other named object bound under a name; inside a statement, a local symbol visible from it under the
         * name as written answers before the name is read again with the session's defaults, as it always has. A name
         * composed with a routine's scope ("PROC.@X") no longer names a local symbol: local symbols are keyed by their
         * declaring scope and their names as written.
         */
        public Table getTableByName(String tableName) {
                if (tableName == null) {
                        return null;
                }
                Table table = (Table) tableNamesMap.get(tableName);
                if (table != null) {
                        return table;
                }
                Stack<TCustomSqlStatement> stmtStack = getGlobalStmtStack();
                if (stmtStack != null && !stmtStack.isEmpty()) {
                        Table local = visibleLocal(tableName, gudusoft.gsqlparser.dlineage.symbol.LocalSymbolKey.Kind.VARIABLE);
                        if (local != null) {
                                return local;
                        }
                        return (Table) tableNamesMap.get(DlineageUtil.getTableFullName(tableName));
                }
                Table named = (Table) tableNamesMap.get(DlineageUtil.getTableFullName(tableName));
                return named != null ? named : visibleLocal(tableName, gudusoft.gsqlparser.dlineage.symbol.LocalSymbolKey.Kind.VARIABLE);
        }


        /** The routine-registry shadow of this analysis (measurement only; see RoutineShadow). */
        public gudusoft.gsqlparser.dlineage.routine.RoutineShadow.State routineShadowState() {
                if (routineShadowState == null) {
                        routineShadowState = new gudusoft.gsqlparser.dlineage.routine.RoutineShadow.State();
                }
                return routineShadowState;
        }

        /**
         * The lineage model of a routine statement: the routine model last bound to it, whatever else the statement was
         * bound to since. Null when no routine model was bound to it.
         */
        public Procedure getRoutineModel(TCustomSqlStatement routine) {
                return routine == null ? null : routineModels.get(routine);
        }

        /** Binds a routine model under one of its names as written with one alias suffix. */
        public void bindProcedure(RoutineAliasKey key, Procedure procedureModel) {
                procedureAliases.put(key, procedureModel);
                noteRoutineService(key);
        }

        private void noteRoutineService(RoutineAliasKey key) {
                if (key != null && routineService == null) {
                        routineService = getGlobalIdentifierService();
                }
        }

        /**
         * Deprecated text read under the rules this manager's routines were keyed by, else under the analysis's on this
         * thread: another analysis on the calling thread must not change how this manager reads a name.
         */
        private RoutineAliasKey legacyTextKey(String text) {
                return RoutineAliasKey.ofLegacyText(text, routineService != null ? routineService : getGlobalIdentifierService());
        }

        /**
         * Binds a routine model under a name of the deprecated text-keyed API: the text as given, and the routine name the
         * text reads as, so the analysis's own lookups see it.
         *
         * @deprecated routines are keyed by their names as written: use {@link #bindProcedure(RoutineAliasKey, Procedure)}
         */
        @Deprecated
        public void bindProcedureByName(String procedureName, Procedure procedureModel) {
                legacyProcedureNames.put(procedureName, procedureModel);
                bindProcedure(legacyTextKey(procedureName), procedureModel);
        }

        /**
         * The routine a name of the deprecated text-keyed API names: looked up as the legacy map was (the enclosing package's
         * name prefixed unless the text starts with it; the text as given; then the first entry whose text starts with the
         * name and a suffix, or whose last segment matches when one side is qualified), then the routine name the text
         * reads as.
         *
         * @deprecated routines are keyed by their names as written: use {@link #getProcedure(RoutineAliasKey)}
         */
        @Deprecated
        public Procedure getProcedureByName(String procedureName) {
                if (procedureName == null) {
                        return null;
                }
                String name = procedureName;
                if (getGlobalOraclePackage() != null && !name.startsWith(getGlobalOraclePackage().getName())) {
                        name = getGlobalOraclePackage().getName() + "." + name;
                }
                Procedure procedure = legacyProcedureNames.get(name);
                if (procedure == null) {
                        boolean suffixed = name.indexOf("(") != -1;
                        for (Map.Entry<String, Procedure> entry : legacyProcedureNames.entrySet()) {
                                String key = entry.getKey();
                                if (key == null) {
                                        continue;
                                }
                                if (!suffixed) {
                                        if (key.startsWith(name + "(")) {
                                                return entry.getValue();
                                        }
                                        if (key.indexOf(".") != -1 && name.indexOf(".") == -1
                                                        && key.substring(key.lastIndexOf(".") + 1).startsWith(name + "(")) {
                                                return entry.getValue();
                                        }
                                        if (key.indexOf(".") == -1 && name.indexOf(".") != -1
                                                        && key.startsWith(name.substring(name.lastIndexOf(".") + 1) + "(")) {
                                                return entry.getValue();
                                        }
                                } else {
                                        if (key.startsWith(name)) {
                                                return entry.getValue();
                                        }
                                        if (key.indexOf(".") != -1 && name.indexOf(".") == -1 && sameStoredBindingName(
                                                        ESQLDataObjectType.dotProcedure, key.substring(key.lastIndexOf(".") + 1), name)) {
                                                return entry.getValue();
                                        }
                                        if (key.indexOf(".") == -1 && name.indexOf(".") != -1 && sameStoredBindingName(
                                                        ESQLDataObjectType.dotProcedure, key, name.substring(name.lastIndexOf(".") + 1))) {
                                                return entry.getValue();
                                        }
                                }
                        }
                        procedure = getProcedure(legacyTextKey(procedureName));
                }
                return procedure;
        }

        /** The routine a name as written refers to, by the legacy index's precedence (RoutineAliasRegistry.lookup). */
        public Procedure getProcedure(RoutineAliasKey key) {
                OraclePackage enclosing = getGlobalOraclePackage();
                return procedureAliases.lookup(key, enclosing == null ? null : enclosing.getAliasKey());
        }

        public void bindOraclePackage(RoutineAliasKey key, OraclePackage oraclePackageModel) {
                packageAliases.put(key, oraclePackageModel);
                noteRoutineService(key);
        }

        public OraclePackage getOraclePackage(RoutineAliasKey key) {
                return packageAliases.get(key);
        }

        /**
         * Binds an Oracle package under a name of the deprecated text-keyed API: the text as given, and the package name
         * the text reads as.
         *
         * @deprecated packages are keyed by their names as written: use {@link #bindOraclePackage(RoutineAliasKey, OraclePackage)}
         */
        @Deprecated
        public void bindOraclePackageByName(String oraclePackageName, OraclePackage oraclePackageModel) {
                legacyPackageNames.put(oraclePackageName, oraclePackageModel);
                bindOraclePackage(legacyTextKey(oraclePackageName), oraclePackageModel);
        }

        /**
         * The Oracle package under a name of the deprecated text-keyed API: the text as given, then the package name the
         * text reads as.
         *
         * @deprecated packages are keyed by their names as written: use {@link #getOraclePackage(RoutineAliasKey)}
         */
        @Deprecated
        public OraclePackage getOraclePackageByName(String oraclePackageName) {
                OraclePackage oraclePackage = legacyPackageNames.get(oraclePackageName);
                return oraclePackage != null ? oraclePackage : getOraclePackage(legacyTextKey(oraclePackageName));
        }


        public String getSqlHash(TCustomSqlStatement stmt) {
                return topStmtHashMap.get(stmt);
        }

        public Map getHashSQLMap() {
                return hashSQLMap;
        }

        public Map getDynamicSQLMap() {
                return dynamicSQLMap;
        }

        public void collectSqlHash(TCustomSqlStatement stmt) {
                if (getGlobalOption().getAnalyzeMode() == AnalyzeMode.crud) {
                        String sql = stmt.toString();
                        if (sql != null) {
                                sql = stmt.getStartToken().lineNo + ":" + sql;
                                String hash = SQLUtil.stringToMD5(sql);
                                topStmtHashMap.put(stmt, hash);
                                hashSQLMap.put(hash, new Pair3<Long, Long, String>(stmt.getStartToken().lineNo, stmt.getEndToken().lineNo, ModelBindingManager.getGlobalHash()));
                        }
                } else {
                        try {
                                String sql = stmt.asCanonical();
                                if (sql != null) {
                                        String hash = SQLUtil.stringToMD5(sql);
                                        topStmtHashMap.put(stmt, hash);
                                        hashSQLMap.put(hash, sql);
                                }
                        } catch (Exception e) {
                                logger.error("collectSqlHash error: " + e.getMessage(), e);
                        }
                }
        }
        
        public void collectDynamicSqlHash(TCustomSqlStatement stmt) {
                if (getGlobalOption().getAnalyzeMode() == AnalyzeMode.dynamic) {
                        String sql = stmt.toString();
                        if (sql != null) {
                                sql = stmt.getStartToken().lineNo + ":" + sql;
                                String hash = SQLUtil.stringToMD5(sql);
                                dynamicSQLMap.put(hash, new Pair3<Long, Long, String>(stmt.getStartToken().lineNo, stmt.getEndToken().lineNo, ModelBindingManager.getGlobalHash()));
                        }
                }
        }

        public void appendDblinkTable(String name) {
                if (!SQLUtil.isEmpty(name)) {
                        dblinkTableSet.add(name);
                }
        }
        
        public boolean isDblinkTable(String name) {
                return dblinkTableSet.contains(name);
        }

        public Set<ResultSet> getResultSets() {
                return resultSetSet;
        }
        
        public void dropTable(Table table) {
                List tableNames = new ArrayList(tableNamesMap.keySet());
                for (Object tableName : tableNames) {
                        if(tableNamesMap.get(tableName) == table) {
                                tableNamesMap.remove(tableName);
                                dropTables.add(table);
                        }
                }
        }
        
        public void cleanTempTable() {
                Iterator<Object> iter = tableNamesMap.keySet().iterator();
                while(iter.hasNext()) {
                        Object tableName = iter.next();
                        if(DlineageUtil.isTempTable((Table)tableNamesMap.get(tableName), getGlobalVendor())) {
                                dropTables.add((Table)tableNamesMap.get(tableName));
                                iter.remove();
                        }
                }
        }

        /**
         * Save session/caller bindings while analyzing a separate routine body. The first two maps
         * hold the temporary tables visible on entry; the last two, filled while the body is analyzed,
         * hold the shared tables its own temporary tables displaced by name.
         */
        public List<Map> enterTemporaryTableScope() {
                List<Map> saved = new ArrayList<Map>();
                for (Map bindings : Arrays.asList(tableNamesMap, createModelQuickBindingMap)) {
                        Map snapshot = new LinkedHashMap();
                        for (Object key : bindings.keySet()) {
                                if (isScopedTemporaryModel(bindings.get(key))) snapshot.put(key, bindings.get(key));
                        }
                        saved.add(snapshot);
                }
                saved.add(new LinkedHashMap());
                saved.add(new LinkedHashMap());
                temporaryScopes.push(saved);
                return saved;
        }

        /** Local declarations remain in the output, but cannot become another routine's metadata. */
        public void leaveTemporaryTableScope(List<Map> saved) {
                for (Iterator<List<Map>> scopes = temporaryScopes.iterator(); scopes.hasNext();) {
                        if (scopes.next() == saved) {
                                scopes.remove();
                                break;
                        }
                }
                int index = 0;
                for (Map bindings : Arrays.asList(tableNamesMap, createModelQuickBindingMap)) {
                        Iterator iterator = bindings.values().iterator();
                        while (iterator.hasNext()) {
                                if (isScopedTemporaryModel(iterator.next())) iterator.remove();
                        }
                        bindings.putAll(saved.get(index));
                        // A temporary table named like a shared one (CREATE TEMP TABLE t, with a permanent t)
                        // hid it only while this body was analyzed.
                        for (Object entry : saved.get(index + 2).entrySet()) {
                                Map.Entry displaced = (Map.Entry) entry;
                                if (!bindings.containsKey(displaced.getKey())) bindings.put(displaced.getKey(), displaced.getValue());
                        }
                        index++;
                }
        }

        /** Remember a shared binding that a routine body's temporary table is about to hide. */
        private void displaceBinding(Map bindings, int index, Object key, Object model) {
                if (temporaryScopes.isEmpty() || !isScopedTemporaryModel(model)) return;
                Object previous = bindings.get(key);
                if (previous == null || previous == model || isScopedTemporaryModel(previous)) return;
                Map displaced = temporaryScopes.peek().get(index + 2);
                if (!displaced.containsKey(key)) displaced.put(key, previous);
        }

        private boolean isScopedTemporaryModel(Object model) {
                return model instanceof Table && isScopedTemporary(((Table) model).getTableObject());
        }

        public Set<Table> getDropTables() {
                return dropTables;
        }

        // --- Pipelined function stitching methods ---

        /**
         * Indexes an object type's fields under a key of the deprecated text API.
         *
         * @deprecated types are keyed by their names as written: use {@link #indexObjectTypeFields(Object, List)}
         */
        @Deprecated
        public void indexObjectType(String normalizedName, List<String> fieldNames) {
                objectTypeIndex.put(normalizedName, fieldNames);
        }

        /** @deprecated use {@link #getObjectTypeFieldsByKey(Object)} */
        @Deprecated
        public List<String> getObjectTypeFields(String normalizedName) {
                return objectTypeIndex.get(normalizedName);
        }

        /** @deprecated use {@link #indexCollectionElementType(Object, String)} */
        @Deprecated
        public void indexCollectionType(String collectionName, String elementTypeName) {
                collectionToElementTypeIndex.put(collectionName, elementTypeName);
        }

        /** @deprecated use {@link #getCollectionElementType(Object)} */
        @Deprecated
        public String getElementTypeName(String collectionName) {
                return collectionToElementTypeIndex.get(collectionName);
        }

        /** Indexes an object type's fields under the identity of its name. */
        public void indexObjectTypeFields(Object typeKey, List<String> fieldNames) {
                if (typeKey != null) {
                        objectTypeIndex.put(typeKey, fieldNames);
                }
        }

        /** The fields of the object type a key names, or null. */
        public List<String> getObjectTypeFieldsByKey(Object typeKey) {
                return typeKey == null ? null : objectTypeIndex.get(typeKey);
        }

        /** Indexes a collection type's element type, the element type's name as written, under the collection's key. */
        public void indexCollectionElementType(Object collectionKey, String elementTypeName) {
                if (collectionKey != null) {
                        collectionToElementTypeIndex.put(collectionKey, elementTypeName);
                }
        }

        /** The element type name, as written, of the collection type a key names, or null. */
        public String getCollectionElementType(Object collectionKey) {
                return collectionKey == null ? null : collectionToElementTypeIndex.get(collectionKey);
        }

        /**
         * Registers a pipelined signature under its function's identity and the identity of its bare name; a signature
         * built through the deprecated text keys is registered under those.
         */
        public void addPipelinedSignature(PipelinedFunctionSignature sig) {
                Object key = sig.getFunctionIdentity() != null ? sig.getFunctionIdentity() : sig.getFunctionKey();
                Object naked = sig.getNakedIdentity() != null ? sig.getNakedIdentity() : sig.getNakedKey();
                pipelinedSignatures.computeIfAbsent(key, k -> new ArrayList<>()).add(sig);
                if (naked != null && !naked.equals(key)) {
                        pipelinedSignatures.computeIfAbsent(naked, k -> new ArrayList<>()).add(sig);
                }
        }

        /**
         * The signature a call names under keys of the deprecated text API.
         *
         * @deprecated signatures are registered under the identities of their names: use
         *             {@link #findPipelinedSignatureByKeys(List, int)}
         */
        @Deprecated
        public PipelinedFunctionSignature findPipelinedSignature(List<String> candidates, int argCount) {
                return findPipelinedSignatureByKeys(candidates, argCount);
        }

        /**
         * The one signature registered under the first of {@code keys} that has any accepting {@code argCount} (any count
         * when negative); null when none, or when that key is ambiguous.
         */
        public PipelinedFunctionSignature findPipelinedSignatureByKeys(List<?> keys, int argCount) {
                for (Object key : keys) {
                        List<PipelinedFunctionSignature> sigs = pipelinedSignatures.get(key);
                        if (sigs != null) {
                                PipelinedFunctionSignature match = null;
                                for (PipelinedFunctionSignature sig : sigs) {
                                        if (sig.getArgCount() == argCount || argCount < 0) {
                                                if (match != null) {
                                                        return null; // ambiguous
                                                }
                                                match = sig;
                                        }
                                }
                                if (match != null) {
                                        return match;
                                }
                        }
                }
                return null;
        }

        /**
         * @deprecated signatures are registered under the identities of their names: use
         *             {@link #findPipelinedSignatureAnyByKeys(List)}
         */
        @Deprecated
        public PipelinedFunctionSignature findPipelinedSignatureAny(List<String> candidates) {
                return findPipelinedSignatureAnyByKeys(candidates);
        }

        /** The only signature registered under the first of {@code keys} that has exactly one; null when none. */
        public PipelinedFunctionSignature findPipelinedSignatureAnyByKeys(List<?> keys) {
                for (Object key : keys) {
                        List<PipelinedFunctionSignature> sigs = pipelinedSignatures.get(key);
                        if (sigs != null && !sigs.isEmpty()) {
                                if (sigs.size() == 1) {
                                        return sigs.get(0);
                                }
                        }
                }
                return null;
        }

        public void addPendingPipelinedCallSite(PendingPipelinedCallSite callSite) {
                pendingPipelinedCallSites.add(callSite);
        }

        public List<PendingPipelinedCallSite> getPendingPipelinedCallSites() {
                return pendingPipelinedCallSites;
        }

        public Set<String> getResolvingPipelinedFunctions() {
                return resolvingPipelinedFunctions;
        }

        /**
         * The registered signatures under their names as written, the function's name and then its bare name: a view for
         * the deprecated text API (the registry is keyed by the names' identities).
         *
         * @deprecated use {@link #getPipelinedSignaturesByKey()}
         */
        @Deprecated
        public Map<String, List<PipelinedFunctionSignature>> getPipelinedSignatures() {
                Map<String, List<PipelinedFunctionSignature>> byName = new LinkedHashMap<>();
                Set<PipelinedFunctionSignature> listed = Collections.newSetFromMap(
                                new IdentityHashMap<PipelinedFunctionSignature, Boolean>());
                for (List<PipelinedFunctionSignature> signatures : pipelinedSignatures.values()) {
                        for (PipelinedFunctionSignature sig : signatures) {
                                if (!listed.add(sig)) {
                                        continue;
                                }
                                byName.computeIfAbsent(sig.getFunctionKey(), k -> new ArrayList<>()).add(sig);
                                if (sig.getNakedKey() != null && !sig.getNakedKey().equals(sig.getFunctionKey())) {
                                        byName.computeIfAbsent(sig.getNakedKey(), k -> new ArrayList<>()).add(sig);
                                }
                        }
                }
                return byName;
        }

        /** The pipelined signature registry: signatures under the identities of their names (and deprecated text keys). */
        public Map<Object, List<PipelinedFunctionSignature>> getPipelinedSignaturesByKey() {
                return pipelinedSignatures;
        }

}