package gudusoft.gsqlparser.dlineage.dynamicsql;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.TBaseType;
import gudusoft.gsqlparser.TCustomSqlStatement;
import gudusoft.gsqlparser.TSourceToken;
import gudusoft.gsqlparser.TStatementList;
import gudusoft.gsqlparser.dlineage.DataFlowAnalyzer;
import gudusoft.gsqlparser.dlineage.dataflow.model.DynamicSqlSite;
import gudusoft.gsqlparser.dlineage.dataflow.model.Option;
import gudusoft.gsqlparser.dlineage.dataflow.model.xml.dataflow;
import gudusoft.gsqlparser.dlineage.dataflow.model.xml.relationship;
import gudusoft.gsqlparser.dlineage.dataflow.model.xml.sourceColumn;
import gudusoft.gsqlparser.dlineage.dataflow.model.xml.table;
import gudusoft.gsqlparser.dlineage.dataflow.model.xml.targetColumn;
import gudusoft.gsqlparser.nodes.TParameterDeclaration;
import gudusoft.gsqlparser.nodes.TParameterDeclarationList;
import gudusoft.gsqlparser.sqlenv.ESQLDataObjectType;
import gudusoft.gsqlparser.sqlenv.TSQLEnv;
import gudusoft.gsqlparser.stmt.mssql.TMssqlCreateProcedure;
import gudusoft.gsqlparser.util.SQLUtil;

import java.io.UnsupportedEncodingException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

/**
 * Orchestrates dynamic-SQL lineage resolution: evaluate the procedure's
 * dynamic-SQL string building under the given bindings
 * ({@link TDynamicSqlStringEvaluator}), then for each materialized EXEC site run
 * ordinary dlineage on the concrete string and tag the resulting edges with
 * dynamic provenance.
 *
 * <p>This is purely additive — it constructs fresh, throwaway
 * {@link DataFlowAnalyzer} instances for the materialized strings and never
 * touches the default analysis path, so default dlineage output is unchanged.
 */
public final class DynamicSqlLineageResolver {

    private DynamicSqlLineageResolver() {
    }

    /**
     * Materialized dynamic-SQL text for one EXEC / sp_executesql site, produced by the
     * no-bindings default-path evaluation ({@link #materializeSitesWithoutBindings}).
     */
    public static final class MaterializedSite {
        /** Usable (possibly placeholder-bearing) SQL text, or {@code null} if the string did not reduce. */
        public final String sqlText;
        /** True when the text still contains placeholder tokens for unbound variables/parameters. */
        public final boolean partial;
        /**
         * True unless the materialization is usable and every rendered character
         * has literal provenance. This is intentionally stricter than
         * {@link #partial}: a legacy-CONCRETE numeric/inexact transform can still
         * have a provenance hole that SHADOW must report.
         */
        public final boolean provenanceIncomplete;
        /** Why the string did not reduce; non-null iff {@link #sqlText} is null. */
        public final String reason;
        /**
         * Ordered provenance fragments. When {@link #sqlText} is non-null their
         * concatenated text equals it (design:
         * dynamic-sql-fragment-provenance-design.md); SHADOW completeness checks
         * and resolved dynamic edges consume that. When the string did not reduce
         * ({@link #sqlText} null) they are the best-effort provenance of the
         * argument — every hole met, in order, so a consumer can still name the
         * value that stopped the fold; their concatenated text is only how far
         * the fold got. Empty when the producing channel carries no provenance.
         */
        public final java.util.List<SqlFragment> fragments;
        /** Additive analysis note, such as a constant-relation over-approximation. */
        public final String diagnostic;
        /** Stable value-set row-tuple suffix; empty on the scalar compatibility path. */
        public final String variantPath;
        /**
         * False when the statement may not run on the evaluated path: it sits in a CATCH block, or behind a
         * condition or loop whose outcome is not known. Its text is still what it would run (Mantis 4962).
         */
        public final boolean executionCertain;
        /** Why the statement may not run, when {@link #executionCertain} is false; also part of the diagnostic. */
        public final String executionNote;
        /**
         * Non-null when the string is SQL NULL for a reason the evaluation proves (a query over a literal relation
         * returned no row), so the site runs nothing on this variant; says why (Mantis 4962).
         */
        public final String provenNullReason;
        /** The parameter values this variant was evaluated with: none, or the call or caller that supplied them. */
        public final BindingSource bindingSource;

        MaterializedSite(String sqlText, boolean partial, String reason) {
            this(sqlText, partial, reason, null);
        }

        MaterializedSite(String sqlText, boolean partial, String reason,
                java.util.List<SqlFragment> fragments) {
            this(sqlText, partial, reason, fragments, null, "");
        }

        MaterializedSite(String sqlText, boolean partial, String reason,
                java.util.List<SqlFragment> fragments, String diagnostic,
                String variantPath) {
            this(sqlText, partial, reason, fragments, diagnostic, variantPath, true, null);
        }

        MaterializedSite(String sqlText, boolean partial, String reason,
                java.util.List<SqlFragment> fragments, String diagnostic,
                String variantPath, boolean executionCertain, String executionNote) {
            this(sqlText, partial, reason, fragments, diagnostic, variantPath, executionCertain, executionNote, null,
                    BindingSource.NONE);
        }

        MaterializedSite(String sqlText, boolean partial, String reason,
                java.util.List<SqlFragment> fragments, String diagnostic,
                String variantPath, boolean executionCertain, String executionNote, String provenNullReason,
                BindingSource bindingSource) {
            this.provenNullReason = sqlText == null ? provenNullReason : null;
            this.bindingSource = bindingSource == null ? BindingSource.NONE : bindingSource;
            this.sqlText = sqlText;
            this.partial = partial;
            this.reason = reason;
            this.fragments = fragments == null || fragments.isEmpty()
                    ? java.util.Collections.<SqlFragment>emptyList()
                    : java.util.Collections.unmodifiableList(
                            new java.util.ArrayList<SqlFragment>(fragments));
            this.provenanceIncomplete = !DynamicSqlLineageResolver
                    .hasCompleteLiteralProvenance(sqlText, this.fragments);
            this.diagnostic = diagnostic;
            this.variantPath = variantPath == null ? "" : variantPath;
            this.executionCertain = executionCertain;
            this.executionNote = executionCertain ? null : executionNote;
        }

        public boolean hasCompleteLiteralProvenance() {
            return !provenanceIncomplete;
        }

        /** The same variant, its diagnostic carrying {@code note} too (sources merged when variants coincide). */
        public MaterializedSite withNote(String note) {
            return new MaterializedSite(sqlText, partial, reason, fragments, joinNotes(diagnostic, note), variantPath,
                    executionCertain, executionNote, provenNullReason, bindingSource);
        }

        /**
         * One variant standing for this one and {@code other}, which gives the same text (two bindings with the same
         * result, Mantis 4962): the weaker evidence of the two, so no hole and no uncertainty is lost. Its provenance
         * is the one with incomplete provenance or more holes; it runs for certain only when both do; its diagnostic
         * and binding name both.
         */
        public MaterializedSite mergedWith(MaterializedSite other) {
            if (other == null || other == this) {
                return this;
            }
            MaterializedSite weaker = weakness(other) > weakness(this) ? other : this;
            MaterializedSite stronger = weaker == this ? other : this;
            boolean certain = executionCertain && other.executionCertain;
            String note = !certain ? (executionCertain ? other.executionNote : executionNote) : null;
            String merged = weaker.diagnostic;
            if (stronger.diagnostic != null) {
                for (String part : stronger.diagnostic.split("; ")) {
                    if (merged == null || !java.util.Arrays.asList(merged.split("; ")).contains(part)) {
                        merged = joinNotes(merged, part);
                    }
                }
            }
            return new MaterializedSite(weaker.sqlText, weaker.partial, weaker.reason, weaker.fragments, merged,
                    weaker.variantPath, certain, note, weaker.provenNullReason,
                    weaker.bindingSource.alsoAt(stronger.bindingSource));
        }

        /** Incomplete provenance first, then the number of holes: how little the evidence proves. */
        private int weakness(MaterializedSite site) {
            int holes = 0;
            for (SqlFragment fragment : site.fragments) {
                if (!fragment.isLiteral()) {
                    holes++;
                }
            }
            return (site.provenanceIncomplete ? 1000000 : 0) + holes;
        }
    }

    /**
     * Default-path hook for {@link DataFlowAnalyzer}: abstractly evaluate a procedure's
     * dynamic-SQL string building with NO call-site bindings — only literal parameter
     * defaults are seeded — and return the materialized string per EXEC/sp_executesql
     * statement node (identity-keyed against the SAME parse tree that was passed in).
     * Constant- and template-built strings (REPLACE/QUOTENAME/CONCAT chains over
     * literals and literal-seeded variables) reduce fully; strings depending on unbound
     * parameters reduce to placeholder-bearing PARTIAL text; anything else is reported
     * with a reason. Purely computational — nothing is executed and no model state of
     * any analyzer is touched.
     */
    public static Map<TCustomSqlStatement, MaterializedSite> materializeSitesWithoutBindings(
            TCustomSqlStatement procAst, EDbVendor vendor, DynamicLineageOptions options) {
        return materializeSites(procAst, vendor, null, options);
    }

    /**
     * Same as {@link #materializeSitesWithoutBindings}, but with caller-supplied parameter
     * bindings (e.g. extracted from a literal call site) seeded before the walk. Parameters
     * absent from the bindings fall back to their literal defaults, then to placeholders.
     */
    public static Map<TCustomSqlStatement, MaterializedSite> materializeSites(
            TCustomSqlStatement procAst, EDbVendor vendor, Map<String, SqlValue> bindings,
            DynamicLineageOptions options) {
        List<Map<TCustomSqlStatement, MaterializedSite>> variants =
                materializeSiteVariants(procAst, vendor, bindings, options);
        return variants.isEmpty()
                ? new java.util.IdentityHashMap<TCustomSqlStatement, MaterializedSite>()
                : variants.get(0);
    }

    /**
     * Materialize all bounded, row-correlated constant-relation variants for a
     * procedure. Variant order is deterministic: declaration/statement order,
     * then INSERT VALUES row order. The legacy single-map API above returns the
     * first entry and is byte-compatible when the value-set feature is unused.
     */
    public static List<Map<TCustomSqlStatement, MaterializedSite>> materializeSiteVariants(
            TCustomSqlStatement procAst, EDbVendor vendor, Map<String, SqlValue> bindings,
            DynamicLineageOptions options) {
        return materializeSiteVariants(procAst, vendor, bindings, options,
                bindings == null || bindings.isEmpty() ? BindingSource.NONE : BindingSource.explicit(hashBindings(bindings)));
    }

    /**
     * {@link #materializeSiteVariants(TCustomSqlStatement, EDbVendor, Map, DynamicLineageOptions)}, each site
     * stamped with where its bindings came from (Mantis 4962): a site's diagnostic names the binding, and the
     * default analysis publishes a site some binding reached with the bound variants only.
     */
    public static List<Map<TCustomSqlStatement, MaterializedSite>> materializeSiteVariants(
            TCustomSqlStatement procAst, EDbVendor vendor, Map<String, SqlValue> bindings,
            DynamicLineageOptions options, BindingSource source) {
        if (source == null) {
            source = BindingSource.NONE;
        }
        if (options == null) {
            options = DynamicLineageOptions.createDefault();
        }
        List<Map<TCustomSqlStatement, MaterializedSite>> variants =
                new ArrayList<Map<TCustomSqlStatement, MaterializedSite>>();
        // Same resource guardrails as resolve(): a binding count over the cap is
        // rejected outright (best-effort empty result, since this hook must not throw
        // into the default analysis path).
        if (bindings != null && bindings.size() > options.getMaxBindings()) {
            return variants;
        }
        TStatementList body = extractBody(procAst);
        if (body == null) {
            return variants;
        }
        long deadlineNanos = System.nanoTime() + options.getTimeoutMillis() * 1_000_000L;
        ConstRelationVariantPlanner.EvaluationPlan plan =
                ConstRelationVariantPlanner.plan(body, vendor, options);
        List<TDynamicSqlStringEvaluator> runs = evaluations(procAst, body, vendor, bindings, options, plan,
                deadlineNanos);
        // a run cut short, or variants left unexplored, make the variants a part of what may run: no NULL among
        // them is proven for every run, and the sites say so (Mantis 4962)
        String truncation = null;
        for (TDynamicSqlStringEvaluator run : runs) {
            if (run.isSitesTruncated()) {
                truncation = "evaluation stopped at a limit after " + runs.size()
                        + " variant(s) (maxValueSetSize, maxBindings, maxSites or the timeout): other variants of"
                        + " the procedure are not analyzed";
                break;
            }
        }
        for (TDynamicSqlStringEvaluator evaluator : runs) {
            Map<TCustomSqlStatement, MaterializedSite> result =
                    new java.util.IdentityHashMap<TCustomSqlStatement, MaterializedSite>();
            for (TDynamicSqlStringEvaluator.RawSite raw : evaluator.evaluatedSites()) {
                if (raw.node == null) {
                    continue;
                }
                SqlStringValue sql = raw.sql;
                String diagnostic = joinNotes(joinNotes(joinNotes(raw.diagnostic, raw.executionNote), truncation),
                        source.getDescription());
                if (sql != null && sql.usable() && sql.text != null
                        && sql.text.length() > options.getMaxResolvedSqlLength()) {
                    result.put(raw.node, new MaterializedSite(null, false,
                            "resolved SQL length " + sql.text.length()
                                    + " exceeds maxResolvedSqlLength",
                            sql.fragments, diagnostic, raw.variantPath, raw.controlFlowCertain,
                            raw.executionNote, null, source));
                } else if (sql != null && sql.usable()) {
                    result.put(raw.node, new MaterializedSite(sql.text,
                            sql.state == SqlStringValue.State.PARTIAL, null, sql.fragments,
                            diagnostic, raw.variantPath, raw.controlFlowCertain,
                            raw.executionNote, null, source));
                } else {
                    // Unreduced: no text, but the value still carries the holes the
                    // evaluator met (which variable, assigned from what, where) —
                    // that is the site's unresolved-fragment evidence.
                    result.put(raw.node, new MaterializedSite(null, false,
                            sql != null && sql.reason != null ? sql.reason
                                    : "dynamic SQL did not reduce to a concrete string",
                            sql == null ? null : sql.fragments, diagnostic, raw.variantPath,
                            raw.controlFlowCertain, raw.executionNote,
                            truncation == null ? raw.provenNullReason : null, source));
                }
            }
            variants.add(result);
        }
        return variants;
    }

    /**
     * Every path through the procedure's choice points (a SELECT that reads a literal relation's rows, Mantis 4962),
     * as finished evaluations in variant order. The first run takes every choice's first alternative; then, depth
     * first, each further alternative of each choice the earlier runs met, the deepest choice first, which orders
     * the variants by their choices left to right, as the former plan expansion did. Copying the evaluation state
     * at each choice and going on with every copy would give the same variants; replaying the procedure with the
     * choices fixed keeps the evaluator a plain walk.
     */
    private static List<TDynamicSqlStringEvaluator> evaluations(TCustomSqlStatement procAst, TStatementList body,
            EDbVendor vendor, Map<String, SqlValue> bindings, DynamicLineageOptions options,
            ConstRelationVariantPlanner.EvaluationPlan plan, long deadlineNanos) {
        return evaluations(procAst, body, vendor, bindings, options, plan, deadlineNanos, null);
    }

    /** {@link #evaluations}, each run recording the operands {@code capture} names when it reaches its statement. */
    private static List<TDynamicSqlStringEvaluator> evaluations(TCustomSqlStatement procAst, TStatementList body,
            EDbVendor vendor, Map<String, SqlValue> bindings, DynamicLineageOptions options,
            ConstRelationVariantPlanner.EvaluationPlan plan, long deadlineNanos, Capture capture) {
        List<TDynamicSqlStringEvaluator> runs = new ArrayList<TDynamicSqlStringEvaluator>();
        // each path's product of alternatives is capped by the evaluator; this bounds paths of differing shape
        int limit = 4 * Math.max(1, Math.min(options.getMaxValueSetSize(), options.getMaxBindings()));
        explore(new ArrayList<Integer>(), runs, limit, procAst, body, vendor, bindings, options, plan, deadlineNanos,
                capture);
        return runs;
    }

    /** A statement whose operands every run records when it reaches it: a call and its actuals (Mantis 4962). */
    private static final class Capture {
        final TCustomSqlStatement statement;
        final List<gudusoft.gsqlparser.nodes.TExpression> expressions;

        Capture(TCustomSqlStatement statement, List<gudusoft.gsqlparser.nodes.TExpression> expressions) {
            this.statement = statement;
            this.expressions = expressions;
        }
    }

    private static void explore(List<Integer> prefix, List<TDynamicSqlStringEvaluator> runs, int limit,
            TCustomSqlStatement procAst, TStatementList body, EDbVendor vendor, Map<String, SqlValue> bindings,
            DynamicLineageOptions options, ConstRelationVariantPlanner.EvaluationPlan plan, long deadlineNanos,
            Capture capture) {
        TDynamicSqlStringEvaluator evaluator =
                new TDynamicSqlStringEvaluator(vendor, options, plan, deadlineNanos, prefix);
        if (capture != null) {
            evaluator.captureAt(capture.statement, capture.expressions);
        }
        evaluator.seedBindings(bindings);
        evaluator.seedParameterDefaults(extractParams(procAst));
        evaluator.evaluate(body);
        runs.add(evaluator);
        List<Integer> taken = evaluator.takenDecisions();
        List<Integer> counts = evaluator.choiceCounts();
        for (int j = counts.size() - 1; j >= prefix.size(); j--) {
            for (int k = 1; k < counts.get(j); k++) {
                if (runs.size() >= limit || System.nanoTime() > deadlineNanos) {
                    evaluator.markSitesTruncated();
                    return;
                }
                List<Integer> next = new ArrayList<Integer>(taken.subList(0, j));
                next.add(k);
                explore(next, runs, limit, procAst, body, vendor, bindings, options, plan, deadlineNanos, capture);
            }
        }
    }

