duckdb 0.8.1-dev96.0 → 0.8.1

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

@@ -69,6 +69,9 @@ void Node::Free(ART &art, Node &node) {
 
 		// free the prefixes and children of the nodes
 		switch (type) {
+		case NType::LEAF_SEGMENT:
+			LeafSegment::Free(art, node);
+			break;
 		case NType::LEAF:
 			Leaf::Free(art, node);
 			break;
@@ -159,65 +162,57 @@ void Node::DeleteChild(ART &art, Node &node, const uint8_t byte) {
 
 optional_ptr<Node> Node::GetChild(ART &art, const uint8_t byte) const {
 
-	D_ASSERT(!IsSwizzled());
+	D_ASSERT(IsSet() && !IsSwizzled());
 
 	optional_ptr<Node> child;
 	switch (DecodeARTNodeType()) {
-	case NType::NODE_4: {
+	case NType::NODE_4:
 		child = Node4::Get(art, *this).GetChild(byte);
 		break;
-	}
-	case NType::NODE_16: {
+	case NType::NODE_16:
 		child = Node16::Get(art, *this).GetChild(byte);
 		break;
-	}
-	case NType::NODE_48: {
+	case NType::NODE_48:
 		child = Node48::Get(art, *this).GetChild(byte);
 		break;
-	}
-	case NType::NODE_256: {
+	case NType::NODE_256:
 		child = Node256::Get(art, *this).GetChild(byte);
 		break;
-	}
 	default:
 		throw InternalException("Invalid node type for GetChild.");
 	}
 
-	// unswizzle the ART node before returning it
+	// deserialize the ART node before returning it
 	if (child && child->IsSwizzled()) {
 		child->Deserialize(art);
 	}
 	return child;
 }
 
-optional_ptr<Node> Node::GetNextChild(ART &art, uint8_t &byte) const {
+optional_ptr<Node> Node::GetNextChild(ART &art, uint8_t &byte, const bool deserialize) const {
 
-	D_ASSERT(!IsSwizzled());
+	D_ASSERT(IsSet() && !IsSwizzled());
 
 	optional_ptr<Node> child;
 	switch (DecodeARTNodeType()) {
-	case NType::NODE_4: {
+	case NType::NODE_4:
 		child = Node4::Get(art, *this).GetNextChild(byte);
 		break;
-	}
-	case NType::NODE_16: {
+	case NType::NODE_16:
 		child = Node16::Get(art, *this).GetNextChild(byte);
 		break;
-	}
-	case NType::NODE_48: {
+	case NType::NODE_48:
 		child = Node48::Get(art, *this).GetNextChild(byte);
 		break;
-	}
-	case NType::NODE_256: {
+	case NType::NODE_256:
 		child = Node256::Get(art, *this).GetNextChild(byte);
 		break;
-	}
 	default:
 		throw InternalException("Invalid node type for GetNextChild.");
 	}
 
-	// unswizzle the ART node before returning it
-	if (child && child->IsSwizzled()) {
+	// deserialize the ART node before returning it
+	if (child && deserialize && child->IsSwizzled()) {
 		child->Deserialize(art);
 	}
 	return child;
@@ -260,10 +255,11 @@ void Node::Deserialize(ART &art) {
 	type = reader.Read<uint8_t>();
 	swizzle_flag = 0;
 
-	auto type = DecodeARTNodeType();
-	SetPtr(Node::GetAllocator(art, type).New());
+	auto decoded_type = DecodeARTNodeType();
+	SetPtr(Node::GetAllocator(art, decoded_type).New());
+	type = (uint8_t)decoded_type;
 
-	switch (type) {
+	switch (decoded_type) {
 	case NType::LEAF:
 		return Leaf::Get(art, *this).Deserialize(art, reader);
 	case NType::NODE_4:
@@ -283,28 +279,44 @@ void Node::Deserialize(ART &art) {
 // Utility
 //===--------------------------------------------------------------------===//
 
-string Node::ToString(ART &art) const {
+string Node::VerifyAndToString(ART &art, const bool only_verify) {
 
-	D_ASSERT(!IsSwizzled());
+	D_ASSERT(IsSet());
+	if (IsSwizzled()) {
+		return only_verify ? "" : "swizzled";
+	}
 
-	if (DecodeARTNodeType() == NType::LEAF) {
-		return Leaf::Get(art, *this).ToString(art);
+	auto type = DecodeARTNodeType();
+	if (type == NType::LEAF) {
+		auto str = Leaf::Get(art, *this).VerifyAndToString(art, only_verify);
+		return only_verify ? "" : "\n" + str;
 	}
 
 	string str = "Node" + to_string(GetCapacity()) + ": [";
 
+	idx_t child_count = 0;
 	uint8_t byte = 0;
-	auto child = GetNextChild(art, byte);
+	auto child = GetNextChild(art, byte, false);
 	while (child) {
-		str += "(" + to_string(byte) + ", " + child->ToString(art) + ")";
-		if (byte == NumericLimits<uint8_t>::Maximum()) {
-			break;
+		child_count++;
+		if (child->IsSwizzled()) {
+			if (!only_verify) {
+				str += "(swizzled)";
+			}
+		} else {
+			str += "(" + to_string(byte) + ", " + child->VerifyAndToString(art, only_verify) + ")";
+			if (byte == NumericLimits<uint8_t>::Maximum()) {
+				break;
+			}
 		}
 		byte++;
-		child = GetNextChild(art, byte);
+		child = GetNextChild(art, byte, false);
 	}
 
-	return str + "]";
+	(void)child_count;
+	// ensure that the child count is at least two
+	D_ASSERT(child_count > 1);
+	return only_verify ? "" : "\n" + str + "]";
 }
 
 idx_t Node::GetCapacity() const {
@@ -567,6 +579,7 @@ void Node::Vacuum(ART &art, Node &node, const ARTFlags &flags) {
 	needs_vacuum = flags.vacuum_flags[node.type - 1] && allocator.NeedsVacuum(node);
 	if (needs_vacuum) {
 		node.SetPtr(allocator.VacuumPointer(node));
+		node.type = (uint8_t)type;
 	}
 
 	switch (type) {

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

@@ -60,6 +60,7 @@ Node16 &Node16::ShrinkNode48(ART &art, Node &node16, Node &node48) {
 	n16.prefix.Move(n48.prefix);
 
 	for (idx_t i = 0; i < Node::NODE_256_CAPACITY; i++) {
+		D_ASSERT(n16.count <= Node::NODE_16_CAPACITY);
 		if (n48.child_index[i] != Node::EMPTY_MARKER) {
 			n16.key[n16.count] = i;
 			n16.children[n16.count] = n48.children[n48.child_index[i]];
@@ -160,6 +161,7 @@ optional_ptr<Node> Node16::GetChild(const uint8_t byte) {
 
 	for (idx_t i = 0; i < count; i++) {
 		if (key[i] == byte) {
+			D_ASSERT(children[i].IsSet());
 			return &children[i];
 		}
 	}
@@ -171,6 +173,7 @@ optional_ptr<Node> Node16::GetNextChild(uint8_t &byte) {
 	for (idx_t i = 0; i < count; i++) {
 		if (key[i] >= byte) {
 			byte = key[i];
+			D_ASSERT(children[i].IsSet());
 			return &children[i];
 		}
 	}

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

@@ -83,6 +83,7 @@ void Node256::InsertChild(ART &art, Node &node, const uint8_t byte, const Node c
 	D_ASSERT(!n256.children[byte].IsSet());
 
 	n256.count++;
+	D_ASSERT(n256.count <= Node::NODE_256_CAPACITY);
 	n256.children[byte] = child;
 }
 

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

@@ -37,6 +37,7 @@ Node4 &Node4::ShrinkNode16(ART &art, Node &node4, Node &node16) {
 	auto &n4 = Node4::New(art, node4);
 	auto &n16 = Node16::Get(art, node16);
 
+	D_ASSERT(n16.count <= Node::NODE_4_CAPACITY);
 	n4.count = n16.count;
 	n4.prefix.Move(n16.prefix);
 
@@ -145,6 +146,7 @@ optional_ptr<Node> Node4::GetChild(const uint8_t byte) {
 
 	for (idx_t i = 0; i < count; i++) {
 		if (key[i] == byte) {
+			D_ASSERT(children[i].IsSet());
 			return &children[i];
 		}
 	}
@@ -156,6 +158,7 @@ optional_ptr<Node> Node4::GetNextChild(uint8_t &byte) {
 	for (idx_t i = 0; i < count; i++) {
 		if (key[i] >= byte) {
 			byte = key[i];
+			D_ASSERT(children[i].IsSet());
 			return &children[i];
 		}
 	}

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

@@ -85,6 +85,7 @@ Node48 &Node48::ShrinkNode256(ART &art, Node &node48, Node &node256) {
 	n48.prefix.Move(n256.prefix);
 
 	for (idx_t i = 0; i < Node::NODE_256_CAPACITY; i++) {
+		D_ASSERT(n48.count <= Node::NODE_48_CAPACITY);
 		if (n256.children[i].IsSet()) {
 			n48.child_index[i] = n48.count;
 			n48.children[n48.count] = n256.children[i];
@@ -168,6 +169,7 @@ optional_ptr<Node> Node48::GetNextChild(uint8_t &byte) {
 	for (idx_t i = byte; i < Node::NODE_256_CAPACITY; i++) {
 		if (child_index[i] != Node::EMPTY_MARKER) {
 			byte = i;
+			D_ASSERT(children[child_index[i]].IsSet());
 			return &children[child_index[i]];
 		}
 	}

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

@@ -427,6 +427,7 @@ void Prefix::Vacuum(ART &art) {
 	auto &allocator = Node::GetAllocator(art, NType::PREFIX_SEGMENT);
 	if (allocator.NeedsVacuum(data.ptr)) {
 		data.ptr.SetPtr(allocator.VacuumPointer(data.ptr));
+		data.ptr.type = (uint8_t)NType::PREFIX_SEGMENT;
 	}
 
 	auto ptr = data.ptr;
@@ -435,6 +436,7 @@ void Prefix::Vacuum(ART &art) {
 		ptr = segment.next;
 		if (ptr.IsSet() && allocator.NeedsVacuum(ptr)) {
 			segment.next.SetPtr(allocator.VacuumPointer(ptr));
+			segment.next.type = (uint8_t)NType::PREFIX_SEGMENT;
 			ptr = segment.next;
 		}
 	}

package/src/duckdb/src/execution/join_hashtable.cpp

@@ -627,6 +627,8 @@ void ScanStructure::NextMarkJoin(DataChunk &keys, DataChunk &input, DataChunk &r
 		ConstructMarkJoinResult(keys, input, result);
 	} else {
 		auto &info = ht.correlated_mark_join_info;
+		lock_guard<mutex> mj_lock(info.mj_lock);
+
 		// there are correlated columns
 		// first we fetch the counts from the aggregate hashtable corresponding to these entries
 		D_ASSERT(keys.ColumnCount() == info.group_chunk.ColumnCount() + 1);

package/src/duckdb/src/execution/operator/aggregate/physical_window.cpp

@@ -1,7 +1,9 @@
 #include "duckdb/execution/operator/aggregate/physical_window.hpp"
 
+#include "duckdb/common/operator/add.hpp"
 #include "duckdb/common/operator/cast_operators.hpp"
 #include "duckdb/common/operator/comparison_operators.hpp"
+#include "duckdb/common/operator/subtract.hpp"
 #include "duckdb/common/optional_ptr.hpp"
 #include "duckdb/common/radix_partitioning.hpp"
 #include "duckdb/common/row_operations/row_operations.hpp"
@@ -224,12 +226,14 @@ struct WindowInputColumn {
 	}
 
 	void Append(DataChunk &input_chunk) {
-		if (input_expr.expr && (!input_expr.scalar || !count)) {
-			input_expr.Execute(input_chunk);
-			auto &source = input_expr.chunk.data[0];
-			const auto source_count = input_expr.chunk.size();
+		if (input_expr.expr) {
+			const auto source_count = input_chunk.size();
 			D_ASSERT(count + source_count <= capacity);
-			VectorOperations::Copy(source, *target, source_count, 0, count);
+			if (!input_expr.scalar || !count) {
+				input_expr.Execute(input_chunk);
+				auto &source = input_expr.chunk.data[0];
+				VectorOperations::Copy(source, *target, source_count, 0, count);
+			}
 			count += source_count;
 		}
 	}
@@ -527,11 +531,17 @@ void WindowBoundariesState::Update(const idx_t row_idx, WindowInputColumn &range
 		bounds.window_start = bounds.peer_start;
 		break;
 	case WindowBoundary::EXPR_PRECEDING_ROWS: {
-		bounds.window_start = (int64_t)row_idx - boundary_start.GetCell<int64_t>(expr_idx);
+		if (!TrySubtractOperator::Operation(int64_t(row_idx), boundary_start.GetCell<int64_t>(expr_idx),
+		                                    bounds.window_start)) {
+			throw OutOfRangeException("Overflow computing ROWS PRECEDING start");
+		}
 		break;
 	}
 	case WindowBoundary::EXPR_FOLLOWING_ROWS: {
-		bounds.window_start = row_idx + boundary_start.GetCell<int64_t>(expr_idx);
+		if (!TryAddOperator::Operation(int64_t(row_idx), boundary_start.GetCell<int64_t>(expr_idx),
+		                               bounds.window_start)) {
+			throw OutOfRangeException("Overflow computing ROWS FOLLOWING start");
+		}
 		break;
 	}
 	case WindowBoundary::EXPR_PRECEDING_RANGE: {
@@ -567,10 +577,16 @@ void WindowBoundariesState::Update(const idx_t row_idx, WindowInputColumn &range
 		bounds.window_end = bounds.partition_end;
 		break;
 	case WindowBoundary::EXPR_PRECEDING_ROWS:
-		bounds.window_end = (int64_t)row_idx - boundary_end.GetCell<int64_t>(expr_idx) + 1;
+		if (!TrySubtractOperator::Operation(int64_t(row_idx + 1), boundary_end.GetCell<int64_t>(expr_idx),
+		                                    bounds.window_end)) {
+			throw OutOfRangeException("Overflow computing ROWS PRECEDING end");
+		}
 		break;
 	case WindowBoundary::EXPR_FOLLOWING_ROWS:
-		bounds.window_end = row_idx + boundary_end.GetCell<int64_t>(expr_idx) + 1;
+		if (!TryAddOperator::Operation(int64_t(row_idx + 1), boundary_end.GetCell<int64_t>(expr_idx),
+		                               bounds.window_end)) {
+			throw OutOfRangeException("Overflow computing ROWS FOLLOWING end");
+		}
 		break;
 	case WindowBoundary::EXPR_PRECEDING_RANGE: {
 		if (boundary_end.CellIsNull(expr_idx)) {
@@ -1254,6 +1270,7 @@ void WindowLocalSourceState::GeneratePartition(WindowGlobalSinkState &gstate, co
 		// Overwrite the collections with the sorted data
 		hash_group = std::move(gsink.hash_groups[hash_bin]);
 		hash_group->ComputeMasks(partition_mask, order_mask);
+		external = hash_group->global_sort->external;
 		MaterializeSortedData();
 	} else {
 		return;

package/src/duckdb/src/execution/operator/helper/physical_reset.cpp

@@ -20,10 +20,14 @@ void PhysicalReset::ResetExtensionVariable(ExecutionContext &context, DBConfig &
 }
 
 SourceResultType PhysicalReset::GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const {
+	auto &config = DBConfig::GetConfig(context.client);
+	if (config.options.lock_configuration) {
+		throw InvalidInputException("Cannot reset configuration option \"%s\" - the configuration has been locked",
+		                            name);
+	}
 	auto option = DBConfig::GetOptionByName(name);
 	if (!option) {
 		// check if this is an extra extension variable
-		auto &config = DBConfig::GetConfig(context.client);
 		auto entry = config.extension_parameters.find(name);
 		if (entry == config.extension_parameters.end()) {
 			throw Catalog::UnrecognizedConfigurationError(context.client, name);
@@ -49,7 +53,6 @@ SourceResultType PhysicalReset::GetData(ExecutionContext &context, DataChunk &ch
 			throw CatalogException("option \"%s\" cannot be reset globally", name);
 		}
 		auto &db = DatabaseInstance::GetDatabase(context.client);
-		auto &config = DBConfig::GetConfig(context.client);
 		config.ResetOption(&db, *option);
 		break;
 	}

package/src/duckdb/src/execution/operator/helper/physical_set.cpp

@@ -23,10 +23,14 @@ void PhysicalSet::SetExtensionVariable(ClientContext &context, ExtensionOption &
 }
 
 SourceResultType PhysicalSet::GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const {
+	auto &config = DBConfig::GetConfig(context.client);
+	if (config.options.lock_configuration) {
+		throw InvalidInputException("Cannot change configuration option \"%s\" - the configuration has been locked",
+		                            name);
+	}
 	auto option = DBConfig::GetOptionByName(name);
 	if (!option) {
 		// check if this is an extra extension variable
-		auto &config = DBConfig::GetConfig(context.client);
 		auto entry = config.extension_parameters.find(name);
 		if (entry == config.extension_parameters.end()) {
 			throw Catalog::UnrecognizedConfigurationError(context.client, name);

package/src/duckdb/src/execution/operator/join/physical_iejoin.cpp

@@ -1016,19 +1016,16 @@ void PhysicalIEJoin::BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeli
 
 	// Create one child meta pipeline that will hold the LHS and RHS pipelines
 	auto &child_meta_pipeline = meta_pipeline.CreateChildMetaPipeline(current, *this);
-	auto lhs_pipeline = child_meta_pipeline.GetBasePipeline();
-	auto rhs_pipeline = child_meta_pipeline.CreatePipeline();
 
 	// Build out LHS
+	auto lhs_pipeline = child_meta_pipeline.GetBasePipeline();
 	children[0]->BuildPipelines(*lhs_pipeline, child_meta_pipeline);
 
-	// RHS depends on everything in LHS
-	child_meta_pipeline.AddDependenciesFrom(rhs_pipeline, lhs_pipeline.get(), true);
-
 	// Build out RHS
+	auto rhs_pipeline = child_meta_pipeline.CreatePipeline();
 	children[1]->BuildPipelines(*rhs_pipeline, child_meta_pipeline);
 
-	// Despite having the same sink, RHS needs its own PipelineFinishEvent
+	// Despite having the same sink, RHS and everything created after it need their own (same) PipelineFinishEvent
 	child_meta_pipeline.AddFinishEvent(rhs_pipeline);
 }
 

package/src/duckdb/src/execution/operator/projection/physical_tableinout_function.cpp

@@ -70,6 +70,7 @@ OperatorResultType PhysicalTableInOutFunction::Execute(ExecutionContext &context
 			return OperatorResultType::NEED_MORE_INPUT;
 		}
 		// we are processing a new row: fetch the data for the current row
+		state.input_chunk.Reset();
 		D_ASSERT(input.ColumnCount() == state.input_chunk.ColumnCount());
 		// set up the input data to the table in-out function
 		for (idx_t col_idx = 0; col_idx < input.ColumnCount(); col_idx++) {

package/src/duckdb/src/execution/operator/projection/physical_unnest.cpp

@@ -65,8 +65,8 @@ void UnnestOperatorState::SetLongestListLength() {
 		if (vector_data.validity.RowIsValid(current_idx)) {
 
 			// check if this list is longer
-			auto list_data = UnifiedVectorFormat::GetData<list_entry_t>(vector_data);
-			auto list_entry = list_data[current_idx];
+			auto list_data_entries = UnifiedVectorFormat::GetData<list_entry_t>(vector_data);
+			auto list_entry = list_data_entries[current_idx];
 			if (list_entry.length > longest_list_length) {
 				longest_list_length = list_entry.length;
 			}
@@ -259,6 +259,11 @@ OperatorResultType PhysicalUnnest::ExecuteInternal(ExecutionContext &context, Da
 	auto &state = state_p.Cast<UnnestOperatorState>();
 
 	do {
+		// reset validities, if previous loop iteration contained UNNEST(NULL)
+		if (include_input) {
+			chunk.Reset();
+		}
+
 		// prepare the input data by executing any expressions and getting the
 		// UnifiedVectorFormat of each LIST vector (list_vector_data) and its child vector (list_child_data)
 		if (state.first_fetch) {
@@ -271,7 +276,7 @@ OperatorResultType PhysicalUnnest::ExecuteInternal(ExecutionContext &context, Da
 			return OperatorResultType::NEED_MORE_INPUT;
 		}
 
-		// each UNNEST in the select_list contains a list (or NULL) for this row, find longest list
+		// each UNNEST in the select_list contains a list (or NULL) for this row, find the longest list
 		// because this length determines how many times we need to repeat for the current row
 		if (state.longest_list_length == DConstants::INVALID_INDEX) {
 			state.SetLongestListLength();

package/src/duckdb/src/execution/operator/schema/physical_attach.cpp

@@ -14,7 +14,6 @@ namespace duckdb {
 //===--------------------------------------------------------------------===//
 // Source
 //===--------------------------------------------------------------------===//
-
 SourceResultType PhysicalAttach::GetData(ExecutionContext &context, DataChunk &chunk,
                                          OperatorSourceInput &input) const {
 	// parse the options

package/src/duckdb/src/execution/operator/schema/physical_create_index.cpp

@@ -7,6 +7,8 @@
 #include "duckdb/storage/storage_manager.hpp"
 #include "duckdb/main/database_manager.hpp"
 #include "duckdb/execution/index/art/art_key.hpp"
+#include "duckdb/execution/index/art/node.hpp"
+#include "duckdb/execution/index/art/leaf.hpp"
 
 namespace duckdb {
 
@@ -106,6 +108,28 @@ SinkResultType PhysicalCreateIndex::Sink(ExecutionContext &context, DataChunk &c
 	if (!lstate.local_index->MergeIndexes(*art)) {
 		throw ConstraintException("Data contains duplicates on indexed column(s)");
 	}
+
+#ifdef DEBUG
+	// ensure that all row IDs of this chunk exist in the ART
+	auto row_ids = FlatVector::GetData<row_t>(row_identifiers);
+	for (idx_t i = 0; i < lstate.key_chunk.size(); i++) {
+		auto leaf_node =
+		    lstate.local_index->Cast<ART>().Lookup(*lstate.local_index->Cast<ART>().tree, lstate.keys[i], 0);
+		D_ASSERT(leaf_node.IsSet());
+		auto &leaf = Leaf::Get(lstate.local_index->Cast<ART>(), leaf_node);
+
+		if (leaf.IsInlined()) {
+			D_ASSERT(row_ids[i] == leaf.row_ids.inlined);
+			continue;
+		}
+
+		D_ASSERT(leaf.row_ids.ptr.IsSet());
+		Node leaf_segment = leaf.row_ids.ptr;
+		auto position = leaf.FindRowId(lstate.local_index->Cast<ART>(), leaf_segment, row_ids[i]);
+		D_ASSERT(position != (uint32_t)DConstants::INVALID_INDEX);
+	}
+#endif
+
 	return SinkResultType::NEED_MORE_INPUT;
 }
 
@@ -119,6 +143,9 @@ void PhysicalCreateIndex::Combine(ExecutionContext &context, GlobalSinkState &gs
 	if (!gstate.global_index->MergeIndexes(*lstate.local_index)) {
 		throw ConstraintException("Data contains duplicates on indexed column(s)");
 	}
+
+	// vacuum excess memory
+	gstate.global_index->Vacuum();
 }
 
 SinkFinalizeType PhysicalCreateIndex::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
@@ -127,6 +154,8 @@ SinkFinalizeType PhysicalCreateIndex::Finalize(Pipeline &pipeline, Event &event,
 	// here, we just set the resulting global index as the newly created index of the table
 
 	auto &state = gstate_p.Cast<CreateIndexGlobalSinkState>();
+	D_ASSERT(!state.global_index->VerifyAndToString(true).empty());
+
 	auto &storage = table.GetStorage();
 	if (!storage.IsRoot()) {
 		throw TransactionException("Transaction conflict: cannot add an index to a table that has been altered!");
@@ -147,9 +176,6 @@ SinkFinalizeType PhysicalCreateIndex::Finalize(Pipeline &pipeline, Event &event,
 		index.parsed_expressions.push_back(parsed_expr->Copy());
 	}
 
-	// vacuum excess memory
-	state.global_index->Vacuum();
-
 	// add index to storage
 	storage.info->indexes.AddIndex(std::move(state.global_index));
 	return SinkFinalizeType::READY;

package/src/duckdb/src/execution/reservoir_sample.cpp

@@ -104,10 +104,24 @@ void ReservoirSamplePercentage::AddToReservoir(DataChunk &input) {
 		idx_t append_to_next_sample = input.size() - append_to_current_sample_count;
 		if (append_to_current_sample_count > 0) {
 			// we have elements remaining, first add them to the current sample
-			input.Flatten();
-
-			input.SetCardinality(append_to_current_sample_count);
-			current_sample->AddToReservoir(input);
+			if (append_to_next_sample > 0) {
+				// we need to also add to the next sample
+				DataChunk new_chunk;
+				new_chunk.Initialize(allocator, input.GetTypes());
+				SelectionVector sel(append_to_current_sample_count);
+				for (idx_t r = 0; r < append_to_current_sample_count; r++) {
+					sel.set_index(r, r);
+				}
+				new_chunk.Slice(sel, append_to_current_sample_count);
+				new_chunk.Flatten();
+
+				current_sample->AddToReservoir(new_chunk);
+			} else {
+				input.Flatten();
+
+				input.SetCardinality(append_to_current_sample_count);
+				current_sample->AddToReservoir(input);
+			}
 		}
 		if (append_to_next_sample > 0) {
 			// slice the input for the remainder