@quereus/quereus 4.16.0 → 4.17.0

package/dist/src/core/database-auto-analyze.js

@@ -0,0 +1,616 @@
+/**
+ * Auto-analyze staleness bookkeeping and background statistics refresh.
+ *
+ * Tracks, per base table, how many distinct rows committed transactions have
+ * changed since statistics were last collected for that table, decides when that
+ * drift is large enough to call the table's statistics stale, and — off the write
+ * path, from a debounced timer — refreshes them by running the ordinary `ANALYZE`
+ * statement for that one table.
+ *
+ * The counts come from the transaction change log (`TransactionManager`), read
+ * post-commit while the log is still alive. That log is maintained
+ * unconditionally on every write path already, so counting costs one `Map.size`
+ * read per table per savepoint layer and nothing on the write path itself.
+ *
+ * The refresh goes through `db.exec('analyze …')` rather than reaching into the
+ * collection internals. Two things fall out of that:
+ *
+ * - `db.exec` acquires the database's execution mutex, which is what serializes
+ *   all statement execution. A refresh driven from a timer therefore queues
+ *   behind whatever is running instead of racing it. It cannot deadlock, because
+ *   it is never started from inside a statement.
+ * - There is exactly one implementation of "collect and record statistics for a
+ *   table" (`runtime/emit/analyze.ts`), including its per-table `try` that logs
+ *   and continues.
+ *
+ * A refresh cannot trigger itself: `ANALYZE` performs no DML, and it publishes
+ * its result by swapping the `TableSchema` and firing the internal catalog
+ * notifier rather than the data-change channel. Its implicit transaction commits
+ * with an empty change log, so no counter advances.
+ */
+import { createLogger } from '../common/logger.js';
+import { quoteIdentifier } from '../emit/ast-stringify.js';
+import { catalogRowCount } from '../planner/stats/table-cardinality.js';
+import { splitBaseKey } from '../util/qualified-name.js';
+const log = createLogger('core:auto-analyze');
+const debugLog = log.extend('debug');
+const warnLog = log.extend('warn');
+/**
+ * How long a crossing waits before its refresh starts. Long enough that a burst
+ * of small commits collapses into one refresh, short enough that a test or an
+ * interactive session does not notice it.
+ */
+const AUTO_ANALYZE_DEBOUNCE_MS = 50;
+/**
+ * A table may spend at most `1 / AUTO_ANALYZE_DUTY_CYCLE` of wall-clock time in
+ * automatic `ANALYZE`: after a refresh that took `t` ms, the next one for that
+ * table may not start for `t × AUTO_ANALYZE_DUTY_CYCLE` ms.
+ *
+ * NOTE: this cooldown is load-bearing, not decoration. Without it a bulk load
+ * re-analyzes on a geometric ladder — a refresh at 50k rows records
+ * `analyzedRowCount = 50k`, so the next threshold is `ratio × 50k = 10k` further
+ * rows, and the scan that follows visits 60k, then 72k, then 86k… Each scan is
+ * O(rows) and they compound. Capping the duty cycle bounds the background cost to
+ * a fixed fraction of one core regardless of write rate, without having to model
+ * the workload. Do not remove it as "an unnecessary timer".
+ */
+const AUTO_ANALYZE_DUTY_CYCLE = 10;
+/** Floor on the cooldown after a *failed* refresh, so a permanently unreadable
+ *  table cannot spin (a fast failure has a near-zero duty-cycle cooldown). */
+const AUTO_ANALYZE_FAILURE_BACKOFF_MS = 5000;
+/**
+ * First delay before retrying a refresh that was deferred because a transaction
+ * was open, doubling on each further retry (250, 500, 1000, 2000 ms).
+ *
+ * NOT the debounce: the debounce exists to let a burst of commits collapse, and
+ * 50 ms is far too soon to expect a statement that was in flight a moment ago to
+ * have finished. Starting an order of magnitude higher means the common case — a
+ * timer landing inside one ordinary `UPDATE` — is served by the first retry
+ * instead of burning the whole budget on wakeups that all land inside the same
+ * statement.
+ *
+ * NOTE: 250 ms is reasoning, not measurement — nothing has measured how long a
+ * statement actually holds its implicit transaction, and a memory-backed one
+ * frequently never yields to the timer queue at all (a 400-row `insert … values`
+ * ran to completion without a single `setTimeout(0)` firing), so this mostly
+ * governs store-backed workloads and explicit `BEGIN`s. If the debug log shows
+ * crossings routinely spending the whole budget, measure a real workload before
+ * raising the retry count — a longer first delay is likelier to be the fix.
+ */
+export const AUTO_ANALYZE_DEFER_RETRY_MS = 250;
+/**
+ * How many times one crossing may reschedule itself after being deferred. The
+ * geometric backoff above makes that about 3.75 s of total patience.
+ *
+ * Bounded on purpose: a user may park an explicit transaction open indefinitely,
+ * and an unbounded retry would then cost a wakeup per stale table forever. Once
+ * the budget is spent the crossing is dropped exactly as it was before retries
+ * existed — the counter stays over threshold and the next commit that touches the
+ * table re-arms.
+ *
+ * Must stay at or below `AUTO_ANALYZE_IDLE_MAX_PASSES - 2`: {@link
+ * AutoAnalyzeManager.whenIdle} spends one settle pass per retry plus one for the
+ * initial attempt and one to observe that nothing is left armed.
+ */
+export const AUTO_ANALYZE_MAX_DEFER_RETRIES = 4;
+/**
+ * Safety bound on {@link AutoAnalyzeManager.whenIdle}'s settle loop. Exported so the
+ * inequality against {@link AUTO_ANALYZE_MAX_DEFER_RETRIES} is checked by a test
+ * rather than only implied by one failing if it were ever violated.
+ */
+export const AUTO_ANALYZE_IDLE_MAX_PASSES = 10;
+/**
+ * Delay for a debounce timer armed at `now` for a table not eligible until
+ * `nextEligibleAt`: the debounce, or the remaining duty-cycle cooldown when that
+ * is longer. Exported for the same reason {@link isStaleCount} is — the cooldown
+ * arithmetic is otherwise only observable through timing.
+ */
+export function armDelayMs(nextEligibleAt, now) {
+    return Math.max(AUTO_ANALYZE_DEBOUNCE_MS, nextEligibleAt - now);
+}
+/**
+ * The staleness threshold in changed rows:
+ *
+ * ```
+ * stale  ⟺  changedSinceAnalyze >= max(minMutations, ratio × knownRowCount)
+ * ```
+ *
+ * `knownRowCount` is 0 for a never-analyzed table (`SchemaManager` hardcodes
+ * `estimatedRows` to 0 at create), so the absolute floor governs exactly the
+ * case that matters most: bulk-loading rows into a fresh table trips
+ * `minMutations` long before any percentage of zero could.
+ *
+ * Precedent for the defaults: SQL Server's auto-update-stats uses 500 + 20% of
+ * rows; PostgreSQL's autoanalyze uses 50 + 10%.
+ */
+export function stalenessThreshold(minMutations, ratio, knownRowCount) {
+    return Math.max(minMutations, ratio * knownRowCount);
+}
+/** Pure form of the staleness predicate — see {@link stalenessThreshold}. */
+export function isStaleCount(changedSinceAnalyze, minMutations, ratio, knownRowCount) {
+    return changedSinceAnalyze >= stalenessThreshold(minMutations, ratio, knownRowCount);
+}
+/**
+ * Tracks committed-mutation drift per base table for a single `Database`, and
+ * schedules the background refresh that clears it.
+ */
+export class AutoAnalyzeManager {
+    ctx;
+    /**
+     * Lowercased `schema.table` → staleness bookkeeping. Same key convention the
+     * change log uses, so no re-derivation and no second key convention.
+     *
+     * NOTE: nothing here is persisted. After a restart the store backend's saved
+     * statistics still exist, but staleness accumulation restarts from zero — a
+     * table that drifted while the process was down looks fresh until it drifts
+     * again. Accepted for v1 (a restart is rare relative to the mutation
+     * threshold). If it ever matters, persist `changedSinceAnalyze` beside the
+     * table's statistics entry and reload it when the catalog loads.
+     */
+    entries = new Map();
+    unsubscribeSchemaChanges = null;
+    /** Set by {@link dispose}; every scheduled path checks it before doing work. */
+    disposed = false;
+    /** Refreshes that actually reached the `ANALYZE` statement. Test instrumentation. */
+    refreshes = 0;
+    constructor(ctx) {
+        this.ctx = ctx;
+        this.subscribeToSchemaChanges();
+    }
+    subscribeToSchemaChanges() {
+        const notifier = this.ctx.schemaManager.getChangeNotifier();
+        this.unsubscribeSchemaChanges = notifier.addListener((event) => {
+            // Only `table_removed`, so a table re-created under a dropped name starts
+            // clean. Deliberately NOT `table_modified`: a statistics refresh fires that
+            // event itself (runtime/emit/analyze.ts), so reacting to it would couple this
+            // manager to its own output.
+            //
+            // That decoupling has a cost, taken knowingly: a hand-typed `analyze t` also
+            // arrives only as `table_modified`, so it does NOT reset `changedSinceAnalyze`.
+            // A user who analyzes an already-over-threshold table by hand leaves the
+            // counter where it was, and this manager then re-scans a table whose
+            // statistics are seconds old — one wasted O(rows) scan, after which the reset
+            // in `refresh` makes it self-correcting. The reset path keys off THIS
+            // MANAGER'S OWN refresh only. Distinguishing "a successful ANALYZE happened"
+            // from any other schema edit would need a signal the notifier does not carry;
+            // adding one to save a single redundant scan is not worth re-coupling to the
+            // channel the refresh itself fires.
+            //
+            // NOTE: `DETACH` removes a whole schema WITHOUT firing per-table events
+            // (`SchemaManager.removeSchema`), so entries for a detached schema's tables
+            // outlive it. Harmless today — each is a handful of numbers, and
+            // `knownRowCountOrDrop` evicts one the next time it is consulted — but if a
+            // host ever attaches and detaches schemas in a loop, drop entries whose
+            // schema segment matches the detached name.
+            if (event.type === 'table_removed') {
+                const key = `${event.schemaName}.${event.objectName}`.toLowerCase();
+                this.dropEntry(key);
+            }
+        });
+    }
+    /**
+     * Fold one committed transaction's per-table changed-row counts into the
+     * staleness map and re-evaluate the threshold for every table it touched.
+     * Entries are created lazily on first touch.
+     */
+    recordCommit(counts) {
+        for (const [key, count] of counts) {
+            if (count <= 0)
+                continue;
+            let entry = this.entries.get(key);
+            if (!entry) {
+                entry = {
+                    changedSinceAnalyze: 0,
+                    analyzedRowCount: undefined,
+                    staleLogged: false,
+                    timer: undefined,
+                    running: undefined,
+                    nextEligibleAt: 0,
+                    oversizeLogged: false,
+                    deferRetries: 0,
+                };
+                this.entries.set(key, entry);
+            }
+            entry.changedSinceAnalyze += count;
+            // A commit is proof the transaction that kept deferring this table's refresh
+            // has ended, so whatever retry budget it burned is refunded. Zeroed BEFORE
+            // `evaluate`, so the crossing this commit may arm starts with a full budget.
+            entry.deferRetries = 0;
+            this.evaluate(key, entry);
+        }
+    }
+    /**
+     * Whether the named table (lowercased `schema.table`) has drifted past the
+     * threshold. Not a pure predicate: a table that has since disappeared answers
+     * `false` and has its entry dropped — see {@link knownRowCountOrDrop}.
+     */
+    isStale(key) {
+        const entry = this.entries.get(key);
+        if (!entry)
+            return false;
+        const known = this.knownRowCountOrDrop(key, entry);
+        if (known === undefined)
+            return false;
+        return isStaleCount(entry.changedSinceAnalyze, this.minMutations(), this.ratio(), known);
+    }
+    /** @internal Current bookkeeping for a table; `undefined` when untracked. */
+    getEntry(key) {
+        return this.entries.get(key);
+    }
+    /** @internal Every table currently tracked (lowercased `schema.table`). */
+    trackedTables() {
+        return [...this.entries.keys()];
+    }
+    /**
+     * @internal How many refreshes have reached the `ANALYZE` statement since this
+     * manager was created. Lets a test assert coalescing by counting work rather than
+     * by timing it.
+     */
+    refreshCount() {
+        return this.refreshes;
+    }
+    /**
+     * @internal Resolve once no table has an armed timer or an in-flight refresh.
+     *
+     * Any armed timer is fired IMMEDIATELY — the debounce, the duty-cycle cooldown and
+     * the deferral backoff are all bypassed — rather than waited out, so tests never
+     * sleep.
+     *
+     * It deliberately does NOT bypass the open-transaction deferral: a test that wants
+     * a refresh to happen must be in autocommit, which is what real callers face.
+     *
+     * A retry timer is an armed timer like any other, so driving this while a
+     * transaction is open SPENDS the whole deferral budget in one call — fire, defer,
+     * re-arm, fire… until `AUTO_ANALYZE_MAX_DEFER_RETRIES` is reached, then settle.
+     * That is the intended behaviour, and it is what makes the budget observable
+     * without sleeping. It costs one settle pass per retry, which is why the budget
+     * must stay at or below `AUTO_ANALYZE_IDLE_MAX_PASSES - 2`.
+     */
+    async whenIdle() {
+        for (let pass = 0; pass < AUTO_ANALYZE_IDLE_MAX_PASSES; pass++) {
+            const pending = [];
+            for (const [key, entry] of [...this.entries]) {
+                if (entry.timer !== undefined) {
+                    clearTimeout(entry.timer);
+                    entry.timer = undefined;
+                    entry.nextEligibleAt = 0;
+                    this.start(key, entry);
+                }
+                if (entry.running !== undefined)
+                    pending.push(entry.running);
+            }
+            if (pending.length === 0)
+                return;
+            await Promise.all(pending);
+        }
+        // Loud rather than hanging: a bounded self-re-arm (the deferral retry) is expected
+        // and fits inside the pass budget, so reaching here means an UNBOUNDED one.
+        warnLog('Auto-analyze did not settle after %d passes; still tracking: %s', AUTO_ANALYZE_IDLE_MAX_PASSES, [...this.entries.keys()].join(', '));
+    }
+    /**
+     * @internal Fire one table's armed timer NOW, bypassing its delay, and resolve once
+     * that SINGLE attempt has settled and its outcome has been applied. No-op when
+     * nothing is armed for `key`.
+     *
+     * {@link whenIdle} cannot stand in for this: it loops until nothing is armed, so
+     * driven while a transaction is open it spends the entire deferral budget in one
+     * call. A test that wants to watch one deferral reschedule itself needs one attempt.
+     */
+    async fireArmedRefresh(key) {
+        const entry = this.entries.get(key);
+        if (!entry || entry.timer === undefined)
+            return;
+        this.clearTimer(entry);
+        entry.nextEligibleAt = 0;
+        this.start(key, entry);
+        await entry.running;
+    }
+    dispose() {
+        this.disposed = true;
+        if (this.unsubscribeSchemaChanges) {
+            this.unsubscribeSchemaChanges();
+            this.unsubscribeSchemaChanges = null;
+        }
+        // Armed timers must not outlive the database — both to avoid holding a Node
+        // process open and to avoid a refresh firing against a closed database. An
+        // already-running refresh is left alone: `db.exec` throws once the database is
+        // closed, and the failure path logs and continues rather than rejecting.
+        for (const entry of this.entries.values()) {
+            this.clearTimer(entry);
+        }
+        this.entries.clear();
+    }
+    /** Cancel any armed timer for `entry`. Safe to call when none is armed. */
+    clearTimer(entry) {
+        if (entry.timer === undefined)
+            return;
+        clearTimeout(entry.timer);
+        entry.timer = undefined;
+    }
+    /** Forget a table, cancelling any refresh armed for it. */
+    dropEntry(key) {
+        const entry = this.entries.get(key);
+        if (!entry)
+            return;
+        this.clearTimer(entry);
+        this.entries.delete(key);
+    }
+    /**
+     * Row count the ratio arm of the threshold applies to: what the last refresh
+     * this process observed reported, else whatever the catalog knows.
+     *
+     * Named for its side effect: a table that is gone (dropped between the commit
+     * and this lookup, or carried in from a detached schema) answers `undefined`
+     * AND has its entry evicted here, so every consumer of a row count doubles as
+     * the eviction path for stale keys. That is why {@link isStale} mutates.
+     */
+    knownRowCountOrDrop(key, entry) {
+        if (entry.analyzedRowCount !== undefined)
+            return entry.analyzedRowCount;
+        const table = this.findTable(key);
+        if (!table) {
+            this.dropEntry(key);
+            return undefined;
+        }
+        return catalogRowCount(table) ?? 0;
+    }
+    findTable(key) {
+        const [schemaName, tableName] = splitBaseKey(key);
+        return this.ctx._findTable(tableName, schemaName);
+    }
+    /**
+     * Re-evaluate the threshold for one table after its counter moved: log the first
+     * crossing (a busy table must not flood the log) and arm a refresh.
+     */
+    evaluate(key, entry) {
+        // Absorbed: a pending refresh already covers whatever this commit added. The
+        // counter keeps climbing, and the NEXT commit after the refresh settles is what
+        // re-arms — nothing re-evaluates on the refresh's own completion. That is what
+        // makes N commits past the threshold cost O(1) refreshes rather than O(N), and
+        // it is checked first so the common busy-table case does no catalog lookup at
+        // all. Its cost: a burst that stops immediately after a refresh leaves a
+        // still-over-threshold counter with nothing scheduled until the next write.
+        if (entry.timer !== undefined || entry.running !== undefined)
+            return;
+        const known = this.knownRowCountOrDrop(key, entry);
+        if (known === undefined)
+            return;
+        const threshold = stalenessThreshold(this.minMutations(), this.ratio(), known);
+        if (entry.changedSinceAnalyze < threshold)
+            return;
+        if (!entry.staleLogged) {
+            entry.staleLogged = true;
+            debugLog('Statistics for %s are stale: %d rows changed since last analyze (threshold %d over %d known rows)', key, entry.changedSinceAnalyze, threshold, known);
+        }
+        this.arm(key, entry);
+    }
+    /** Schedule the debounced refresh for a table that has just crossed the threshold. */
+    arm(key, entry) {
+        if (this.disposed)
+            return;
+        if (entry.timer !== undefined || entry.running !== undefined)
+            return;
+        // A plain view stores no rows and `ANALYZE` rejects it by name, so never arm one.
+        // (A materialized view is a real backing table and is refreshed like any other.)
+        const table = this.findTable(key);
+        if (!table) {
+            this.dropEntry(key);
+            return;
+        }
+        if (table.isView)
+            return;
+        const delay = armDelayMs(entry.nextEligibleAt, Date.now());
+        const timer = setTimeout(() => {
+            entry.timer = undefined;
+            this.start(key, entry);
+        }, delay);
+        // `unref` is Node-only — browsers and React Native return a numeric handle with
+        // no such method. Where it exists, a pending refresh must not hold the process open.
+        const unref = timer.unref;
+        if (typeof unref === 'function')
+            unref.call(timer);
+        entry.timer = timer;
+    }
+    /**
+     * Begin a refresh, publish its settle promise on the entry, and act on how it
+     * ended. This is the single place that turns a {@link RefreshOutcome} into a
+     * scheduling decision — `refresh` itself only reports.
+     */
+    start(key, entry) {
+        if (entry.running !== undefined)
+            return;
+        // `running` must never reject: nothing awaits it in production, so a rejection
+        // from a timer callback is a process-level crash for a background chore. `refresh`
+        // has a total try/catch, and the trailing `catch` covers the rescheduling that
+        // follows it. Logged and dropped; the next commit re-arms.
+        const run = this.refresh(key, entry).then(outcome => {
+            // `running` must be cleared BEFORE the outcome is applied: `arm` early-returns
+            // while a refresh is in flight, so a retry armed ahead of this clear would be
+            // silently dropped. Sequenced, not raced.
+            if (entry.running === run)
+                entry.running = undefined;
+            this.applyOutcome(key, entry, outcome);
+        }).catch(e => {
+            warnLog('Auto-analyze rescheduling for %s failed: %s', key, e);
+        });
+        entry.running = run;
+    }
+    /** Decide what a finished refresh means for scheduling. */
+    applyOutcome(key, entry, outcome) {
+        switch (outcome) {
+            case 'analyzed':
+                // The crossing was served, so the next one starts with a full retry budget.
+                entry.deferRetries = 0;
+                break;
+            case 'deferred':
+                this.armDeferRetry(key, entry);
+                break;
+            case 'declined':
+            case 'failed':
+                // Nothing to reschedule. `declined` is a deliberate refusal that a retry would
+                // only repeat; `failed` already recorded its own backoff in `refresh`'s catch.
+                // Both wait for the next commit, as they did before retries existed.
+                break;
+        }
+    }
+    /**
+     * Reschedule a refusal that was purely about timing, on a geometric backoff and
+     * within a fixed budget. Once the budget is spent the crossing is dropped and the
+     * next commit that touches the table is what revives it.
+     */
+    armDeferRetry(key, entry) {
+        // The table may have been dropped, or its entry replaced, while the deferred
+        // refresh ran — do not resurrect a detached object. (`arm` re-checks the table
+        // itself; this checks the entry's identity, which `arm` cannot see.)
+        if (this.entries.get(key) !== entry)
+            return;
+        if (entry.deferRetries >= AUTO_ANALYZE_MAX_DEFER_RETRIES) {
+            debugLog('Auto-analyze of %s deferred %d times by an open transaction; dropping the crossing ' +
+                'until the next commit touches the table', key, entry.deferRetries);
+            // Drop the backoff with it: the spent retries must not also delay the refresh
+            // the next commit arms. `deferRetries` itself stays at the cap until a commit
+            // or a successful refresh refunds it, so the spent budget stays observable.
+            //
+            // NOTE: zeroing is safe only because every refresh reaches here through `arm`,
+            // whose timer cannot fire before `nextEligibleAt` — so the duty-cycle cooldown
+            // this discards has already elapsed. If a future path ever starts a refresh
+            // without going through `arm`, this silently drops a live cooldown; carry the
+            // pre-deferral value instead of zeroing at that point.
+            entry.nextEligibleAt = 0;
+            return;
+        }
+        const delay = AUTO_ANALYZE_DEFER_RETRY_MS * 2 ** entry.deferRetries;
+        entry.deferRetries++;
+        // Expressed as a cooldown rather than a second timer concept, so `arm` and
+        // `armDelayMs` remain the only places a delay is computed.
+        entry.nextEligibleAt = Date.now() + delay;
+        this.arm(key, entry);
+    }
+    /**
+     * Refresh one table's statistics, reporting how it ended. Never throws: a failed
+     * automatic refresh must not surface as an error on an unrelated user statement,
+     * and nothing awaits this.
+     *
+     * It decides nothing about scheduling — every exit names a {@link RefreshOutcome}
+     * and {@link start} decides what that means. A new early return therefore has to
+     * say whether it is a refusal or a deferral, which is what keeps "abandoned
+     * crossing" from being writable by accident.
+     */
+    async refresh(key, entry) {
+        const startedAt = Date.now();
+        try {
+            if (this.disposed)
+                return 'declined';
+            // Re-read the switch at fire time: `pragma auto_analyze = false` between the
+            // arming and now must abandon the refresh, leaving the counter intact.
+            if (!this.enabled())
+                return 'declined';
+            // Deferred while a transaction is open. A memory table's `ANALYZE` adopts the
+            // connection already registered for the table INCLUDING its pending transaction
+            // layer (see `getStatistics` in `vtab/memory/table.ts`), so refreshing
+            // mid-transaction would bake uncommitted rows into the statistics.
+            //
+            // The counter is left untouched and the crossing is RETRIED on a backoff —
+            // `start` → `armDeferRetry`, up to AUTO_ANALYZE_MAX_DEFER_RETRIES times. That
+            // matters because this check is not only about an explicit `BEGIN`: a writing
+            // statement (`update`, `delete`, `insert … select`, any DDL) opens an implicit
+            // transaction too, so a timer for table `t` can land inside a write to some
+            // unrelated table. Without the retry that crossing was abandoned outright, and
+            // only the next commit touching `t` itself would ever revive it.
+            //
+            // NOTE: the retry budget is deliberately finite — see
+            // AUTO_ANALYZE_MAX_DEFER_RETRIES. A transaction held open past it drops the
+            // crossing and the pre-retry behaviour resumes: wait for the next commit.
+            //
+            // NOTE: accepted tradeoff — a `begin` landing between this check and `exec`'s
+            // mutex acquisition lets the refresh run inside that transaction after all.
+            // Worst outcome is statistics that include uncommitted rows, which is exactly
+            // what a user typing `begin; insert …; analyze;` gets today, and the store's
+            // `saveStatistics` already carries an accepted-tradeoff NOTE for the persisted
+            // half of the same situation. Closing it would mean holding the execution mutex
+            // across the check, i.e. blocking user statements on a background scan. Revisit
+            // only if statistics polluted by uncommitted rows show up in practice.
+            if (!this.ctx.getAutocommit())
+                return 'deferred';
+            // NOTE: a never-analyzed table reports 0 known rows (`SchemaManager` hardcodes
+            // `estimatedRows` to 0 at CREATE), so its FIRST automatic refresh is not size
+            // gated — a table bulk-loaded to 10M rows in a single transaction gets one
+            // unbounded scan before `analyzedRowCount` starts gating the rest. Deliberate:
+            // the obvious tightening — treating `changedSinceAnalyze` as a size proxy —
+            // deadlocks, because a table skipped as oversize never resets its counter and
+            // would therefore be skipped forever. If that first scan ever matters, give the
+            // gate a real size source (a module-reported row count) rather than a proxy.
+            const known = entry.analyzedRowCount ?? this.catalogRowCount(key) ?? 0;
+            const limit = this.rowLimit();
+            // 0 disables the cap (documented with the option), hence `limit > 0 &&` rather
+            // than a bare comparison — otherwise 0 would mean "never auto-analyze anything".
+            if (limit > 0 && known > limit) {
+                if (!entry.oversizeLogged) {
+                    entry.oversizeLogged = true;
+                    log('Statistics for %s are stale but the table is too large for auto-analyze ' +
+                        '(%d known rows > auto_analyze_row_limit %d) — run ANALYZE manually', key, known, limit);
+                }
+                return 'declined';
+            }
+            const table = this.findTable(key);
+            if (!table || table.isView) {
+                this.dropEntry(key);
+                return 'declined';
+            }
+            // Snapshot rather than zero: mutations that commit between here and the reset
+            // below stay accounted for.
+            const snapshot = entry.changedSinceAnalyze;
+            this.refreshes++;
+            const [schemaName, tableName] = splitBaseKey(key);
+            await this.ctx.exec(`analyze ${quoteIdentifier(schemaName)}.${quoteIdentifier(tableName)}`);
+            // The table may have been dropped while the refresh ran, in which case
+            // `dropEntry` already discarded this object — do not resurrect it.
+            if (this.entries.get(key) !== entry)
+                return 'declined';
+            entry.changedSinceAnalyze = Math.max(0, entry.changedSinceAnalyze - snapshot);
+            const refreshed = this.findTable(key);
+            entry.analyzedRowCount = refreshed ? catalogRowCount(refreshed) : undefined;
+            entry.staleLogged = false;
+            entry.oversizeLogged = false;
+            const elapsed = Date.now() - startedAt;
+            entry.nextEligibleAt = Date.now() + elapsed * AUTO_ANALYZE_DUTY_CYCLE;
+            debugLog('Auto-analyzed %s in %d ms (%s rows)', key, elapsed, entry.analyzedRowCount);
+            return 'analyzed';
+        }
+        catch (e) {
+            // The staleness is real, so the counter is left alone and the next commit
+            // re-arms — behind a backoff, so an unreadable table cannot spin.
+            warnLog('Automatic ANALYZE of %s failed: %s', key, e);
+            entry.nextEligibleAt = Date.now() + Math.max(AUTO_ANALYZE_FAILURE_BACKOFF_MS, (Date.now() - startedAt) * AUTO_ANALYZE_DUTY_CYCLE);
+            return 'failed';
+        }
+    }
+    /** Catalog row count for a table, ignoring the entry's own record. */
+    catalogRowCount(key) {
+        const table = this.findTable(key);
+        return table ? catalogRowCount(table) : undefined;
+    }
+    enabled() {
+        return this.ctx.options.getBooleanOption('auto_analyze');
+    }
+    minMutations() {
+        return this.ctx.options.getNumberOption('auto_analyze_min_mutations');
+    }
+    ratio() {
+        return this.ctx.options.getNumberOption('auto_analyze_ratio');
+    }
+    /**
+     * Largest table (in known rows) an automatic refresh will scan; 0 disables the cap.
+     *
+     * NOTE: the gate is purely on row count. An earlier design also exempted modules
+     * whose `getStatistics()` answers the whole question cheaply, but no shipped module
+     * does — both the store backend (`store-table-base.ts`) and the memory backend
+     * (`vtab/memory/table.ts`) deliberately return an EMPTY `columnStats`, which
+     * `ANALYZE` reads as "size answered, scan for the rest". The exemption would be dead
+     * code. If a module that reports complete statistics ever appears, exempt it here.
+     */
+    rowLimit() {
+        return this.ctx.options.getNumberOption('auto_analyze_row_limit');
+    }
+}
+//# sourceMappingURL=database-auto-analyze.js.map