    public static DynamicLineageResult resolve(TCustomSqlStatement procAst, EDbVendor vendor, TSQLEnv sqlEnv,
            String currentDatabase, String defaultSchema, Map<String, SqlValue> bindings,
            DynamicLineageOptions options) {

        if (options == null) {
            options = DynamicLineageOptions.createDefault();
        }
        if (bindings != null && bindings.size() > options.getMaxBindings()) {
            throw new IllegalArgumentException(
                    "binding count " + bindings.size() + " exceeds maxBindings " + options.getMaxBindings());
        }
        // no bindings given: the values preset in the catalog bind the procedure; bindings given replace them
        if (bindings == null || bindings.isEmpty()) {
            Map<String, SqlValue> presets = presetBindings(procAst, sqlEnv, currentDatabase, defaultSchema);
            if (presets != null) {
                if (presets.size() > options.getMaxBindings()) {
                    throw new IllegalArgumentException("preset binding count " + presets.size()
                            + " exceeds maxBindings " + options.getMaxBindings());
                }
                bindings = presets;
            }
        }

        TStatementList body = extractBody(procAst);
        List<TParameterDeclaration> params = extractParams(procAst);
        String sourceProc = extractProcName(procAst);
        String bindingHash = hashBindings(bindings);

        DynamicLineageResult result = new DynamicLineageResult(sourceProc, bindingHash);
        if (body == null) {
            return result; // not a recognized procedure shape — nothing to evaluate
        }
        String collision = caseCollision(procAst, sqlEnv);
        if (collision != null) {
            result.addSite(new DynamicSiteResult(DynamicSiteResult.Kind.EXEC_STRING,
                    DynamicSiteResult.Status.UNRESOLVED, null, null, sourceProc,
                    dynamicSiteId(sourceProc, "not-evaluated"), bindingHash,
                    "the dynamic SQL of the procedure is not evaluated: " + collision,
                    0L, 0L, new ArrayList<DynamicLineageEdge>(), options.getTrustMode(), 0, -1, false));
            return result;
        }

        long deadlineNanos = System.nanoTime() + options.getTimeoutMillis() * 1_000_000L;
        ConstRelationVariantPlanner.EvaluationPlan plan =
                ConstRelationVariantPlanner.plan(body, vendor, options);
        java.util.IdentityHashMap<TCustomSqlStatement, java.util.Set<String>> seen =
                new java.util.IdentityHashMap<TCustomSqlStatement, java.util.Set<String>>();
        boolean truncated = false;
        int emitted = 0;
        NodeNames nodeNames = new NodeNames();
        for (TDynamicSqlStringEvaluator evaluator : evaluations(procAst, body, vendor, bindings, options,
                plan, deadlineNanos)) {
            for (TDynamicSqlStringEvaluator.RawSite raw : evaluator.evaluatedSites()) {
                if (raw.node == null) {
                    continue;
                }
                String valueKey = raw.sql == null ? "<null>"
                        : raw.sql.state + "\u0000" + raw.sql.text + "\u0000" + raw.sql.reason
                                + "\u0000" + raw.controlFlowCertain;
                java.util.Set<String> values = seen.get(raw.node);
                if (values == null) {
                    values = new java.util.LinkedHashSet<String>();
                    seen.put(raw.node, values);
                }
                if (!values.add(valueKey)) {
                    continue;
                }
                if (emitted >= options.getMaxSites()) {
                    truncated = true;
                    break;
                }
                result.addSite(buildSite(raw, vendor, sqlEnv, currentDatabase,
                        defaultSchema, sourceProc, bindingHash, options, nodeNames));
                emitted++;
            }
            truncated |= evaluator.isSitesTruncated();
            if (truncated) {
                break;
            }
        }
        // Never let a truncated walk look complete — emit an honest diagnostic.
        if (truncated) {
            result.addSite(new DynamicSiteResult(DynamicSiteResult.Kind.EXEC_STRING,
                    DynamicSiteResult.Status.UNRESOLVED, null, null, sourceProc,
                    dynamicSiteId(sourceProc, "truncated"), bindingHash,
                    "site/time limit reached (maxSites=" + options.getMaxSites()
                            + ", timeout=" + options.getTimeoutMillis() + "ms); further sites dropped",
                    0L, 0L, new ArrayList<DynamicLineageEdge>(), options.getTrustMode(),
                    0, -1, false));
        }
        return result;
    }

    /**
     * The values preset in {@code sqlEnv} for the parameters of the procedure {@code procAst} defines (Mantis 4962),
     * as bindings, or null when none is set. The procedure is found under the database its definition is in (its
     * name's, the USE before it, else {@code currentDatabase}) and its schema ({@link #presetRoutineNames}): a preset
     * never binds a procedure of the same name in another database. A value supplied but not known is
     * {@link SqlValue#suppliedUnknown}, never an absent parameter (its default does not apply).
     */
    public static Map<String, SqlValue> presetBindings(TCustomSqlStatement procAst, TSQLEnv sqlEnv,
            String currentDatabase, String defaultSchema) {
        // nothing preset anywhere: no lookup at all (a lazy catalog would fetch metadata for it)
        if (sqlEnv == null || !sqlEnv.hasParameterPresets()) {
            return null;
        }
        String name = presetRoutineName(procAst, sqlEnv, currentDatabase, defaultSchema);
        if (name == null) {
            return null;
        }
        Map<String, gudusoft.gsqlparser.sqlenv.TSQLRoutine.PresetValue> presets;
        try {
            presets = sqlEnv.getProcedureParameterPresets(name);
        } catch (UnsupportedOperationException notSqlServer) {
            return null;
        }
        if (presets.isEmpty()) {
            return null;
        }
        Map<String, SqlValue> bindings = new java.util.LinkedHashMap<String, SqlValue>();
        for (Map.Entry<String, gudusoft.gsqlparser.sqlenv.TSQLRoutine.PresetValue> preset : presets.entrySet()) {
            bindings.put(preset.getKey(), sqlValueOfPreset(preset.getKey(), preset.getValue()));
        }
        return bindings;
    }

    /** Where the presets of {@link #presetBindings} came from, for a site's diagnostic. */
    public static BindingSource presetSource(TCustomSqlStatement procAst, Map<String, SqlValue> presets) {
        String name = procAst instanceof TMssqlCreateProcedure
                && ((TMssqlCreateProcedure) procAst).getProcedureName() != null
                ? ((TMssqlCreateProcedure) procAst).getProcedureName().toString() : "the procedure";
        return BindingSource.preset(name, hashBindings(presets));
    }

    /**
     * The one catalog name of the procedure {@code procAst} defines, as presets are found under it: its database
     * (its name's, the USE before the definition, else {@code currentDatabase}, else the catalog's default) and its
     * schema (its name's, else {@code defaultSchema}, else the catalog's default schema, else dbo), by
     * {@link TSQLEnv#qualifyForPresets}. A procedure has one identity: a preset of a procedure of the same name in
     * another schema or database never binds it.
     */
    static String presetRoutineName(TCustomSqlStatement procAst, TSQLEnv sqlEnv, String currentDatabase,
            String defaultSchema) {
        if (sqlEnv == null || !(procAst instanceof TMssqlCreateProcedure)) {
            return null;
        }
        gudusoft.gsqlparser.nodes.TObjectName name = ((TMssqlCreateProcedure) procAst).getProcedureName();
        if (name == null || name.getObjectString() == null || name.getObjectString().isEmpty()) {
            return null;
        }
        String db = name.getDatabaseString();
        if ((db == null || db.isEmpty()) && procAst.getGsqlparser() != null) {
            db = effectiveDatabaseOfProc(procAst.getGsqlparser().getSqlstatements(), procAst);
        }
        if (db == null || db.isEmpty()) {
            db = currentDatabase;
        }
        String schema = name.getSchemaString();
        if (schema == null || schema.isEmpty()) {
            schema = defaultSchema;
        }
        return sqlEnv.qualifyForPresets(name.getObjectString(), db, schema);
    }

    private static SqlValue sqlValueOfPreset(String parameter, gudusoft.gsqlparser.sqlenv.TSQLRoutine.PresetValue preset) {
        switch (preset.getKind()) {
            case STRING:
                return SqlValue.of(preset.getText());
            case NUMBER: {
                // the number as written, exact: a double would round 100000000000000000000 and long decimals
                return SqlValue.of(new java.math.BigDecimal(preset.getText()));
            }
            case SQL_NULL:
                return SqlValue.nullValue();
            default:
                return SqlValue.suppliedUnknown(parameter + " is preset as supplied with a value that is not known");
        }
    }

    /**
     * Discover parameter bindings from literal call sites of {@code procAst} in the same
     * parsed file: top-level {@code EXEC <proc> 'literal', @p = 'literal', ...} statements
     * whose (unqualified) module name matches the procedure name. Positional and named
     * arguments are supported; OUTPUT and non-literal arguments are left unbound (they
     * become placeholders during evaluation). Returns up to {@code maxBindingSets} distinct
     * binding sets in file order.
     */
    public static List<Map<String, SqlValue>> discoverCallSiteBindings(TCustomSqlStatement procAst,
            int maxBindingSets) {
        return discoverCallSites(procAst, maxBindingSets).getBindingSets();
    }

    /**
     * What a call-site discovery found and what it left: the literal binding sets, each with the call it came
     * from, and a note for every call that names the procedure but was not taken, saying why (Mantis 4962). A
     * call is not taken when the database in effect at the call is not the definition's, when its qualified name
     * names another procedure, or when no argument can be bound.
     */
    public static final class CallSiteDiscovery {
        private final List<Map<String, SqlValue>> bindingSets = new ArrayList<Map<String, SqlValue>>();
        private final List<String> sources = new ArrayList<String>();
        private final List<BindingSource> bindingSources = new ArrayList<BindingSource>();
        private final List<String> notes = new ArrayList<String>();
        private boolean exhaustive = true;

        /**
         * True when the binding sets stand for every call of the procedure the discovery looked at (Mantis 4962):
         * no call of it was left unbound (an actual that is not a literal, no bindable argument), none was dropped
         * by the cap, none sits in a routine body, a block or INSERT ... EXEC, and no call names it without a schema
         * while it is outside the default schema (the call may name another procedure of that name).
         */
        public boolean isExhaustive() {
            return exhaustive;
        }

        /** A call of the procedure the binding sets do not stand for; {@code why} says which and why. */
        void incomplete(String why) {
            exhaustive = false;
            note(why);
        }

        /** The binding sets, in the order and under the cap of the discovery. */
        public List<Map<String, SqlValue>> getBindingSets() {
            return bindingSets;
        }

        /** Where each binding set came from ({@code "line 12"}, {@code "unit 2 line 1"}), parallel to the sets. */
        public List<String> getSources() {
            return sources;
        }

        /** The call each binding set came from, kind and position, parallel to the sets. */
        public List<BindingSource> getBindingSources() {
            return bindingSources;
        }

        /** Why each call that names the procedure was not bound. */
        public List<String> getNotes() {
            return notes;
        }

        void note(String note) {
            if (notes.size() < MAX_DISCOVERY_NOTES && !notes.contains(note)) {
                notes.add(note);
            }
        }
    }

    /** Notes beyond this many add nothing a reader needs. */
    private static final int MAX_DISCOVERY_NOTES = 8;

    /**
     * {@link #discoverCallSiteBindings} with its account: the same binding sets in the same order, the call each
     * came from, and the calls in the file that name the procedure but were not bound.
     */
    public static CallSiteDiscovery discoverCallSites(TCustomSqlStatement procAst, int maxBindingSets) {
        return discoverCallSites(procAst, maxBindingSets, null, null, null);
    }

    /**
     * {@link #discoverCallSites(TCustomSqlStatement, int)} with what a call whose actuals are not literals needs
     * (Mantis 4962): the catalog ({@code sqlEnv}, for a calling procedure's presets), the other units
     * ({@code catalog}, for a calling procedure's own calls there) and the evaluation's options. Every call of the
     * procedure in the file is bound: a call in a batch with its actuals as the batch has them at the call, a call in
     * another procedure's body with its actuals as that procedure has them, its own parameters bound in turn (its
     * presets, else its calls, up to {@value #MAX_CALLER_DEPTH} levels, else values nobody knows).
     */
    public static CallSiteDiscovery discoverCallSites(TCustomSqlStatement procAst, int maxBindingSets, TSQLEnv sqlEnv,
            RoutineCatalog catalog, DynamicLineageOptions options) {
        return discoverCallSites(procAst, maxBindingSets, new DiscoveryContext(procAst, sqlEnv, catalog, options));
    }

    private static CallSiteDiscovery discoverCallSites(TCustomSqlStatement procAst, int maxBindingSets,
            DiscoveryContext ctx) {
        CallSiteDiscovery discovery = new CallSiteDiscovery();
        if (!(procAst instanceof TMssqlCreateProcedure) || procAst.getGsqlparser() == null) {
            return discovery;
        }
        TMssqlCreateProcedure proc = (TMssqlCreateProcedure) procAst;
        if (proc.getProcedureName() == null) {
            return discovery;
        }
        String procSimpleName = lastNameSegment(proc.getProcedureName().toString());
        List<TParameterDeclaration> params = extractParams(procAst);
        String procDb = effectiveDatabaseOfProc(procAst.getGsqlparser().getSqlstatements(), procAst);
        List<BindingCandidate> candidates = sameFileBindingCandidates(procAst, proc, procSimpleName,
                params, procDb, Integer.MAX_VALUE, discovery, ctx);
        for (int i = 0; i < candidates.size(); i++) {
            if (i >= maxBindingSets) {
                discovery.incomplete("calls of " + proc.getProcedureName() + " give " + candidates.size()
                        + " distinct bindings, more than the " + maxBindingSets + " evaluated");
                break;
            }
            discovery.bindingSets.add(candidates.get(i).bindings);
            discovery.sources.add(candidates.get(i).source);
            discovery.bindingSources.add(candidates.get(i).bindingSource);
        }
        return discovery;
    }

    /** How many levels of calling procedures a call's actuals are followed through. */
    static final int MAX_CALLER_DEPTH = 4;

    /** What one call-site discovery shares while it follows actuals through calling procedures. */
    private static final class DiscoveryContext {
        final TSQLEnv sqlEnv;
        final RoutineCatalog catalog;
        final DynamicLineageOptions options;
        final long deadlineNanos;
        final int depth;
        /** The procedures whose calls are being followed, the callee first: a call among them is recursive. */
        final java.util.Set<TCustomSqlStatement> chain;
        /**
         * Each calling procedure's preset binding sets, worked out once. Only presets are kept: a binding found by
         * following the caller's own calls depends on the depth and the chain it was reached through.
         */
        final Map<TCustomSqlStatement, List<Map<String, SqlValue>>> callerBindings;
        /** The catalog's identifier rules, or null for SQL Server's own (no catalog). */
        final gudusoft.gsqlparser.sqlenv.IdentifierService names;

        DiscoveryContext(TCustomSqlStatement callee, TSQLEnv sqlEnv, RoutineCatalog catalog,
                DynamicLineageOptions options) {
            this.names = sqlEnv == null ? null : sqlEnv.getIdentifierService();
            this.sqlEnv = sqlEnv;
            this.catalog = catalog;
            this.options = options == null ? DynamicLineageOptions.createDefault() : options;
            this.deadlineNanos = System.nanoTime() + this.options.getTimeoutMillis() * 1_000_000L;
            this.depth = 0;
            this.chain = java.util.Collections.newSetFromMap(
                    new java.util.IdentityHashMap<TCustomSqlStatement, Boolean>());
            if (callee != null) {
                this.chain.add(callee);
            }
            this.callerBindings = new java.util.IdentityHashMap<TCustomSqlStatement, List<Map<String, SqlValue>>>();
        }

        private DiscoveryContext(DiscoveryContext parent, TCustomSqlStatement caller) {
            this.names = parent.names;
            this.sqlEnv = parent.sqlEnv;
            this.catalog = parent.catalog;
            this.options = parent.options;
            this.deadlineNanos = parent.deadlineNanos;
            this.depth = parent.depth + 1;
            this.chain = java.util.Collections.newSetFromMap(
                    new java.util.IdentityHashMap<TCustomSqlStatement, Boolean>());
            this.chain.addAll(parent.chain);
            this.chain.add(caller);
            this.callerBindings = parent.callerBindings;
        }

        DiscoveryContext deeper(TCustomSqlStatement caller) {
            return new DiscoveryContext(this, caller);
        }

        boolean timedOut() {
            return System.nanoTime() > deadlineNanos;
        }
    }

    /** A call of some procedure in a unit, with where it sits. */
    private static final class CallSite {
        final gudusoft.gsqlparser.stmt.mssql.TMssqlExecute call;
        final TStatementList unit;
        /** The index in {@link #unit} of the top-level statement that is or holds the call. */
        final int topIndex;
        /** The routine whose body holds the call; null for a call in a batch (also in its block, IF or INSERT ... EXEC). */
        final TCustomSqlStatement routine;
        /** The database in effect (USE) at the top-level statement. */
        final String db;

        CallSite(gudusoft.gsqlparser.stmt.mssql.TMssqlExecute call, TStatementList unit, int topIndex,
                TCustomSqlStatement routine, String db) {
            this.call = call;
            this.unit = unit;
            this.topIndex = topIndex;
            this.routine = routine;
            this.db = db;
        }

        boolean topLevel() {
            return routine == null && unit.get(topIndex) == call;
        }
    }

    /** Every EXEC of a module in {@code unit}, top-level or nested, in order. */
    private static List<CallSite> callSitesIn(final TStatementList unit) {
        final List<CallSite> sites = new ArrayList<CallSite>();
        if (unit == null) {
            return sites;
        }
        String currentDb = null;
        for (int i = 0; i < unit.size(); i++) {
            final TCustomSqlStatement top = unit.get(i);
            if (top instanceof gudusoft.gsqlparser.stmt.TUseDatabase) {
                currentDb = String.valueOf(((gudusoft.gsqlparser.stmt.TUseDatabase) top).getDatabaseName());
                continue;
            }
            if (top instanceof gudusoft.gsqlparser.stmt.mssql.TMssqlExecute) {
                sites.add(new CallSite((gudusoft.gsqlparser.stmt.mssql.TMssqlExecute) top, unit, i, null, currentDb));
                continue;
            }
            final int index = i;
            final String db = currentDb;
            final TCustomSqlStatement routine = top instanceof gudusoft.gsqlparser.stmt.TStoredProcedureSqlStatement
                    ? top : null;
            top.acceptChildren(new gudusoft.gsqlparser.nodes.TParseTreeVisitor() {
                @Override
                public void preVisit(gudusoft.gsqlparser.stmt.mssql.TMssqlExecute call) {
                    if (call != top) {
                        sites.add(new CallSite(call, unit, index, routine, db));
                    }
                }
            });
        }
        return sites;
    }

