duckdb 0.8.1-dev96.0 → 0.8.1

package/src/duckdb/src/core_functions/aggregate/regression/regr_sxx_syy.cpp

@@ -16,30 +16,29 @@ struct RegrSState {
 
 struct RegrBaseOperation {
 	template <class STATE>
-	static void Initialize(STATE *state) {
-		RegrCountFunction::Initialize<size_t>(&state->count);
-		STDDevBaseOperation::Initialize<StddevState>(&state->var_pop);
+	static void Initialize(STATE &state) {
+		RegrCountFunction::Initialize<size_t>(state.count);
+		STDDevBaseOperation::Initialize<StddevState>(state.var_pop);
 	}
 
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &aggr_input_data) {
-		RegrCountFunction::Combine<size_t, OP>(source.count, &target->count, aggr_input_data);
-		STDDevBaseOperation::Combine<StddevState, OP>(source.var_pop, &target->var_pop, aggr_input_data);
+	static void Combine(const STATE &source, STATE &target, AggregateInputData &aggr_input_data) {
+		RegrCountFunction::Combine<size_t, OP>(source.count, target.count, aggr_input_data);
+		STDDevBaseOperation::Combine<StddevState, OP>(source.var_pop, target.var_pop, aggr_input_data);
 	}
 
 	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &aggr_input_data, STATE *state, T *target,
-	                     ValidityMask &mask, idx_t idx) {
-		if (state->var_pop.count == 0) {
-			mask.SetInvalid(idx);
+	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
+		if (state.var_pop.count == 0) {
+			finalize_data.ReturnNull();
 			return;
 		}
-		auto var_pop = state->var_pop.count > 1 ? (state->var_pop.dsquared / state->var_pop.count) : 0;
+		auto var_pop = state.var_pop.count > 1 ? (state.var_pop.dsquared / state.var_pop.count) : 0;
 		if (!Value::DoubleIsFinite(var_pop)) {
 			throw OutOfRangeException("VARPOP is out of range!");
 		}
-		RegrCountFunction::Finalize<T, size_t>(result, aggr_input_data, &state->count, target, mask, idx);
-		target[idx] *= var_pop;
+		RegrCountFunction::Finalize<T, size_t>(state.count, target, finalize_data);
+		target *= var_pop;
 	}
 
 	static bool IgnoreNull() {
@@ -49,21 +48,17 @@ struct RegrBaseOperation {
 
 struct RegrSXXOperation : RegrBaseOperation {
 	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &aggr_input_data, const A_TYPE *x_data, const B_TYPE *y_data,
-	                      ValidityMask &amask, ValidityMask &bmask, idx_t xidx, idx_t yidx) {
-		RegrCountFunction::Operation<A_TYPE, B_TYPE, size_t, OP>(&state->count, aggr_input_data, y_data, x_data, bmask,
-		                                                         amask, yidx, xidx);
-		STDDevBaseOperation::Operation<A_TYPE, StddevState, OP>(&state->var_pop, aggr_input_data, y_data, bmask, yidx);
+	static void Operation(STATE &state, const A_TYPE &x, const B_TYPE &y, AggregateBinaryInput &idata) {
+		RegrCountFunction::Operation<A_TYPE, B_TYPE, size_t, OP>(state.count, x, y, idata);
+		STDDevBaseOperation::Execute<A_TYPE, StddevState>(state.var_pop, y);
 	}
 };
 
 struct RegrSYYOperation : RegrBaseOperation {
 	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &aggr_input_data, const A_TYPE *x_data, const B_TYPE *y_data,
-	                      ValidityMask &amask, ValidityMask &bmask, idx_t xidx, idx_t yidx) {
-		RegrCountFunction::Operation<A_TYPE, B_TYPE, size_t, OP>(&state->count, aggr_input_data, y_data, x_data, bmask,
-		                                                         amask, yidx, xidx);
-		STDDevBaseOperation::Operation<A_TYPE, StddevState, OP>(&state->var_pop, aggr_input_data, x_data, bmask, xidx);
+	static void Operation(STATE &state, const A_TYPE &x, const B_TYPE &y, AggregateBinaryInput &idata) {
+		RegrCountFunction::Operation<A_TYPE, B_TYPE, size_t, OP>(state.count, x, y, idata);
+		STDDevBaseOperation::Execute<A_TYPE, StddevState>(state.var_pop, x);
 	}
 };
 

package/src/duckdb/src/core_functions/aggregate/regression/regr_sxy.cpp

@@ -14,33 +14,29 @@ struct RegrSXyState {
 
 struct RegrSXYOperation {
 	template <class STATE>
-	static void Initialize(STATE *state) {
-		RegrCountFunction::Initialize<size_t>(&state->count);
-		CovarOperation::Initialize<CovarState>(&state->cov_pop);
+	static void Initialize(STATE &state) {
+		RegrCountFunction::Initialize<size_t>(state.count);
+		CovarOperation::Initialize<CovarState>(state.cov_pop);
 	}
 
 	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &aggr_input_data, const A_TYPE *x_data, const B_TYPE *y_data,
-	                      ValidityMask &amask, ValidityMask &bmask, idx_t xidx, idx_t yidx) {
-		RegrCountFunction::Operation<A_TYPE, B_TYPE, size_t, OP>(&state->count, aggr_input_data, y_data, x_data, bmask,
-		                                                         amask, yidx, xidx);
-		CovarOperation::Operation<A_TYPE, B_TYPE, CovarState, OP>(&state->cov_pop, aggr_input_data, x_data, y_data,
-		                                                          amask, bmask, xidx, yidx);
+	static void Operation(STATE &state, const A_TYPE &x, const B_TYPE &y, AggregateBinaryInput &idata) {
+		RegrCountFunction::Operation<A_TYPE, B_TYPE, size_t, OP>(state.count, x, y, idata);
+		CovarOperation::Operation<A_TYPE, B_TYPE, CovarState, OP>(state.cov_pop, x, y, idata);
 	}
 
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &aggr_input_data) {
-		CovarOperation::Combine<CovarState, OP>(source.cov_pop, &target->cov_pop, aggr_input_data);
-		RegrCountFunction::Combine<size_t, OP>(source.count, &target->count, aggr_input_data);
+	static void Combine(const STATE &source, STATE &target, AggregateInputData &aggr_input_data) {
+		CovarOperation::Combine<CovarState, OP>(source.cov_pop, target.cov_pop, aggr_input_data);
+		RegrCountFunction::Combine<size_t, OP>(source.count, target.count, aggr_input_data);
 	}
 
 	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &aggr_input_data, STATE *state, T *target,
-	                     ValidityMask &mask, idx_t idx) {
-		CovarPopOperation::Finalize<T, CovarState>(result, aggr_input_data, &state->cov_pop, target, mask, idx);
-		auto cov_pop = target[idx];
-		RegrCountFunction::Finalize<T, size_t>(result, aggr_input_data, &state->count, target, mask, idx);
-		target[idx] *= cov_pop;
+	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
+		CovarPopOperation::Finalize<T, CovarState>(state.cov_pop, target, finalize_data);
+		auto cov_pop = target;
+		RegrCountFunction::Finalize<T, size_t>(state.count, target, finalize_data);
+		target *= cov_pop;
 	}
 
 	static bool IgnoreNull() {

package/src/duckdb/src/core_functions/function_list.cpp

@@ -169,6 +169,7 @@ static StaticFunctionDefinition internal_functions[] = {
 	DUCKDB_SCALAR_FUNCTION_SET(HexFun),
 	DUCKDB_AGGREGATE_FUNCTION_SET(HistogramFun),
 	DUCKDB_SCALAR_FUNCTION_SET(HoursFun),
+	DUCKDB_SCALAR_FUNCTION(InSearchPathFun),
 	DUCKDB_SCALAR_FUNCTION(InstrFun),
 	DUCKDB_SCALAR_FUNCTION_SET(IsFiniteFun),
 	DUCKDB_SCALAR_FUNCTION_SET(IsInfiniteFun),

package/src/duckdb/src/core_functions/scalar/date/date_part.cpp

@@ -1377,7 +1377,7 @@ struct StructDatePart {
 		writer.WriteList<DatePartSpecifier>(info.part_codes);
 	}
 
-	static unique_ptr<FunctionData> DeserializeFunction(ClientContext &context, FieldReader &reader,
+	static unique_ptr<FunctionData> DeserializeFunction(PlanDeserializationState &state, FieldReader &reader,
 	                                                    ScalarFunction &bound_function) {
 		auto stype = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
 		auto part_codes = reader.ReadRequiredList<DatePartSpecifier>();

package/src/duckdb/src/core_functions/scalar/date/make_date.cpp

@@ -47,6 +47,9 @@ struct MakeTimeOperator {
 	static RESULT_TYPE Operation(HH hh, MM mm, SS ss) {
 		int64_t secs = ss;
 		int64_t micros = std::round((ss - secs) * Interval::MICROS_PER_SEC);
+		if (!Time::IsValidTime(hh, mm, secs, micros)) {
+			throw ConversionException("Time out of range: %d:%d:%d.%d", hh, mm, secs, micros);
+		}
 		return Time::FromTime(hh, mm, secs, micros);
 	}
 };

package/src/duckdb/src/core_functions/scalar/generic/system_functions.cpp

@@ -49,6 +49,16 @@ static void CurrentSchemasFunction(DataChunk &input, ExpressionState &state, Vec
 	result.Reference(val);
 }
 
+// in_search_path
+static void InSearchPathFunction(DataChunk &input, ExpressionState &state, Vector &result) {
+	auto &context = state.GetContext();
+	auto &search_path = ClientData::Get(context).catalog_search_path;
+	BinaryExecutor::Execute<string_t, string_t, bool>(
+	    input.data[0], input.data[1], result, input.size(), [&](string_t db_name, string_t schema_name) {
+		    return search_path->SchemaInSearchPath(context, db_name.GetString(), schema_name.GetString());
+	    });
+}
+
 // txid_current
 static void TransactionIdCurrent(DataChunk &input, ExpressionState &state, Vector &result) {
 	auto &context = state.GetContext();
@@ -83,6 +93,10 @@ ScalarFunction CurrentSchemasFun::GetFunction() {
 	return ScalarFunction({LogicalType::BOOLEAN}, varchar_list_type, CurrentSchemasFunction);
 }
 
+ScalarFunction InSearchPathFun::GetFunction() {
+	return ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN, InSearchPathFunction);
+}
+
 ScalarFunction CurrentTransactionIdFun::GetFunction() {
 	return ScalarFunction({}, LogicalType::BIGINT, TransactionIdCurrent);
 }

package/src/duckdb/src/core_functions/scalar/list/array_slice.cpp

@@ -28,7 +28,7 @@ template <typename INPUT_TYPE, typename INDEX_TYPE>
 bool ClampIndex(INDEX_TYPE &index, const INPUT_TYPE &value) {
 	const auto length = ValueLength<INPUT_TYPE, INDEX_TYPE>(value);
 	if (index < 0) {
-		if (-index > length) {
+		if (index < -length) {
 			return false;
 		}
 		index = length + index;

package/src/duckdb/src/core_functions/scalar/list/list_aggregates.cpp

@@ -15,6 +15,12 @@ namespace duckdb {
 // FIXME: use a local state for each thread to increase performance?
 // FIXME: benchmark the use of simple_update against using update (if applicable)
 
+static unique_ptr<FunctionData> ListAggregatesBindFailure(ScalarFunction &bound_function) {
+	bound_function.arguments[0] = LogicalType::SQLNULL;
+	bound_function.return_type = LogicalType::SQLNULL;
+	return make_uniq<VariableReturnBindData>(LogicalType::SQLNULL);
+}
+
 struct ListAggregatesBindData : public FunctionData {
 	ListAggregatesBindData(const LogicalType &stype_p, unique_ptr<Expression> aggr_expr_p);
 	~ListAggregatesBindData() override;
@@ -31,11 +37,24 @@ struct ListAggregatesBindData : public FunctionData {
 		return stype == other.stype && aggr_expr->Equals(*other.aggr_expr);
 	}
 	static void Serialize(FieldWriter &writer, const FunctionData *bind_data_p, const ScalarFunction &function) {
-		throw NotImplementedException("FIXME: list aggr serialize");
+		auto bind_data = dynamic_cast<const ListAggregatesBindData *>(bind_data_p);
+		if (!bind_data) {
+			writer.WriteField<bool>(false);
+		} else {
+			writer.WriteField<bool>(true);
+			writer.WriteSerializable(bind_data->stype);
+			writer.WriteSerializable(*bind_data->aggr_expr);
+		}
 	}
-	static unique_ptr<FunctionData> Deserialize(ClientContext &context, FieldReader &reader,
+	static unique_ptr<FunctionData> Deserialize(PlanDeserializationState &state, FieldReader &reader,
 	                                            ScalarFunction &bound_function) {
-		throw NotImplementedException("FIXME: list aggr deserialize");
+		if (reader.ReadRequired<bool>()) {
+			auto s_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
+			auto expr = reader.ReadRequiredSerializable<Expression>(state);
+			return make_uniq<ListAggregatesBindData>(s_type, std::move(expr));
+		} else {
+			return ListAggregatesBindFailure(bound_function);
+		}
 	}
 };
 
@@ -396,9 +415,7 @@ template <bool IS_AGGR = false>
 static unique_ptr<FunctionData> ListAggregatesBind(ClientContext &context, ScalarFunction &bound_function,
                                                    vector<unique_ptr<Expression>> &arguments) {
 	if (arguments[0]->return_type.id() == LogicalTypeId::SQLNULL) {
-		bound_function.arguments[0] = LogicalType::SQLNULL;
-		bound_function.return_type = LogicalType::SQLNULL;
-		return make_uniq<VariableReturnBindData>(bound_function.return_type);
+		return ListAggregatesBindFailure(bound_function);
 	}
 
 	bool is_parameter = arguments[0]->return_type.id() == LogicalTypeId::UNKNOWN;

package/src/duckdb/src/core_functions/scalar/list/list_lambdas.cpp

@@ -24,7 +24,7 @@ public:
 	static void Serialize(FieldWriter &writer, const FunctionData *bind_data_p, const ScalarFunction &function) {
 		throw NotImplementedException("FIXME: list lambda serialize");
 	}
-	static unique_ptr<FunctionData> Deserialize(ClientContext &context, FieldReader &reader,
+	static unique_ptr<FunctionData> Deserialize(PlanDeserializationState &state, FieldReader &reader,
 	                                            ScalarFunction &bound_function) {
 		throw NotImplementedException("FIXME: list lambda deserialize");
 	}
@@ -328,7 +328,6 @@ static unique_ptr<FunctionData> ListLambdaBind(ClientContext &context, ScalarFun
 	}
 
 	if (arguments[0]->return_type.id() == LogicalTypeId::SQLNULL) {
-		bound_function.arguments.pop_back();
 		bound_function.arguments[0] = LogicalType::SQLNULL;
 		bound_function.return_type = LogicalType::SQLNULL;
 		return make_uniq<VariableReturnBindData>(bound_function.return_type);

package/src/duckdb/src/core_functions/scalar/map/map_concat.cpp

@@ -153,6 +153,9 @@ static unique_ptr<FunctionData> MapConcatBind(ClientContext &context, ScalarFunc
 			// The maps are allowed to be NULL
 			continue;
 		}
+		if (map.id() != LogicalTypeId::MAP) {
+			throw InvalidInputException("MAP_CONCAT only takes map arguments");
+		}
 		is_null = false;
 		if (IsEmptyMap(map)) {
 			// Map is allowed to be empty

package/src/duckdb/src/core_functions/scalar/math/numeric.cpp

@@ -502,13 +502,13 @@ struct RoundOperatorPrecision {
 	static inline TR Operation(TA input, TB precision) {
 		double rounded_value;
 		if (precision < 0) {
-			double modifier = std::pow(10, -precision);
+			double modifier = std::pow(10, -TA(precision));
 			rounded_value = (std::round(input / modifier)) * modifier;
 			if (std::isinf(rounded_value) || std::isnan(rounded_value)) {
 				return 0;
 			}
 		} else {
-			double modifier = std::pow(10, precision);
+			double modifier = std::pow(10, TA(precision));
 			rounded_value = (std::round(input * modifier)) / modifier;
 			if (std::isinf(rounded_value) || std::isnan(rounded_value)) {
 				return input;
@@ -574,7 +574,7 @@ static void DecimalRoundNegativePrecisionFunction(DataChunk &input, ExpressionSt
 	auto &info = func_expr.bind_info->Cast<RoundPrecisionFunctionData>();
 	auto source_scale = DecimalType::GetScale(func_expr.children[0]->return_type);
 	auto width = DecimalType::GetWidth(func_expr.children[0]->return_type);
-	if (-info.target_scale >= width) {
+	if (info.target_scale <= -int32_t(width)) {
 		// scale too big for width
 		result.SetVectorType(VectorType::CONSTANT_VECTOR);
 		result.SetValue(0, Value::INTEGER(0));

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

@@ -18,7 +18,6 @@
 #include "duckdb/storage/table/scan_state.hpp"
 
 #include <algorithm>
-#include <cstring>
 
 namespace duckdb {
 
@@ -347,7 +346,31 @@ bool ART::ConstructFromSorted(idx_t count, vector<ARTKey> &keys, Vector &row_ide
 
 	auto key_section = KeySection(0, count - 1, 0, 0);
 	auto has_constraint = IsUnique();
-	return Construct(*this, keys, row_ids, *this->tree, key_section, has_constraint);
+	if (!Construct(*this, keys, row_ids, *this->tree, key_section, has_constraint)) {
+		return false;
+	}
+
+#ifdef DEBUG
+	D_ASSERT(!VerifyAndToStringInternal(true).empty());
+	for (idx_t i = 0; i < count; i++) {
+		D_ASSERT(!keys[i].Empty());
+		auto leaf_node = Lookup(*tree, keys[i], 0);
+		D_ASSERT(leaf_node.IsSet());
+		auto &leaf = Leaf::Get(*this, 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(*this, leaf_segment, row_ids[i]);
+		D_ASSERT(position != (uint32_t)DConstants::INVALID_INDEX);
+	}
+#endif
+
+	return true;
 }
 
 //===--------------------------------------------------------------------===//
@@ -397,6 +420,29 @@ PreservedError ART::Insert(IndexLock &lock, DataChunk &input, Vector &row_ids) {
 		return PreservedError(ConstraintException("PRIMARY KEY or UNIQUE constraint violated: duplicate key \"%s\"",
 		                                          AppendRowError(input, failed_index)));
 	}
+
+#ifdef DEBUG
+	for (idx_t i = 0; i < input.size(); i++) {
+		if (keys[i].Empty()) {
+			continue;
+		}
+
+		auto leaf_node = Lookup(*tree, keys[i], 0);
+		D_ASSERT(leaf_node.IsSet());
+		auto &leaf = Leaf::Get(*this, leaf_node);
+
+		if (leaf.IsInlined()) {
+			D_ASSERT(row_identifiers[i] == leaf.row_ids.inlined);
+			continue;
+		}
+
+		D_ASSERT(leaf.row_ids.ptr.IsSet());
+		Node leaf_segment = leaf.row_ids.ptr;
+		auto position = leaf.FindRowId(*this, leaf_segment, row_identifiers[i]);
+		D_ASSERT(position != (uint32_t)DConstants::INVALID_INDEX);
+	}
+#endif
+
 	return PreservedError();
 }
 
@@ -535,16 +581,31 @@ void ART::Delete(IndexLock &state, DataChunk &input, Vector &row_ids) {
 			continue;
 		}
 		Erase(*tree, keys[i], 0, row_identifiers[i]);
+	}
+
 #ifdef DEBUG
+	// verify that we removed all row IDs
+	for (idx_t i = 0; i < input.size(); i++) {
+		if (keys[i].Empty()) {
+			continue;
+		}
+
 		auto node = Lookup(*tree, keys[i], 0);
 		if (node.IsSet()) {
 			auto &leaf = Leaf::Get(*this, node);
-			for (idx_t k = 0; k < leaf.count; k++) {
-				D_ASSERT(leaf.GetRowId(*this, k) != row_identifiers[i]);
+
+			if (leaf.IsInlined()) {
+				D_ASSERT(row_identifiers[i] != leaf.row_ids.inlined);
+				continue;
 			}
+
+			D_ASSERT(leaf.row_ids.ptr.IsSet());
+			Node leaf_segment = leaf.row_ids.ptr;
+			auto position = leaf.FindRowId(*this, leaf_segment, row_identifiers[i]);
+			D_ASSERT(position == (uint32_t)DConstants::INVALID_INDEX);
 		}
-#endif
 	}
+#endif
 }
 
 void ART::Erase(Node &node, const ARTKey &key, idx_t depth, const row_t &row_id) {
@@ -1022,6 +1083,10 @@ void ART::Vacuum(IndexLock &state) {
 
 	// finalize the vacuum operation
 	FinalizeVacuum(flags);
+
+	for (auto &allocator : allocators) {
+		allocator->Verify();
+	}
 }
 
 //===--------------------------------------------------------------------===//
@@ -1059,6 +1124,10 @@ bool ART::MergeIndexes(IndexLock &state, Index &other_index) {
 	if (!tree->Merge(*this, *other_art.tree)) {
 		return false;
 	}
+
+	for (auto &allocator : allocators) {
+		allocator->Verify();
+	}
 	return true;
 }
 
@@ -1066,9 +1135,13 @@ bool ART::MergeIndexes(IndexLock &state, Index &other_index) {
 // Utility
 //===--------------------------------------------------------------------===//
 
-string ART::ToString() {
+string ART::VerifyAndToString(IndexLock &state, const bool only_verify) {
+	return VerifyAndToStringInternal(only_verify);
+}
+
+string ART::VerifyAndToStringInternal(const bool only_verify) {
 	if (tree->IsSet()) {
-		return tree->ToString(*this);
+		return "ART: " + tree->VerifyAndToString(*this, only_verify);
 	}
 	return "[empty]";
 }

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

@@ -126,13 +126,20 @@ void FixedSizeAllocator::Merge(FixedSizeAllocator &other) {
 
 bool FixedSizeAllocator::InitializeVacuum() {
 
+	if (total_allocations == 0) {
+		Reset();
+		return false;
+	}
+
 	auto total_available_allocations = allocations_per_buffer * buffers.size();
+	D_ASSERT(total_available_allocations >= total_allocations);
 	auto total_free_positions = total_available_allocations - total_allocations;
 
 	// vacuum_count buffers can be freed
-	auto vacuum_count = total_free_positions / allocations_per_buffer / 2;
+	auto vacuum_count = total_free_positions / allocations_per_buffer;
 
 	// calculate the vacuum threshold adaptively
+	D_ASSERT(vacuum_count < buffers.size());
 	idx_t memory_usage = GetMemoryUsage();
 	idx_t excess_memory_usage = vacuum_count * BUFFER_ALLOC_SIZE;
 	auto excess_percentage = (double)excess_memory_usage / (double)memory_usage;
@@ -171,10 +178,22 @@ SwizzleablePointer FixedSizeAllocator::VacuumPointer(const SwizzleablePointer pt
 	// buffer after the vacuum operation
 
 	auto new_ptr = New();
+
+	// new increases the allocation count
+	total_allocations--;
+
 	memcpy(Get(new_ptr), Get(ptr), allocation_size);
 	return new_ptr;
 }
 
+void FixedSizeAllocator::Verify() const {
+#ifdef DEBUG
+	auto total_available_allocations = allocations_per_buffer * buffers.size();
+	D_ASSERT(total_available_allocations >= total_allocations);
+	D_ASSERT(buffers.size() >= buffers_with_free_space.size());
+#endif
+}
+
 uint32_t FixedSizeAllocator::GetOffset(ValidityMask &mask, const idx_t allocation_count) {
 
 	auto data = mask.GetData();

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

@@ -60,16 +60,10 @@ void Leaf::Free(ART &art, Node &node) {
 	D_ASSERT(node.IsSet());
 	D_ASSERT(!node.IsSwizzled());
 
+	// free leaf segments
 	auto &leaf = Leaf::Get(art, node);
-
-	// delete all leaf segments
 	if (!leaf.IsInlined()) {
-		auto ptr = leaf.row_ids.ptr;
-		while (ptr.IsSet()) {
-			auto next_ptr = LeafSegment::Get(art, ptr).next;
-			Node::Free(art, ptr);
-			ptr = next_ptr;
-		}
+		Node::Free(art, leaf.row_ids.ptr);
 	}
 }
 
@@ -275,10 +269,10 @@ uint32_t Leaf::FindRowId(const ART &art, Node &ptr, const row_t row_id) const {
 	return (uint32_t)DConstants::INVALID_INDEX;
 }
 
-string Leaf::ToString(const ART &art) const {
+string Leaf::VerifyAndToString(const ART &art, const bool only_verify) const {
 
 	if (IsInlined()) {
-		return "Leaf (" + to_string(count) + "): [" + to_string(row_ids.inlined) + "]";
+		return only_verify ? "" : "Leaf [count: 1, row ID: " + to_string(row_ids.inlined) + "]";
 	}
 
 	auto ptr = row_ids.ptr;
@@ -296,7 +290,11 @@ string Leaf::ToString(const ART &art) const {
 		remaining -= to_string_count;
 		ptr = segment.next;
 	}
-	return "Leaf (" + to_string(this_count) + ", " + to_string(count) + "): [" + str + "] \n";
+
+	D_ASSERT(remaining == 0);
+	(void)this_count;
+	D_ASSERT(this_count == count);
+	return only_verify ? "" : "Leaf [count: " + to_string(count) + ", row IDs: " + str + "] \n";
 }
 
 BlockPointer Leaf::Serialize(const ART &art, MetaBlockWriter &writer) const {
@@ -366,6 +364,7 @@ void Leaf::Vacuum(ART &art) {
 	auto &allocator = Node::GetAllocator(art, NType::LEAF_SEGMENT);
 	if (allocator.NeedsVacuum(row_ids.ptr)) {
 		row_ids.ptr.SetPtr(allocator.VacuumPointer(row_ids.ptr));
+		row_ids.ptr.type = (uint8_t)NType::LEAF_SEGMENT;
 	}
 
 	auto ptr = row_ids.ptr;
@@ -374,6 +373,7 @@ void Leaf::Vacuum(ART &art) {
 		ptr = segment.next;
 		if (ptr.IsSet() && allocator.NeedsVacuum(ptr)) {
 			segment.next.SetPtr(allocator.VacuumPointer(ptr));
+			segment.next.type = (uint8_t)NType::LEAF_SEGMENT;
 			ptr = segment.next;
 		}
 	}

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

@@ -15,6 +15,16 @@ LeafSegment &LeafSegment::New(ART &art, Node &node) {
 	return segment;
 }
 
+void LeafSegment::Free(ART &art, Node &node) {
+
+	D_ASSERT(node.IsSet());
+	D_ASSERT(!node.IsSwizzled());
+
+	// free next segment
+	auto next_segment = LeafSegment::Get(art, node).next;
+	Node::Free(art, next_segment);
+}
+
 LeafSegment &LeafSegment::Append(ART &art, uint32_t &count, const row_t row_id) {
 
 	reference<LeafSegment> segment(*this);