package/dist/src/core/database-auto-analyze.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"database-auto-analyze.js","sourceRoot":"","sources":["../../../src/core/database-auto-analyze.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,EAAE,eAAe,EAAE,MAAM,uCAAuC,CAAC;AAExE,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAGzD,MAAM,GAAG,GAAG,YAAY,CAAC,mBAAmB,CAAC,CAAC;AAC9C,MAAM,QAAQ,GAAG,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;AACrC,MAAM,OAAO,GAAG,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;AAEnC;;;;GAIG;AACH,MAAM,wBAAwB,GAAG,EAAE,CAAC;AAEpC;;;;;;;;;;;;GAYG;AACH,MAAM,uBAAuB,GAAG,EAAE,CAAC;AAEnC;8EAC8E;AAC9E,MAAM,+BAA+B,GAAG,IAAI,CAAC;AAE7C;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAAG,GAAG,CAAC;AAE/C;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,8BAA8B,GAAG,CAAC,CAAC;AAEhD;;;;GAIG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAG,EAAE,CAAC;AAc/C;;;;;GAKG;AACH,MAAM,UAAU,UAAU,CAAC,cAAsB,EAAE,GAAW;IAC7D,OAAO,IAAI,CAAC,GAAG,CAAC,wBAAwB,EAAE,cAAc,GAAG,GAAG,CAAC,CAAC;AACjE,CAAC;AAoDD;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,kBAAkB,CAAC,YAAoB,EAAE,KAAa,EAAE,aAAqB;IAC5F,OAAO,IAAI,CAAC,GAAG,CAAC,YAAY,EAAE,KAAK,GAAG,aAAa,CAAC,CAAC;AACtD,CAAC;AAED,6EAA6E;AAC7E,MAAM,UAAU,YAAY,CAC3B,mBAA2B,EAC3B,YAAoB,EACpB,KAAa,EACb,aAAqB;IAErB,OAAO,mBAAmB,IAAI,kBAAkB,CAAC,YAAY,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC;AACtF,CAAC;AAED;;;GAGG;AACH,MAAM,OAAO,kBAAkB;IAmBD;IAlB7B;;;;;;;;;;OAUG;IACc,OAAO,GAAG,IAAI,GAAG,EAA+B,CAAC;IAC1D,wBAAwB,GAAwB,IAAI,CAAC;IAC7D,gFAAgF;IACxE,QAAQ,GAAG,KAAK,CAAC;IACzB,qFAAqF;IAC7E,SAAS,GAAG,CAAC,CAAC;IAEtB,YAA6B,GAA8B;QAA9B,QAAG,GAAH,GAAG,CAA2B;QAC1D,IAAI,CAAC,wBAAwB,EAAE,CAAC;IACjC,CAAC;IAEO,wBAAwB;QAC/B,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,aAAa,CAAC,iBAAiB,EAAE,CAAC;QAC5D,IAAI,CAAC,wBAAwB,GAAG,QAAQ,CAAC,WAAW,CAAC,CAAC,KAAwB,EAAE,EAAE;YACjF,0EAA0E;YAC1E,4EAA4E;YAC5E,8EAA8E;YAC9E,6BAA6B;YAC7B,EAAE;YACF,6EAA6E;YAC7E,gFAAgF;YAChF,yEAAyE;YACzE,qEAAqE;YACrE,8EAA8E;YAC9E,sEAAsE;YACtE,6EAA6E;YAC7E,8EAA8E;YAC9E,6EAA6E;YAC7E,oCAAoC;YACpC,EAAE;YACF,wEAAwE;YACxE,4EAA4E;YAC5E,iEAAiE;YACjE,4EAA4E;YAC5E,wEAAwE;YACxE,4CAA4C;YAC5C,IAAI,KAAK,CAAC,IAAI,KAAK,eAAe,EAAE,CAAC;gBACpC,MAAM,GAAG,GAAG,GAAG,KAAK,CAAC,UAAU,IAAI,KAAK,CAAC,UAAU,EAAE,CAAC,WAAW,EAAE,CAAC;gBACpE,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;YACrB,CAAC;QACF,CAAC,CAAC,CAAC;IACJ,CAAC;IAED;;;;OAIG;IACH,YAAY,CAAC,MAA2B;QACvC,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,EAAE,CAAC;YACnC,IAAI,KAAK,IAAI,CAAC;gBAAE,SAAS;YACzB,IAAI,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YAClC,IAAI,CAAC,KAAK,EAAE,CAAC;gBACZ,KAAK,GAAG;oBACP,mBAAmB,EAAE,CAAC;oBACtB,gBAAgB,EAAE,SAAS;oBAC3B,WAAW,EAAE,KAAK;oBAClB,KAAK,EAAE,SAAS;oBAChB,OAAO,EAAE,SAAS;oBAClB,cAAc,EAAE,CAAC;oBACjB,cAAc,EAAE,KAAK;oBACrB,YAAY,EAAE,CAAC;iBACf,CAAC;gBACF,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;YAC9B,CAAC;YACD,KAAK,CAAC,mBAAmB,IAAI,KAAK,CAAC;YACnC,6EAA6E;YAC7E,2EAA2E;YAC3E,6EAA6E;YAC7E,KAAK,CAAC,YAAY,GAAG,CAAC,CAAC;YACvB,IAAI,CAAC,QAAQ,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QAC3B,CAAC;IACF,CAAC;IAED;;;;OAIG;IACH,OAAO,CAAC,GAAW;QAClB,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACpC,IAAI,CAAC,KAAK;YAAE,OAAO,KAAK,CAAC;QACzB,MAAM,KAAK,GAAG,IAAI,CAAC,mBAAmB,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QACnD,IAAI,KAAK,KAAK,SAAS;YAAE,OAAO,KAAK,CAAC;QACtC,OAAO,YAAY,CAAC,KAAK,CAAC,mBAAmB,EAAE,IAAI,CAAC,YAAY,EAAE,EAAE,IAAI,CAAC,KAAK,EAAE,EAAE,KAAK,CAAC,CAAC;IAC1F,CAAC;IAED,6EAA6E;IAC7E,QAAQ,CAAC,GAAW;QACnB,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAC9B,CAAC;IAED,2EAA2E;IAC3E,aAAa;QACZ,OAAO,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC;IACjC,CAAC;IAED;;;;OAIG;IACH,YAAY;QACX,OAAO,IAAI,CAAC,SAAS,CAAC;IACvB,CAAC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,KAAK,CAAC,QAAQ;QACb,KAAK,IAAI,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,4BAA4B,EAAE,IAAI,EAAE,EAAE,CAAC;YAChE,MAAM,OAAO,GAAoB,EAAE,CAAC;YACpC,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;gBAC9C,IAAI,KAAK,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;oBAC/B,YAAY,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;oBAC1B,KAAK,CAAC,KAAK,GAAG,SAAS,CAAC;oBACxB,KAAK,CAAC,cAAc,GAAG,CAAC,CAAC;oBACzB,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;gBACxB,CAAC;gBACD,IAAI,KAAK,CAAC,OAAO,KAAK,SAAS;oBAAE,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;YAC9D,CAAC;YACD,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;gBAAE,OAAO;YACjC,MAAM,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QAC5B,CAAC;QACD,mFAAmF;QACnF,4EAA4E;QAC5E,OAAO,CACN,iEAAiE,EACjE,4BAA4B,EAC5B,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CACnC,CAAC;IACH,CAAC;IAED;;;;;;;;OAQG;IACH,KAAK,CAAC,gBAAgB,CAAC,GAAW;QACjC,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACpC,IAAI,CAAC,KAAK,IAAI,KAAK,CAAC,KAAK,KAAK,SAAS;YAAE,OAAO;QAChD,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;QACvB,KAAK,CAAC,cAAc,GAAG,CAAC,CAAC;QACzB,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QACvB,MAAM,KAAK,CAAC,OAAO,CAAC;IACrB,CAAC;IAED,OAAO;QACN,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;QACrB,IAAI,IAAI,CAAC,wBAAwB,EAAE,CAAC;YACnC,IAAI,CAAC,wBAAwB,EAAE,CAAC;YAChC,IAAI,CAAC,wBAAwB,GAAG,IAAI,CAAC;QACtC,CAAC;QACD,4EAA4E;QAC5E,2EAA2E;QAC3E,+EAA+E;QAC/E,yEAAyE;QACzE,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC;YAC3C,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;QACxB,CAAC;QACD,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;IACtB,CAAC;IAED,2EAA2E;IACnE,UAAU,CAAC,KAA0B;QAC5C,IAAI,KAAK,CAAC,KAAK,KAAK,SAAS;YAAE,OAAO;QACtC,YAAY,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QAC1B,KAAK,CAAC,KAAK,GAAG,SAAS,CAAC;IACzB,CAAC;IAED,2DAA2D;IACnD,SAAS,CAAC,GAAW;QAC5B,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACpC,IAAI,CAAC,KAAK;YAAE,OAAO;QACnB,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;QACvB,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IAC1B,CAAC;IAED;;;;;;;;OAQG;IACK,mBAAmB,CAAC,GAAW,EAAE,KAA0B;QAClE,IAAI,KAAK,CAAC,gBAAgB,KAAK,SAAS;YAAE,OAAO,KAAK,CAAC,gBAAgB,CAAC;QACxE,MAAM,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;QAClC,IAAI,CAAC,KAAK,EAAE,CAAC;YACZ,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;YACpB,OAAO,SAAS,CAAC;QAClB,CAAC;QACD,OAAO,eAAe,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IACpC,CAAC;IAEO,SAAS,CAAC,GAAW;QAC5B,MAAM,CAAC,UAAU,EAAE,SAAS,CAAC,GAAG,YAAY,CAAC,GAAG,CAAC,CAAC;QAClD,OAAO,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC;IACnD,CAAC;IAED;;;OAGG;IACK,QAAQ,CAAC,GAAW,EAAE,KAA0B;QACvD,6EAA6E;QAC7E,gFAAgF;QAChF,+EAA+E;QAC/E,+EAA+E;QAC/E,8EAA8E;QAC9E,yEAAyE;QACzE,4EAA4E;QAC5E,IAAI,KAAK,CAAC,KAAK,KAAK,SAAS,IAAI,KAAK,CAAC,OAAO,KAAK,SAAS;YAAE,OAAO;QAErE,MAAM,KAAK,GAAG,IAAI,CAAC,mBAAmB,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QACnD,IAAI,KAAK,KAAK,SAAS;YAAE,OAAO;QAChC,MAAM,SAAS,GAAG,kBAAkB,CAAC,IAAI,CAAC,YAAY,EAAE,EAAE,IAAI,CAAC,KAAK,EAAE,EAAE,KAAK,CAAC,CAAC;QAC/E,IAAI,KAAK,CAAC,mBAAmB,GAAG,SAAS;YAAE,OAAO;QAElD,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC;YACxB,KAAK,CAAC,WAAW,GAAG,IAAI,CAAC;YACzB,QAAQ,CACP,mGAAmG,EACnG,GAAG,EAAE,KAAK,CAAC,mBAAmB,EAAE,SAAS,EAAE,KAAK,CAChD,CAAC;QACH,CAAC;QACD,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;IACtB,CAAC;IAED,sFAAsF;IAC9E,GAAG,CAAC,GAAW,EAAE,KAA0B;QAClD,IAAI,IAAI,CAAC,QAAQ;YAAE,OAAO;QAC1B,IAAI,KAAK,CAAC,KAAK,KAAK,SAAS,IAAI,KAAK,CAAC,OAAO,KAAK,SAAS;YAAE,OAAO;QAErE,kFAAkF;QAClF,iFAAiF;QACjF,MAAM,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;QAClC,IAAI,CAAC,KAAK,EAAE,CAAC;YACZ,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;YACpB,OAAO;QACR,CAAC;QACD,IAAI,KAAK,CAAC,MAAM;YAAE,OAAO;QAEzB,MAAM,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC,cAAc,EAAE,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC;QAC3D,MAAM,KAAK,GAAG,UAAU,CAAC,GAAG,EAAE;YAC7B,KAAK,CAAC,KAAK,GAAG,SAAS,CAAC;YACxB,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QACxB,CAAC,EAAE,KAAK,CAAC,CAAC;QACV,gFAAgF;QAChF,qFAAqF;QACrF,MAAM,KAAK,GAAI,KAAgC,CAAC,KAAK,CAAC;QACtD,IAAI,OAAO,KAAK,KAAK,UAAU;YAAE,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACnD,KAAK,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,CAAC;IAED;;;;OAIG;IACK,KAAK,CAAC,GAAW,EAAE,KAA0B;QACpD,IAAI,KAAK,CAAC,OAAO,KAAK,SAAS;YAAE,OAAO;QACxC,+EAA+E;QAC/E,mFAAmF;QACnF,+EAA+E;QAC/E,2DAA2D;QAC3D,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE;YACnD,+EAA+E;YAC/E,8EAA8E;YAC9E,0CAA0C;YAC1C,IAAI,KAAK,CAAC,OAAO,KAAK,GAAG;gBAAE,KAAK,CAAC,OAAO,GAAG,SAAS,CAAC;YACrD,IAAI,CAAC,YAAY,CAAC,GAAG,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;QACxC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE;YACZ,OAAO,CAAC,6CAA6C,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;QAChE,CAAC,CAAC,CAAC;QACH,KAAK,CAAC,OAAO,GAAG,GAAG,CAAC;IACrB,CAAC;IAED,2DAA2D;IACnD,YAAY,CAAC,GAAW,EAAE,KAA0B,EAAE,OAAuB;QACpF,QAAQ,OAAO,EAAE,CAAC;YACjB,KAAK,UAAU;gBACd,4EAA4E;gBAC5E,KAAK,CAAC,YAAY,GAAG,CAAC,CAAC;gBACvB,MAAM;YACP,KAAK,UAAU;gBACd,IAAI,CAAC,aAAa,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;gBAC/B,MAAM;YACP,KAAK,UAAU,CAAC;YAChB,KAAK,QAAQ;gBACZ,+EAA+E;gBAC/E,+EAA+E;gBAC/E,qEAAqE;gBACrE,MAAM;QACR,CAAC;IACF,CAAC;IAED;;;;OAIG;IACK,aAAa,CAAC,GAAW,EAAE,KAA0B;QAC5D,6EAA6E;QAC7E,+EAA+E;QAC/E,qEAAqE;QACrE,IAAI,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,KAAK,KAAK;YAAE,OAAO;QAE5C,IAAI,KAAK,CAAC,YAAY,IAAI,8BAA8B,EAAE,CAAC;YAC1D,QAAQ,CACP,qFAAqF;gBACrF,yCAAyC,EACzC,GAAG,EAAE,KAAK,CAAC,YAAY,CACvB,CAAC;YACF,8EAA8E;YAC9E,8EAA8E;YAC9E,4EAA4E;YAC5E,EAAE;YACF,+EAA+E;YAC/E,+EAA+E;YAC/E,4EAA4E;YAC5E,8EAA8E;YAC9E,uDAAuD;YACvD,KAAK,CAAC,cAAc,GAAG,CAAC,CAAC;YACzB,OAAO;QACR,CAAC;QAED,MAAM,KAAK,GAAG,2BAA2B,GAAG,CAAC,IAAI,KAAK,CAAC,YAAY,CAAC;QACpE,KAAK,CAAC,YAAY,EAAE,CAAC;QACrB,2EAA2E;QAC3E,2DAA2D;QAC3D,KAAK,CAAC,cAAc,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC;QAC1C,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;IACtB,CAAC;IAED;;;;;;;;;OASG;IACK,KAAK,CAAC,OAAO,CAAC,GAAW,EAAE,KAA0B;QAC5D,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAC7B,IAAI,CAAC;YACJ,IAAI,IAAI,CAAC,QAAQ;gBAAE,OAAO,UAAU,CAAC;YACrC,6EAA6E;YAC7E,uEAAuE;YACvE,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE;gBAAE,OAAO,UAAU,CAAC;YAEvC,8EAA8E;YAC9E,gFAAgF;YAChF,uEAAuE;YACvE,mEAAmE;YACnE,EAAE;YACF,2EAA2E;YAC3E,8EAA8E;YAC9E,8EAA8E;YAC9E,+EAA+E;YAC/E,4EAA4E;YAC5E,+EAA+E;YAC/E,iEAAiE;YACjE,EAAE;YACF,sDAAsD;YACtD,4EAA4E;YAC5E,0EAA0E;YAC1E,EAAE;YACF,8EAA8E;YAC9E,4EAA4E;YAC5E,8EAA8E;YAC9E,6EAA6E;YAC7E,+EAA+E;YAC/E,gFAAgF;YAChF,gFAAgF;YAChF,uEAAuE;YACvE,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,aAAa,EAAE;gBAAE,OAAO,UAAU,CAAC;YAEjD,+EAA+E;YAC/E,8EAA8E;YAC9E,2EAA2E;YAC3E,+EAA+E;YAC/E,4EAA4E;YAC5E,8EAA8E;YAC9E,gFAAgF;YAChF,6EAA6E;YAC7E,MAAM,KAAK,GAAG,KAAK,CAAC,gBAAgB,IAAI,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;YACvE,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;YAC9B,+EAA+E;YAC/E,iFAAiF;YACjF,IAAI,KAAK,GAAG,CAAC,IAAI,KAAK,GAAG,KAAK,EAAE,CAAC;gBAChC,IAAI,CAAC,KAAK,CAAC,cAAc,EAAE,CAAC;oBAC3B,KAAK,CAAC,cAAc,GAAG,IAAI,CAAC;oBAC5B,GAAG,CACF,0EAA0E;wBAC1E,oEAAoE,EACpE,GAAG,EAAE,KAAK,EAAE,KAAK,CACjB,CAAC;gBACH,CAAC;gBACD,OAAO,UAAU,CAAC;YACnB,CAAC;YAED,MAAM,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;YAClC,IAAI,CAAC,KAAK,IAAI,KAAK,CAAC,MAAM,EAAE,CAAC;gBAC5B,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;gBACpB,OAAO,UAAU,CAAC;YACnB,CAAC;YAED,8EAA8E;YAC9E,4BAA4B;YAC5B,MAAM,QAAQ,GAAG,KAAK,CAAC,mBAAmB,CAAC;YAC3C,IAAI,CAAC,SAAS,EAAE,CAAC;YACjB,MAAM,CAAC,UAAU,EAAE,SAAS,CAAC,GAAG,YAAY,CAAC,GAAG,CAAC,CAAC;YAClD,MAAM,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,WAAW,eAAe,CAAC,UAAU,CAAC,IAAI,eAAe,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;YAE5F,uEAAuE;YACvE,mEAAmE;YACnE,IAAI,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,KAAK,KAAK;gBAAE,OAAO,UAAU,CAAC;YAEvD,KAAK,CAAC,mBAAmB,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,CAAC,mBAAmB,GAAG,QAAQ,CAAC,CAAC;YAC9E,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;YACtC,KAAK,CAAC,gBAAgB,GAAG,SAAS,CAAC,CAAC,CAAC,eAAe,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;YAC5E,KAAK,CAAC,WAAW,GAAG,KAAK,CAAC;YAC1B,KAAK,CAAC,cAAc,GAAG,KAAK,CAAC;YAC7B,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS,CAAC;YACvC,KAAK,CAAC,cAAc,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,OAAO,GAAG,uBAAuB,CAAC;YACtE,QAAQ,CAAC,qCAAqC,EAAE,GAAG,EAAE,OAAO,EAAE,KAAK,CAAC,gBAAgB,CAAC,CAAC;YACtF,OAAO,UAAU,CAAC;QACnB,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACZ,0EAA0E;YAC1E,kEAAkE;YAClE,OAAO,CAAC,oCAAoC,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;YACtD,KAAK,CAAC,cAAc,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,GAAG,CAC3C,+BAA+B,EAC/B,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS,CAAC,GAAG,uBAAuB,CAClD,CAAC;YACF,OAAO,QAAQ,CAAC;QACjB,CAAC;IACF,CAAC;IAED,sEAAsE;IAC9D,eAAe,CAAC,GAAW;QAClC,MAAM,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;QAClC,OAAO,KAAK,CAAC,CAAC,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IACnD,CAAC;IAEO,OAAO;QACd,OAAO,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,gBAAgB,CAAC,cAAc,CAAC,CAAC;IAC1D,CAAC;IAEO,YAAY;QACnB,OAAO,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,eAAe,CAAC,4BAA4B,CAAC,CAAC;IACvE,CAAC;IAEO,KAAK;QACZ,OAAO,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,eAAe,CAAC,oBAAoB,CAAC,CAAC;IAC/D,CAAC;IAED;;;;;;;;;OASG;IACK,QAAQ;QACf,OAAO,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,eAAe,CAAC,wBAAwB,CAAC,CAAC;IACnE,CAAC;CACD"}