    /**
     * The binding sets one call of the procedure gives (Mantis 4962). A top-level call whose actuals are all
     * literals binds them as written. Otherwise the call's environment is evaluated with every path through its
     * choice points, and each run that reaches the call records its actuals: a call in a batch runs after the
     * batch's statements before it (T-SQL variables live in their batch); a call in a procedure's body runs with
     * that procedure's parameters bound by its presets, else by its own calls when they cover all of them, else to
     * values nobody knows. An actual is bound to its value when the value is exact (a literal string, an exact
     * number, a NULL the run vouches for), else to a value supplied but not known. A call in a function or trigger
     * body, a recursive call, or a run cut by a limit makes the discovery incomplete.
     */
    private static List<BindingCandidate> candidatesForCall(CallSite site, TMssqlCreateProcedure proc,
            List<TParameterDeclaration> params, String where, DiscoveryContext ctx, CallSiteDiscovery discovery) {
        List<BindingCandidate> out = new ArrayList<BindingCandidate>();
        gudusoft.gsqlparser.stmt.mssql.TMssqlExecute call = site.call;
        String described = "call at " + where + " (" + call.getModuleName() + ")";
        if (site.topLevel() && allActualsLiteral(call)) {
            String[] whyNot = new String[1];
            BindingCandidate candidate = bindingCandidateFromCall(call, params, where, whyNot, ctx.names);
            if (candidate != null) {
                out.add(candidate);
            } else if (discovery != null) {
                discovery.incomplete(described + " not bound: " + whyNot[0]);
            }
            return out;
        }
        if (site.routine != null && !(site.routine instanceof TMssqlCreateProcedure)) {
            if (discovery != null) {
                discovery.incomplete(described + " not bound: a call in a function or trigger body is not followed");
            }
            return out;
        }
        if (site.routine != null && ctx.chain.contains(site.routine)) {
            if (discovery != null) {
                discovery.incomplete(described + " not bound: it is a recursive call");
            }
            return out;
        }
        List<gudusoft.gsqlparser.nodes.TExpression> actuals = actualExpressions(call);
        Capture capture = new Capture(call, actuals);
        List<TDynamicSqlStringEvaluator> runs = new ArrayList<TDynamicSqlStringEvaluator>();
        TStatementList evaluated = site.routine == null ? batchOf(site.unit, site.topIndex)
                : extractBody(site.routine);
        if (evaluated == null) {
            return out;
        }
        // the walk is linear: a GOTO may skip an assignment it applies, or reach the call again with other values;
        // a GOTO after the call in its batch can jump back before it, so the whole batch is looked at
        if (hasGoto(site.routine == null ? wholeBatchOf(site.unit, site.topIndex) : evaluated)) {
            if (discovery != null) {
                discovery.incomplete(described + " not bound: its caller has a GOTO, which the evaluation does not"
                        + " follow");
            }
            return out;
        }
        String collision = caseCollision(declaredNames(evaluated,
                site.routine == null ? null : extractParams(site.routine)), ctx.names);
        if (collision != null) {
            if (discovery != null) {
                discovery.incomplete(described + " not bound: " + collision);
            }
            return out;
        }
        // the caller's choice points are the ones before the call: only its actuals are read from these runs
        ConstRelationVariantPlanner.EvaluationPlan plan =
                ConstRelationVariantPlanner.plan(evaluated, EDbVendor.dbvmssql, ctx.options, call);
        if (site.routine == null) {
            runs.addAll(evaluations(null, evaluated, EDbVendor.dbvmssql, null, ctx.options, plan, ctx.deadlineNanos,
                    capture));
        } else {
            TMssqlCreateProcedure caller = (TMssqlCreateProcedure) site.routine;
            List<Map<String, SqlValue>> callerSets = callerBindings(caller, ctx);
            if (callerSets == null) {
                if (discovery != null) {
                    discovery.incomplete(described + " not bound: the presets of " + extractProcName(caller)
                            + " give more bindings than maxBindings(" + ctx.options.getMaxBindings() + ")");
                }
                return out;
            }
            for (Map<String, SqlValue> callerBindings : callerSets) {
                runs.addAll(evaluations(caller, evaluated, EDbVendor.dbvmssql, callerBindings, ctx.options, plan,
                        ctx.deadlineNanos, capture));
            }
        }
        boolean cut = ctx.timedOut();
        for (TDynamicSqlStringEvaluator run : runs) {
            cut |= run.isSitesTruncated();
            List<SqlStringValue> values = run.capturedValues();
            if (values == null) {
                // this path does not reach the call
                continue;
            }
            if (run.capturedInLoop() && discovery != null) {
                // the first iteration's actuals bind; a later iteration may pass others, which nothing here sees
                discovery.incomplete(described + " not bound for every run of it: it is in a loop body, whose later"
                        + " iterations may pass other values");
            }
            BindingCandidate candidate = bindingCandidateFromValues(call, params, actuals, values, run, where,
                    ctx.names);
            if (candidate == null) {
                if (discovery != null) {
                    discovery.incomplete(described + " not bound: no argument binds a parameter");
                }
                continue;
            }
            candidate.routine = site.routine == null ? null : extractProcName(site.routine);
            candidate.mayNotRun = !run.capturedExecutionCertain();
            out.add(candidate);
        }
        if (cut && discovery != null) {
            discovery.incomplete(described + " not bound in every way: the evaluation of its caller stopped at a"
                    + " limit");
        }
        return out;
    }

    /**
     * The binding sets of a calling procedure's parameters: its presets in the catalog; else the binding sets of its
     * own calls, when they cover every call of it (followed up to {@value #MAX_CALLER_DEPTH} levels); else one set of
     * values nobody knows (a caller outside the analysis may pass anything). Null when the presets give more bindings
     * than maxBindings: the caller is then not evaluated with them, as {@link #resolve} refuses them.
     */
    private static List<Map<String, SqlValue>> callerBindings(TMssqlCreateProcedure caller, DiscoveryContext ctx) {
        List<Map<String, SqlValue>> known = ctx.callerBindings.get(caller);
        if (known != null) {
            return known;
        }
        List<Map<String, SqlValue>> sets = new ArrayList<Map<String, SqlValue>>();
        Map<String, SqlValue> presets = presetBindings(caller, ctx.sqlEnv, null, null);
        if (presets != null) {
            if (presets.size() > ctx.options.getMaxBindings()) {
                return null;
            }
            sets.add(presets);
            // presets do not depend on how the caller was reached
            ctx.callerBindings.put(caller, sets);
            return sets;
        }
        if (ctx.depth + 1 < MAX_CALLER_DEPTH && !ctx.timedOut()) {
            DiscoveryContext deeper = ctx.deeper(caller);
            CallSiteDiscovery own = discoverCallSites(caller, 4, deeper);
            boolean exhaustive = own.isExhaustive();
            List<Map<String, SqlValue>> found = new ArrayList<Map<String, SqlValue>>(own.getBindingSets());
            if (ctx.catalog != null && found.size() < 4) {
                CallSiteDiscovery cross = discoverCrossFileCallSites(caller, ctx.catalog, 4 - found.size(), deeper);
                exhaustive &= cross.isExhaustive();
                found.addAll(cross.getBindingSets());
            } else if (ctx.catalog != null) {
                exhaustive = false;
            }
            if (exhaustive && !found.isEmpty()) {
                sets.addAll(found);
            }
        }
        if (sets.isEmpty()) {
            Map<String, SqlValue> unknown = new java.util.LinkedHashMap<String, SqlValue>();
            for (TParameterDeclaration param : extractParams(caller)) {
                if (param.getParameterName() != null) {
                    String name = param.getParameterName().toString();
                    unknown.put(name, SqlValue.suppliedUnknown(name + " is a parameter of " + extractProcName(caller)
                            + ", which no call in the analysis binds for every caller"));
                }
            }
            sets.add(unknown);
        }
        // not kept: what the caller's own calls give depends on the depth and the chain it is reached through
        return sets;
    }

    /** Every statement of the batch the top-level statement at {@code index} is in, between the GOs around it. */
    private static TStatementList wholeBatchOf(TStatementList unit, int index) {
        TStatementList batch = batchOf(unit, index);
        for (int k = index + 1; k < unit.size(); k++) {
            if (unit.get(k) instanceof gudusoft.gsqlparser.stmt.mssql.TMssqlGo) {
                break;
            }
            batch.add(unit.get(k));
        }
        return batch;
    }

    /** The statements of the batch the top-level statement at {@code index} is in, up to it (after the last GO). */
    private static TStatementList batchOf(TStatementList unit, int index) {
        int start = 0;
        for (int k = index - 1; k >= 0; k--) {
            if (unit.get(k) instanceof gudusoft.gsqlparser.stmt.mssql.TMssqlGo) {
                start = k + 1;
                break;
            }
        }
        TStatementList batch = new TStatementList();
        for (int k = start; k <= index; k++) {
            batch.add(unit.get(k));
        }
        return batch;
    }

    /**
     * The actual of each argument of {@code call}, in order. An OUTPUT argument is one too: the procedure receives
     * the caller's value in it (the call's own write-back is the evaluator's, after the call).
     */
    private static List<gudusoft.gsqlparser.nodes.TExpression> actualExpressions(
            gudusoft.gsqlparser.stmt.mssql.TMssqlExecute call) {
        List<gudusoft.gsqlparser.nodes.TExpression> actuals = new ArrayList<gudusoft.gsqlparser.nodes.TExpression>();
        for (int j = 0; call.getParameters() != null && j < call.getParameters().size(); j++) {
            gudusoft.gsqlparser.nodes.TExecParameter arg = call.getParameters().getExecParameter(j);
            actuals.add(arg == null ? null : arg.getParameterValue());
        }
        return actuals;
    }

    /** True when every argument of {@code call} is a literal or DEFAULT. */
    private static boolean allActualsLiteral(gudusoft.gsqlparser.stmt.mssql.TMssqlExecute call) {
        for (gudusoft.gsqlparser.nodes.TExpression actual : actualExpressions(call)) {
            if (actual != null && !isDefaultKeyword(actual) && literalToSqlValue(actual) == null) {
                return false;
            }
        }
        return true;
    }

    /** The DEFAULT keyword as an argument: the parameter takes its declared default, as if it were omitted. */
    private static boolean isDefaultKeyword(gudusoft.gsqlparser.nodes.TExpression actual) {
        gudusoft.gsqlparser.EExpressionType type = actual.getExpressionType();
        return (type == gudusoft.gsqlparser.EExpressionType.simple_source_token_t
                || type == gudusoft.gsqlparser.EExpressionType.simple_object_name_t
                || type == gudusoft.gsqlparser.EExpressionType.simple_constant_t)
                && "DEFAULT".equalsIgnoreCase(actual.toString().trim()); // non-identifier-compare: the DEFAULT keyword
    }

    /**
     * The binding set a run's values of the call's actuals give: a literal argument binds as written (NULL, signed
     * numbers, strings), DEFAULT binds nothing (the default applies), and any other argument binds its value when
     * the value is exact, else a value supplied but not known ("call-site actual @f is not a known value"); null when
     * no argument binds a parameter.
     */
    private static BindingCandidate bindingCandidateFromValues(gudusoft.gsqlparser.stmt.mssql.TMssqlExecute call,
            List<TParameterDeclaration> params, List<gudusoft.gsqlparser.nodes.TExpression> actuals,
            List<SqlStringValue> values, TDynamicSqlStringEvaluator run, String source,
            gudusoft.gsqlparser.sqlenv.IdentifierService names) {
        Map<String, SqlValue> bindings = new java.util.LinkedHashMap<String, SqlValue>();
        for (int j = 0; j < actuals.size(); j++) {
            gudusoft.gsqlparser.nodes.TExpression actual = actuals.get(j);
            if (actual == null || isDefaultKeyword(actual)) {
                continue;
            }
            gudusoft.gsqlparser.nodes.TExecParameter arg = call.getParameters().getExecParameter(j);
            String paramName = arg.getParameterName() != null ? arg.getParameterName().toString()
                    : j < params.size() && params.get(j).getParameterName() != null
                            ? params.get(j).getParameterName().toString() : null;
            if (paramName == null) {
                continue;
            }
            SqlValue literal = literalToSqlValue(actual);
            bindings.put(paramName, literal != null ? literal : boundValue(values.get(j), run, actual));
        }
        return bindings.isEmpty() ? null : new BindingCandidate(bindings, bindingKey(bindings, params, names), source);
    }

    /**
     * One key for a binding set, the same for a literal call and an evaluated one (Mantis 4962): each formal of the
     * procedure in declaration order with the typed value bound to it (names compared under the catalog's rules),
     * then the names no formal has, with theirs. Equal keys are equal binding sets.
     */
    private static String bindingKey(Map<String, SqlValue> bindings, List<TParameterDeclaration> params,
            gudusoft.gsqlparser.sqlenv.IdentifierService names) {
        StringBuilder key = new StringBuilder();
        java.util.Set<String> matched = new java.util.HashSet<String>();
        for (int i = 0; i < params.size(); i++) {
            String formal = params.get(i).getParameterName() == null ? null
                    : params.get(i).getParameterName().toString();
            SqlValue bound = null;
            for (Map.Entry<String, SqlValue> entry : bindings.entrySet()) {
                if (formal != null && !matched.contains(entry.getKey())
                        && sameName(names, ESQLDataObjectType.dotColumn, formal, entry.getKey())) {
                    bound = entry.getValue();
                    matched.add(entry.getKey());
                    break;
                }
            }
            key.append(i).append('=').append(bound == null ? "-" : valueKey(bound)).append(';');
        }
        for (Map.Entry<String, SqlValue> entry : bindings.entrySet()) {
            if (!matched.contains(entry.getKey())) {
                key.append(entry.getKey().length()).append(':').append(entry.getKey()).append('=')
                        .append(valueKey(entry.getValue())).append(';');
            }
        }
        return key.toString();
    }

    /** A bound value, typed and length-prefixed: no two different values share it. */
    private static String valueKey(SqlValue value) {
        if (value.isSuppliedUnknown()) {
            return "?";
        }
        if (value.isNull()) {
            return "NULL";
        }
        String text = value.asText() == null ? "" : value.asText();
        return (value.isNumber() ? "N" : "S") + text.length() + ":" + text;
    }

    /** Two names of the role {@code type} are one: under the catalog's identifier rules when given, else SQL Server's. */
    private static boolean sameName(gudusoft.gsqlparser.sqlenv.IdentifierService names, ESQLDataObjectType type,
            String a, String b) {
        return names != null ? names.areEqual(a, b, type) : SQLUtil.sameName(EDbVendor.dbvmssql, type, a, b);
    }

    /** True when a GOTO is among {@code statements}, nested in blocks, IF, WHILE or TRY/CATCH included. */
    private static boolean hasGoto(TStatementList statements) {
        java.util.Deque<TCustomSqlStatement> stack = new java.util.ArrayDeque<TCustomSqlStatement>();
        pushAll(stack, statements);
        while (!stack.isEmpty()) {
            TCustomSqlStatement s = stack.pop();
            if (s instanceof gudusoft.gsqlparser.stmt.mssql.TMssqlGoTo) {
                return true;
            }
            pushNested(stack, s);
        }
        return false;
    }

    /**
     * The names {@code statements} declare (DECLARE, nested in blocks, IF, WHILE or TRY/CATCH) and the formals
     * {@code params}, in order.
     */
    private static List<String> declaredNames(TStatementList statements, List<TParameterDeclaration> params) {
        List<String> names = new ArrayList<String>();
        for (int i = 0; params != null && i < params.size(); i++) {
            if (params.get(i).getParameterName() != null) {
                names.add(params.get(i).getParameterName().toString());
            }
        }
        java.util.Deque<TCustomSqlStatement> stack = new java.util.ArrayDeque<TCustomSqlStatement>();
        pushAll(stack, statements);
        while (!stack.isEmpty()) {
            TCustomSqlStatement s = stack.pop();
            if (s instanceof gudusoft.gsqlparser.stmt.mssql.TMssqlDeclare
                    && ((gudusoft.gsqlparser.stmt.mssql.TMssqlDeclare) s).getVariables() != null) {
                gudusoft.gsqlparser.nodes.TDeclareVariableList variables =
                        ((gudusoft.gsqlparser.stmt.mssql.TMssqlDeclare) s).getVariables();
                for (int i = 0; i < variables.size(); i++) {
                    if (variables.getDeclareVariable(i) != null
                            && variables.getDeclareVariable(i).getVariableName() != null) {
                        names.add(variables.getDeclareVariable(i).getVariableName().toString());
                    }
                }
            }
            pushNested(stack, s);
        }
        return names;
    }

    /**
     * Why the evaluation cannot be trusted with {@code declared} under the catalog's rules {@code names}: the
     * evaluation keys variables without their case, so two names the rules keep apart but that differ only in case
     * would share a value. Null when there are none (SQL Server's default rules ignore case as the evaluation does).
     */
    public static String caseCollision(TCustomSqlStatement procAst, TSQLEnv sqlEnv) {
        if (sqlEnv == null || procAst == null) {
            return null;
        }
        return caseCollision(declaredNames(extractBody(procAst), extractParams(procAst)), sqlEnv.getIdentifierService());
    }

    static String caseCollision(List<String> declared, gudusoft.gsqlparser.sqlenv.IdentifierService names) {
        if (names == null) {
            return null;
        }
        Map<String, String> byKey = new java.util.HashMap<String, String>();
        for (String name : declared) {
            String key = TDynamicSqlStringEvaluator.variableKey(name);
            String other = byKey.get(key);
            if (other == null) {
                byKey.put(key, name);
            } else if (!names.areEqual(other, name, ESQLDataObjectType.dotColumn)) {
                return "variables " + other + " and " + name + " differ only in case, which the dynamic SQL"
                        + " evaluation does not tell apart";
            }
        }
        return null;
    }

    private static void pushAll(java.util.Deque<TCustomSqlStatement> stack, TStatementList statements) {
        for (int i = 0; statements != null && i < statements.size(); i++) {
            if (statements.get(i) != null) {
                stack.push(statements.get(i));
            }
        }
    }

    private static void pushNested(java.util.Deque<TCustomSqlStatement> stack, TCustomSqlStatement s) {
        if (s instanceof gudusoft.gsqlparser.stmt.mssql.TMssqlBlock) {
            pushAll(stack, ((gudusoft.gsqlparser.stmt.mssql.TMssqlBlock) s).getBodyStatements());
        } else if (s instanceof gudusoft.gsqlparser.stmt.mssql.TMssqlIfElse) {
            if (((gudusoft.gsqlparser.stmt.mssql.TMssqlIfElse) s).getStmt() != null) {
                stack.push(((gudusoft.gsqlparser.stmt.mssql.TMssqlIfElse) s).getStmt());
            }
            if (((gudusoft.gsqlparser.stmt.mssql.TMssqlIfElse) s).getElseStmt() != null) {
                stack.push(((gudusoft.gsqlparser.stmt.mssql.TMssqlIfElse) s).getElseStmt());
            }
        } else if (s instanceof gudusoft.gsqlparser.stmt.mssql.TMssqlTryCatch) {
            pushAll(stack, ((gudusoft.gsqlparser.stmt.mssql.TMssqlTryCatch) s).getTryStatements());
            pushAll(stack, ((gudusoft.gsqlparser.stmt.mssql.TMssqlTryCatch) s).getCatchStatements());
        } else if (s instanceof gudusoft.gsqlparser.stmt.TWhileStmt) {
            pushAll(stack, ((gudusoft.gsqlparser.stmt.TWhileStmt) s).getBodyStatements());
        }
    }

    /** What an actual's value binds: the value when it is exact, else a value supplied but not known. */
    private static SqlValue boundValue(SqlStringValue value, TDynamicSqlStringEvaluator run,
            gudusoft.gsqlparser.nodes.TExpression actual) {
        String written = actual.toString() == null ? "" : actual.toString().trim();
        SqlValue unknown = SqlValue.suppliedUnknown("call-site actual " + written + " is not a known value");
        if (value == null) {
            return unknown;
        }
        switch (value.state) {
            case NULL:
                return run.isTrustedNull(value) ? SqlValue.nullValue() : unknown;
            case CONCRETE:
                if (value.number != null) {
                    return LiteralRelation.isExactNumber(value) ? numberValue(value.text) : unknown;
                }
                for (SqlFragment fragment : value.fragments) {
                    if (!fragment.isLiteral()) {
                        return unknown;
                    }
                }
                return value.text == null ? unknown : SqlValue.of(value.text);
            default:
                return unknown;
        }
    }

