Capture resolved conflict outcomes

Author: ila

docs/codebase-audit-2026-07-22.md

@@ -15,9 +15,10 @@ maintenance path. A bug must not be hidden by weakening a test or silently chang
   appends through the caller's `ClientContext`, so base DML and delta rows share one commit or rollback. A resolved
   catalog-level lock prevents refresh from advancing its watermark past an uncommitted delta. Regression coverage includes
   rollback, constraint failure, defaults, generated columns, `RETURNING`, and an uncommitted DML/refresh race.
-- [ ] **Capture actual `ON CONFLICT` outcomes.** `INSERT ... ON CONFLICT DO UPDATE` and `INSERT OR REPLACE` do not emit the
-  required delete-old/insert-new delta pair. Derive deltas from rows actually inserted or updated, not merely the input to
-  `LogicalInsert`.
+- [x] **Capture actual `ON CONFLICT` outcomes.** Conflict clauses lower to `LogicalMergeInto`; a transparent physical action
+  decorator now captures only the INSERT, UPDATE, and DELETE rows selected by DuckDB after match and action predicates are
+  resolved. Updates emit the required delete-old/insert-new pair, volatile defaults are evaluated once, `RETURNING` is
+  preserved, and all writes remain in the base DML transaction. The same boundary also covers native `MERGE` actions.
 - [ ] **Make MV lifecycle and native refresh transactional.** CREATE, REPLACE, DROP, ALTER, and `PRAGMA refresh` currently
   execute material work through helper autocommit connections. Caller rollback cannot restore a consistent collection of
   user view, backing table, metadata, and deltas; failed replacement can destroy the old MV. Use the caller transaction for

src/include/rules/transactional_delta_capture.hpp

@@ -35,6 +35,27 @@ class LogicalTransactionalDeltaCapture : public LogicalExtensionOperator {
 	void ResolveTypes() override;
 };
 
+// Transparent wrapper around a LogicalMergeInto. At physical-plan creation it decorates
+// DuckDB's resolved action sinks, so only rows that actually INSERT/UPDATE/DELETE are captured.
+class LogicalTransactionalMergeDeltaCapture : public LogicalExtensionOperator {
+public:
+	LogicalTransactionalMergeDeltaCapture(TableCatalogEntry &base_table, TableCatalogEntry &delta_table);
+
+	TableCatalogEntry &base_table;
+	TableCatalogEntry &delta_table;
+
+	PhysicalOperator &CreatePlan(ClientContext &context, PhysicalPlanGenerator &planner) override;
+	vector<ColumnBinding> GetColumnBindings() override;
+	string GetName() const override;
+	string GetExtensionName() const override;
+	bool SupportSerialization() const override {
+		return false;
+	}
+
+protected:
+	void ResolveTypes() override;
+};
+
 } // namespace duckdb
 
 #endif // TRANSACTIONAL_DELTA_CAPTURE_HPP

src/rules/refresh_insert_rule.cpp

@@ -18,6 +18,7 @@
 #include "duckdb/planner/expression/bound_columnref_expression.hpp"
 #include "duckdb/planner/operator/logical_delete.hpp"
 #include "duckdb/planner/operator/logical_insert.hpp"
+#include "duckdb/planner/operator/logical_merge_into.hpp"
 #include "duckdb/planner/operator/logical_projection.hpp"
 #include "duckdb/planner/operator/logical_simple.hpp"
 #include "duckdb/planner/operator/logical_update.hpp"
@@ -297,13 +298,15 @@ void RefreshInsertRule::RefreshInsertRuleFunction(OptimizerExtensionInput &input
 		return;
 	}
 
-	auto dml = root;
+	auto dml_owner = &plan;
+	auto dml = dml_owner->get();
 	while (dml->type != LogicalOperatorType::LOGICAL_INSERT && dml->type != LogicalOperatorType::LOGICAL_DELETE &&
-	       dml->type != LogicalOperatorType::LOGICAL_UPDATE) {
+	       dml->type != LogicalOperatorType::LOGICAL_UPDATE && dml->type != LogicalOperatorType::LOGICAL_MERGE_INTO) {
 		if (dml->children.size() != 1) {
 			return;
 		}
-		dml = dml->children[0].get();
+		dml_owner = &dml->children[0];
+		dml = dml_owner->get();
 	}
 
 	switch (dml->type) {
@@ -361,6 +364,19 @@ void RefreshInsertRule::RefreshInsertRuleFunction(OptimizerExtensionInput &input
 		OPENIVM_DEBUG_PRINT("[INSERT RULE] transactional UPDATE delta capture for '%s'\n", table_name.c_str());
 		break;
 	}
+	case LogicalOperatorType::LOGICAL_MERGE_INTO: {
+		auto &merge = dml->Cast<LogicalMergeInto>();
+		const auto &table_name = merge.table.name;
+		auto delta_table = TryGetTrackedDeltaTable(input.context, merge.table);
+		if (!delta_table) {
+			return;
+		}
+		auto capture = make_uniq<LogicalTransactionalMergeDeltaCapture>(merge.table, *delta_table);
+		capture->children.push_back(std::move(*dml_owner));
+		*dml_owner = std::move(capture);
+		OPENIVM_DEBUG_PRINT("[INSERT RULE] transactional MERGE action delta capture for '%s'\n", table_name.c_str());
+		break;
+	}
 	default:
 		return;
 	}