duckdb 1.1.2-dev6.0 → 1.1.4-dev11.0

package/src/duckdb/src/execution/column_binding_resolver.cpp

@@ -156,13 +156,13 @@ unique_ptr<Expression> ColumnBindingResolver::VisitReplace(BoundColumnRefExpress
 				// in verification mode
 				return nullptr;
 			}
-			return make_uniq<BoundReferenceExpression>(expr.alias, expr.return_type, i);
+			return make_uniq<BoundReferenceExpression>(expr.GetAlias(), expr.return_type, i);
 		}
 	}
 	// LCOV_EXCL_START
 	// could not bind the column reference, this should never happen and indicates a bug in the code
 	// generate an error message
-	throw InternalException("Failed to bind column reference \"%s\" [%d.%d] (bindings: %s)", expr.alias,
+	throw InternalException("Failed to bind column reference \"%s\" [%d.%d] (bindings: %s)", expr.GetAlias(),
 	                        expr.binding.table_index, expr.binding.column_index,
 	                        LogicalOperator::ColumnBindingsToString(bindings));
 	// LCOV_EXCL_STOP

package/src/duckdb/src/execution/expression_executor/execute_between.cpp

@@ -7,6 +7,7 @@
 
 namespace duckdb {
 
+#ifndef DUCKDB_SMALLER_BINARY
 struct BothInclusiveBetweenOperator {
 	template <class T>
 	static inline bool Operation(T input, T lower, T upper) {
@@ -85,6 +86,7 @@ static idx_t BetweenLoopTypeSwitch(Vector &input, Vector &lower, Vector &upper,
 		throw InvalidTypeException(input.GetType(), "Invalid type for BETWEEN");
 	}
 }
+#endif
 
 unique_ptr<ExpressionState> ExpressionExecutor::InitializeState(const BoundBetweenExpression &expr,
                                                                 ExpressionExecutorState &root) {
@@ -131,6 +133,9 @@ void ExpressionExecutor::Execute(const BoundBetweenExpression &expr, ExpressionS
 
 idx_t ExpressionExecutor::Select(const BoundBetweenExpression &expr, ExpressionState *state, const SelectionVector *sel,
                                  idx_t count, SelectionVector *true_sel, SelectionVector *false_sel) {
+#ifdef DUCKDB_SMALLER_BINARY
+	throw InternalException("ExpressionExecutor::Select not available with DUCKDB_SMALLER_BINARY");
+#else
 	// resolve the children
 	Vector input(state->intermediate_chunk.data[0]);
 	Vector lower(state->intermediate_chunk.data[1]);
@@ -152,6 +157,7 @@ idx_t ExpressionExecutor::Select(const BoundBetweenExpression &expr, ExpressionS
 	} else {
 		return BetweenLoopTypeSwitch<ExclusiveBetweenOperator>(input, lower, upper, sel, count, true_sel, false_sel);
 	}
+#endif
 }
 
 } // namespace duckdb

package/src/duckdb/src/execution/expression_executor/execute_cast.cpp

@@ -12,7 +12,8 @@ unique_ptr<ExpressionState> ExpressionExecutor::InitializeState(const BoundCastE
 	result->Finalize();
 
 	if (expr.bound_cast.init_local_state) {
-		CastLocalStateParameters parameters(root.executor->GetContext(), expr.bound_cast.cast_data);
+		auto context_ptr = root.executor->HasContext() ? &root.executor->GetContext() : nullptr;
+		CastLocalStateParameters parameters(context_ptr, expr.bound_cast.cast_data);
 		result->local_state = expr.bound_cast.init_local_state(parameters);
 	}
 	return std::move(result);
@@ -32,13 +33,13 @@ void ExpressionExecutor::Execute(const BoundCastExpression &expr, ExpressionStat
 	if (expr.try_cast) {
 		string error_message;
 		CastParameters parameters(expr.bound_cast.cast_data.get(), false, &error_message, lstate);
-		parameters.query_location = expr.query_location;
+		parameters.query_location = expr.GetQueryLocation();
 		expr.bound_cast.function(child, result, count, parameters);
 	} else {
 		// cast it to the type specified by the cast expression
 		D_ASSERT(result.GetType() == expr.return_type);
 		CastParameters parameters(expr.bound_cast.cast_data.get(), false, nullptr, lstate);
-		parameters.query_location = expr.query_location;
+		parameters.query_location = expr.GetQueryLocation();
 		expr.bound_cast.function(child, result, count, parameters);
 	}
 }

package/src/duckdb/src/execution/expression_executor/execute_comparison.cpp

@@ -29,7 +29,7 @@ void ExpressionExecutor::Execute(const BoundComparisonExpression &expr, Expressi
 	Execute(*expr.left, state->child_states[0].get(), sel, count, left);
 	Execute(*expr.right, state->child_states[1].get(), sel, count, right);
 
-	switch (expr.type) {
+	switch (expr.GetExpressionType()) {
 	case ExpressionType::COMPARE_EQUAL:
 		VectorOperations::Equals(left, right, result, count);
 		break;
@@ -357,7 +357,7 @@ idx_t ExpressionExecutor::Select(const BoundComparisonExpression &expr, Expressi
 	Execute(*expr.left, state->child_states[0].get(), sel, count, left);
 	Execute(*expr.right, state->child_states[1].get(), sel, count, right);
 
-	switch (expr.type) {
+	switch (expr.GetExpressionType()) {
 	case ExpressionType::COMPARE_EQUAL:
 		return VectorOperations::Equals(left, right, sel, count, true_sel, false_sel);
 	case ExpressionType::COMPARE_NOTEQUAL:

package/src/duckdb/src/execution/expression_executor/execute_conjunction.cpp

@@ -38,7 +38,7 @@ void ExpressionExecutor::Execute(const BoundConjunctionExpression &expr, Express
 		} else {
 			Vector intermediate(LogicalType::BOOLEAN);
 			// AND/OR together
-			switch (expr.type) {
+			switch (expr.GetExpressionType()) {
 			case ExpressionType::CONJUNCTION_AND:
 				VectorOperations::And(current_result, result, intermediate, count);
 				break;
@@ -58,7 +58,7 @@ idx_t ExpressionExecutor::Select(const BoundConjunctionExpression &expr, Express
                                  SelectionVector *false_sel) {
 	auto &state = state_p->Cast<ConjunctionState>();
 
-	if (expr.type == ExpressionType::CONJUNCTION_AND) {
+	if (expr.GetExpressionType() == ExpressionType::CONJUNCTION_AND) {
 		// get runtime statistics
 		auto filter_state = state.adaptive_filter->BeginFilter();
 		const SelectionVector *current_sel = sel;

package/src/duckdb/src/execution/expression_executor/execute_function.cpp

@@ -76,6 +76,7 @@ void ExpressionExecutor::Execute(const BoundFunctionExpression &expr, Expression
 	arguments.Verify();
 
 	D_ASSERT(expr.function.function);
+	// #ifdef DEBUG
 	expr.function.function(arguments, *state, result);
 
 	VerifyNullHandling(expr, arguments, result);

package/src/duckdb/src/execution/expression_executor/execute_operator.cpp

@@ -19,7 +19,8 @@ void ExpressionExecutor::Execute(const BoundOperatorExpression &expr, Expression
                                  const SelectionVector *sel, idx_t count, Vector &result) {
 	// special handling for special snowflake 'IN'
 	// IN has n children
-	if (expr.type == ExpressionType::COMPARE_IN || expr.type == ExpressionType::COMPARE_NOT_IN) {
+	if (expr.GetExpressionType() == ExpressionType::COMPARE_IN ||
+	    expr.GetExpressionType() == ExpressionType::COMPARE_NOT_IN) {
 		if (expr.children.size() < 2) {
 			throw InvalidInputException("IN needs at least two children");
 		}
@@ -53,14 +54,14 @@ void ExpressionExecutor::Execute(const BoundOperatorExpression &expr, Expression
 				intermediate.Reference(new_result);
 			}
 		}
-		if (expr.type == ExpressionType::COMPARE_NOT_IN) {
+		if (expr.GetExpressionType() == ExpressionType::COMPARE_NOT_IN) {
 			// NOT IN: invert result
 			VectorOperations::Not(intermediate, result, count);
 		} else {
 			// directly use the result
 			result.Reference(intermediate);
 		}
-	} else if (expr.type == ExpressionType::OPERATOR_COALESCE) {
+	} else if (expr.GetExpressionType() == ExpressionType::OPERATOR_COALESCE) {
 		SelectionVector sel_a(count);
 		SelectionVector sel_b(count);
 		SelectionVector slice_sel(count);
@@ -115,7 +116,7 @@ void ExpressionExecutor::Execute(const BoundOperatorExpression &expr, Expression
 		auto &child = state->intermediate_chunk.data[0];
 
 		Execute(*expr.children[0], state->child_states[0].get(), sel, count, child);
-		switch (expr.type) {
+		switch (expr.GetExpressionType()) {
 		case ExpressionType::OPERATOR_NOT: {
 			VectorOperations::Not(child, result, count);
 			break;

package/src/duckdb/src/execution/expression_executor.cpp

@@ -141,7 +141,7 @@ void ExpressionExecutor::Verify(const Expression &expr, Vector &vector, idx_t co
 
 unique_ptr<ExpressionState> ExpressionExecutor::InitializeState(const Expression &expr,
                                                                 ExpressionExecutorState &state) {
-	switch (expr.expression_class) {
+	switch (expr.GetExpressionClass()) {
 	case ExpressionClass::BOUND_REF:
 		return InitializeState(expr.Cast<BoundReferenceExpression>(), state);
 	case ExpressionClass::BOUND_BETWEEN:
@@ -191,7 +191,7 @@ void ExpressionExecutor::Execute(const Expression &expr, ExpressionState *state,
 		    "ExpressionExecutor::Execute called with a result vector of type %s that does not match expression type %s",
 		    result.GetType(), expr.return_type);
 	}
-	switch (expr.expression_class) {
+	switch (expr.GetExpressionClass()) {
 	case ExpressionClass::BOUND_BETWEEN:
 		Execute(expr.Cast<BoundBetweenExpression>(), state, sel, count, result);
 		break;
@@ -235,9 +235,11 @@ idx_t ExpressionExecutor::Select(const Expression &expr, ExpressionState *state,
 	}
 	D_ASSERT(true_sel || false_sel);
 	D_ASSERT(expr.return_type.id() == LogicalTypeId::BOOLEAN);
-	switch (expr.expression_class) {
+	switch (expr.GetExpressionClass()) {
+#ifndef DUCKDB_SMALLER_BINARY
 	case ExpressionClass::BOUND_BETWEEN:
 		return Select(expr.Cast<BoundBetweenExpression>(), state, sel, count, true_sel, false_sel);
+#endif
 	case ExpressionClass::BOUND_COMPARISON:
 		return Select(expr.Cast<BoundComparisonExpression>(), state, sel, count, true_sel, false_sel);
 	case ExpressionClass::BOUND_CONJUNCTION:

package/src/duckdb/src/execution/index/art/art.cpp

@@ -45,7 +45,7 @@ ART::ART(const string &name, const IndexConstraintType index_constraint_type, co
          const shared_ptr<array<unsafe_unique_ptr<FixedSizeAllocator>, ALLOCATOR_COUNT>> &allocators_ptr,
          const IndexStorageInfo &info)
     : BoundIndex(name, ART::TYPE_NAME, index_constraint_type, column_ids, table_io_manager, unbound_expressions, db),
-      allocators(allocators_ptr), owns_data(false) {
+      allocators(allocators_ptr), owns_data(false), append_mode(ARTAppendMode::DEFAULT) {
 
 	// FIXME: Use the new byte representation function to support nested types.
 	for (idx_t i = 0; i < types.size(); i++) {
@@ -138,8 +138,10 @@ unique_ptr<IndexScanState> ART::TryInitializeScan(const Expression &expr, const
 
 	// Try to find a matching index for any of the filter expressions.
 	ComparisonExpressionMatcher matcher;
+
 	// Match on a comparison type.
 	matcher.expr_type = make_uniq<ComparisonExpressionTypeMatcher>();
+
 	// Match on a constant comparison with the indexed expression.
 	matcher.matchers.push_back(make_uniq<ExpressionEqualityMatcher>(expr));
 	matcher.matchers.push_back(make_uniq<ConstantExpressionMatcher>());
@@ -155,9 +157,9 @@ unique_ptr<IndexScanState> ART::TryInitializeScan(const Expression &expr, const
 		// 		bindings[2] = the constant
 		auto &comparison = bindings[0].get().Cast<BoundComparisonExpression>();
 		auto constant_value = bindings[2].get().Cast<BoundConstantExpression>().value;
-		auto comparison_type = comparison.type;
+		auto comparison_type = comparison.GetExpressionType();
 
-		if (comparison.left->type == ExpressionType::VALUE_CONSTANT) {
+		if (comparison.left->GetExpressionType() == ExpressionType::VALUE_CONSTANT) {
 			// The expression is on the right side, we flip the comparison expression.
 			comparison_type = FlipComparisonExpression(comparison_type);
 		}
@@ -176,15 +178,15 @@ unique_ptr<IndexScanState> ART::TryInitializeScan(const Expression &expr, const
 			high_comparison_type = comparison_type;
 		}
 
-	} else if (filter_expr.type == ExpressionType::COMPARE_BETWEEN) {
+	} else if (filter_expr.GetExpressionType() == ExpressionType::COMPARE_BETWEEN) {
 		auto &between = filter_expr.Cast<BoundBetweenExpression>();
 		if (!between.input->Equals(expr)) {
 			// The expression does not match the index expression.
 			return nullptr;
 		}
 
-		if (between.lower->type != ExpressionType::VALUE_CONSTANT ||
-		    between.upper->type != ExpressionType::VALUE_CONSTANT) {
+		if (between.lower->GetExpressionType() != ExpressionType::VALUE_CONSTANT ||
+		    between.upper->GetExpressionType() != ExpressionType::VALUE_CONSTANT) {
 			// Not a constant expression.
 			return nullptr;
 		}
@@ -477,32 +479,44 @@ bool ART::Construct(unsafe_vector<ARTKey> &keys, unsafe_vector<ARTKey> &row_ids,
 // Insert and Constraint Checking
 //===--------------------------------------------------------------------===//
 
-ErrorData ART::Insert(IndexLock &lock, DataChunk &input, Vector &row_ids) {
+ErrorData ART::Insert(IndexLock &l, DataChunk &chunk, Vector &row_ids) {
+	return Insert(l, chunk, row_ids, nullptr);
+}
+
+ErrorData ART::Insert(IndexLock &l, DataChunk &chunk, Vector &row_ids, optional_ptr<BoundIndex> delete_index) {
 	D_ASSERT(row_ids.GetType().InternalType() == ROW_TYPE);
-	auto row_count = input.size();
+	auto row_count = chunk.size();
 
 	ArenaAllocator allocator(BufferAllocator::Get(db));
 	unsafe_vector<ARTKey> keys(row_count);
 	unsafe_vector<ARTKey> row_id_keys(row_count);
-	GenerateKeyVectors(allocator, input, row_ids, keys, row_id_keys);
+	GenerateKeyVectors(allocator, chunk, row_ids, keys, row_id_keys);
 
-	// Insert the entries into the index.
-	idx_t failed_index = DConstants::INVALID_INDEX;
+	optional_ptr<ART> delete_art;
+	if (delete_index) {
+		delete_art = delete_index->Cast<ART>();
+	}
+
+	auto conflict_type = ARTConflictType::NO_CONFLICT;
+	optional_idx conflict_idx;
 	auto was_empty = !tree.HasMetadata();
+
+	// Insert the entries into the index.
 	for (idx_t i = 0; i < row_count; i++) {
 		if (keys[i].Empty()) {
 			continue;
 		}
-		if (!Insert(tree, keys[i], 0, row_id_keys[i], tree.GetGateStatus())) {
-			// Insertion failure due to a constraint violation.
-			failed_index = i;
+		conflict_type = Insert(tree, keys[i], 0, row_id_keys[i], tree.GetGateStatus(), delete_art);
+		if (conflict_type != ARTConflictType::NO_CONFLICT) {
+			conflict_idx = i;
 			break;
 		}
 	}
 
 	// Remove any previously inserted entries.
-	if (failed_index != DConstants::INVALID_INDEX) {
-		for (idx_t i = 0; i < failed_index; i++) {
+	if (conflict_type != ARTConflictType::NO_CONFLICT) {
+		D_ASSERT(conflict_idx.IsValid());
+		for (idx_t i = 0; i < conflict_idx.GetIndex(); i++) {
 			if (keys[i].Empty()) {
 				continue;
 			}
@@ -515,9 +529,14 @@ ErrorData ART::Insert(IndexLock &lock, DataChunk &input, Vector &row_ids) {
 		VerifyAllocationsInternal();
 	}
 
-	if (failed_index != DConstants::INVALID_INDEX) {
-		auto msg = AppendRowError(input, failed_index);
-		return ErrorData(ConstraintException("PRIMARY KEY or UNIQUE constraint violated: duplicate key \"%s\"", msg));
+	if (conflict_type == ARTConflictType::TRANSACTION) {
+		auto msg = AppendRowError(chunk, conflict_idx.GetIndex());
+		return ErrorData(TransactionException("write-write conflict on key: \"%s\"", msg));
+	}
+
+	if (conflict_type == ARTConflictType::CONSTRAINT) {
+		auto msg = AppendRowError(chunk, conflict_idx.GetIndex());
+		return ErrorData(ConstraintException("PRIMARY KEY or UNIQUE constraint violation: duplicate key \"%s\"", msg));
 	}
 
 #ifdef DEBUG
@@ -531,22 +550,34 @@ ErrorData ART::Insert(IndexLock &lock, DataChunk &input, Vector &row_ids) {
 	return ErrorData();
 }
 
-ErrorData ART::Append(IndexLock &lock, DataChunk &input, Vector &row_ids) {
+ErrorData ART::Append(IndexLock &l, DataChunk &chunk, Vector &row_ids) {
 	// Execute all column expressions before inserting the data chunk.
 	DataChunk expr_chunk;
 	expr_chunk.Initialize(Allocator::DefaultAllocator(), logical_types);
-	ExecuteExpressions(input, expr_chunk);
-	return Insert(lock, expr_chunk, row_ids);
+	ExecuteExpressions(chunk, expr_chunk);
+
+	// Now insert the data chunk.
+	return Insert(l, expr_chunk, row_ids, nullptr);
 }
 
-void ART::VerifyAppend(DataChunk &chunk) {
-	ConflictManager conflict_manager(VerifyExistenceType::APPEND, chunk.size());
-	CheckConstraintsForChunk(chunk, conflict_manager);
+ErrorData ART::AppendWithDeleteIndex(IndexLock &l, DataChunk &chunk, Vector &row_ids,
+                                     optional_ptr<BoundIndex> delete_index) {
+	// Execute all column expressions before inserting the data chunk.
+	DataChunk expr_chunk;
+	expr_chunk.Initialize(Allocator::DefaultAllocator(), logical_types);
+	ExecuteExpressions(chunk, expr_chunk);
+
+	// Now insert the data chunk.
+	return Insert(l, expr_chunk, row_ids, delete_index);
 }
 
-void ART::VerifyAppend(DataChunk &chunk, ConflictManager &conflict_manager) {
-	D_ASSERT(conflict_manager.LookupType() == VerifyExistenceType::APPEND);
-	CheckConstraintsForChunk(chunk, conflict_manager);
+void ART::VerifyAppend(DataChunk &chunk, optional_ptr<BoundIndex> delete_index, optional_ptr<ConflictManager> manager) {
+	if (manager) {
+		D_ASSERT(manager->LookupType() == VerifyExistenceType::APPEND);
+		return VerifyConstraint(chunk, delete_index, *manager);
+	}
+	ConflictManager local_manager(VerifyExistenceType::APPEND, chunk.size());
+	VerifyConstraint(chunk, delete_index, local_manager);
 }
 
 void ART::InsertIntoEmpty(Node &node, const ARTKey &key, const idx_t depth, const ARTKey &row_id,
@@ -566,26 +597,61 @@ void ART::InsertIntoEmpty(Node &node, const ARTKey &key, const idx_t depth, cons
 	Leaf::New(ref, row_id.GetRowId());
 }
 
-bool ART::InsertIntoNode(Node &node, const ARTKey &key, const idx_t depth, const ARTKey &row_id,
-                         const GateStatus status) {
+ARTConflictType ART::InsertIntoInlined(Node &node, const ARTKey &key, const idx_t depth, const ARTKey &row_id,
+                                       const GateStatus status, optional_ptr<ART> delete_art) {
+
+	if (!IsUnique() || append_mode == ARTAppendMode::INSERT_DUPLICATES) {
+		Leaf::InsertIntoInlined(*this, node, row_id, depth, status);
+		return ARTConflictType::NO_CONFLICT;
+	}
+
+	if (!delete_art) {
+		if (append_mode == ARTAppendMode::IGNORE_DUPLICATES) {
+			return ARTConflictType::NO_CONFLICT;
+		}
+		return ARTConflictType::CONSTRAINT;
+	}
+
+	// Lookup in the delete_art.
+	auto delete_leaf = delete_art->Lookup(delete_art->tree, key, 0);
+	if (!delete_leaf) {
+		return ARTConflictType::CONSTRAINT;
+	}
+
+	// The row ID has changed.
+	// Thus, the local index has a newer (local) row ID, and this is a constraint violation.
+	D_ASSERT(delete_leaf->GetType() == NType::LEAF_INLINED);
+	auto deleted_row_id = delete_leaf->GetRowId();
+	auto this_row_id = node.GetRowId();
+	if (deleted_row_id != this_row_id) {
+		return ARTConflictType::CONSTRAINT;
+	}
+
+	// The deleted key and its row ID match the current key and its row ID.
+	Leaf::InsertIntoInlined(*this, node, row_id, depth, status);
+	return ARTConflictType::NO_CONFLICT;
+}
+
+ARTConflictType ART::InsertIntoNode(Node &node, const ARTKey &key, const idx_t depth, const ARTKey &row_id,
+                                    const GateStatus status, optional_ptr<ART> delete_art) {
 	D_ASSERT(depth < key.len);
 	auto child = node.GetChildMutable(*this, key[depth]);
 
 	// Recurse, if a child exists at key[depth].
 	if (child) {
 		D_ASSERT(child->HasMetadata());
-		bool success = Insert(*child, key, depth + 1, row_id, status);
+		auto conflict_type = Insert(*child, key, depth + 1, row_id, status, delete_art);
 		node.ReplaceChild(*this, key[depth], *child);
-		return success;
+		return conflict_type;
 	}
 
 	// Create an inlined prefix at key[depth].
 	if (status == GateStatus::GATE_SET) {
 		Node remainder;
 		auto byte = key[depth];
-		auto success = Insert(remainder, key, depth + 1, row_id, status);
+		auto conflict_type = Insert(remainder, key, depth + 1, row_id, status, delete_art);
 		Node::InsertChild(*this, node, byte, remainder);
-		return success;
+		return conflict_type;
 	}
 
 	// Insert an inlined leaf at key[depth].
@@ -601,49 +667,56 @@ bool ART::InsertIntoNode(Node &node, const ARTKey &key, const idx_t depth, const
 	// Create the inlined leaf.
 	Leaf::New(ref, row_id.GetRowId());
 	Node::InsertChild(*this, node, key[depth], leaf);
-	return true;
+	return ARTConflictType::NO_CONFLICT;
 }
 
-bool ART::Insert(Node &node, const ARTKey &key, idx_t depth, const ARTKey &row_id, const GateStatus status) {
+ARTConflictType ART::Insert(Node &node, const ARTKey &key, idx_t depth, const ARTKey &row_id, const GateStatus status,
+                            optional_ptr<ART> delete_art) {
 	if (!node.HasMetadata()) {
 		InsertIntoEmpty(node, key, depth, row_id, status);
-		return true;
+		return ARTConflictType::NO_CONFLICT;
 	}
 
 	// Enter a nested leaf.
 	if (status == GateStatus::GATE_NOT_SET && node.GetGateStatus() == GateStatus::GATE_SET) {
-		return Insert(node, row_id, 0, row_id, GateStatus::GATE_SET);
+		if (IsUnique()) {
+			// Unique indexes can have duplicates, if another transaction DELETE + INSERT
+			// the same key. In that case, the previous value must be kept alive until all
+			// other transactions do not depend on it anymore.
+
+			// We restrict this transactionality to two-value leaves, so any subsequent
+			// incoming transaction must fail here.
+			return ARTConflictType::TRANSACTION;
+		}
+		return Insert(node, row_id, 0, row_id, GateStatus::GATE_SET, delete_art);
 	}
 
 	auto type = node.GetType();
 	switch (type) {
 	case NType::LEAF_INLINED: {
-		if (IsUnique()) {
-			return false;
-		}
-		Leaf::InsertIntoInlined(*this, node, row_id, depth, status);
-		return true;
+		return InsertIntoInlined(node, key, depth, row_id, status, delete_art);
 	}
 	case NType::LEAF: {
 		Leaf::TransformToNested(*this, node);
-		return Insert(node, key, depth, row_id, status);
+		return Insert(node, key, depth, row_id, status, delete_art);
 	}
 	case NType::NODE_7_LEAF:
 	case NType::NODE_15_LEAF:
 	case NType::NODE_256_LEAF: {
+		// Row IDs are unique, so there are never any duplicate byte conflicts here.
 		auto byte = key[Prefix::ROW_ID_COUNT];
 		Node::InsertChild(*this, node, byte);
-		return true;
+		return ARTConflictType::NO_CONFLICT;
 	}
 	case NType::NODE_4:
 	case NType::NODE_16:
 	case NType::NODE_48:
 	case NType::NODE_256:
-		return InsertIntoNode(node, key, depth, row_id, status);
+		return InsertIntoNode(node, key, depth, row_id, status, delete_art);
 	case NType::PREFIX:
-		return Prefix::Insert(*this, node, key, depth, row_id, status);
+		return Prefix::Insert(*this, node, key, depth, row_id, status, delete_art);
 	default:
-		throw InternalException("Invalid node type for Insert.");
+		throw InternalException("Invalid node type for ART::Insert.");
 	}
 }
 
@@ -953,11 +1026,7 @@ string ART::GenerateConstraintErrorMessage(VerifyExistenceType verify_type, cons
 	case VerifyExistenceType::APPEND: {
 		// APPEND to PK/UNIQUE table, but node/key already exists in PK/UNIQUE table.
 		string type = IsPrimary() ? "primary key" : "unique";
-		return StringUtil::Format("Duplicate key \"%s\" violates %s constraint. "
-		                          "If this is an unexpected constraint violation please double "
-		                          "check with the known index limitations section in our documentation "
-		                          "(https://duckdb.org/docs/sql/indexes).",
-		                          key_name, type);
+		return StringUtil::Format("Duplicate key \"%s\" violates %s constraint.", key_name, type);
 	}
 	case VerifyExistenceType::APPEND_FK: {
 		// APPEND_FK to FK table, node/key does not exist in PK/UNIQUE table.
@@ -975,50 +1044,117 @@ string ART::GenerateConstraintErrorMessage(VerifyExistenceType verify_type, cons
 	}
 }
 
-void ART::CheckConstraintsForChunk(DataChunk &input, ConflictManager &conflict_manager) {
+void ART::VerifyLeaf(const Node &leaf, const ARTKey &key, optional_ptr<ART> delete_art, ConflictManager &manager,
+                     optional_idx &conflict_idx, idx_t i) {
+	// Fast path, the leaf is inlined, and the delete ART does not exist.
+	if (leaf.GetType() == NType::LEAF_INLINED && !delete_art) {
+		if (manager.AddHit(i, leaf.GetRowId())) {
+			conflict_idx = i;
+		}
+		return;
+	}
+
+	// Get the delete_leaf.
+	// All leaves in the delete ART are inlined.
+	auto deleted_leaf = delete_art->Lookup(delete_art->tree, key, 0);
+
+	// The leaf is inlined, and the same key does not exist in the delete ART.
+	if (leaf.GetType() == NType::LEAF_INLINED && !deleted_leaf) {
+		if (manager.AddHit(i, leaf.GetRowId())) {
+			conflict_idx = i;
+		}
+		return;
+	}
+
+	// The leaf is inlined, and the same key exists in the delete ART.
+	if (leaf.GetType() == NType::LEAF_INLINED && deleted_leaf) {
+		auto deleted_row_id = deleted_leaf->GetRowId();
+		auto this_row_id = leaf.GetRowId();
+
+		if (deleted_row_id == this_row_id) {
+			if (manager.AddMiss(i)) {
+				conflict_idx = i;
+			}
+			return;
+		}
+
+		if (manager.AddHit(i, this_row_id)) {
+			conflict_idx = i;
+		}
+		return;
+	}
+
+	// Scan the two row IDs in the leaf.
+	Iterator it(*this);
+	it.FindMinimum(leaf);
+	ARTKey empty_key = ARTKey();
+	unsafe_vector<row_t> row_ids;
+	it.Scan(empty_key, 2, row_ids, false);
+
+	if (!deleted_leaf) {
+		if (manager.AddHit(i, row_ids[0]) || manager.AddHit(i, row_ids[0])) {
+			conflict_idx = i;
+		}
+		return;
+	}
+
+	auto deleted_row_id = deleted_leaf->GetRowId();
+
+	if (deleted_row_id == row_ids[0] || deleted_row_id == row_ids[1]) {
+		if (manager.AddMiss(i)) {
+			conflict_idx = i;
+		}
+		return;
+	}
+
+	if (manager.AddHit(i, row_ids[0]) || manager.AddHit(i, row_ids[1])) {
+		conflict_idx = i;
+	}
+}
+
+void ART::VerifyConstraint(DataChunk &chunk, optional_ptr<BoundIndex> delete_index, ConflictManager &manager) {
 	// Lock the index during constraint checking.
 	lock_guard<mutex> l(lock);
 
 	DataChunk expr_chunk;
 	expr_chunk.Initialize(Allocator::DefaultAllocator(), logical_types);
-	ExecuteExpressions(input, expr_chunk);
+	ExecuteExpressions(chunk, expr_chunk);
 
 	ArenaAllocator arena_allocator(BufferAllocator::Get(db));
 	unsafe_vector<ARTKey> keys(expr_chunk.size());
 	GenerateKeys<>(arena_allocator, expr_chunk, keys);
 
-	auto found_conflict = DConstants::INVALID_INDEX;
-	for (idx_t i = 0; found_conflict == DConstants::INVALID_INDEX && i < input.size(); i++) {
+	optional_ptr<ART> delete_art;
+	if (delete_index) {
+		delete_art = delete_index->Cast<ART>();
+	}
+
+	optional_idx conflict_idx;
+	for (idx_t i = 0; !conflict_idx.IsValid() && i < chunk.size(); i++) {
 		if (keys[i].Empty()) {
-			if (conflict_manager.AddNull(i)) {
-				found_conflict = i;
+			if (manager.AddNull(i)) {
+				conflict_idx = i;
 			}
 			continue;
 		}
 
 		auto leaf = Lookup(tree, keys[i], 0);
 		if (!leaf) {
-			if (conflict_manager.AddMiss(i)) {
-				found_conflict = i;
+			if (manager.AddMiss(i)) {
+				conflict_idx = i;
 			}
 			continue;
 		}
-
-		// If we find a node, we need to update the 'matches' and 'row_ids'.
-		// We only perform constraint checking on unique indexes, i.e., all leaves are inlined.
-		D_ASSERT(leaf->GetType() == NType::LEAF_INLINED);
-		if (conflict_manager.AddHit(i, leaf->GetRowId())) {
-			found_conflict = i;
-		}
+		VerifyLeaf(*leaf, keys[i], delete_art, manager, conflict_idx, i);
 	}
 
-	conflict_manager.FinishLookup();
-	if (found_conflict == DConstants::INVALID_INDEX) {
+	manager.FinishLookup();
+	if (!conflict_idx.IsValid()) {
 		return;
 	}
 
-	auto key_name = GenerateErrorKeyName(input, found_conflict);
-	auto exception_msg = GenerateConstraintErrorMessage(conflict_manager.LookupType(), key_name);
+	auto key_name = GenerateErrorKeyName(chunk, conflict_idx.GetIndex());
+	auto exception_msg = GenerateConstraintErrorMessage(manager.LookupType(), key_name);
 	throw ConstraintException(exception_msg);
 }
 

package/src/duckdb/src/execution/index/art/base_leaf.cpp

@@ -154,7 +154,7 @@ void Node15Leaf::ShrinkNode256Leaf(ART &art, Node &node15_leaf, Node &node256_le
 	auto &n256 = Node::Ref<Node256Leaf>(art, node256_leaf, NType::NODE_256_LEAF);
 	node15_leaf.SetGateStatus(node256_leaf.GetGateStatus());
 
-	ValidityMask mask(&n256.mask[0]);
+	ValidityMask mask(&n256.mask[0], Node256::CAPACITY);
 	for (uint16_t i = 0; i < Node256::CAPACITY; i++) {
 		if (mask.RowIsValid(i)) {
 			n15.key[n15.count] = UnsafeNumericCast<uint8_t>(i);