    /** A number written as {@code text}, exact. */
    private static SqlValue numberValue(String text) {
        return SqlValue.of(new java.math.BigDecimal(text.trim()));
    }

    /**
     * True when {@code call} names the procedure without a schema while the procedure is outside the default
     * schema (dbo): the call may name a procedure of that name in the caller's default schema instead.
     */
    private static boolean ambiguousUnqualifiedCall(gudusoft.gsqlparser.stmt.mssql.TMssqlExecute call,
            TMssqlCreateProcedure proc, gudusoft.gsqlparser.sqlenv.IdentifierService names) {
        if (call.getModuleName() == null || SQLUtil.parseNames(call.getModuleName().toString()).size() != 1) {
            return false;
        }
        String schema = proc.getProcedureName().getSchemaString();
        return schema != null && !schema.isEmpty() && !sameName(names, ESQLDataObjectType.dotSchema, schema, "dbo");
    }

    /**
     * Matching call sites in the procedure's own file, in file order, deduplicated by
     * canonical key, up to {@code cap}. Tracks the effective database (USE statements)
     * so a call after USE DbB is never bound to a same-named procedure defined under
     * USE DbA. A call that names the procedure but is not taken is noted in
     * {@code discovery} when one is given.
     */
    private static List<BindingCandidate> sameFileBindingCandidates(TCustomSqlStatement procAst,
            TMssqlCreateProcedure proc, String procSimpleName, List<TParameterDeclaration> params,
            String procDb, int cap, CallSiteDiscovery discovery, DiscoveryContext ctx) {
        List<BindingCandidate> result = new ArrayList<BindingCandidate>();
        Map<String, BindingCandidate> seen = new java.util.HashMap<String, BindingCandidate>();
        for (CallSite site : callSitesIn(procAst.getGsqlparser().getSqlstatements())) {
            if (result.size() >= cap) {
                break;
            }
            gudusoft.gsqlparser.stmt.mssql.TMssqlExecute call = site.call;
            if (call.getModuleName() == null || call.getSqlText() != null) {
                continue;
            }
            String where = "line " + lineOf(call);
            if (!callMatchesProc(call, proc, procSimpleName, procDb, site.db, ctx.names)) {
                if (site.topLevel()) {
                    noteSkippedCall(discovery, call, proc, procSimpleName, procDb, site.db, where, ctx.names);
                }
                continue;
            }
            if (discovery != null && ambiguousUnqualifiedCall(call, proc, ctx.names)) {
                discovery.incomplete("call at " + where + " (" + call.getModuleName() + ") names "
                        + proc.getProcedureName() + " without a schema: it may name a procedure of that name in the"
                        + " caller's default schema");
            }
            for (BindingCandidate candidate : candidatesForCall(site, proc, params, where, ctx, discovery)) {
                candidate.bindingSource = BindingSource.sameFile(lineOf(call), hashBindings(candidate.bindings),
                        candidate.routine, candidate.mayNotRun);
                BindingCandidate earlier = seen.get(candidate.canonicalKey);
                if (earlier == null) {
                    seen.put(candidate.canonicalKey, candidate);
                    result.add(candidate);
                } else {
                    // the same values from another call: one binding set that names both calls
                    earlier.bindingSource = earlier.bindingSource.alsoAt(candidate.bindingSource);
                }
            }
        }
        return result;
    }

    /**
     * Notes why a call that names the procedure by its simple name was not matched to it. Calls to other
     * procedures say nothing.
     */
    private static void noteSkippedCall(CallSiteDiscovery discovery,
            gudusoft.gsqlparser.stmt.mssql.TMssqlExecute call, TMssqlCreateProcedure proc, String procSimpleName,
            String procDb, String callDb, String where, gudusoft.gsqlparser.sqlenv.IdentifierService names) {
        if (discovery == null || call.getModuleName() == null || call.getSqlText() != null) {
            return;
        }
        String callName = call.getModuleName().toString();
        if (!sameName(names, ESQLDataObjectType.dotProcedure, lastNameSegment(callName), procSimpleName)) {
            return;
        }
        List<String> callParts = SQLUtil.parseNames(callName);
        List<String> procParts = SQLUtil.parseNames(proc.getProcedureName().toString());
        String why;
        if (!sameEffectiveDatabase(procDb, callDb, callName, names)) {
            why = "the database in effect at the call (" + describeDatabase(callDb)
                    + ") is not the one the procedure is defined in (" + describeDatabase(procDb)
                    + "); a one- or two-part name is bound only within the same database";
        } else if (callParts.size() == 3 && procParts.size() == 2 && procDb == null) {
            why = "no USE precedes the definition, so its database is unknown and a three-part name"
                    + " cannot be shown to name it";
        } else {
            why = "the qualified name does not name the definition " + proc.getProcedureName();
        }
        discovery.note("call at " + where + " (" + callName + ") not bound: " + why);
    }

    private static String describeDatabase(String db) {
        return db == null ? "none" : db;
    }

    private static long lineOf(TCustomSqlStatement stmt) {
        return stmt == null || stmt.getStartToken() == null ? -1 : stmt.getStartToken().lineNo;
    }

    /**
     * Discover parameter bindings from literal call sites of {@code procAst} located in
     * OTHER files of the same multi-file analysis (plan Phase 5: cross-file routine
     * references). {@code otherFileSqlTexts} holds the raw SQL text of every analysis
     * unit; the procedure's own file is skipped by text identity. A text is parsed at
     * most once per analysis via the caller-owned {@code parseCache} (key: the text),
     * and only when it mentions the procedure's simple name at all.
     *
     * <p>Never guesses across ambiguity: if any other file defines a procedure with the
     * same simple name in a database-compatible context, there are two candidate owners
     * for a matching call and this method returns no bindings at all. Binding sets are
     * returned in canonical-key order, so the result is independent of the file order
     * of the analysis. Binding sets already surfaced by the same-file discovery above
     * are excluded here, so duplicates never consume the caller's shared cap.
     */
    public static List<Map<String, SqlValue>> discoverCrossFileCallSiteBindings(
            TCustomSqlStatement procAst, RoutineCatalog catalog, int maxBindingSets) {
        return discoverCrossFileCallSites(procAst, catalog, maxBindingSets).getBindingSets();
    }

    /**
     * {@link #discoverCrossFileCallSiteBindings} with its account: the same binding sets in the same order, the
     * unit and line each came from, and why calls in other units that name the procedure were not bound.
     */
    public static CallSiteDiscovery discoverCrossFileCallSites(
            TCustomSqlStatement procAst, RoutineCatalog catalog, int maxBindingSets) {
        return discoverCrossFileCallSites(procAst, catalog, maxBindingSets, null, null);
    }

    /**
     * {@link #discoverCrossFileCallSites(TCustomSqlStatement, RoutineCatalog, int)} with the catalog and options a
     * call whose actuals are not literals needs ({@link #discoverCallSites(TCustomSqlStatement, int, TSQLEnv,
     * RoutineCatalog, DynamicLineageOptions)}).
     */
    public static CallSiteDiscovery discoverCrossFileCallSites(TCustomSqlStatement procAst, RoutineCatalog catalog,
            int maxBindingSets, TSQLEnv sqlEnv, DynamicLineageOptions options) {
        return discoverCrossFileCallSites(procAst, catalog, maxBindingSets,
                new DiscoveryContext(procAst, sqlEnv, catalog, options));
    }

    private static CallSiteDiscovery discoverCrossFileCallSites(TCustomSqlStatement procAst, RoutineCatalog catalog,
            int maxBindingSets, DiscoveryContext ctx) {
        CallSiteDiscovery discovery = new CallSiteDiscovery();
        if (maxBindingSets <= 0 || catalog == null
                || !(procAst instanceof TMssqlCreateProcedure)
                || procAst.getGsqlparser() == null) {
            return discovery;
        }
        TMssqlCreateProcedure proc = (TMssqlCreateProcedure) procAst;
        if (proc.getProcedureName() == null) {
            return discovery;
        }
        String procSimpleName = lastNameSegment(proc.getProcedureName().toString());
        String probeName = bareName(procSimpleName);
        if (probeName.isEmpty()) {
            return discovery;
        }
        List<TParameterDeclaration> params = extractParams(procAst);
        String ownText = procAst.getGsqlparser().sqltext;
        // For matching and the ambiguity verdict, an explicit catalog on the target
        // definition's own three-part name outranks the USE-derived database (a
        // definition CREATE PROC DbA.dbo.p IS provably in DbA).
        String sameFileProcDb = effectiveDatabaseOfProc(procAst.getGsqlparser().getSqlstatements(), procAst);
        String procDb = definitionDatabase(proc, sameFileProcDb);

        // The same-file pass already surfaced these binding sets (cross-file is only
        // invoked when its cap was not reached, so an uncapped re-collection sees
        // exactly the sets it returned). Excluding their keys keeps duplicates from
        // consuming the shared cap and displacing distinct cross-file bindings.
        java.util.Set<String> sameFileKeys = new java.util.HashSet<String>();
        for (BindingCandidate sameFile : sameFileBindingCandidates(procAst, proc, procSimpleName,
                params, sameFileProcDb, Integer.MAX_VALUE, null, ctx)) {
            sameFileKeys.add(sameFile.canonicalKey);
        }

        // Canonical-key ordering makes the accepted binding sets (and which ones
        // survive the cap) independent of the order files were passed in.
        java.util.TreeMap<String, BindingCandidate> ordered =
                new java.util.TreeMap<String, BindingCandidate>();
        List<String> texts = catalog.unitTexts();
        for (int unitIndex = 0; unitIndex < texts.size(); unitIndex++) {
            String text = texts.get(unitIndex);
            if (text == null || text.equals(ownText)) {
                continue;
            }
            if (!text.toLowerCase(java.util.Locale.ENGLISH)
                    .contains(probeName.toLowerCase(java.util.Locale.ENGLISH))) {
                continue;
            }
            RoutineCatalog.UnitIndex unit = catalog.indexOf(text);
            if (unit == null) {
                continue;
            }
            for (RoutineCatalog.Definition def : unit.definitions) {
                // A same-named definition in another file: unless the two are
                // provably in different databases, a matching call has two
                // candidate owners - bail out entirely rather than guess.
                if (sameName(ctx.names, ESQLDataObjectType.dotProcedure, def.simple, procSimpleName)
                        && !provablyDifferentDatabase(procDb, def.db, ctx.names)) {
                    CallSiteDiscovery ambiguous = new CallSiteDiscovery();
                    ambiguous.incomplete("calls in other units not bound: unit " + (unitIndex + 1)
                            + " also defines a procedure named " + def.simple
                            + " that is not provably in another database");
                    return ambiguous;
                }
            }
            String unitName = "unit " + (unitIndex + 1);
            for (CallSite site : callSitesIn(catalog.statementsOf(text))) {
                gudusoft.gsqlparser.stmt.mssql.TMssqlExecute call = site.call;
                if (call.getModuleName() == null || call.getSqlText() != null) {
                    continue;
                }
                String where = unitName + " line " + lineOf(call);
                if (!callMatchesProc(call, proc, procSimpleName, procDb, site.db, ctx.names)) {
                    if (site.topLevel()) {
                        noteSkippedCall(discovery, call, proc, procSimpleName, procDb, site.db, where, ctx.names);
                    }
                    continue;
                }
                if (ambiguousUnqualifiedCall(call, proc, ctx.names)) {
                    discovery.incomplete("call at " + where + " (" + call.getModuleName() + ") names "
                            + proc.getProcedureName() + " without a schema: it may name a procedure of that name"
                            + " in the caller's default schema");
                }
                for (BindingCandidate candidate : candidatesForCall(site, proc, params, where, ctx, discovery)) {
                    candidate.bindingSource = BindingSource.crossFile(unitName, lineOf(call),
                            hashBindings(candidate.bindings), candidate.routine, candidate.mayNotRun);
                    BindingCandidate earlier = ordered.get(candidate.canonicalKey);
                    if (earlier != null) {
                        earlier.bindingSource = earlier.bindingSource.alsoAt(candidate.bindingSource);
                    } else if (!sameFileKeys.contains(candidate.canonicalKey)) {
                        ordered.put(candidate.canonicalKey, candidate);
                    }
                }
            }
        }
        for (BindingCandidate candidate : ordered.values()) {
            if (discovery.bindingSets.size() >= maxBindingSets) {
                discovery.incomplete("calls of " + proc.getProcedureName() + " in the other units give "
                        + ordered.size() + " distinct bindings, more than the " + maxBindingSets + " evaluated");
                break;
            }
            discovery.bindingSets.add(candidate.bindings);
            discovery.sources.add(candidate.source);
            discovery.bindingSources.add(candidate.bindingSource);
        }
        return discovery;
    }

    /**
     * Oracle analog of cross-file call-site discovery (plan Phase 5): collect
     * top-level statements from OTHER files (anonymous blocks, CALL statements)
     * that mention a routine defined in the current file, so the caller can feed
     * them to {@code TASTEvaluator} together with the file's own statements and
     * fold parameter-dependent EXECUTE IMMEDIATE templates under the callers'
     * literal arguments.
     *
     * <p>Mirrors the MSSQL rules: a text is parsed at most once per analysis via
     * {@code parseCache} and only when it mentions one of the candidate routine
     * names; a same-simple-name routine DEFINITION in another file makes that
     * name ambiguous and drops it from the harvest (never guess between two
     * candidate owners); foreign definitions themselves are never appended.
     * Returned statements are ordered by their source text, so evaluation order
     * is independent of the file order of the analysis.
     */
    public static List<TCustomSqlStatement> plsqlInterpretationStatements(
            TStatementList ownStatements, String ownText, RoutineCatalog catalog,
            int maxForeignCallers) {
        List<TCustomSqlStatement> result = new ArrayList<TCustomSqlStatement>();
        if (ownStatements == null) {
            return result;
        }
        // Routine definitions in this file - the possible callees. Only routines whose
        // partial dynamic-SQL expressions are provably literal-bindable participate:
        // the interpreter folds any dependency it cannot evaluate (SELECT INTO
        // locals, function results, ...) to an EMPTY string, which would produce a
        // concrete-looking but WRONG statement that the placeholder classifier
        // cannot catch.
        List<PlsqlRoutineIdent> idents = new ArrayList<PlsqlRoutineIdent>();
        for (int i = 0; i < ownStatements.size(); i++) {
            TCustomSqlStatement stmt = ownStatements.get(i);
            String name = plsqlRoutineSimpleName(stmt);
            if (name == null || name.isEmpty()) {
                continue;
            }
            if (plsqlDynamicSqlLiteralBindable(stmt)) {
                idents.add(new PlsqlRoutineIdent(stmt, name));
            }
        }
        if (idents.isEmpty()) {
            return result;
        }
        // Foreign pass 1: definitions in other files decide ambiguity. A same-simple-
        // name definition that is not provably in a different schema means a matching
        // call has two candidate owners.
        List<RoutineCatalog.UnitIndex> foreignUnits = new ArrayList<RoutineCatalog.UnitIndex>();
        if (catalog != null) {
            for (String text : catalog.unitTexts()) {
                if (text == null || text.equals(ownText)) {
                    continue;
                }
                String lowered = text.toLowerCase(java.util.Locale.ENGLISH);
                boolean mentionsAny = false;
                for (PlsqlRoutineIdent ident : idents) {
                    if (lowered.contains(bareName(ident.simple).toLowerCase(java.util.Locale.ENGLISH))) {
                        mentionsAny = true;
                        break;
                    }
                }
                if (!mentionsAny) {
                    continue;
                }
                RoutineCatalog.UnitIndex unit = catalog.indexOf(text);
                if (unit == null) {
                    continue;
                }
                foreignUnits.add(unit);
                for (RoutineCatalog.Definition def : unit.definitions) {
                    for (PlsqlRoutineIdent ident : idents) {
                        if (!SQLUtil.sameName(EDbVendor.dbvoracle, ESQLDataObjectType.dotProcedure,
                                def.simple, ident.simple)) {
                            continue;
                        }
                        // ANY same-simple-name duplicate disqualifies UNQUALIFIED calls:
                        // the caller's current schema is unknown, so even a provably
                        // different schema could be the one the call resolves in.
                        ident.hasForeignSameName = true;
                        if (!provablyDifferentSchema(ident.schema, def.schema)) {
                            // Not provably different: qualified calls cannot separate
                            // the two candidates either.
                            ident.ambiguous = true;
                        }
                    }
                }
            }
        }
        // Same-file callers (file order, no cap - they were always visible to the
        // analysis), then foreign callers ordered by their EXACT source text so the
        // pick under the cap is independent of file order and distinct quoted
        // literals are never conflated.
        List<TCustomSqlStatement> callers = new ArrayList<TCustomSqlStatement>();
        for (int i = 0; i < ownStatements.size(); i++) {
            TCustomSqlStatement stmt = ownStatements.get(i);
            if (plsqlRoutineSimpleName(stmt) != null || isPlsqlDefinitionShape(stmt)) {
                continue;
            }
            if (isVettedLiteralCaller(stmt, idents)) {
                callers.add(stmt);
            }
        }
        java.util.TreeMap<String, TCustomSqlStatement> ordered =
                new java.util.TreeMap<String, TCustomSqlStatement>();
        for (RoutineCatalog.UnitIndex unit : foreignUnits) {
            for (RoutineCatalog.CallCandidate callCandidate : unit.callCandidates) {
                TCustomSqlStatement stmt = callCandidate.stmt;
                if (isPlsqlDefinitionShape(stmt)) {
                    continue;
                }
                if (isVettedLiteralCaller(stmt, idents)) {
                    String key = String.valueOf(stmt.toString());
                    if (!ordered.containsKey(key)) {
                        ordered.put(key, stmt);
                    }
                }
            }
        }
        int foreignAdded = 0;
        List<TCustomSqlStatement> foreignCallers = new ArrayList<TCustomSqlStatement>();
        for (TCustomSqlStatement stmt : ordered.values()) {
            if (foreignAdded >= maxForeignCallers) {
                break;
            }
            foreignCallers.add(stmt);
            foreignAdded++;
        }
        callers.addAll(foreignCallers);
        if (callers.isEmpty()) {
            // No vetted caller anywhere - interpretation would bind nothing.
            return result;
        }
        for (PlsqlRoutineIdent ident : idents) {
            result.add(ident.definition);
        }
        result.addAll(callers);
        return result;
    }

    /** Qualified identity of an own-file routine definition, plus its ambiguity verdicts. */
    private static final class PlsqlRoutineIdent {
        final TCustomSqlStatement definition;
        final String schema; // null when the definition name is unqualified
        final String simple;
        /** Some other file defines the same simple name AND it is not provably in a different schema. */
        boolean ambiguous;
        /** Some other file defines the same simple name at all (disqualifies unqualified calls). */
        boolean hasForeignSameName;

        PlsqlRoutineIdent(TCustomSqlStatement definition, String simple) {
            this.definition = definition;
            this.schema = plsqlRoutineSchema(definition);
            this.simple = simple;
        }
    }

