@quereus/quereus 2.9.0 → 3.0.1

package/dist/src/planner/analysis/change-scope.js

@@ -0,0 +1,825 @@
+import { TableReferenceNode, ColumnReferenceNode, ParameterReferenceNode } from '../nodes/reference.js';
+import { ScalarFunctionCallNode } from '../nodes/function.js';
+import { PlanNodeType } from '../nodes/plan-node-type.js';
+import { FunctionFlags } from '../../common/constants.js';
+import { extractBindings } from './binding-extractor.js';
+import { extractConstraintsForTable } from './constraint-extractor.js';
+import { compareSqlValues } from '../../util/comparison.js';
+import { getTypeOrDefault } from '../../types/registry.js';
+function isParamScopeValue(v) {
+    return v !== null
+        && typeof v === 'object'
+        && !(v instanceof Uint8Array)
+        && !Array.isArray(v)
+        && 'kind' in v
+        && v.kind === 'param'
+        && 'index' in v
+        && 'type' in v;
+}
+function portableFromScalarType(t) {
+    const result = {
+        typeName: t.logicalType.name,
+        nullable: t.nullable,
+        ...(t.collationName !== undefined ? { collationName: t.collationName } : {}),
+        ...(t.isReadOnly !== undefined ? { isReadOnly: t.isReadOnly } : {}),
+    };
+    return result;
+}
+/**
+ * Reconstruct a full {@link ScalarType} from a {@link PortableScalarType} by
+ * resolving the logical type through the global type registry. Useful for
+ * callers that received a deserialized {@link ChangeScope} and need to feed
+ * the parameter type into other planner APIs.
+ */
+export function scalarTypeFromPortable(p) {
+    const logical = getTypeOrDefault(p.typeName);
+    return {
+        typeClass: 'scalar',
+        logicalType: logical,
+        nullable: p.nullable,
+        ...(p.collationName !== undefined ? { collationName: p.collationName } : {}),
+        ...(p.isReadOnly !== undefined ? { isReadOnly: p.isReadOnly } : {}),
+    };
+}
+/* --- Constants ----------------------------------------------------------- */
+const KNOWN_TIME_FUNCS = new Set([
+    'now', 'current_timestamp', 'current_time', 'current_date',
+    'date', 'time', 'datetime', 'julianday',
+    'epoch_s', 'epoch_ms', 'epoch_s_frac',
+    'strftime',
+]);
+const KNOWN_RANDOM_FUNCS = new Set(['random', 'randomblob']);
+const DML_NODE_TYPES = new Set([
+    PlanNodeType.Update,
+    PlanNodeType.Insert,
+    PlanNodeType.Delete,
+    PlanNodeType.UpdateExecutor,
+]);
+/* --- Analyzer ------------------------------------------------------------ */
+/**
+ * Walk a (post-analysis) plan and produce its `ChangeScope`. If `params`
+ * is supplied, parameter placeholders are substituted in-place and the
+ * corresponding indices are dropped from `unboundParameters`.
+ */
+export function analyzeChangeScope(plan, options) {
+    const dmlWithoutReturning = isDmlWithoutReturning(plan);
+    const { perRelation } = extractBindings(plan);
+    const tableRefs = collectTableRefs(plan);
+    const columnsByRelKey = collectColumnReads(plan, tableRefs);
+    const nonDetSources = [];
+    const unboundParams = new Set();
+    collectNonDeterminism(plan, nonDetSources, unboundParams, perRelation);
+    const watches = [];
+    if (!dmlWithoutReturning) {
+        for (const ref of tableRefs) {
+            const relKey = relKeyFor(ref);
+            const mode = perRelation.get(relKey);
+            if (!mode)
+                continue;
+            const schemaName = ref.tableSchema.schemaName.toLowerCase();
+            const tableName = ref.tableSchema.name.toLowerCase();
+            const table = { schema: schemaName, table: tableName };
+            const colIndices = columnsByRelKey.get(relKey);
+            const columns = buildColumnSet(ref, colIndices);
+            const scope = buildScopeForMode(plan, ref, relKey, mode, unboundParams);
+            watches.push({ table, columns, scope });
+        }
+    }
+    let scope = {
+        watches: normalizeWatches(watches),
+        nonDeterministicSources: normalizeNonDet(nonDetSources),
+        unboundParameters: sortedDedupParamIndices(unboundParams),
+    };
+    if (options?.params !== undefined) {
+        scope = bindParameters(scope, options.params);
+    }
+    return scope;
+}
+/**
+ * Detects an UPDATE/INSERT/DELETE plan with no RETURNING clause: such a plan
+ * doesn't surface table state to the caller, so watches are empty (but
+ * parameters in the WHERE/SET clauses still count toward unboundParameters).
+ */
+function isDmlWithoutReturning(plan) {
+    function hasReturning(node) {
+        if (node.nodeType === PlanNodeType.Returning)
+            return true;
+        for (const c of node.getChildren()) {
+            if (hasReturning(c))
+                return true;
+        }
+        return false;
+    }
+    function isDmlRoot(node) {
+        if (DML_NODE_TYPES.has(node.nodeType))
+            return true;
+        if (node.nodeType === PlanNodeType.Block) {
+            // A Block wraps one or more statements; check the last statement.
+            const stmts = node.statements;
+            if (stmts && stmts.length > 0) {
+                return isDmlRoot(stmts[stmts.length - 1]);
+            }
+        }
+        // Some DML may be wrapped by sinks/constraint-check nodes; recurse into
+        // a single relational child to find the inner DML.
+        const children = node.getChildren();
+        if (children.length === 1)
+            return isDmlRoot(children[0]);
+        return false;
+    }
+    if (!isDmlRoot(plan))
+        return false;
+    return !hasReturning(plan);
+}
+/* --- Plan walking helpers ------------------------------------------------ */
+function relKeyFor(ref) {
+    const base = `${ref.tableSchema.schemaName}.${ref.tableSchema.name}`.toLowerCase();
+    return `${base}#${ref.id ?? 'unknown'}`;
+}
+function collectTableRefs(plan) {
+    const out = [];
+    const seen = new Set();
+    function walk(node) {
+        if (node instanceof TableReferenceNode) {
+            if (!seen.has(node)) {
+                seen.add(node);
+                out.push(node);
+            }
+        }
+        for (const c of node.getChildren())
+            walk(c);
+    }
+    walk(plan);
+    return out;
+}
+/**
+ * Walk the plan and, for each TableReference, collect the set of output
+ * column indices that any scalar expression in the plan reads.
+ */
+function collectColumnReads(plan, tableRefs) {
+    const result = new Map();
+    const attrToRelKeyAndIdx = new Map();
+    for (const ref of tableRefs) {
+        const relKey = relKeyFor(ref);
+        const attrs = ref.getAttributes();
+        attrs.forEach((a, i) => attrToRelKeyAndIdx.set(a.id, { relKey, colIdx: i }));
+    }
+    function visit(node) {
+        if (node instanceof ColumnReferenceNode) {
+            const info = attrToRelKeyAndIdx.get(node.attributeId);
+            if (info) {
+                let s = result.get(info.relKey);
+                if (!s) {
+                    s = new Set();
+                    result.set(info.relKey, s);
+                }
+                s.add(info.colIdx);
+            }
+        }
+        for (const c of node.getChildren())
+            visit(c);
+    }
+    visit(plan);
+    return result;
+}
+/**
+ * Walk every scalar expression in the plan and collect non-deterministic
+ * sources (volatile functions, parameters used outside a row-binding equality).
+ */
+function collectNonDeterminism(plan, out, unboundParams, perRelation) {
+    // Track parameters that *are* used as the value side of a row-binding
+    // equality predicate. These are already represented as ScopeValue.param
+    // placeholders inside the watch and don't need to also be flagged as
+    // nondeterministic sources (though they remain in unboundParameters).
+    const rowBindingParams = collectRowBindingParams(plan, perRelation);
+    function visit(node) {
+        if (node instanceof ScalarFunctionCallNode) {
+            const isDet = (node.functionSchema.flags & FunctionFlags.DETERMINISTIC) !== 0;
+            if (!isDet) {
+                const name = node.functionSchema.name.toLowerCase();
+                if (KNOWN_TIME_FUNCS.has(name)) {
+                    out.push({ kind: 'time' });
+                }
+                else if (KNOWN_RANDOM_FUNCS.has(name)) {
+                    out.push({ kind: 'random' });
+                }
+                else {
+                    out.push({ kind: 'volatileUdf', name });
+                }
+            }
+        }
+        if (node instanceof ParameterReferenceNode) {
+            const id = node.nameOrIndex;
+            unboundParams.add(id);
+            if (!rowBindingParams.has(id)) {
+                out.push({ kind: 'parameter', index: id });
+            }
+        }
+        for (const c of node.getChildren())
+            visit(c);
+    }
+    visit(plan);
+}
+/** Collect every parameter id used as the value side of a row/group binding equality. */
+function collectRowBindingParams(plan, perRelation) {
+    const result = new Set();
+    for (const [relKey, mode] of perRelation) {
+        if (mode.kind === 'global')
+            continue;
+        const constraints = extractConstraintsForTable(plan, relKey);
+        const keyCols = mode.kind === 'row' ? mode.keyColumns : mode.groupColumns;
+        for (const colIdx of keyCols) {
+            const match = constraints.find(c => c.columnIndex === colIdx && (c.op === '=' || c.op === 'IN'));
+            if (!match)
+                continue;
+            const ve = match.valueExpr;
+            if (!ve)
+                continue;
+            const exprs = Array.isArray(ve) ? ve : [ve];
+            for (const e of exprs) {
+                const id = extractParamId(e);
+                if (id !== undefined)
+                    result.add(id);
+            }
+        }
+    }
+    return result;
+}
+function extractParamId(expr) {
+    // Unwrap a cast inserted by the planner for cross-category coercion.
+    const inner = expr.nodeType === PlanNodeType.Cast
+        ? expr.operand
+        : expr;
+    if (inner instanceof ParameterReferenceNode) {
+        return inner.nameOrIndex;
+    }
+    return undefined;
+}
+/* --- Scope building ------------------------------------------------------ */
+function buildColumnSet(ref, indices) {
+    if (indices === undefined || indices.size === 0)
+        return 'all';
+    const attrs = ref.getAttributes();
+    const names = new Set();
+    for (const idx of indices) {
+        const attr = attrs[idx];
+        if (attr)
+            names.add(attr.name.toLowerCase());
+    }
+    return names;
+}
+function buildScopeForMode(plan, ref, relKey, mode, unboundParams) {
+    const attrs = ref.getAttributes();
+    const colName = (i) => attrs[i]?.name.toLowerCase() ?? `_col${i}`;
+    if (mode.kind === 'global') {
+        return { kind: 'full' };
+    }
+    if (mode.kind === 'row') {
+        const keyNames = mode.keyColumns.map(colName);
+        const values = extractRowKeyValues(plan, relKey, mode.keyColumns, unboundParams);
+        // If the binding-extractor classified this as 'row' but we couldn't
+        // decode literal/parameter values for every key column (e.g. equality
+        // against a complex expression like `pk = a + b`), an empty `values`
+        // array would mean "watch zero rows" — strictly less than what the
+        // query reads. Fall back to `full` to stay sound.
+        if (values.length === 0)
+            return { kind: 'full' };
+        return { kind: 'rows', key: keyNames, values };
+    }
+    // mode.kind === 'group'
+    const groupNames = mode.groupColumns.map(colName);
+    const values = extractRowKeyValues(plan, relKey, mode.groupColumns, unboundParams);
+    if (values.length > 0) {
+        return { kind: 'rowsByGroup', groupBy: groupNames, values };
+    }
+    return { kind: 'groups', groupBy: groupNames };
+}
+/**
+ * For each key column, pick the equality constraint and translate the
+ * RHS into a `ScopeValue` (literal or `param` placeholder). Returns one
+ * tuple per row-binding values combination present in the constraints.
+ */
+function extractRowKeyValues(plan, relKey, keyColumns, unboundParams) {
+    const constraints = extractConstraintsForTable(plan, relKey);
+    // For each key column, gather candidate value expressions.
+    const perColValues = [];
+    for (const colIdx of keyColumns) {
+        const matches = constraints.filter(c => c.columnIndex === colIdx && (c.op === '=' || c.op === 'IN'));
+        if (matches.length === 0)
+            return [];
+        const colValues = new Set();
+        const ordered = [];
+        const push = (v) => {
+            const key = stringifyScopeValue(v);
+            if (!colValues.has(key)) {
+                colValues.add(key);
+                ordered.push(v);
+            }
+        };
+        for (const c of matches) {
+            if (c.op === 'IN' && Array.isArray(c.value)) {
+                const inExprs = Array.isArray(c.valueExpr) ? c.valueExpr : undefined;
+                for (let i = 0; i < c.value.length; i++) {
+                    const v = c.value[i];
+                    const exprAt = inExprs?.[i];
+                    if (v !== undefined) {
+                        push(v);
+                    }
+                    else if (exprAt) {
+                        const sv = scopeValueFromExpr(exprAt, unboundParams);
+                        if (sv === undefined)
+                            return [];
+                        push(sv);
+                    }
+                    else {
+                        return [];
+                    }
+                }
+            }
+            else if (c.op === '=') {
+                if (c.bindingKind === 'literal' || c.value !== undefined && !c.valueExpr) {
+                    push(c.value);
+                }
+                else if (c.valueExpr && !Array.isArray(c.valueExpr)) {
+                    const sv = scopeValueFromExpr(c.valueExpr, unboundParams);
+                    if (sv === undefined)
+                        return [];
+                    push(sv);
+                }
+                else if (c.value !== undefined) {
+                    push(c.value);
+                }
+                else {
+                    return [];
+                }
+            }
+        }
+        perColValues.push(ordered);
+    }
+    // Take the cartesian product but only for single-column keys we keep
+    // independent rows; for multi-column keys without a matching tuple
+    // extraction the conservative thing is to produce the cross product.
+    const tuples = cartesianProduct(perColValues);
+    return sortAndDedupTuples(tuples);
+}
+function scopeValueFromExpr(expr, unboundParams) {
+    const inner = expr.nodeType === PlanNodeType.Cast
+        ? expr.operand
+        : expr;
+    if (inner instanceof ParameterReferenceNode) {
+        unboundParams.add(inner.nameOrIndex);
+        return { kind: 'param', index: inner.nameOrIndex, type: portableFromScalarType(inner.targetType) };
+    }
+    if (inner.nodeType === PlanNodeType.Literal) {
+        const lit = inner;
+        const v = lit.expression?.value;
+        if (v === undefined)
+            return undefined;
+        return v;
+    }
+    return undefined;
+}
+function cartesianProduct(input) {
+    if (input.length === 0)
+        return [];
+    if (input.some(arr => arr.length === 0))
+        return [];
+    const result = [[]];
+    for (const arr of input) {
+        const next = [];
+        for (const prefix of result) {
+            for (const v of arr) {
+                next.push([...prefix, v]);
+            }
+        }
+        result.length = 0;
+        result.push(...next);
+    }
+    return result;
+}
+/* --- Normalization, sorting, dedup --------------------------------------- */
+function normalizeWatches(watches) {
+    return [...watches].sort(compareWatches);
+}
+function compareWatches(a, b) {
+    const sc = a.table.schema.localeCompare(b.table.schema);
+    if (sc !== 0)
+        return sc;
+    const tc = a.table.table.localeCompare(b.table.table);
+    if (tc !== 0)
+        return tc;
+    const ak = a.scope.kind;
+    const bk = b.scope.kind;
+    if (ak !== bk)
+        return ak.localeCompare(bk);
+    return scopeKeySerialization(a.scope).localeCompare(scopeKeySerialization(b.scope));
+}
+function scopeKeySerialization(scope) {
+    if (scope.kind === 'full')
+        return 'full';
+    if (scope.kind === 'groups')
+        return `groups:${scope.groupBy.join(',')}`;
+    if (scope.kind === 'rows')
+        return `rows:${scope.key.join(',')}:${tuplesKey(scope.values)}`;
+    return `rowsByGroup:${scope.groupBy.join(',')}:${tuplesKey(scope.values)}`;
+}
+function tuplesKey(values) {
+    return values.map(t => t.map(stringifyScopeValue).join('|')).join(';');
+}
+function stringifyScopeValue(v) {
+    if (isParamScopeValue(v)) {
+        return `@${v.index}`;
+    }
+    if (v === null)
+        return 'null';
+    if (typeof v === 'bigint')
+        return `b:${v.toString()}`;
+    if (typeof v === 'number')
+        return `n:${v}`;
+    if (typeof v === 'string')
+        return `s:${v}`;
+    if (typeof v === 'boolean')
+        return `B:${v}`;
+    if (v instanceof Uint8Array)
+        return `x:${Array.from(v).map(b => b.toString(16).padStart(2, '0')).join('')}`;
+    return `j:${JSON.stringify(v)}`;
+}
+function sortAndDedupTuples(tuples) {
+    const seen = new Map();
+    for (const t of tuples) {
+        const k = t.map(stringifyScopeValue).join('|');
+        if (!seen.has(k))
+            seen.set(k, t);
+    }
+    return [...seen.values()].sort(compareTuples);
+}
+function compareTuples(a, b) {
+    const len = Math.min(a.length, b.length);
+    for (let i = 0; i < len; i++) {
+        const ca = compareScopeValues(a[i], b[i]);
+        if (ca !== 0)
+            return ca;
+    }
+    return a.length - b.length;
+}
+function compareScopeValues(a, b) {
+    const aIsParam = isParamScopeValue(a);
+    const bIsParam = isParamScopeValue(b);
+    if (aIsParam && bIsParam) {
+        return String(a.index).localeCompare(String(b.index));
+    }
+    if (aIsParam)
+        return 1;
+    if (bIsParam)
+        return -1;
+    return compareSqlValues(a, b);
+}
+function normalizeNonDet(sources) {
+    const seen = new Map();
+    for (const s of sources) {
+        const k = nonDetKey(s);
+        if (!seen.has(k))
+            seen.set(k, s);
+    }
+    return [...seen.values()].sort((a, b) => nonDetKey(a).localeCompare(nonDetKey(b)));
+}
+function nonDetKey(s) {
+    switch (s.kind) {
+        case 'time': {
+            return 't';
+        }
+        case 'random': {
+            return 'r';
+        }
+        case 'volatileUdf': {
+            return `u:${s.name}`;
+        }
+        case 'parameter': {
+            return `p:${s.index}`;
+        }
+    }
+}
+function sortedDedupParamIndices(set) {
+    const arr = [...set];
+    arr.sort((a, b) => {
+        const aIsNum = typeof a === 'number';
+        const bIsNum = typeof b === 'number';
+        if (aIsNum && bIsNum)
+            return a - b;
+        if (aIsNum)
+            return -1;
+        if (bIsNum)
+            return 1;
+        return a.localeCompare(b);
+    });
+    return arr;
+}
+/* --- Composition helpers ------------------------------------------------- */
+export function unionScopes(a, b) {
+    const byTable = new Map();
+    for (const w of a.watches)
+        byTable.set(tableKey(w.table), w);
+    for (const w of b.watches) {
+        const k = tableKey(w.table);
+        const prev = byTable.get(k);
+        byTable.set(k, prev ? unionWatch(prev, w) : w);
+    }
+    return {
+        watches: normalizeWatches([...byTable.values()]),
+        nonDeterministicSources: normalizeNonDet([...a.nonDeterministicSources, ...b.nonDeterministicSources]),
+        unboundParameters: sortedDedupParamIndices(new Set([...a.unboundParameters, ...b.unboundParameters])),
+    };
+}
+export function intersectScopes(a, b) {
+    const byTableA = new Map();
+    for (const w of a.watches)
+        byTableA.set(tableKey(w.table), w);
+    const out = [];
+    for (const w of b.watches) {
+        const k = tableKey(w.table);
+        const other = byTableA.get(k);
+        if (!other)
+            continue;
+        const merged = intersectWatch(other, w);
+        if (merged)
+            out.push(merged);
+    }
+    // Intersection of non-determinism is the set-intersection.
+    const bNonDet = new Set(b.nonDeterministicSources.map(nonDetKey));
+    const sharedNonDet = a.nonDeterministicSources.filter(s => bNonDet.has(nonDetKey(s)));
+    // Intersection of unbound parameters is the set-intersection.
+    const aParams = new Set(a.unboundParameters);
+    const sharedParams = new Set();
+    for (const p of b.unboundParameters)
+        if (aParams.has(p))
+            sharedParams.add(p);
+    return {
+        watches: normalizeWatches(out),
+        nonDeterministicSources: normalizeNonDet(sharedNonDet),
+        unboundParameters: sortedDedupParamIndices(sharedParams),
+    };
+}
+function tableKey(t) {
+    return `${t.schema}.${t.table}`;
+}
+function unionWatch(a, b) {
+    const columns = unionColumns(a.columns, b.columns);
+    const scope = unionWatchScope(a.scope, b.scope);
+    return { table: a.table, columns, scope };
+}
+function unionColumns(a, b) {
+    if (a === 'all' || b === 'all')
+        return 'all';
+    const out = new Set(a);
+    for (const c of b)
+        out.add(c);
+    return out;
+}
+function unionWatchScope(a, b) {
+    if (a.kind === 'full' || b.kind === 'full')
+        return { kind: 'full' };
+    if (a.kind === 'groups' && b.kind === 'groups') {
+        const aSet = new Set(a.groupBy);
+        const bSet = new Set(b.groupBy);
+        const aSubsetB = [...aSet].every(c => bSet.has(c));
+        const bSubsetA = [...bSet].every(c => aSet.has(c));
+        if (aSubsetB)
+            return { kind: 'groups', groupBy: a.groupBy };
+        if (bSubsetA)
+            return { kind: 'groups', groupBy: b.groupBy };
+        return { kind: 'full' };
+    }
+    if (a.kind === 'rows' && b.kind === 'rows') {
+        if (sameKey(a.key, b.key)) {
+            return { kind: 'rows', key: a.key, values: mergeValues(a.values, b.values) };
+        }
+        return { kind: 'full' };
+    }
+    if (a.kind === 'rowsByGroup' && b.kind === 'rowsByGroup') {
+        if (sameKey(a.groupBy, b.groupBy)) {
+            return { kind: 'rowsByGroup', groupBy: a.groupBy, values: mergeValues(a.values, b.values) };
+        }
+        return { kind: 'full' };
+    }
+    // Mixed shapes (rows vs groups, etc.) cannot be unioned narrowly.
+    return { kind: 'full' };
+}
+function intersectWatch(a, b) {
+    const columns = intersectColumns(a.columns, b.columns);
+    const scope = intersectWatchScope(a.scope, b.scope);
+    if (!scope)
+        return null;
+    return { table: a.table, columns, scope };
+}
+function intersectColumns(a, b) {
+    if (a === 'all')
+        return b;
+    if (b === 'all')
+        return a;
+    const out = new Set();
+    for (const c of a)
+        if (b.has(c))
+            out.add(c);
+    return out;
+}
+function intersectWatchScope(a, b) {
+    if (a.kind === 'full')
+        return b;
+    if (b.kind === 'full')
+        return a;
+    if (a.kind === 'groups' && b.kind === 'groups') {
+        const aSet = new Set(a.groupBy);
+        const bSet = new Set(b.groupBy);
+        const aSubsetB = [...aSet].every(c => bSet.has(c));
+        const bSubsetA = [...bSet].every(c => aSet.has(c));
+        // Intersect picks the *finer* (longer) groupBy that is a superset of the other.
+        if (aSubsetB)
+            return { kind: 'groups', groupBy: b.groupBy };
+        if (bSubsetA)
+            return { kind: 'groups', groupBy: a.groupBy };
+        return null;
+    }
+    if (a.kind === 'rows' && b.kind === 'rows') {
+        if (!sameKey(a.key, b.key))
+            return null;
+        const merged = intersectValues(a.values, b.values);
+        if (merged.length === 0)
+            return null;
+        return { kind: 'rows', key: a.key, values: merged };
+    }
+    if (a.kind === 'rowsByGroup' && b.kind === 'rowsByGroup') {
+        if (!sameKey(a.groupBy, b.groupBy))
+            return null;
+        const merged = intersectValues(a.values, b.values);
+        if (merged.length === 0)
+            return null;
+        return { kind: 'rowsByGroup', groupBy: a.groupBy, values: merged };
+    }
+    return null;
+}
+function sameKey(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++)
+        if (a[i] !== b[i])
+            return false;
+    return true;
+}
+function mergeValues(a, b) {
+    const seen = new Map();
+    for (const t of a) {
+        const k = t.map(stringifyScopeValue).join('|');
+        seen.set(k, t);
+    }
+    for (const t of b) {
+        const k = t.map(stringifyScopeValue).join('|');
+        if (!seen.has(k))
+            seen.set(k, t);
+    }
+    return [...seen.values()].sort(compareTuples);
+}
+function intersectValues(a, b) {
+    const bKeys = new Set(b.map(t => t.map(stringifyScopeValue).join('|')));
+    return a.filter(t => bKeys.has(t.map(stringifyScopeValue).join('|')));
+}
+/* --- Parameter binding --------------------------------------------------- */
+export function bindParameters(scope, params) {
+    const lookup = (id) => {
+        if (Array.isArray(params)) {
+            if (typeof id !== 'number')
+                return undefined;
+            const v = params[id - 1];
+            return v;
+        }
+        if (typeof id === 'number') {
+            return params[id];
+        }
+        const key = id.startsWith(':') || id.startsWith('@') || id.startsWith('$')
+            ? id.substring(1)
+            : id;
+        const obj = params;
+        if (key in obj)
+            return obj[key];
+        if (id in obj)
+            return obj[id];
+        return undefined;
+    };
+    const substituteValue = (v) => {
+        if (isParamScopeValue(v)) {
+            const bound = lookup(v.index);
+            if (bound !== undefined)
+                return bound;
+        }
+        return v;
+    };
+    const substituteTuples = (tuples) => {
+        const out = tuples.map(t => t.map(substituteValue));
+        return sortAndDedupTuples(out);
+    };
+    const newWatches = scope.watches.map(w => {
+        let newScope = w.scope;
+        if (w.scope.kind === 'rows') {
+            newScope = { kind: 'rows', key: w.scope.key, values: substituteTuples(w.scope.values) };
+        }
+        else if (w.scope.kind === 'rowsByGroup') {
+            newScope = { kind: 'rowsByGroup', groupBy: w.scope.groupBy, values: substituteTuples(w.scope.values) };
+        }
+        return { table: w.table, columns: w.columns, scope: newScope };
+    });
+    const remainingUnbound = new Set();
+    for (const id of scope.unboundParameters) {
+        if (lookup(id) === undefined)
+            remainingUnbound.add(id);
+    }
+    const remainingNonDet = scope.nonDeterministicSources.filter(s => {
+        if (s.kind === 'parameter')
+            return lookup(s.index) === undefined;
+        return true;
+    });
+    return {
+        watches: normalizeWatches(newWatches),
+        nonDeterministicSources: normalizeNonDet(remainingNonDet),
+        unboundParameters: sortedDedupParamIndices(remainingUnbound),
+    };
+}
+/* --- Predicates ---------------------------------------------------------- */
+export function isEmpty(scope) {
+    return scope.watches.length === 0
+        && scope.nonDeterministicSources.length === 0
+        && scope.unboundParameters.length === 0;
+}
+export function describesEverything(scope) {
+    if (scope.watches.length === 0)
+        return false;
+    return scope.watches.every(w => w.scope.kind === 'full' && w.columns === 'all');
+}
+export function serializeChangeScope(scope) {
+    return {
+        watches: scope.watches.map(w => ({
+            table: { schema: w.table.schema, table: w.table.table },
+            columns: w.columns === 'all' ? 'all' : [...w.columns].sort(),
+            scope: serializeScope(w.scope),
+        })),
+        nonDeterministicSources: [...scope.nonDeterministicSources],
+        unboundParameters: [...scope.unboundParameters],
+    };
+}
+function serializeScope(scope) {
+    if (scope.kind === 'full')
+        return { kind: 'full' };
+    if (scope.kind === 'groups')
+        return { kind: 'groups', groupBy: [...scope.groupBy] };
+    if (scope.kind === 'rows') {
+        return {
+            kind: 'rows',
+            key: [...scope.key],
+            values: scope.values.map(t => t.map(serializeScopeValue)),
+        };
+    }
+    return {
+        kind: 'rowsByGroup',
+        groupBy: [...scope.groupBy],
+        values: scope.values.map(t => t.map(serializeScopeValue)),
+    };
+}
+function serializeScopeValue(v) {
+    if (isParamScopeValue(v)) {
+        return { p: v.index, t: { ...v.type } };
+    }
+    return { v: v };
+}
+export function deserializeChangeScope(obj) {
+    return {
+        watches: obj.watches.map(w => ({
+            table: { schema: w.table.schema, table: w.table.table },
+            columns: w.columns === 'all' ? 'all' : new Set(w.columns),
+            scope: deserializeScope(w.scope),
+        })),
+        nonDeterministicSources: [...obj.nonDeterministicSources],
+        unboundParameters: [...obj.unboundParameters],
+    };
+}
+function deserializeScope(scope) {
+    if (scope.kind === 'full')
+        return { kind: 'full' };
+    if (scope.kind === 'groups')
+        return { kind: 'groups', groupBy: [...scope.groupBy] };
+    if (scope.kind === 'rows') {
+        return {
+            kind: 'rows',
+            key: [...scope.key],
+            values: scope.values.map(t => t.map(deserializeScopeValue)),
+        };
+    }
+    return {
+        kind: 'rowsByGroup',
+        groupBy: [...scope.groupBy],
+        values: scope.values.map(t => t.map(deserializeScopeValue)),
+    };
+}
+function deserializeScopeValue(v) {
+    if ('p' in v)
+        return { kind: 'param', index: v.p, type: { ...v.t } };
+    return v.v;
+}
+//# sourceMappingURL=change-scope.js.map