When people edit data through a view, which is a filtered or joined window onto underlying tables, the database usually has several valid ways to carry the edit back to those tables. Take a manager who deletes an employee from a "Marketing staff" view. The system could delete the employee record, clear their department, or delete the department itself. All three remove the row from the manager's view. They differ in what they silently break for everyone else who reads the same tables. Today that choice is made in one of three ways: a programmer hard-codes it, a solver picks whichever option touches the fewest tuples, or whichever write arrives first wins. None of these asks the people whose views get damaged.
We propose to make that choice with a Delphi process, the structured expert-consensus method in which panelists rate options anonymously over several rounds and see controlled feedback between rounds. The change we make is in what that feedback contains. A classical Delphi shows panelists the group's median rating. Ours shows them a computed side-effect report: for each candidate write-back strategy, applied to the real data, exactly which rows in each other stakeholder's view would change or disappear. The agreed strategies, including conditional ones ("clear the department, unless the employee is the department's only member"), are then compiled into an executable, verified write-back program. Our claim is that most disagreement over update policy comes from stakeholders not seeing each other's collateral damage. If that is right, side-effect feedback should converge faster, and to policies that cause less real harm on held-out updates, than either standard Delphi feedback or automated minimization of side effects.
Core Claim and Where It Sits
Two lines of work treat the view-update problem, and both assume the cost of a side effect is already known. Deletion-propagation theory, the study of which source tuples to delete so that given view rows disappear, measures cost as a count of collaterally deleted view tuples. Multi-Tuple Deletion Propagation: Approximations and Complexity proves a trichotomy for self-join-free conjunctive queries: polynomial, approximable by linear-programming rounding, or inapproximable. Aggregated Deletion Propagation for Counting Conjunctive Query Answers gives exact dynamic programs and a greedy heuristic for removing at least k answers. Both supply our strongest automated competitor. Both also motivate the proposal, because their objective treats every collateral tuple as equally costly.
The putback line, Making View Update Strategies Programmable and the Dejima peer-to-peer architecture in Controlling and Sharing Distributed Data for Implementing Service Alliance, lets a developer write the write-back rule (put) directly in Datalog, a rule-based query language. It proves that a well-behaved put determines at most one matching view query (get), and compiles the rules to PostgreSQL triggers. We reuse this machinery as our compilation target. What it lacks is any account of where the rule comes from when several parties disagree; Dejima itself leaves conflicting peer policies unresolved.
Capuchin: Causal Database Repair for Algorithmic Fairness shows the same pattern in database repair. Its MaxSAT solver minimizes changed tuples once someone has declared which variables are "admissible," but the declaring is left outside the system.
On the consensus side, The Human-AI Hybrid Delphi Model contributes three things we use: a four-tier outcome taxonomy (strong, conditional, operational, divergent), evidence that panels of about six senior experts reach thematic saturation, and a language-model facilitator that pre-synthesizes evidence. A consensus privacy metrics framework for synthetic data is the closest methodological precedent. It ran a "Round 0" of empirical attack simulations before its Delphi, and that evidence moved the panel away from popular but flawed similarity metrics. That study fed evidence in once, offline, and produced prose recommendations. We regenerate evidence every round, specific to each candidate strategy, and produce executable rules.
CALMA constrains the design. It found that participants who agree on a word like "bias" can mean different things by it. This is why we elicit judgments over concrete row-level consequences rather than over policy labels such as "minimize disruption."
Research Program
The system has three parts.
The first is a candidate generator. For each class of view update (a delete, insert, or modify on a given view), it enumerates a small set of write-back strategies expressed as Datalog delta rules, meaning rules that list the tuples to insert and delete. The set covers the base-tuple delete, nulling a foreign key, cascading deletes, refusing the update, and the minimum-cardinality solution where one is tractable.
The second is a side-effect reporter. It applies each candidate to a snapshot of the data and diffs every registered downstream view. This only needs execution and comparison, not optimal propagation, so it stays cheap even for queries where the optimization problem is intractable. Each panelist receives a report on their own view plus anonymized summaries of the damage to others' views.
The third is the Delphi loop. Panelists rank strategies per update class and may state conditions. Between rounds they see the side-effect reports, the group distribution of rankings, and anonymized rationales from panelists who stand outside the group. A language-model facilitator in the style of the Human-AI Hybrid Delphi Model clusters these rationales and proposes candidate conditions.
At the end, each update class carries one of the four consensus tiers. Strong consensus becomes an unconditional rule. Conditional and operational consensus become guarded rules whose condition is a Datalog predicate. Divergent outcomes become an explicit refusal that routes the update to a human. The compiled program is checked mechanically against the two round-trip laws: writing back an unchanged view leaves the source unchanged (GetPut), and querying the updated source reproduces the edited view (PutGet). These laws are checked on the domain of accepted updates, and refused updates count as a partial put. The rules are deployed as INSTEAD OF triggers through the Dejima compiler.
The main analytic question is how often consensus with conditions can be stated as a guard over data the system can see. Conditions that depend on unrecorded facts, such as clinical judgment, cannot be compiled. We will report what fraction of conditional consensus survives compilation and what fraction is flattened anyway.
Evaluation Design
There is no ground truth for the "right" write-back policy, so we borrow the induced-value design from experimental economics. On the TPC-H schema we define six stakeholder roles, for example finance reporting, order fulfilment and supplier management, each with its own views. Each panelist receives a private brief that scores the loss of particular rows in their view. Some brief items are numeric. Others are deliberately qualitative ("losing the only open order for a supplier is unacceptable"), so that the process must carry conditional reasoning.
This design makes harm measurable as total induced loss. It also allows an oracle that knows every brief, which gives a ceiling. Policies are elicited on a training set of update requests and then scored on held-out updates whose data configurations the panel never saw.
A second setting reuses the Dejima ride-sharing alliance simulation, where peers keep their schemas private. This tests whether side-effect reports can be shared at the shared-table boundary without exposing a peer's private tables.
Human panels follow the six-person size supported by the Human-AI Hybrid Delphi Model and are drawn from database practitioners. A cheaper language-model-simulated panel serves only as a pilot. We do not treat it as evidence, given the open questions that work raises about AI participants carrying legitimate epistemic weight.
Baselines
The naive reference is first-come serialization combined with the database's default write-back. This mirrors how Blockchain-based Bidirectional Updates on Fine-grained Medical Data settles conflicting concurrent writes, by accepting the first in each block and rejecting the rest. It is run on the same held-out update streams. Any process that cannot beat it on induced loss is not worth its overhead.
The strongest automated competitor is minimum-collateral deletion propagation. We use the exact dynamic program where IsPtime(Q) from the aggregated-deletion paper says the query is tractable, the linear-programming rounding approximation where the multi-tuple paper says it applies, and the greedy heuristic otherwise. Every candidate set includes this solution, so the panel can always choose it. It is the strongest competitor because it directly minimizes side effects with provable guarantees and needs no human time. Neither paper reports a number on our metric: no reported result was found on Lacuna for collateral-tuple counts or runtimes of these algorithms on TPC-H, and the aggregated-deletion paper reports only qualitatively that data skew makes the problem easier. We will measure it ourselves on identical data. Beating it means significantly lower held-out induced loss, especially on the qualitative brief items, at a comparable rate of accepted updates.
A stronger version of this baseline is weighted optimization. Each panelist states numeric weights for row types once, and the solver minimizes the weighted collateral damage. This variant is the main threat and is discussed below.
A standard-feedback Delphi, with the same panel size, rounds and facilitator but showing only medians, interquartile ranges and rationales, is the ablation that isolates our key ingredient. A single-round side-effect condition, where reports are shown once and there is no iteration, isolates the value of iterating.
Majority vote over strategy labels in one round is the cheap deliberation baseline. A single-developer putback rule, written by one experienced database engineer given all briefs in the Dejima style, tests whether consensus adds anything over one informed author.
All human conditions use separate, size-matched panels drawn from the same pool, the same briefs and update streams, and the same total time budget per panelist.
Why not just…?
Why not just minimize collateral tuples with a solver? Counting tuples assumes every lost row costs the same. Our briefs, like real downstream consumers, do not. In addition, the multi-tuple paper shows that for queries lacking head domination, the solver cannot even approximate its own objective. The held-out comparison measures directly how much induced loss the cardinality objective leaves on the table. We expect it to do well on the numeric brief items and poorly on the conditional ones. If it matches us overall, the Delphi machinery is unnecessary for this class of workloads, and we will say so.
Why not just collect weights once and optimize? This is the serious threat. If stakeholders can state their costs numerically up front, a weighted solver needs no rounds. Our hypothesis is that people misjudge their costs until they see concrete damage, and that some costs are conditional rather than additive. The single-round side-effect ablation and the weighted-optimization baseline together settle this. If one-shot weighting plus reports matches the full loop, the contribution shrinks to "show stakeholders the side-effect report." That would still be a useful and simpler result, and we would report it as the finding.
Why not just vote? CALMA's finding that a shared label can hide different meanings, and the privacy Delphi's reversal on similarity metrics once evidence was shown, both suggest that voting on strategy names locks in uninformed preferences. The majority-vote arm tests this on our metric rather than asserting it.
Why not just let one well-briefed engineer write the rule? This is what Dejima assumes. It fails when briefs are private and peers will not reveal their schemas. Even in the centralized TPC-H setting, the single-author arm shows whether aggregation adds anything over informed authorship.
Decisive Checks
The core claim is supported if full side-effect Delphi has lower held-out induced loss than both the standard-feedback Delphi and the cardinality solver, reaches stability in fewer rounds than standard Delphi, and compiles to programs that pass both round-trip laws. The claim fails, and we will report the failure, if the standard-feedback ablation matches it, since that would mean the side-effect report is not the active ingredient. The claim is reduced to its simpler form if the one-round side-effect condition matches it. A secondary result is the share of conditional consensus that compiles into guards, which measures how much "it depends" a database can actually enforce.
References
- Multi-Tuple Deletion Propagation: Approximations and Complexity
- Aggregated Deletion Propagation for Counting Conjunctive Query Answers
- Making View Update Strategies Programmable - Toward Controlling and Sharing Distributed Data -
- Controlling and Sharing Distributed Data for Implementing Service Alliance
- Interventional Fairness: Causal Database Repair for Algorithmic Fairness
- The Human-AI Hybrid Delphi Model: A Structured Framework for Context-Rich, Expert Consensus in Complex Domains
- A Consensus Privacy Metrics Framework for Synthetic Data
- CALMA: Context‑Aligned Axes for Language Model Alignment
- Blockchain-Based Bidirectional Updates on Fine-Grained Medical Data