    /** Schema segment of a routine definition name; null when unqualified. */
    private static String plsqlRoutineSchema(TCustomSqlStatement stmt) {
        gudusoft.gsqlparser.nodes.TObjectName name = null;
        if (stmt instanceof gudusoft.gsqlparser.stmt.oracle.TPlsqlCreateProcedure) {
            name = ((gudusoft.gsqlparser.stmt.oracle.TPlsqlCreateProcedure) stmt).getProcedureName();
        } else if (stmt instanceof gudusoft.gsqlparser.stmt.oracle.TPlsqlCreateFunction) {
            name = ((gudusoft.gsqlparser.stmt.oracle.TPlsqlCreateFunction) stmt).getFunctionName();
        }
        if (name == null) {
            return null;
        }
        List<String> parts = SQLUtil.parseNames(name.toString());
        return parts.size() >= 2 ? parts.get(parts.size() - 2) : null;
    }

    /**
     * True only when the two schema contexts are BOTH known and differ; a null on
     * either side could be the same schema (the conservative direction for the
     * ambiguity verdict).
     */
    private static boolean provablyDifferentSchema(String schemaA, String schemaB) {
        if (schemaA == null || schemaB == null) {
            return false;
        }
        return !SQLUtil.sameName(EDbVendor.dbvoracle, ESQLDataObjectType.dotSchema, schemaA, schemaB);
    }

    /**
     * Definition shapes that must never enter the interpretation list. Anonymous
     * blocks (TCommonBlock) ARE TStoredProcedureSqlStatement subclasses and are the
     * primary caller shape, so this names the definition classes explicitly.
     */
    private static boolean isPlsqlDefinitionShape(TCustomSqlStatement stmt) {
        return stmt instanceof gudusoft.gsqlparser.stmt.oracle.TPlsqlCreatePackage
                || stmt instanceof gudusoft.gsqlparser.stmt.oracle.TPlsqlCreateTrigger
                || stmt instanceof gudusoft.gsqlparser.stmt.oracle.TPlsqlCreateType;
    }

    /**
     * True when {@code stmt} contains at least one call that provably targets one of
     * {@code idents} and EVERY name-colliding call in the statement (a) resolves to
     * exactly one non-ambiguous identity - unqualified calls match by simple name,
     * two-part calls require the definition's schema to match, anything the shape
     * rules cannot prove is rejected because the interpreter may still bind it by
     * simple name - and (b) passes only compile-time literal arguments. A call fed
     * by a variable or expression is rejected wholesale: the interpreter would fold
     * the unevaluated operand to an EMPTY string - not a placeholder - which can
     * silently produce wrong object names (e.g. 'x' || p_suffix folding to just
     * "x"). The mssql discovery applies the same literal-only discipline.
     */
    private static boolean isVettedLiteralCaller(TCustomSqlStatement stmt,
            List<PlsqlRoutineIdent> idents) {
        final boolean[] found = { false };
        final boolean[] rejected = { false };
        final List<PlsqlRoutineIdent> targets = idents;
        try {
            stmt.acceptChildren(new gudusoft.gsqlparser.nodes.TParseTreeVisitor() {
                public void preVisit(gudusoft.gsqlparser.nodes.TFunctionCall call) {
                    vetCall(call);
                }

                public void preVisit(gudusoft.gsqlparser.stmt.TCallStatement call) {
                    // TCallStatement.acceptChildren does not surface its routine
                    // expression as a TFunctionCall - vet it explicitly, else
                    // CALL p('src') callers are silently never harvested.
                    if (call.getRoutineExpr() != null) {
                        vetCall(call.getRoutineExpr().getFunctionCall());
                    }
                }

                private void vetCall(gudusoft.gsqlparser.nodes.TFunctionCall call) {
                    if (call == null || call.getFunctionName() == null) {
                        return;
                    }
                    List<String> parts = SQLUtil.parseNames(call.getFunctionName().toString());
                    if (parts.isEmpty()) {
                        return;
                    }
                    String simple = parts.get(parts.size() - 1);
                    PlsqlRoutineIdent matched = null;
                    boolean collides = false;
                    boolean multi = false;
                    for (PlsqlRoutineIdent ident : targets) {
                        if (!SQLUtil.sameName(EDbVendor.dbvoracle, ESQLDataObjectType.dotProcedure,
                                simple, ident.simple)) {
                            continue;
                        }
                        collides = true;
                        boolean resolves;
                        if (parts.size() == 1) {
                            // An unqualified call resolves in the CALLER's (unknown)
                            // current schema: any same-named definition elsewhere -
                            // even in a provably different schema - leaves two
                            // candidates.
                            resolves = !ident.hasForeignSameName && !ident.ambiguous;
                        } else if (parts.size() == 2) {
                            resolves = !ident.ambiguous && ident.schema != null
                                    && SQLUtil.sameName(EDbVendor.dbvoracle, ESQLDataObjectType.dotSchema,
                                            parts.get(0), ident.schema);
                        } else {
                            resolves = false;
                        }
                        if (resolves) {
                            if (matched != null) {
                                multi = true;
                            }
                            matched = ident;
                        }
                    }
                    if (!collides) {
                        return;
                    }
                    if (matched == null || multi) {
                        rejected[0] = true;
                        return;
                    }
                    if (call.getArgs() == null || call.getArgs().size() == 0) {
                        found[0] = true;
                        return;
                    }
                    for (int i = 0; i < call.getArgs().size(); i++) {
                        if (!isCompileTimeLiteral(call.getArgs().getExpression(i))) {
                            rejected[0] = true;
                            return;
                        }
                    }
                    found[0] = true;
                }
            });
        } catch (RuntimeException ex) {
            return false;
        }
        return found[0] && !rejected[0];
    }

    /**
     * F1 guard: true when every partial/unfolded EXECUTE IMMEDIATE inside
     * {@code routine} builds its SQL exclusively from compile-time literals,
     * routine parameters, and local variables whose every assignment (and declared
     * default) is itself so composed, connected by || concatenation. Any other
     * dependency - SELECT/FETCH/EXECUTE..INTO targets, function results, variables
     * passed to other calls (possible OUT), nested routine declarations (scope
     * conflation) - disqualifies the whole routine: the interpreter folds what it
     * cannot evaluate to an EMPTY string, which would fabricate concrete-looking
     * but wrong SQL that the placeholder classifier cannot detect.
     */
    private static boolean plsqlDynamicSqlLiteralBindable(TCustomSqlStatement routine) {
        PlsqlBindContext ctx = buildPlsqlBindContext(routine);
        if (ctx == null || ctx.unbindable) {
            return false;
        }
        for (gudusoft.gsqlparser.nodes.TExpression expr : ctx.partialDynamicExprs) {
            if (!isLiteralBindableExpr(expr, ctx.params, ctx.assignments, ctx.disallowed,
                    new java.util.HashSet<String>())) {
                return false;
            }
        }
        return true;
    }

    /**
     * Binding-relevant facts collected from one routine's body, shared between the
     * EXECUTE IMMEDIATE bindability gate and the DBMS_SQL text fold: declared
     * parameters, tracked single-variable assignments, names disqualified by
     * untrackable writes, and the dynamic-string expressions of partial/unfolded
     * EXECUTE IMMEDIATE sites.
     */
    static final class PlsqlBindContext {
        final java.util.Set<String> params = new java.util.HashSet<String>();
        final Map<String, List<BoundSource>> assignments =
                new HashMap<String, List<BoundSource>>();
        final java.util.Set<String> disallowed = new java.util.HashSet<String>();
        final List<gudusoft.gsqlparser.nodes.TExpression> partialDynamicExprs =
                new ArrayList<gudusoft.gsqlparser.nodes.TExpression>();
        /** Nested routine declarations (scope conflation) or a partial site with no expression. */
        boolean unbindable;
    }

    /** One tracked assignment source with its source position (for flow-order checks). */
    static final class BoundSource {
        final gudusoft.gsqlparser.nodes.TExpression expr;
        final long line;
        final long col;

        BoundSource(gudusoft.gsqlparser.nodes.TExpression expr, long line, long col) {
            this.expr = expr;
            this.line = line;
            this.col = col;
        }
    }

    /** Collector behind {@link PlsqlBindContext}; null when the walk crashed. */
    static PlsqlBindContext buildPlsqlBindContext(TCustomSqlStatement routine) {
        try {
            final PlsqlBindContext ctx = new PlsqlBindContext();
            final java.util.Set<String> params = ctx.params;
            if (routine instanceof gudusoft.gsqlparser.stmt.TStoredProcedureSqlStatement) {
                TParameterDeclarationList declared = ((gudusoft.gsqlparser.stmt.TStoredProcedureSqlStatement) routine)
                        .getParameterDeclarations();
                if (declared != null) {
                    for (int i = 0; i < declared.size(); i++) {
                        TParameterDeclaration pd = declared.getParameterDeclarationItem(i);
                        if (pd != null && pd.getParameterName() != null) {
                            params.add(canonVarKey(pd.getParameterName().toString()));
                        }
                    }
                }
            }
            final Map<String, List<BoundSource>> assignments = ctx.assignments;
            final java.util.Set<String> disallowed = ctx.disallowed;
            final List<gudusoft.gsqlparser.nodes.TExpression> dynamicExprs = ctx.partialDynamicExprs;
            final boolean[] nestedRoutine = { false };
            final TCustomSqlStatement root = routine;
            routine.acceptChildren(new gudusoft.gsqlparser.nodes.TParseTreeVisitor() {
                public void preVisit(gudusoft.gsqlparser.stmt.TAssignStmt stmt) {
                    if (stmt.getLeft() == null || stmt.getExpression() == null) {
                        return;
                    }
                    String left = stmt.getLeft().toString();
                    if (left == null || left.indexOf('(') >= 0
                            || SQLUtil.parseNames(left).size() != 1) {
                        return; // record fields / collection elements are not tracked
                    }
                    recordAssignment(canonVarKey(left), stmt.getExpression(),
                            stmt.getStartToken() != null ? stmt.getStartToken()
                                    : stmt.getExpression().getStartToken());
                }

                public void preVisit(gudusoft.gsqlparser.stmt.TVarDeclStmt stmt) {
                    if (stmt.getElementName() == null) {
                        return;
                    }
                    if (stmt.getDefaultValue() != null) {
                        recordAssignment(canonVarKey(stmt.getElementName().toString()),
                                stmt.getDefaultValue(), stmt.getStartToken());
                    }
                }

                private void recordAssignment(String key,
                        gudusoft.gsqlparser.nodes.TExpression source,
                        gudusoft.gsqlparser.TSourceToken position) {
                    List<BoundSource> list = assignments.get(key);
                    if (list == null) {
                        list = new ArrayList<BoundSource>();
                        assignments.put(key, list);
                    }
                    // Unknown position sorts AFTER everything (Long.MAX_VALUE): a source
                    // whose location cannot be established never counts as preceding a
                    // use site - the conservative direction for the flow-order check.
                    list.add(new BoundSource(source,
                            position != null ? position.lineNo : Long.MAX_VALUE,
                            position != null ? position.columnNo : Long.MAX_VALUE));
                }

                public void preVisit(gudusoft.gsqlparser.stmt.TSelectSqlStatement stmt) {
                    if (stmt.getIntoClause() != null && stmt.getIntoClause().getExprList() != null) {
                        for (int i = 0; i < stmt.getIntoClause().getExprList().size(); i++) {
                            disallowExpr(stmt.getIntoClause().getExprList().getExpression(i));
                        }
                    }
                }

                public void preVisit(gudusoft.gsqlparser.stmt.TFetchStmt stmt) {
                    if (stmt.getVariableNames() != null) {
                        for (int i = 0; i < stmt.getVariableNames().size(); i++) {
                            disallowExpr(stmt.getVariableNames().getExpression(i));
                        }
                    }
                }

                public void preVisit(gudusoft.gsqlparser.stmt.TExecImmeStmt stmt) {
                    if (stmt.getIntoVariables() != null) {
                        for (int i = 0; i < stmt.getIntoVariables().size(); i++) {
                            disallowExpr(stmt.getIntoVariables().getExpression(i));
                        }
                    }
                    // USING bind values never rewrite the SQL text, but OUT binds
                    // write variables - disallow every bind target conservatively.
                    if (stmt.getBindArguments() != null) {
                        for (int i = 0; i < stmt.getBindArguments().size(); i++) {
                            gudusoft.gsqlparser.nodes.TBindArgument bind =
                                    stmt.getBindArguments().getBindArgument(i);
                            if (bind != null && bind.getBindArgumentExpr() != null) {
                                disallowExpr(bind.getBindArgumentExpr());
                            }
                        }
                    }
                    if (stmt.getDynamicSQL() == null || stmt.isDynamicSQLPartial()) {
                        if (stmt.getDynamicStringExpr() != null) {
                            dynamicExprs.add(stmt.getDynamicStringExpr());
                        } else {
                            nestedRoutine[0] = true; // unfoldable site with no expression - bail
                        }
                    }
                }

                public void preVisit(gudusoft.gsqlparser.nodes.TFunctionCall call) {
                    disallowBareArgs(call);
                }

                public void preVisit(gudusoft.gsqlparser.stmt.TCallStatement stmt) {
                    // TCallStatement.acceptChildren does not surface its routine
                    // expression as a TFunctionCall - inspect its args explicitly.
                    if (stmt.getRoutineExpr() != null) {
                        disallowBareArgs(stmt.getRoutineExpr().getFunctionCall());
                    }
                }

                public void preVisit(gudusoft.gsqlparser.nodes.TReturningClause clause) {
                    // RETURNING ... INTO writes locals, and the clause's own
                    // acceptChildren does not visit its variable list - handle it
                    // here or a literal-initialized local silently keeps its stale
                    // literal after being overwritten.
                    if (clause.getVariableList() != null) {
                        for (int i = 0; i < clause.getVariableList().size(); i++) {
                            disallowExpr(clause.getVariableList().getExpression(i));
                        }
                    }
                }

                private void disallowBareArgs(gudusoft.gsqlparser.nodes.TFunctionCall call) {
                    // A bare variable handed to any call could be an OUT actual -
                    // except at argument positions of KNOWN in-only builtins
                    // (notably DBMS_SQL.PARSE's own statement argument, which
                    // would otherwise disqualify the very variable it consumes).
                    if (call == null || call.getArgs() == null) {
                        return;
                    }
                    for (int i = 0; i < call.getArgs().size(); i++) {
                        if (isKnownInOnlyArg(call, i)) {
                            continue;
                        }
                        gudusoft.gsqlparser.nodes.TExpression arg = call.getArgs().getExpression(i);
                        if (arg != null && arg.getExpressionType()
                                == gudusoft.gsqlparser.EExpressionType.simple_object_name_t) {
                            disallowExpr(arg);
                        }
                    }
                }

                public void preVisit(gudusoft.gsqlparser.stmt.oracle.TPlsqlCreateProcedure stmt) {
                    if (stmt != root) {
                        nestedRoutine[0] = true; // nested scopes would conflate name keys
                    }
                }

                public void preVisit(gudusoft.gsqlparser.stmt.oracle.TPlsqlCreateFunction stmt) {
                    if (stmt != root) {
                        nestedRoutine[0] = true;
                    }
                }

                private void disallowExpr(gudusoft.gsqlparser.nodes.TExpression expr) {
                    if (expr == null) {
                        return;
                    }
                    String text = expr.toString();
                    if (text != null && SQLUtil.parseNames(text).size() == 1
                            && text.indexOf('(') < 0) {
                        disallowed.add(canonVarKey(text));
                    }
                }
            });
            ctx.unbindable = nestedRoutine[0];
            return ctx;
        } catch (RuntimeException ex) {
            return null;
        }
    }

    /**
     * True when argument {@code index} of {@code call} is an IN-only position of a
     * known builtin, so a bare variable there is a READ and must not disqualify the
     * variable from literal folding. Deliberately tiny: DBMS_SQL.PARSE's statement
     * argument (index 1 positional; named association arrives as an arrow
     * expression and is never a bare name anyway) and DBMS_OUTPUT.PUT_LINE / PUT
     * (pure logging, all-IN) — the calls that most commonly surround dynamic SQL.
     */
    private static boolean isKnownInOnlyArg(gudusoft.gsqlparser.nodes.TFunctionCall call, int index) {
        if (call.getFunctionName() == null) {
            return false;
        }
        String name = call.getFunctionName().toString();
        if (SQLUtil.compareIdentifier(EDbVendor.dbvoracle, ESQLDataObjectType.dotProcedure,
                name, "DBMS_SQL.PARSE")
                || SQLUtil.compareIdentifier(EDbVendor.dbvoracle, ESQLDataObjectType.dotProcedure,
                        name, "SYS.DBMS_SQL.PARSE")) {
            return index == 1;
        }
        return SQLUtil.compareIdentifier(EDbVendor.dbvoracle, ESQLDataObjectType.dotProcedure,
                name, "DBMS_OUTPUT.PUT_LINE")
                || SQLUtil.compareIdentifier(EDbVendor.dbvoracle, ESQLDataObjectType.dotProcedure,
                        name, "DBMS_OUTPUT.PUT");
    }

    /**
     * DBMS_SQL entry point (plan Phase 5 slice 4): fold the SQL-text argument of a
     * {@code DBMS_SQL.PARSE} call into concrete statement texts. Returns the
     * no-binding fold first (literal or literal-composed locals), then one fold per
     * literal call-site binding set (same-file callers first, then cross-file via
     * the catalog), deduplicated, capped at {@code maxVariants}. Empty when nothing
     * folds — the site then keeps its honest unresolved diagnostic. The fold shares
     * the EXECUTE IMMEDIATE whitelist (literals, parameters bound at vetted call
     * sites, locals with exactly one literal-composed assignment, || and
     * parentheses), so a fold can never fabricate object names.
     */
    public static List<String> foldDbmsSqlTexts(TCustomSqlStatement enclosingRoutine,
            gudusoft.gsqlparser.nodes.TExpression sqlArg, RoutineCatalog catalog, int maxVariants) {
        List<String> texts = new ArrayList<String>();
        if (sqlArg == null || maxVariants <= 0) {
            return texts;
        }
        PlsqlBindContext ctx = enclosingRoutine == null ? new PlsqlBindContext()
                : buildPlsqlBindContext(enclosingRoutine);
        if (ctx == null || ctx.unbindable) {
            // Context unavailable: only a directly-literal argument can fold.
            ctx = new PlsqlBindContext();
        }
        // Flow-order bound: only assignments strictly before the PARSE site count.
        // An unknown site position folds no variables at all (literals still do).
        long siteLine = Long.MIN_VALUE;
        long siteCol = Long.MIN_VALUE;
        if (sqlArg.getStartToken() != null) {
            siteLine = sqlArg.getStartToken().lineNo;
            siteCol = sqlArg.getStartToken().columnNo;
        }
        String direct = foldLiteralBindableExpr(sqlArg, ctx,
                new HashMap<String, SqlValue>(), new java.util.HashSet<String>(),
                siteLine, siteCol);
        if (direct != null && !direct.trim().isEmpty()) {
            texts.add(direct);
        }
        if (texts.size() < maxVariants && enclosingRoutine != null) {
            for (Map<String, SqlValue> bindings : discoverPlsqlCallSiteBindings(
                    enclosingRoutine, catalog, maxVariants)) {
                String folded = foldLiteralBindableExpr(sqlArg, ctx, bindings,
                        new java.util.HashSet<String>(), siteLine, siteCol);
                if (folded != null && !folded.trim().isEmpty() && !texts.contains(folded)) {
                    texts.add(folded);
                    if (texts.size() >= maxVariants) {
                        break;
                    }
                }
            }
        }
        return texts;
    }

    /**
     * Fold an expression to its concrete string under the P5-2 whitelist: literals,
     * parameters WITH a supplied binding (a NULL binding folds to the empty string,
     * Oracle's NULL-concatenation semantics), locals with exactly one
     * literal-composed assignment, || and parentheses. Null when anything outside
     * the whitelist (or an unbound parameter) is involved — never a partial text.
     *
     * <p>Flow order: a local's single assignment is usable only when it appears
     * strictly BEFORE ({@code boundLine},{@code boundCol}) — the use site on the
     * first level, then the consuming assignment's own position as the recursion
     * descends — so a value assigned after the site can never fabricate lineage.
     */
    private static String foldLiteralBindableExpr(gudusoft.gsqlparser.nodes.TExpression expr,
            PlsqlBindContext ctx, Map<String, SqlValue> bindings, java.util.Set<String> visiting,
            long boundLine, long boundCol) {
        if (expr == null) {
            return null;
        }
        if (isCompileTimeLiteral(expr)) {
            SqlValue value = literalToSqlValue(expr);
            if (value == null) {
                return null;
            }
            return value.isNull() ? "" : String.valueOf(value.text());
        }
        gudusoft.gsqlparser.EExpressionType type = expr.getExpressionType();
        if (type == gudusoft.gsqlparser.EExpressionType.concatenate_t) {
            String left = foldLiteralBindableExpr(expr.getLeftOperand(), ctx, bindings, visiting,
                    boundLine, boundCol);
            String right = foldLiteralBindableExpr(expr.getRightOperand(), ctx, bindings, visiting,
                    boundLine, boundCol);
            return left == null || right == null ? null : left + right;
        }
        if (type == gudusoft.gsqlparser.EExpressionType.parenthesis_t) {
            return foldLiteralBindableExpr(expr.getLeftOperand(), ctx, bindings, visiting,
                    boundLine, boundCol);
        }
        if (type == gudusoft.gsqlparser.EExpressionType.simple_object_name_t) {
            String text = expr.toString();
            if (text == null || SQLUtil.parseNames(text).size() != 1) {
                return null;
            }
            String key = canonVarKey(text);
            if (ctx.disallowed.contains(key)) {
                return null;
            }
            if (ctx.params.contains(key)) {
                SqlValue bound = bindings.get(key);
                if (bound == null) {
                    return null; // unbound parameter - never fold partially
                }
                return bound.isNull() ? "" : String.valueOf(bound.text());
            }
            List<BoundSource> sources = ctx.assignments.get(key);
            if (sources == null || sources.size() != 1 || !visiting.add(key)) {
                return null;
            }
            try {
                BoundSource source = sources.get(0);
                if (source.line > boundLine
                        || (source.line == boundLine && source.col >= boundCol)) {
                    return null; // assigned at or after the use site - value unavailable
                }
                return foldLiteralBindableExpr(source.expr, ctx, bindings, visiting,
                        source.line, source.col);
            } finally {
                visiting.remove(key);
            }
        }
        return null;
    }

    /**
     * Literal call-site binding sets for an Oracle routine, mirroring the T-SQL
     * {@link #discoverCallSiteBindings} semantics: same-file callers first (file
     * order), then cross-file callers via the catalog (exact-text order); vetted by
     * {@link #isVettedLiteralCaller} (so only positional, compile-time-literal
     * arguments to a provably-unambiguous target survive); one binding map per
     * matching call, deduplicated by canonical key, capped.
     */
    static List<Map<String, SqlValue>> discoverPlsqlCallSiteBindings(
            TCustomSqlStatement procAst, RoutineCatalog catalog, int maxBindingSets) {
        List<Map<String, SqlValue>> bindingSets = new ArrayList<Map<String, SqlValue>>();
        if (maxBindingSets <= 0 || procAst == null || procAst.getGsqlparser() == null) {
            return bindingSets;
        }
        String simple = plsqlRoutineSimpleName(procAst);
        if (simple == null || simple.isEmpty()) {
            return bindingSets;
        }
        final PlsqlRoutineIdent ident = new PlsqlRoutineIdent(procAst, simple);
        TStatementList ownStatements = procAst.getGsqlparser().getSqlstatements();
        String ownText = procAst.getGsqlparser().sqltext;
        // Same-FILE duplicate definitions make the name just as ambiguous as foreign
        // ones (the interpretation path catches this via its multi-ident matching;
        // this single-ident path must check explicitly).
        if (ownStatements != null) {
            for (int i = 0; i < ownStatements.size(); i++) {
                TCustomSqlStatement stmt = ownStatements.get(i);
                if (stmt == procAst) {
                    continue;
                }
                String otherSimple = plsqlRoutineSimpleName(stmt);
                if (otherSimple == null || !SQLUtil.sameName(EDbVendor.dbvoracle,
                        ESQLDataObjectType.dotProcedure, otherSimple, ident.simple)) {
                    continue;
                }
                ident.hasForeignSameName = true;
                if (!provablyDifferentSchema(ident.schema, plsqlRoutineSchema(stmt))) {
                    ident.ambiguous = true;
                }
            }
        }
        // Foreign definitions decide the ambiguity verdicts (same rules as the
        // interpretation path).
        List<RoutineCatalog.UnitIndex> foreignUnits = new ArrayList<RoutineCatalog.UnitIndex>();
        if (catalog != null) {
            String probe = bareName(simple).toLowerCase(java.util.Locale.ENGLISH);
            for (String text : catalog.unitTexts()) {
                if (text == null || text.equals(ownText)
                        || !text.toLowerCase(java.util.Locale.ENGLISH).contains(probe)) {
                    continue;
                }
                RoutineCatalog.UnitIndex unit = catalog.indexOf(text);
                if (unit == null) {
                    continue;
                }
                foreignUnits.add(unit);
                for (RoutineCatalog.Definition def : unit.definitions) {
                    if (!SQLUtil.sameName(EDbVendor.dbvoracle, ESQLDataObjectType.dotProcedure,
                            def.simple, ident.simple)) {
                        continue;
                    }
                    ident.hasForeignSameName = true;
                    if (!provablyDifferentSchema(ident.schema, def.schema)) {
                        ident.ambiguous = true;
                    }
                }
            }
        }
        List<PlsqlRoutineIdent> idents = new ArrayList<PlsqlRoutineIdent>();
        idents.add(ident);
        List<TParameterDeclaration> params = new ArrayList<TParameterDeclaration>();
        if (procAst instanceof gudusoft.gsqlparser.stmt.TStoredProcedureSqlStatement) {
            TParameterDeclarationList declared = ((gudusoft.gsqlparser.stmt.TStoredProcedureSqlStatement) procAst)
                    .getParameterDeclarations();
            if (declared != null) {
                for (int i = 0; i < declared.size(); i++) {
                    params.add(declared.getParameterDeclarationItem(i));
                }
            }
        }
        java.util.Set<String> seen = new java.util.HashSet<String>();
        // Same-file callers in file order.
        if (ownStatements != null) {
            for (int i = 0; i < ownStatements.size()
                    && bindingSets.size() < maxBindingSets; i++) {
                TCustomSqlStatement stmt = ownStatements.get(i);
                if (stmt == procAst || plsqlRoutineSimpleName(stmt) != null
                        || isPlsqlDefinitionShape(stmt)) {
                    continue;
                }
                if (isVettedLiteralCaller(stmt, idents)) {
                    extractPlsqlBindings(stmt, ident, params, seen, bindingSets, maxBindingSets);
                }
            }
        }
        // Cross-file callers ordered by exact statement text.
        java.util.TreeMap<String, TCustomSqlStatement> ordered =
                new java.util.TreeMap<String, TCustomSqlStatement>();
        for (RoutineCatalog.UnitIndex unit : foreignUnits) {
            for (RoutineCatalog.CallCandidate candidate : unit.callCandidates) {
                if (isPlsqlDefinitionShape(candidate.stmt)) {
                    continue;
                }
                if (isVettedLiteralCaller(candidate.stmt, idents)) {
                    String key = String.valueOf(candidate.stmt.toString());
                    if (!ordered.containsKey(key)) {
                        ordered.put(key, candidate.stmt);
                    }
                }
            }
        }
        for (TCustomSqlStatement stmt : ordered.values()) {
            if (bindingSets.size() >= maxBindingSets) {
                break;
            }
            extractPlsqlBindings(stmt, ident, params, seen, bindingSets, maxBindingSets);
        }
        return bindingSets;
    }

    /**
     * Extract one binding map per call to {@code ident} inside a VETTED caller
     * statement. Vetting already guaranteed every matching call is unambiguous and
     * all-literal (positional form — named notation is rejected there), so this
     * maps arguments to parameter declarations by position.
     */
    private static void extractPlsqlBindings(TCustomSqlStatement callerStmt,
            final PlsqlRoutineIdent ident, final List<TParameterDeclaration> params,
            final java.util.Set<String> seen, final List<Map<String, SqlValue>> bindingSets,
            final int maxBindingSets) {
        try {
            callerStmt.acceptChildren(new gudusoft.gsqlparser.nodes.TParseTreeVisitor() {
                public void preVisit(gudusoft.gsqlparser.nodes.TFunctionCall call) {
                    collect(call);
                }

                public void preVisit(gudusoft.gsqlparser.stmt.TCallStatement call) {
                    if (call.getRoutineExpr() != null) {
                        collect(call.getRoutineExpr().getFunctionCall());
                    }
                }

                private void collect(gudusoft.gsqlparser.nodes.TFunctionCall call) {
                    if (call == null || call.getFunctionName() == null
                            || bindingSets.size() >= maxBindingSets) {
                        return;
                    }
                    List<String> parts = SQLUtil.parseNames(call.getFunctionName().toString());
                    if (parts.isEmpty() || !SQLUtil.sameName(EDbVendor.dbvoracle,
                            ESQLDataObjectType.dotProcedure, parts.get(parts.size() - 1),
                            ident.simple)) {
                        return;
                    }
                    if (call.getArgs() == null || call.getArgs().size() == 0) {
                        return;
                    }
                    Map<String, SqlValue> bindings = new java.util.LinkedHashMap<String, SqlValue>();
                    java.util.TreeMap<String, String> canonical = new java.util.TreeMap<String, String>();
                    for (int i = 0; i < call.getArgs().size(); i++) {
                        if (i >= params.size() || params.get(i) == null
                                || params.get(i).getParameterName() == null) {
                            return; // arity beyond declaration - do not guess
                        }
                        SqlValue value = literalToSqlValue(call.getArgs().getExpression(i));
                        if (value == null) {
                            return; // vetting should prevent this; stay safe
                        }
                        String paramName = params.get(i).getParameterName().toString();
                        bindings.put(canonVarKey(paramName), value);
                        canonical.put(canonVarKey(paramName),
                                canonicalValueKey(call.getArgs().getExpression(i)));
                    }
                    if (!bindings.isEmpty() && seen.add(canonical.toString())) {
                        bindingSets.add(bindings);
                    }
                }
            });
        } catch (RuntimeException ex) {
            // best-effort extraction; a crashed walk contributes nothing
        }
    }

    /**
     * Variable-tracking key preserving Oracle quote semantics: unquoted names fold
     * upper (case-insensitive), quoted names keep their exact case inside markers so
     * a quoted lowercase local is never conflated with an unquoted parameter of the
     * same spelling. (Unquoted FOO vs quoted "FOO" key differently - a conservative
     * miss that can only disqualify, never wrongly qualify.)
     */
    private static String canonVarKey(String name) {
        String trimmed = name.trim();
        if (trimmed.length() >= 2 && trimmed.charAt(0) == '"'
                && trimmed.charAt(trimmed.length() - 1) == '"') {
            return "\"" + trimmed.substring(1, trimmed.length() - 1) + "\"";
        }
        return trimmed.toUpperCase(java.util.Locale.ENGLISH);
    }

    /**
     * Recursive whitelist for {@link #plsqlDynamicSqlLiteralBindable}: literals,
     * || concatenation, parentheses, routine parameters, and local variables whose
     * every recorded assignment is itself bindable. Cycles and everything else fail.
     */
    private static boolean isLiteralBindableExpr(gudusoft.gsqlparser.nodes.TExpression expr,
            java.util.Set<String> params,
            Map<String, List<BoundSource>> assignments,
            java.util.Set<String> disallowed, java.util.Set<String> visiting) {
        if (expr == null) {
            return false;
        }
        if (isCompileTimeLiteral(expr)) {
            return true;
        }
        gudusoft.gsqlparser.EExpressionType type = expr.getExpressionType();
        if (type == gudusoft.gsqlparser.EExpressionType.concatenate_t) {
            return isLiteralBindableExpr(expr.getLeftOperand(), params, assignments, disallowed, visiting)
                    && isLiteralBindableExpr(expr.getRightOperand(), params, assignments, disallowed, visiting);
        }
        if (type == gudusoft.gsqlparser.EExpressionType.parenthesis_t) {
            return isLiteralBindableExpr(expr.getLeftOperand(), params, assignments, disallowed, visiting);
        }
        if (type == gudusoft.gsqlparser.EExpressionType.simple_object_name_t) {
            String text = expr.toString();
            if (text == null || SQLUtil.parseNames(text).size() != 1) {
                return false;
            }
            String key = canonVarKey(text);
            if (disallowed.contains(key)) {
                return false;
            }
            if (params.contains(key)) {
                return true;
            }
            List<BoundSource> sources = assignments.get(key);
            // Exactly ONE recorded source (assignment or declared default): with
            // several, control flow (IF/loops) selects which one is live, but the
            // interpreter walks structurally and would collapse them to a single
            // arbitrary winner - presenting one possible lineage as certain. Real
            // branch-sensitive evaluation is Phase 3 CFG work.
            if (sources == null || sources.size() != 1 || !visiting.add(key)) {
                return false;
            }
            try {
                if (!isLiteralBindableExpr(sources.get(0).expr, params, assignments,
                        disallowed, visiting)) {
                    return false;
                }
            } finally {
                visiting.remove(key);
            }
            return true;
        }
        return false;
    }

    /** Compile-time literal: string/numeric constant, signed numeric, or bare NULL. */
    private static boolean isCompileTimeLiteral(gudusoft.gsqlparser.nodes.TExpression expr) {
        if (expr == null) {
            return false;
        }
        gudusoft.gsqlparser.EExpressionType type = expr.getExpressionType();
        if (type == gudusoft.gsqlparser.EExpressionType.unary_plus_t
                || type == gudusoft.gsqlparser.EExpressionType.unary_minus_t) {
            return isCompileTimeLiteral(expr.getRightOperand() != null
                    ? expr.getRightOperand() : expr.getLeftOperand());
        }
        if (type == gudusoft.gsqlparser.EExpressionType.simple_source_token_t
                && expr.toString().trim().equalsIgnoreCase("NULL")) { // non-identifier-compare: the NULL keyword literal
            return true;
        }
        return type == gudusoft.gsqlparser.EExpressionType.simple_constant_t
                && expr.getConstantOperand() != null;
    }

    /** Simple name of an Oracle routine definition; null for any other statement. */
    private static String plsqlRoutineSimpleName(TCustomSqlStatement stmt) {
        gudusoft.gsqlparser.nodes.TObjectName name = null;
        if (stmt instanceof gudusoft.gsqlparser.stmt.oracle.TPlsqlCreateProcedure) {
            name = ((gudusoft.gsqlparser.stmt.oracle.TPlsqlCreateProcedure) stmt).getProcedureName();
        } else if (stmt instanceof gudusoft.gsqlparser.stmt.oracle.TPlsqlCreateFunction) {
            name = ((gudusoft.gsqlparser.stmt.oracle.TPlsqlCreateFunction) stmt).getFunctionName();
        }
        if (name == null) {
            return null;
        }
        return lastNameSegment(name.toString());
    }

    // Package-visible accessors for RoutineCatalog (plan §5.6 index). Same helpers,
    // exposed under index-facing names; no behavior of their own.
    static String mssqlDefinitionDatabase(TMssqlCreateProcedure def, String currentDb) {
        return definitionDatabase(def, currentDb);
    }

    static String simpleNameOf(String name) {
        return lastNameSegment(name);
    }

    static String plsqlRoutineSimpleNameOf(TCustomSqlStatement stmt) {
        return plsqlRoutineSimpleName(stmt);
    }

    static String plsqlRoutineSchemaOf(TCustomSqlStatement stmt) {
        return plsqlRoutineSchema(stmt);
    }

    /** Effective database (last USE before the definition) of {@code procAst} in its file. */
    private static String effectiveDatabaseOfProc(TStatementList all, TCustomSqlStatement procAst) {
        String currentDb = null;
        for (int i = 0; i < all.size(); i++) {
            if (all.get(i) instanceof gudusoft.gsqlparser.stmt.TUseDatabase) {
                currentDb = String.valueOf(((gudusoft.gsqlparser.stmt.TUseDatabase) all.get(i)).getDatabaseName());
            }
            if (all.get(i) == procAst) {
                return currentDb;
            }
        }
        return null;
    }

    /**
     * True when {@code call} is a plain (non-dynamic-text) EXEC of {@code proc} under
     * the matching rules: unqualified operands match by simple name, qualified operands
     * require the full qualified identity (so EXEC audit.load is never taken as a call
     * to dbo.load), and one-/two-part names must agree on the effective USE database.
     */
    private static boolean callMatchesProc(gudusoft.gsqlparser.stmt.mssql.TMssqlExecute call,
            TMssqlCreateProcedure proc, String procSimpleName, String procDb, String callDb,
            gudusoft.gsqlparser.sqlenv.IdentifierService names) {
        if (call.getModuleName() == null || call.getSqlText() != null) {
            return false;
        }
        String callName = call.getModuleName().toString();
        if (!sameEffectiveDatabase(procDb, callDb, callName, names)) {
            return false;
        }
        List<String> callParts = SQLUtil.parseNames(callName);
        if (callParts.size() <= 1) {
            return sameName(names, ESQLDataObjectType.dotProcedure, lastNameSegment(callName), procSimpleName);
        }
        List<String> procParts = SQLUtil.parseNames(proc.getProcedureName().toString());
        if (callParts.size() == procParts.size()) {
            if (names == null) {
                return SQLUtil.compareIdentifier(EDbVendor.dbvmssql, ESQLDataObjectType.dotProcedure,
                        callName, proc.getProcedureName().toString());
            }
            // segment by segment from the name: procedure, schema, database, server
            ESQLDataObjectType[] roles = {ESQLDataObjectType.dotProcedure, ESQLDataObjectType.dotSchema,
                    ESQLDataObjectType.dotCatalog, ESQLDataObjectType.dotCatalog};
            for (int k = 1; k <= callParts.size(); k++) {
                if (!sameName(names, roles[Math.min(k - 1, roles.length - 1)], callParts.get(callParts.size() - k),
                        procParts.get(procParts.size() - k))) {
                    return false;
                }
            }
            return true;
        }
        if (callParts.size() == 2 && procParts.size() == 3) {
            // Two-part call to a three-part definition: database agreement was already
            // established by sameEffectiveDatabase (call's USE db vs the definition's
            // catalog); compare the remaining schema.name segments.
            return sameName(names, ESQLDataObjectType.dotSchema, callParts.get(0), procParts.get(1))
                    && sameName(names, ESQLDataObjectType.dotProcedure, callParts.get(1), procParts.get(2));
        }
        if (callParts.size() == 3 && procParts.size() == 2) {
            // Three-part call to a two-part definition: the call's explicit catalog
            // must equal the definition's known effective database.
            return procDb != null
                    && sameName(names, ESQLDataObjectType.dotCatalog, callParts.get(0), procDb)
                    && sameName(names, ESQLDataObjectType.dotSchema, callParts.get(1), procParts.get(0))
                    && sameName(names, ESQLDataObjectType.dotProcedure, callParts.get(2), procParts.get(1));
        }
        // Other arity combinations (e.g. one-part definition vs qualified call) keep
        // the conservative no-match: schema defaulting is environment-dependent.
        return false;
    }

    /** A literal binding set extracted from one call site plus its canonical dedupe key. */
    private static final class BindingCandidate {
        final Map<String, SqlValue> bindings;
        final String canonicalKey;
        /** Where the call is: {@code "line 12"}, {@code "unit 2 line 1"}. */
        final String source;
        /** The call, kind and position; set by the discovery that found it. */
        BindingSource bindingSource = BindingSource.NONE;
        /** The procedure whose body holds the call; null for a call in a batch. */
        String routine;
        /** The call may not run on the path its values come from (an undecidable branch, a loop, CATCH). */
        boolean mayNotRun;

        BindingCandidate(Map<String, SqlValue> bindings, String canonicalKey, String source) {
            this.bindings = bindings;
            this.canonicalKey = canonicalKey;
            this.source = source;
        }
    }

    /**
     * Convert one EXEC call's literal arguments into a binding set; null when nothing literal was bound
     * ({@code whyNot[0]} says so). A call with an argument that is not a literal is bound by evaluating its
     * caller ({@link #candidatesForCall}), never here.
     */
    private static BindingCandidate bindingCandidateFromCall(
            gudusoft.gsqlparser.stmt.mssql.TMssqlExecute call, List<TParameterDeclaration> params,
            String source, String[] whyNot, gudusoft.gsqlparser.sqlenv.IdentifierService names) {
        Map<String, SqlValue> bindings = new java.util.LinkedHashMap<String, SqlValue>();
        if (call.getParameters() != null) {
            for (int j = 0; j < call.getParameters().size(); j++) {
                gudusoft.gsqlparser.nodes.TExecParameter arg = call.getParameters().getExecParameter(j);
                if (arg == null || arg.getParameterMode() != TBaseType.parameter_mode_default) {
                    // OUT/OUTPUT actuals stay unbound: the value at the dynamic
                    // site may differ from the literal passed in.
                    continue;
                }
                String paramName = null;
                if (arg.getParameterName() != null) {
                    paramName = arg.getParameterName().toString();
                } else if (j < params.size() && params.get(j).getParameterName() != null) {
                    paramName = params.get(j).getParameterName().toString();
                }
                // DEFAULT is no literal: nothing is bound and the default applies
                SqlValue value = literalToSqlValue(arg.getParameterValue());
                if (paramName != null && value != null) {
                    bindings.put(paramName, value);
                }
            }
        }
        if (bindings.isEmpty()) {
            whyNot[0] = "no argument is a literal";
            return null;
        }
        return new BindingCandidate(bindings, bindingKey(bindings, params, names), source);
    }

    /**
     * Database a definition belongs to: the catalog part of a three-part name wins,
     * otherwise the effective USE database at the definition site.
     */
    private static String definitionDatabase(TMssqlCreateProcedure def, String currentDb) {
        List<String> parts = SQLUtil.parseNames(def.getProcedureName().toString());
        if (parts.size() >= 3) {
            return parts.get(0);
        }
        return currentDb;
    }

    /**
     * True only when the two database contexts are BOTH known and differ. A null on
     * either side means "analysis default" - possibly the same database - so it is
     * NOT provably different (the conservative direction for the ambiguity bail-out).
     */
    private static boolean provablyDifferentDatabase(String dbA, String dbB,
            gudusoft.gsqlparser.sqlenv.IdentifierService names) {
        if (dbA == null || dbB == null) {
            return false;
        }
        return !sameName(names, ESQLDataObjectType.dotCatalog, dbA, dbB);
    }

    /** Name stripped of [..] / ".." / `..` quoting, for the cheap contains-prefilter only. */
    private static String bareName(String name) {
        String trimmed = name.trim();
        if (trimmed.length() >= 2) {
            char first = trimmed.charAt(0);
            char last = trimmed.charAt(trimmed.length() - 1);
            if ((first == '[' && last == ']') || (first == '"' && last == '"')
                    || (first == '`' && last == '`')) {
                return trimmed.substring(1, trimmed.length() - 1).trim();
            }
        }
        return trimmed;
    }


    /**
     * True when the call's effective database matches the procedure definition's. An
     * explicit three-part call name carries its own database and was already compared
     * as a full qualified identity; here we only reject cross-USE ambiguity for one-
     * and two-part names.
     */
    private static boolean sameEffectiveDatabase(String procDb, String callDb, String callName,
            gudusoft.gsqlparser.sqlenv.IdentifierService names) {
        if (SQLUtil.parseNames(callName).size() >= 3) {
            return true;
        }
        if (procDb == null && callDb == null) {
            return true;
        }
        if (procDb == null || callDb == null) {
            return false;
        }
        return sameName(names, ESQLDataObjectType.dotCatalog, procDb, callDb);
    }

    private static String lastNameSegment(String name) {
        List<String> parts = SQLUtil.parseNames(name);
        return parts.isEmpty() ? name : parts.get(parts.size() - 1);
    }

    /** T-SQL literal -> binding value; null when the expression is not a compile-time literal. */
    private static SqlValue literalToSqlValue(gudusoft.gsqlparser.nodes.TExpression expr) {
        if (expr == null) {
            return null;
        }
        gudusoft.gsqlparser.EExpressionType type = expr.getExpressionType();
        // Signed numerics arrive as unary +/- wrapping the constant.
        if (type == gudusoft.gsqlparser.EExpressionType.unary_plus_t
                || type == gudusoft.gsqlparser.EExpressionType.unary_minus_t) {
            SqlValue inner = literalToSqlValue(expr.getRightOperand() != null
                    ? expr.getRightOperand() : expr.getLeftOperand());
            if (inner == null || type == gudusoft.gsqlparser.EExpressionType.unary_plus_t) {
                return inner;
            }
            try {
                String innerText = inner.text() == null ? "" : inner.text();
                if (innerText.indexOf('.') >= 0) {
                    return SqlValue.of(-Double.parseDouble(innerText));
                }
                return SqlValue.of(-Long.parseLong(innerText));
            } catch (NumberFormatException nfe) {
                return null;
            }
        }
        // Bare NULL in an EXEC argument surfaces as a plain source token.
        if (type == gudusoft.gsqlparser.EExpressionType.simple_source_token_t
                && expr.toString().trim().equalsIgnoreCase("NULL")) { // non-identifier-compare: the NULL keyword literal
            return SqlValue.nullValue();
        }
        if (type != gudusoft.gsqlparser.EExpressionType.simple_constant_t
                || expr.getConstantOperand() == null) {
            return null;
        }
        String text = expr.getConstantOperand().toString().trim();
        if (text.equalsIgnoreCase("NULL")) { // non-identifier-compare: the NULL keyword literal
            return SqlValue.nullValue();
        }
        String unquoted = unquoteTsqlString(text);
        if (unquoted != null) {
            return SqlValue.of(unquoted);
        }
        try {
            if (text.indexOf('.') >= 0 || text.indexOf('e') >= 0 || text.indexOf('E') >= 0) {
                // Bind decimals only when the double round-trips to the exact source
                // text - otherwise the evaluated string could differ from the real
                // runtime value (precision loss); leave inexact values unbound.
                double parsed = Double.parseDouble(text);
                SqlValue candidate = SqlValue.of(parsed);
                if (text.equals(candidate.text())) {
                    return candidate;
                }
                return null;
            }
            return SqlValue.of(Long.parseLong(text));
        } catch (NumberFormatException nfe) {
            return null;
        }
    }

    /** 'abc''d' / N'abc' -> abc'd ; returns null when not a string literal. */
    private static String unquoteTsqlString(String text) {
        String t = text;
        if (t.length() >= 2 && (t.charAt(0) == 'N' || t.charAt(0) == 'n') && t.charAt(1) == '\'') {
            t = t.substring(1);
        }
        if (t.length() >= 2 && t.charAt(0) == '\'' && t.charAt(t.length() - 1) == '\'') {
            return t.substring(1, t.length() - 1).replace("''", "'");
        }
        return null;
    }

    /** Order/spelling-insensitive value key for binding-set dedupe (length-prefixed to defeat collisions). */
    private static String canonicalValueKey(gudusoft.gsqlparser.nodes.TExpression expr) {
        String raw = expr == null ? "" : expr.toString().trim();
        return raw.length() + ":" + raw;
    }

    /* --------------------------------------------------------- site building */

    private static DynamicSiteResult buildSite(TDynamicSqlStringEvaluator.RawSite raw, EDbVendor vendor,
            TSQLEnv sqlEnv, String currentDatabase, String defaultSchema, String sourceProc, String bindingHash,
            DynamicLineageOptions options, NodeNames nodeNames) {

        long[] pos = coordinate(raw.node);
        String dynamicSite = dynamicSiteId(sourceProc,
                raw.ordinalPath + (raw.variantPath == null ? "" : raw.variantPath));
        SqlStringValue sql = raw.sql;
        // The EXEC site is wrapped in an IF whose predicate we cannot decide from
        // the bindings (e.g. IF @Debug = 0 EXEC(@sql) with @Debug unbound).
        boolean executionGated = !raw.controlFlowCertain;
        DynamicSqlTrustMode trustMode = options.getTrustMode();
        HoleFacts holes = holeFacts(sql);

        // Honest unresolved reasons — never guess.
        // Case (a): the dynamic string itself is not usable — NULL, opaque, or
        // assigned under an undecidable branch and collapsed to UNKNOWN. No
        // usable inner-SQL candidate exists for this site.
        if (sql == null || !sql.usable()) {
            String reason = sql != null && sql.reason != null ? sql.reason
                    : executionGated ? "site " + gateNote(raw, "guarded by an undecidable conditional")
                            : "dynamic SQL did not reduce to a concrete string";
            return unresolved(raw, dynamicSite, sourceProc, bindingHash, pos, reason, trustMode, holes);
        }
        // Case (b): the EXEC site is execution-gated, but the string itself is usable
        // (CONCRETE or PARTIAL) — only the *did-it-run* fact is uncertain, so we
        // degrade-don't-fail rather than dropping the lineage. We fall through to
        // analyzeResolvedSql either way: a fully-concrete gated site emits all its
        // edges (flagged CONDITIONAL below), and a PARTIAL gated site emits exactly
        // the placeholder-free subset a non-gated PARTIAL site would, suppressing only
        // the placeholder edges. The downstream status/reason block surfaces both the
        // placeholder suppression and the execution gate. (Case (a) — an unusable
        // string, NULL/UNKNOWN — was already returned UNRESOLVED above.)
        String resolvedSql = sql.text;
        if (resolvedSql.length() > options.getMaxResolvedSqlLength()) {
            return unresolved(raw, dynamicSite, sourceProc, bindingHash, pos,
                    "resolved SQL length " + resolvedSql.length() + " exceeds maxResolvedSqlLength",
                    trustMode, holes);
        }

        String concreteHash = sha1Hex(resolvedSql);
        boolean partialPlaceholders = sql.state == SqlStringValue.State.PARTIAL;
        boolean provenanceIncomplete = !hasCompleteLiteralProvenance(sql.text, sql.fragments);

        List<DynamicLineageEdge> edges;
        boolean parseError;
        boolean partialParseError;
        boolean nestedIncomplete;
        List<String> withheldFiles = java.util.Collections.emptyList();
        try {
            Analysis a = analyzeResolvedSql(resolvedSql, vendor, sqlEnv, currentDatabase, defaultSchema,
                    sourceProc, dynamicSite, bindingHash, options, sql.fragments, nodeNames);
            edges = a.edges;
            nestedIncomplete = a.nestedIncomplete;
            withheldFiles = a.withheldFiles;
            // No lineage + recorded errors = parse failure (generateDataFlow()
            // does not throw on bad SQL). Errors WITH some lineage = a mixed batch
            // where one statement failed; keep the good edges but flag it honestly.
            // No lineage because file edges were withheld is not a parse failure.
            parseError = a.hadErrors && a.edges.isEmpty() && a.withheldFiles.isEmpty();
            partialParseError = a.hadErrors && !a.edges.isEmpty();
        } catch (RuntimeException ex) {
            edges = new ArrayList<DynamicLineageEdge>();
            parseError = true;
            partialParseError = false;
            nestedIncomplete = false;
        }

        boolean aggregateIncomplete = provenanceIncomplete || nestedIncomplete
                || (partialParseError && trustMode == DynamicSqlTrustMode.SHADOW);
        HoleFacts aggregateHoles = nestedIncomplete ? new HoleFacts(-1, false) : holes;

        DynamicSiteResult.Status status;
        if (parseError) {
            status = DynamicSiteResult.Status.PARSE_ERROR;
        } else if (executionGated) {
            // The undecidable gate dominates the status: whether the string is fully
            // concrete or PARTIAL, every emitted edge is reached only if the guarded
            // branch runs. CONDITIONAL keeps that "might not execute" caveat visible —
            // the strictly-stronger signal to preserve — and the reason below adds the
            // placeholder-suppression note when the string is also PARTIAL.
            status = DynamicSiteResult.Status.CONDITIONAL;
        } else if (partialPlaceholders || !withheldFiles.isEmpty()
                || (aggregateIncomplete && trustMode == DynamicSqlTrustMode.SHADOW)) {
            status = DynamicSiteResult.Status.PARTIAL;
        } else {
            status = DynamicSiteResult.Status.RESOLVED;
        }

        // Compose the reason from every applicable fact rather than picking one — a
        // single site can be partial-parse AND placeholder-suppressed AND gated at
        // once, and a consumer needs all three to gauge how far to trust the edges.
        List<String> reasons = new ArrayList<String>();
        if (parseError) {
            reasons.add("materialized SQL failed to parse");
        } else if (partialParseError) {
            reasons.add("some statements in the materialized SQL failed to parse; emitted edges are from the parseable statements");
        }
        if (partialPlaceholders) {
            reasons.add("materialized SQL still contains unbound placeholder(s); placeholder edges suppressed");
        }
        int unprovenRelationshipCount = 0;
        if (nestedIncomplete) {
            reasons.add("nested dynamic SQL is incomplete");
        }
        for (String withheld : withheldFiles) {
            reasons.add("no edge from " + withheld);
        }
        if (aggregateIncomplete && trustMode == DynamicSqlTrustMode.SHADOW) {
            unprovenRelationshipCount = edges.size();
            reasons.add("SHADOW retained " + unprovenRelationshipCount
                    + " historical candidate relationship(s) without a per-edge commitment proof; "
                    + holeDescription(aggregateHoles));
        }
        if (executionGated) {
            boolean anyEdges = !edges.isEmpty();
            reasons.add("site " + gateNote(raw, "reached through an undecidable conditional")
                    + (anyEdges ? " — emitted edges assume the guarded statement executed"
                            : " — no resolvable edges were produced"));
        }
        String reason = reasons.isEmpty() ? null : String.join("; ", reasons);

        return new DynamicSiteResult(raw.kind, status, resolvedSql, concreteHash, sourceProc, dynamicSite,
                bindingHash, reason, pos[0], pos[1], edges, trustMode,
                unprovenRelationshipCount, aggregateHoles.count, aggregateHoles.exact,
                raw.diagnostic);
    }

    /** A gated site in a CATCH block says so; any other keeps the historical wording it is given. */
    private static String gateNote(TDynamicSqlStringEvaluator.RawSite raw, String undecidedWording) {
        return TDynamicSqlStringEvaluator.CATCH_EXECUTION_NOTE.equals(raw.executionNote)
                ? raw.executionNote : undecidedWording;
    }

    private static DynamicSiteResult unresolved(TDynamicSqlStringEvaluator.RawSite raw, String dynamicSite,
            String sourceProc, String bindingHash, long[] pos, String reason,
            DynamicSqlTrustMode trustMode, HoleFacts holes) {
        String text = raw.sql != null && raw.sql.usable() ? raw.sql.text : null;
        return new DynamicSiteResult(raw.kind, DynamicSiteResult.Status.UNRESOLVED, text,
                text != null ? sha1Hex(text) : null, sourceProc, dynamicSite, bindingHash, reason,
                pos[0], pos[1], new ArrayList<DynamicLineageEdge>(), trustMode,
                0, holes.count, holes.exact, raw.diagnostic);
    }

    private static final class HoleFacts {
        final int count;
        final boolean exact;

        HoleFacts(int count, boolean exact) {
            this.count = count;
            this.exact = exact;
        }
    }

    private static HoleFacts holeFacts(SqlStringValue sql) {
        if (sql == null) {
            return new HoleFacts(-1, false);
        }
        int count = 0;
        for (SqlFragment fragment : sql.fragments) {
            if (!fragment.isLiteral()) {
                count++;
            }
        }
        if (sql.usable() && sql.fragments.isEmpty()) {
            return new HoleFacts(-1, false);
        }
        if (!sql.usable() && count == 0) {
            // The value did not reduce, yet its provenance shows no hole: whatever
            // stopped the fold left no fragment. Not known - never an exact zero.
            return new HoleFacts(-1, false);
        }
        return new HoleFacts(count, true);
    }

    private static String holeDescription(HoleFacts holes) {
        return holes.exact ? holes.count + " unresolved fragment(s)"
                : "unresolved fragment count unavailable from the producer";
    }

    /** Complete means usable text with non-empty, exclusively literal provenance. */
    private static boolean hasCompleteLiteralProvenance(String text, List<SqlFragment> fragments) {
        if (text == null || fragments == null || fragments.isEmpty()) {
            return false;
        }
        StringBuilder rendered = new StringBuilder();
        for (SqlFragment fragment : fragments) {
            if (fragment == null || !fragment.isLiteral()) {
                return false;
            }
            rendered.append(fragment.text);
        }
        return rendered.toString().equals(text);
    }

    /**
     * Shared "analyze a materialized dynamic-SQL string" routine: run ordinary
     * dlineage with the proc's database/schema context and lift each column edge
     * into a provenance-tagged {@link DynamicLineageEdge}.
     */
    /** Edges from analyzing one materialized string, plus whether dlineage recorded parse/analysis errors. */
    private static final class Analysis {
        final List<DynamicLineageEdge> edges;
        final boolean hadErrors;
        final boolean nestedIncomplete;
        /** Files whose edges are withheld, each with why (a location relative to an unknown data source). */
        final List<String> withheldFiles;

        Analysis(List<DynamicLineageEdge> edges, boolean hadErrors, boolean nestedIncomplete) {
            this(edges, hadErrors, nestedIncomplete, java.util.Collections.<String>emptyList());
        }

        Analysis(List<DynamicLineageEdge> edges, boolean hadErrors, boolean nestedIncomplete,
                List<String> withheldFiles) {
            this.edges = edges;
            this.hadErrors = hadErrors;
            this.nestedIncomplete = nestedIncomplete;
            this.withheldFiles = withheldFiles;
        }
    }

    private static Analysis analyzeResolvedSql(String resolvedSql, EDbVendor vendor,
            TSQLEnv sqlEnv, String currentDatabase, String defaultSchema, String sourceProc, String dynamicSite,
            String bindingHash, DynamicLineageOptions options,
            List<SqlFragment> valueProvenance, NodeNames nodeNames) {

        Option opt = new Option();
        opt.setVendor(vendor);
        opt.setSimpleOutput(false);
        opt.setOutput(false);
        opt.setShowImplicitSchema(options.isShowImplicitSchema());
        opt.setDynamicSqlTrustMode(options.getTrustMode());
        if (currentDatabase != null && !currentDatabase.isEmpty()) {
            opt.setDefaultDatabase(currentDatabase);
        }
        if (defaultSchema != null && !defaultSchema.isEmpty()) {
            opt.setDefaultSchema(defaultSchema);
        }

        DataFlowAnalyzer nested = new DataFlowAnalyzer(resolvedSql, opt);
        if (sqlEnv != null) {
            nested.setSqlEnv(sqlEnv);
        }
        nested.generateDataFlow();
        dataflow df = nested.getDataFlow();
        boolean nestedIncomplete = hasIncompleteNestedDynamicSql(nested, options.getTrustMode());

        List<DynamicLineageEdge> edges = new ArrayList<DynamicLineageEdge>();
        if (df == null) {
            return new Analysis(edges, true, nestedIncomplete);
        }
        boolean hadErrors = df.getErrors() != null && !df.getErrors().isEmpty();
        if (df.getRelationships() == null) {
            return new Analysis(edges, hadErrors, nestedIncomplete);
        }

        // Index the real tables/views by id so we can rebuild fully-qualified
        // names from the structured model and fill in the proc's database/schema
        // for names the dynamic SQL left unqualified.
        Map<String, table> realTables = new HashMap<String, table>();
        indexTables(realTables, df.getTables());
        indexTables(realTables, df.getViews());

        boolean showImplicit = options.isShowImplicitSchema();
        Map<String, String> intermediateNames = nodeNames.assign(df.getRelationships(), realTables, currentDatabase,
                defaultSchema, showImplicit);
        // files (a BULK INSERT's path, Mantis 4962): named by their URI, never qualified with the proc's database
        Map<String, table> files = new HashMap<String, table>();
        indexTables(files, df.getPaths());
        boolean holes = hasValueUnknownHole(valueProvenance);
        List<String> withheldFiles = new ArrayList<String>();
        for (relationship rel : df.getRelationships()) {
            if (rel == null || rel.getTarget() == null || rel.getSources() == null) {
                continue;
            }
            // a file feeds a table through the table's load column, a system column like RelationRows; its edge is
            // lineage all the same
            boolean fromFiles = !rel.getSources().isEmpty();
            for (sourceColumn src : rel.getSources()) {
                fromFiles &= src != null && files.containsKey(src.getParent_id());
            }
            String target = fromFiles
                    ? joinName(rel.getTarget().getParent_id(), rel.getTarget().getParent_name(),
                            rel.getTarget().getColumn(), realTables, intermediateNames, currentDatabase, defaultSchema,
                            showImplicit)
                    : fullName(rel.getTarget(), realTables, intermediateNames, currentDatabase, defaultSchema,
                            showImplicit);
            // An edge touching an unresolved placeholder (a name still carrying a
            // @variable from an unbound binding) must NOT be emitted as resolved
            // lineage — it would be a guess. The site stays PARTIAL and its
            // resolvedSql still shows the placeholder; only the fully-resolved
            // edges flow out.
            if (target == null || referencesPlaceholder(target)) {
                continue;
            }
            for (sourceColumn src : rel.getSources()) {
                table file = src == null ? null : files.get(src.getParent_id());
                if (file != null) {
                    // a data source whose LOCATION is not known leaves the file's URI its bare name
                    if (file.getDataSourceName() != null
                            && (file.getUri() == null || file.getUri().equals(file.getName()))) {
                        // relative to a data source whose location is not known: its name alone would make it the
                        // same file as one of that name under another data source (Mantis 4962)
                        String why = "file " + file.getName() + " under data source " + file.getDataSourceName()
                                + ", whose location is not known";
                        if (!withheldFiles.contains(why)) {
                            withheldFiles.add(why);
                        }
                        continue;
                    }
                    String uri = file.getUri() != null ? file.getUri() : file.getName();
                    // a file name may hold an '@' of its own; it is a placeholder only when a hole is left
                    if (uri == null || "DYNAMIC_TEMPLATE".equals(file.getEndpointKind())
                            || (holes && referencesPlaceholder(uri))) {
                        continue;
                    }
                    edges.add(new DynamicLineageEdge(uri, target, rel.getEffectType(), rel.getType(),
                            sourceProc, dynamicSite, bindingHash, valueProvenance));
                    continue;
                }
                if (isSystem(src)) {
                    continue;
                }
                String source = fullName(src, realTables, intermediateNames, currentDatabase, defaultSchema,
                        showImplicit);
                if (source == null || referencesPlaceholder(source)) {
                    continue;
                }
                edges.add(new DynamicLineageEdge(source, target, rel.getEffectType(), rel.getType(),
                        sourceProc, dynamicSite, bindingHash, valueProvenance));
            }
        }
        return new Analysis(edges, hadErrors, nestedIncomplete, withheldFiles);
    }

    private static boolean hasIncompleteNestedDynamicSql(DataFlowAnalyzer analyzer,
            DynamicSqlTrustMode trustMode) {
        if (trustMode == DynamicSqlTrustMode.LEGACY) {
            return false;
        }
        for (DynamicSqlSite site : analyzer.getDynamicSqlSites()) {
            // A nested execution is part of the outer program. Surface its
            // incompleteness in SHADOW without changing the published model.
            if (site.getStatus() != DynamicSqlSite.Status.RESOLVED) {
                return true;
            }
        }
        return false;
    }

    /** Whether {@code fragments} leave a part of the string whose value is not known. */
    private static boolean hasValueUnknownHole(List<SqlFragment> fragments) {
        for (int i = 0; fragments != null && i < fragments.size(); i++) {
            if (!fragments.get(i).isLiteral() && fragments.get(i).valueUnknown) {
                return true;
            }
        }
        return false;
    }

    /** A resolved object name never legitimately contains '@'; if it does, it still holds an unbound placeholder. */
    private static boolean referencesPlaceholder(String name) {
        return name != null && name.indexOf('@') >= 0;
    }

    /* ------------------------------------------------------------- helpers */

    /** The non-null notes, joined with "; "; null when there are none. */
    public static String joinNotes(String first, String second) {
        if (first == null || first.isEmpty()) {
            return second == null || second.isEmpty() ? null : second;
        }
        if (second == null || second.isEmpty() || first.contains(second)) {
            return first;
        }
        return first + "; " + second;
    }

    private static void indexTables(Map<String, table> index, List<table> tables) {
        if (tables == null) {
            return;
        }
        for (table t : tables) {
            if (t != null && t.getId() != null) {
                index.put(t.getId(), t);
            }
        }
    }

    private static String fullName(targetColumn c, Map<String, table> realTables, Map<String, String> nodeNames,
            String currentDatabase, String defaultSchema, boolean showImplicit) {
        if (c == null || "system".equals(c.getSource())) {
            return null;
        }
        return joinName(c.getParent_id(), c.getParent_name(), c.getColumn(), realTables, nodeNames, currentDatabase,
                defaultSchema, showImplicit);
    }

    private static String fullName(sourceColumn c, Map<String, table> realTables, Map<String, String> nodeNames,
            String currentDatabase, String defaultSchema, boolean showImplicit) {
        return joinName(c.getParent_id(), c.getParent_name(), c.getColumn(), realTables, nodeNames, currentDatabase,
                defaultSchema, showImplicit);
    }

    /**
     * The names the intermediate nodes (result sets, functions and other nodes that are no table of the model) of
     * one {@link #resolve} call get, whose projected edges are one list across its dynamic sites and value variants:
     * a display name keeps its spelling for the first node that has it alone, and is numbered, {@code COALESCE#1},
     * {@code COALESCE#2}, for every node of the same or a later analysis that shares it, as every call of a function
     * shares its name, so that following the edges by name never joins two nodes (Mantis 4848). A number that the
     * name of a table of the analysis already has is skipped.
     */
    private static final class NodeNames {
        /** How many nodes each display name has been given to. */
        private final Map<String, Integer> given = new HashMap<String, Integer>();
        /** Every parent name the edges use: given names and the names of tables. */
        private final Set<String> taken = new java.util.HashSet<String>();

        Map<String, String> assign(List<relationship> relationships, Map<String, table> realTables,
                String currentDatabase, String defaultSchema, boolean showImplicit) {
            Map<String, Set<String>> idsByName = new LinkedHashMap<String, Set<String>>();
            for (relationship rel : relationships) {
                if (rel == null) {
                    continue;
                }
                if (rel.getTarget() != null) {
                    note(idsByName, rel.getTarget().getParent_id(), rel.getTarget().getParent_name(), realTables,
                            currentDatabase, defaultSchema, showImplicit);
                }
                if (rel.getSources() != null) {
                    for (sourceColumn src : rel.getSources()) {
                        if (src != null) {
                            note(idsByName, src.getParent_id(), src.getParent_name(), realTables, currentDatabase,
                                    defaultSchema, showImplicit);
                        }
                    }
                }
            }
            Map<String, String> names = new HashMap<String, String>();
            for (Map.Entry<String, Set<String>> group : idsByName.entrySet()) {
                String name = group.getKey();
                List<String> ids = new ArrayList<String>(group.getValue());
                if (ids.size() == 1 && !given.containsKey(name) && !taken.contains(name)) {
                    given.put(name, 1);
                    taken.add(name);
                    names.put(ids.get(0), name);
                    continue;
                }
                if (allNumeric(ids)) {
                    // ids are made in the order the analysis meets the nodes; otherwise the order they appear in
                    java.util.Collections.sort(ids, new java.util.Comparator<String>() {
                        @Override
                        public int compare(String a, String b) {
                            return Long.compare(Long.parseLong(a), Long.parseLong(b));
                        }
                    });
                }
                for (String id : ids) {
                    Integer count = given.get(name);
                    int k = count == null ? 0 : count;
                    String numbered;
                    do {
                        k++;
                        numbered = name + "#" + k;
                    } while (taken.contains(numbered));
                    given.put(name, k);
                    taken.add(numbered);
                    names.put(id, numbered);
                }
            }
            return names;
        }

        /** Notes a parent of an edge: a table's name is taken, a node's id is grouped under its display name. */
        private void note(Map<String, Set<String>> idsByName, String parentId, String parentName,
                Map<String, table> realTables, String currentDatabase, String defaultSchema, boolean showImplicit) {
            if (parentId == null || parentName == null) {
                return;
            }
            if (realTables.containsKey(parentId)) {
                taken.add(qualifiedParent(parentId, parentName, realTables, currentDatabase, defaultSchema,
                        showImplicit));
                return;
            }
            String name = stripBrackets(parentName);
            Set<String> ids = idsByName.get(name);
            if (ids == null) {
                ids = new LinkedHashSet<String>();
                idsByName.put(name, ids);
            }
            ids.add(parentId);
        }
    }

    private static boolean allNumeric(List<String> ids) {
        for (String id : ids) {
            if (id.isEmpty() || id.length() > 18) {
                return false;
            }
            for (int i = 0; i < id.length(); i++) {
                if (!Character.isDigit(id.charAt(i))) {
                    return false;
                }
            }
        }
        return true;
    }

    private static boolean isSystem(sourceColumn c) {
        return c == null || "system".equals(c.getSource()) || "RelationRows".equals(c.getColumn());
    }

    private static String joinName(String parentId, String parentName, String column,
            Map<String, table> realTables, Map<String, String> nodeNames, String currentDatabase,
            String defaultSchema, boolean showImplicit) {
        if (column == null) {
            return null;
        }
        String node = parentId == null ? null : nodeNames.get(parentId);
        if (node != null) {
            return node + "." + stripBrackets(column);
        }
        return qualifiedParent(parentId, parentName, realTables, currentDatabase, defaultSchema, showImplicit)
                + "." + stripBrackets(column);
    }

    /**
     * Build the qualified parent name from the real-table model. dlineage may
     * return the name already qualified (db.schema.table), partly qualified
     * (schema.table), bare (table), or with an empty schema slot (db..table). We
     * normalize per-segment brackets positionally — last = table, then schema,
     * then database — and, only when {@code showImplicit} is on, fill a missing
     * schema/database from the proc's {@code defaultSchema}/{@code currentDatabase}
     * so an unqualified {@code RECON_JE_02_QSP_…} binds to
     * {@code JOURNALENGINE.dbo.RECON_JE_02_QSP_…}. Intermediate result sets
     * (no model table) keep their display name unchanged.
     */
    private static String qualifiedParent(String parentId, String parentName, Map<String, table> realTables,
            String currentDatabase, String defaultSchema, boolean showImplicit) {
        table t = parentId == null ? null : realTables.get(parentId);
        if (t == null) {
            return stripBrackets(parentName); // result set / function / intermediate node
        }
        String full = t.getFullName() != null ? t.getFullName() : t.getName();
        if (full == null || full.isEmpty()) {
            full = parentName;
        }
        if (full == null) {
            return stripBrackets(parentName);
        }

        // Keep empty segments so positions are preserved (e.g. db..table).
        String[] raw = full.split("\\.", -1);
        for (int i = 0; i < raw.length; i++) {
            raw[i] = stripBrackets(raw[i].trim());
        }
        int n = raw.length;
        String table = n >= 1 ? raw[n - 1] : stripBrackets(parentName);
        String schema = n >= 2 ? raw[n - 2] : "";
        String db = n >= 3 ? raw[n - 3] : "";
        // Anything left of the database segment (e.g. linked-server) is kept as a prefix.
        StringBuilder prefix = new StringBuilder();
        for (int i = 0; i < n - 3; i++) {
            if (!raw[i].isEmpty()) {
                prefix.append(raw[i]).append('.');
            }
        }
        if (showImplicit) {
            if (schema.isEmpty()) {
                schema = stripBrackets(defaultSchema);
            }
            if (db.isEmpty()) {
                db = stripBrackets(currentDatabase);
            }
        }
        StringBuilder sb = new StringBuilder(prefix.toString());
        if (db != null && !db.isEmpty()) {
            sb.append(db).append('.');
        }
        if (schema != null && !schema.isEmpty()) {
            sb.append(schema).append('.');
        }
        sb.append(table == null ? "" : table);
        return sb.length() == 0 ? stripBrackets(parentName) : sb.toString();
    }

    private static TStatementList extractBody(TCustomSqlStatement procAst) {
        if (procAst instanceof TMssqlCreateProcedure) {
            return ((TMssqlCreateProcedure) procAst).getBodyStatements();
        }
        return null;
    }

    private static List<TParameterDeclaration> extractParams(TCustomSqlStatement procAst) {
        List<TParameterDeclaration> out = new ArrayList<TParameterDeclaration>();
        if (procAst instanceof TMssqlCreateProcedure) {
            TParameterDeclarationList list = ((TMssqlCreateProcedure) procAst).getParameterDeclarations();
            if (list != null) {
                for (int i = 0; i < list.size(); i++) {
                    out.add(list.getParameterDeclarationItem(i));
                }
            }
        }
        return out;
    }

    private static String extractProcName(TCustomSqlStatement procAst) {
        if (procAst instanceof TMssqlCreateProcedure) {
            TMssqlCreateProcedure cp = (TMssqlCreateProcedure) procAst;
            if (cp.getProcedureName() != null) {
                return cp.getProcedureName().toString();
            }
        }
        return procAst == null ? "" : procAst.getClass().getSimpleName();
    }

    private static long[] coordinate(TCustomSqlStatement node) {
        try {
            TSourceToken t = node.getStartToken();
            if (t != null) {
                return new long[] { t.lineNo, t.columnNo };
            }
        } catch (Throwable ignore) {
            // fall through
        }
        return new long[] { 0L, 0L };
    }

    /** Stable id robust to reformatting: proc identity + structural ordinal path, hashed. */
    private static String dynamicSiteId(String sourceProc, String ordinalPath) {
        return "dyn:" + sha1Hex(stripBrackets(sourceProc) + "#" + ordinalPath).substring(0, 12);
    }

    private static String hashBindings(Map<String, SqlValue> bindings) {
        if (bindings == null || bindings.isEmpty()) {
            return sha1Hex("");
        }
        TreeMap<String, String> sorted = new TreeMap<String, String>();
        for (Map.Entry<String, SqlValue> e : bindings.entrySet()) {
            if (e.getKey() == null) {
                continue;
            }
            sorted.put(stripBrackets(e.getKey().trim()).toLowerCase(java.util.Locale.ROOT),
                    e.getValue() == null ? "NULL" : e.getValue().toString());
        }
        StringBuilder sb = new StringBuilder();
        for (Map.Entry<String, String> e : sorted.entrySet()) {
            sb.append(e.getKey()).append('=').append(e.getValue()).append(';');
        }
        return sha1Hex(sb.toString());
    }

    private static String stripBrackets(String s) {
        if (s == null) {
            return "";
        }
        s = s.trim();
        if (s.length() >= 2) {
            char a = s.charAt(0);
            char z = s.charAt(s.length() - 1);
            if ((a == '[' && z == ']') || (a == '"' && z == '"') || (a == '`' && z == '`')) {
                return s.substring(1, s.length() - 1);
            }
        }
        return s;
    }

    private static String sha1Hex(String input) {
        try {
            MessageDigest md = MessageDigest.getInstance("SHA-1");
            byte[] digest = md.digest(input.getBytes("UTF-8"));
            StringBuilder sb = new StringBuilder(digest.length * 2);
            for (byte b : digest) {
                sb.append(Character.forDigit((b >> 4) & 0xF, 16));
                sb.append(Character.forDigit(b & 0xF, 16));
            }
            return sb.toString();
        } catch (NoSuchAlgorithmException | UnsupportedEncodingException e) {
            return Integer.toHexString(input.hashCode());
        }
    }
}