duckdb 0.8.2-dev2399.0 → 0.8.2-dev2669.0

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

@@ -1,14 +1,62 @@
 #include "duckdb/core_functions/scalar/list_functions.hpp"
-#include "duckdb/common/pair.hpp"
 #include "duckdb/common/string_util.hpp"
+#include "duckdb/common/swap.hpp"
 #include "duckdb/common/types/data_chunk.hpp"
 #include "duckdb/function/scalar/nested_functions.hpp"
 #include "duckdb/function/scalar/string_functions.hpp"
-#include "duckdb/parser/expression/bound_expression.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
+#include "duckdb/planner/expression/bound_constant_expression.hpp"
 
 namespace duckdb {
 
+struct ListSliceBindData : public FunctionData {
+	ListSliceBindData(const LogicalType &return_type_p, bool begin_is_empty_p, bool end_is_empty_p)
+	    : return_type(return_type_p), begin_is_empty(begin_is_empty_p), end_is_empty(end_is_empty_p) {
+	}
+	~ListSliceBindData() override;
+
+	LogicalType return_type;
+
+	bool begin_is_empty;
+	bool end_is_empty;
+
+public:
+	bool Equals(const FunctionData &other_p) const override;
+	unique_ptr<FunctionData> Copy() const override;
+};
+
+ListSliceBindData::~ListSliceBindData() {
+}
+
+bool ListSliceBindData::Equals(const FunctionData &other_p) const {
+	auto &other = other_p.Cast<ListSliceBindData>();
+	return return_type == other.return_type && begin_is_empty == other.begin_is_empty &&
+	       end_is_empty == other.end_is_empty;
+}
+
+unique_ptr<FunctionData> ListSliceBindData::Copy() const {
+	return make_uniq<ListSliceBindData>(return_type, begin_is_empty, end_is_empty);
+}
+
+template <typename INDEX_TYPE>
+static int CalculateSliceLength(idx_t begin, idx_t end, INDEX_TYPE step, bool svalid) {
+	if (step < 0) {
+		step = abs(step);
+	}
+	if (step == 0 && svalid) {
+		throw InvalidInputException("Slice step cannot be zero");
+	}
+	if (step == 1) {
+		return end - begin;
+	} else if (static_cast<idx_t>(step) >= (end - begin)) {
+		return 1;
+	}
+	if ((end - begin) % step != 0) {
+		return (end - begin) / step + 1;
+	}
+	return (end - begin) / step;
+}
+
 template <typename INPUT_TYPE, typename INDEX_TYPE>
 INDEX_TYPE ValueLength(const INPUT_TYPE &value) {
 	return 0;
@@ -20,33 +68,44 @@ int64_t ValueLength(const list_entry_t &value) {
 }
 
 template <>
-int32_t ValueLength(const string_t &value) {
-	return LengthFun::Length<string_t, int32_t>(value);
+int64_t ValueLength(const string_t &value) {
+	return LengthFun::Length<string_t, int64_t>(value);
 }
 
 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);
+static void ClampIndex(INDEX_TYPE &index, const INPUT_TYPE &value, const INDEX_TYPE length, bool is_min) {
 	if (index < 0) {
-		if (index < -length) {
-			return false;
-		}
+		index = (!is_min) ? index + 1 : index;
 		index = length + index;
+		return;
 	} else if (index > length) {
 		index = length;
 	}
-	return true;
+	return;
 }
 
 template <typename INPUT_TYPE, typename INDEX_TYPE>
-static bool ClampSlice(const INPUT_TYPE &value, INDEX_TYPE &begin, INDEX_TYPE &end, bool begin_valid, bool end_valid) {
+static bool ClampSlice(const INPUT_TYPE &value, INDEX_TYPE &begin, INDEX_TYPE &end) {
 	// Clamp offsets
-	begin = begin_valid ? begin : 0;
-	begin = (begin > 0) ? begin - 1 : begin;
-	end = end_valid ? end : ValueLength<INPUT_TYPE, INDEX_TYPE>(value);
-	if (!ClampIndex(begin, value) || !ClampIndex(end, value)) {
-		return false;
+	begin = (begin != 0 && begin != (INDEX_TYPE)NumericLimits<int64_t>::Minimum()) ? begin - 1 : begin;
+
+	bool is_min = false;
+	if (begin == (INDEX_TYPE)NumericLimits<int64_t>::Minimum()) {
+		begin++;
+		is_min = true;
+	}
+
+	const auto length = ValueLength<INPUT_TYPE, INDEX_TYPE>(value);
+	if (begin < 0 && -begin > length && end < 0 && -end > length) {
+		begin = 0;
+		end = 0;
+		return true;
 	}
+	if (begin < 0 && -begin > length) {
+		begin = 0;
+	}
+	ClampIndex(begin, value, length, is_min);
+	ClampIndex(end, value, length, false);
 	end = MaxValue<INDEX_TYPE>(begin, end);
 
 	return true;
@@ -65,108 +124,268 @@ list_entry_t SliceValue(Vector &result, list_entry_t input, int64_t begin, int64
 }
 
 template <>
-string_t SliceValue(Vector &result, string_t input, int32_t begin, int32_t end) {
+string_t SliceValue(Vector &result, string_t input, int64_t begin, int64_t end) {
 	// one-based - zero has strange semantics
 	return SubstringFun::SubstringUnicode(result, input, begin + 1, end - begin);
 }
 
 template <typename INPUT_TYPE, typename INDEX_TYPE>
-static void ExecuteSlice(Vector &result, Vector &s, Vector &b, Vector &e, const idx_t count) {
-	if (result.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		auto rdata = ConstantVector::GetData<INPUT_TYPE>(result);
-		auto sdata = ConstantVector::GetData<INPUT_TYPE>(s);
-		auto bdata = ConstantVector::GetData<INDEX_TYPE>(b);
-		auto edata = ConstantVector::GetData<INDEX_TYPE>(e);
-
-		auto sliced = sdata[0];
-		auto begin = bdata[0];
-		auto end = edata[0];
-
-		auto svalid = !ConstantVector::IsNull(s);
-		auto bvalid = !ConstantVector::IsNull(b);
-		auto evalid = !ConstantVector::IsNull(e);
-
-		// Try to slice
-		if (!svalid || !ClampSlice(sliced, begin, end, bvalid, evalid)) {
-			ConstantVector::SetNull(result, true);
-		} else {
-			rdata[0] = SliceValue<INPUT_TYPE, INDEX_TYPE>(result, sliced, begin, end);
-		}
+INPUT_TYPE SliceValueWithSteps(Vector &result, SelectionVector &sel, INPUT_TYPE input, INDEX_TYPE begin, INDEX_TYPE end,
+                               INDEX_TYPE step, idx_t &sel_idx) {
+	return input;
+}
+
+template <>
+list_entry_t SliceValueWithSteps(Vector &result, SelectionVector &sel, list_entry_t input, int64_t begin, int64_t end,
+                                 int64_t step, idx_t &sel_idx) {
+	if (end - begin == 0) {
+		input.length = 0;
+		input.offset = sel_idx;
+		return input;
+	}
+	input.length = CalculateSliceLength(begin, end, step, true);
+	idx_t child_idx = input.offset + begin;
+	if (step < 0) {
+		child_idx = input.offset + end - 1;
+	}
+	input.offset = sel_idx;
+	for (idx_t i = 0; i < input.length; i++) {
+		sel.set_index(sel_idx, child_idx);
+		child_idx += step;
+		sel_idx++;
+	}
+	return input;
+}
+
+template <typename INPUT_TYPE, typename INDEX_TYPE>
+static void ExecuteConstantSlice(Vector &result, Vector &str_vector, Vector &begin_vector, Vector &end_vector,
+                                 optional_ptr<Vector> step_vector, const idx_t count, SelectionVector &sel,
+                                 idx_t &sel_idx, optional_ptr<Vector> result_child_vector, bool begin_is_empty,
+                                 bool end_is_empty) {
+	auto result_data = ConstantVector::GetData<INPUT_TYPE>(result);
+	auto str_data = ConstantVector::GetData<INPUT_TYPE>(str_vector);
+	auto begin_data = ConstantVector::GetData<INDEX_TYPE>(begin_vector);
+	auto end_data = ConstantVector::GetData<INDEX_TYPE>(end_vector);
+	auto step_data = step_vector ? ConstantVector::GetData<INDEX_TYPE>(*step_vector) : nullptr;
+
+	auto str = str_data[0];
+	auto begin = begin_is_empty ? 0 : begin_data[0];
+	auto end = end_is_empty ? ValueLength<INPUT_TYPE, INDEX_TYPE>(str) : end_data[0];
+	auto step = step_data ? step_data[0] : 1;
+
+	if (step < 0) {
+		swap(begin, end);
+		begin = end_is_empty ? 0 : begin;
+		end = begin_is_empty ? ValueLength<INPUT_TYPE, INDEX_TYPE>(str) : end;
+	}
+
+	auto str_valid = !ConstantVector::IsNull(str_vector);
+	auto begin_valid = !ConstantVector::IsNull(begin_vector);
+	auto end_valid = !ConstantVector::IsNull(end_vector);
+	auto step_valid = step_vector && !ConstantVector::IsNull(*step_vector);
+
+	// Clamp offsets
+	bool clamp_result = false;
+	if (str_valid && begin_valid && end_valid && (step_valid || step == 1)) {
+		clamp_result = ClampSlice(str, begin, end);
+	}
+
+	auto sel_length = 0;
+	if (step_vector && step_valid && str_valid && begin_valid && end_valid && step != 1 && end - begin > 0) {
+		sel_length = CalculateSliceLength(begin, end, step, step_valid);
+		sel.Initialize(sel_length);
+	}
+
+	// Try to slice
+	if (!str_valid || !begin_valid || !end_valid || (step_vector && !step_valid) || !clamp_result) {
+		ConstantVector::SetNull(result, true);
+	} else if (step == 1) {
+		result_data[0] = SliceValue<INPUT_TYPE, INDEX_TYPE>(result, str, begin, end);
 	} else {
-		UnifiedVectorFormat sdata, bdata, edata;
+		result_data[0] = SliceValueWithSteps<INPUT_TYPE, INDEX_TYPE>(result, sel, str, begin, end, step, sel_idx);
+	}
+
+	if (step_vector && step != 0 && end - begin > 0) {
+		result_child_vector->Slice(sel, sel_length);
+	}
+}
 
-		s.ToUnifiedFormat(count, sdata);
-		b.ToUnifiedFormat(count, bdata);
-		e.ToUnifiedFormat(count, edata);
+template <typename INPUT_TYPE, typename INDEX_TYPE>
+static void ExecuteFlatSlice(Vector &result, Vector &list_vector, Vector &begin_vector, Vector &end_vector,
+                             optional_ptr<Vector> step_vector, const idx_t count, SelectionVector &sel, idx_t &sel_idx,
+                             optional_ptr<Vector> result_child_vector, bool begin_is_empty, bool end_is_empty) {
+	UnifiedVectorFormat list_data, begin_data, end_data, step_data;
+	idx_t sel_length = 0;
 
-		auto rdata = FlatVector::GetData<INPUT_TYPE>(result);
-		auto &rmask = FlatVector::Validity(result);
+	list_vector.ToUnifiedFormat(count, list_data);
+	begin_vector.ToUnifiedFormat(count, begin_data);
+	end_vector.ToUnifiedFormat(count, end_data);
+	if (step_vector) {
+		step_vector->ToUnifiedFormat(count, step_data);
+		sel.Initialize(ListVector::GetListSize(list_vector));
+	}
 
-		for (idx_t i = 0; i < count; ++i) {
-			auto sidx = sdata.sel->get_index(i);
-			auto bidx = bdata.sel->get_index(i);
-			auto eidx = edata.sel->get_index(i);
+	auto result_data = FlatVector::GetData<INPUT_TYPE>(result);
+	auto &result_mask = FlatVector::Validity(result);
 
-			auto sliced = (UnifiedVectorFormat::GetData<INPUT_TYPE>(sdata))[sidx];
-			auto begin = (UnifiedVectorFormat::GetData<INDEX_TYPE>(bdata))[bidx];
-			auto end = (UnifiedVectorFormat::GetData<INDEX_TYPE>(edata))[eidx];
+	for (idx_t i = 0; i < count; ++i) {
+		auto list_idx = list_data.sel->get_index(i);
+		auto begin_idx = begin_data.sel->get_index(i);
+		auto end_idx = end_data.sel->get_index(i);
+		auto step_idx = step_vector ? step_data.sel->get_index(i) : 0;
 
-			auto svalid = sdata.validity.RowIsValid(sidx);
-			auto bvalid = bdata.validity.RowIsValid(bidx);
-			auto evalid = edata.validity.RowIsValid(eidx);
+		auto sliced = reinterpret_cast<INPUT_TYPE *>(list_data.data)[list_idx];
+		auto begin = begin_is_empty ? 0 : reinterpret_cast<INDEX_TYPE *>(begin_data.data)[begin_idx];
+		auto end = end_is_empty ? ValueLength<INPUT_TYPE, INDEX_TYPE>(sliced)
+		                        : reinterpret_cast<INDEX_TYPE *>(end_data.data)[end_idx];
+		auto step = step_vector ? reinterpret_cast<INDEX_TYPE *>(step_data.data)[step_idx] : 1;
 
-			// Try to slice
-			if (!svalid || !ClampSlice(sliced, begin, end, bvalid, evalid)) {
-				rmask.SetInvalid(i);
-			} else {
-				rdata[i] = SliceValue<INPUT_TYPE, INDEX_TYPE>(result, sliced, begin, end);
-			}
+		if (step < 0) {
+			swap(begin, end);
+			begin = end_is_empty ? 0 : begin;
+			end = begin_is_empty ? ValueLength<INPUT_TYPE, INDEX_TYPE>(sliced) : end;
+		}
+		auto list_valid = list_data.validity.RowIsValid(list_idx);
+		auto begin_valid = begin_data.validity.RowIsValid(begin_idx);
+		auto end_valid = end_data.validity.RowIsValid(end_idx);
+		auto step_valid = step_vector && step_data.validity.RowIsValid(step_idx);
+
+		bool clamp_result = false;
+		if (list_valid && begin_valid && end_valid && (step_valid || step == 1)) {
+			clamp_result = ClampSlice(sliced, begin, end);
+		}
+
+		auto length = 0;
+		if (step_vector && step_valid && list_valid && begin_valid && end_valid && end - begin > 0) {
+			length = CalculateSliceLength(begin, end, step, step_valid);
+		}
+		sel_length += length;
+
+		if (!list_valid || !begin_valid || !end_valid || (step_vector && !step_valid) || !clamp_result) {
+			result_mask.SetInvalid(i);
+		} else if (!step_vector) {
+			result_data[i] = SliceValue<INPUT_TYPE, INDEX_TYPE>(result, sliced, begin, end);
+		} else {
+			result_data[i] =
+			    SliceValueWithSteps<INPUT_TYPE, INDEX_TYPE>(result, sel, sliced, begin, end, step, sel_idx);
+		}
+	}
+	if (step_vector) {
+		SelectionVector new_sel(sel_length);
+		for (idx_t i = 0; i < sel_length; ++i) {
+			new_sel.set_index(i, sel.get_index(i));
 		}
+		result_child_vector->Slice(new_sel, sel_length);
 	}
+}
+
+template <typename INPUT_TYPE, typename INDEX_TYPE>
+static void ExecuteSlice(Vector &result, Vector &list_or_str_vector, Vector &begin_vector, Vector &end_vector,
+                         optional_ptr<Vector> step_vector, const idx_t count, bool begin_is_empty, bool end_is_empty) {
+	optional_ptr<Vector> result_child_vector;
+	if (step_vector) {
+		result_child_vector = &ListVector::GetEntry(result);
+	}
+
+	SelectionVector sel;
+	idx_t sel_idx = 0;
 
+	if (result.GetVectorType() == VectorType::CONSTANT_VECTOR) {
+		ExecuteConstantSlice<INPUT_TYPE, INDEX_TYPE>(result, list_or_str_vector, begin_vector, end_vector, step_vector,
+		                                             count, sel, sel_idx, result_child_vector, begin_is_empty,
+		                                             end_is_empty);
+	} else {
+		ExecuteFlatSlice<INPUT_TYPE, INDEX_TYPE>(result, list_or_str_vector, begin_vector, end_vector, step_vector,
+		                                         count, sel, sel_idx, result_child_vector, begin_is_empty,
+		                                         end_is_empty);
+	}
 	result.Verify(count);
 }
 
 static void ArraySliceFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(args.ColumnCount() == 3);
-	D_ASSERT(args.data.size() == 3);
+	D_ASSERT(args.ColumnCount() == 3 || args.ColumnCount() == 4);
+	D_ASSERT(args.data.size() == 3 || args.data.size() == 4);
 	auto count = args.size();
 
-	Vector &s = args.data[0];
-	Vector &b = args.data[1];
-	Vector &e = args.data[2];
+	Vector &list_or_str_vector = args.data[0];
+	if (list_or_str_vector.GetType().id() == LogicalTypeId::SQLNULL) {
+		auto &result_validity = FlatVector::Validity(result);
+		result_validity.SetInvalid(0);
+		return;
+	}
+
+	Vector &begin_vector = args.data[1];
+	Vector &end_vector = args.data[2];
+
+	optional_ptr<Vector> step_vector;
+	if (args.ColumnCount() == 4) {
+		step_vector = &args.data[3];
+	}
+
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+	auto &info = func_expr.bind_info->Cast<ListSliceBindData>();
+	auto begin_is_empty = info.begin_is_empty;
+	auto end_is_empty = info.end_is_empty;
 
 	result.SetVectorType(args.AllConstant() ? VectorType::CONSTANT_VECTOR : VectorType::FLAT_VECTOR);
 	switch (result.GetType().id()) {
-	case LogicalTypeId::LIST:
+	case LogicalTypeId::LIST: {
 		// Share the value dictionary as we are just going to slice it
-		if (s.GetVectorType() != VectorType::FLAT_VECTOR && s.GetVectorType() != VectorType::CONSTANT_VECTOR) {
-			s.Flatten(count);
+		if (list_or_str_vector.GetVectorType() != VectorType::FLAT_VECTOR &&
+		    list_or_str_vector.GetVectorType() != VectorType::CONSTANT_VECTOR) {
+			list_or_str_vector.Flatten(count);
 		}
-		ListVector::ReferenceEntry(result, s);
-		ExecuteSlice<list_entry_t, int64_t>(result, s, b, e, count);
+		ListVector::ReferenceEntry(result, list_or_str_vector);
+		ExecuteSlice<list_entry_t, int64_t>(result, list_or_str_vector, begin_vector, end_vector, step_vector, count,
+		                                    begin_is_empty, end_is_empty);
 		break;
-	case LogicalTypeId::VARCHAR:
-		ExecuteSlice<string_t, int32_t>(result, s, b, e, count);
+	}
+	case LogicalTypeId::VARCHAR: {
+		ExecuteSlice<string_t, int64_t>(result, list_or_str_vector, begin_vector, end_vector, step_vector, count,
+		                                begin_is_empty, end_is_empty);
 		break;
+	}
 	default:
 		throw NotImplementedException("Specifier type not implemented");
 	}
 }
 
+static bool CheckIfParamIsEmpty(duckdb::unique_ptr<duckdb::Expression> &param) {
+	bool is_empty = false;
+	if (param->return_type.id() == LogicalTypeId::LIST) {
+		auto empty_list = make_uniq<BoundConstantExpression>(Value::LIST(LogicalType::INTEGER, vector<Value>()));
+		is_empty = param->Equals(*empty_list);
+		if (!is_empty) {
+			// if the param is not empty, the user has entered a list instead of a BIGINT
+			throw BinderException("The upper and lower bounds of the slice must be a BIGINT");
+		}
+	}
+	return is_empty;
+}
+
 static unique_ptr<FunctionData> ArraySliceBind(ClientContext &context, ScalarFunction &bound_function,
                                                vector<unique_ptr<Expression>> &arguments) {
-	D_ASSERT(bound_function.arguments.size() == 3);
+	D_ASSERT(arguments.size() == 3 || arguments.size() == 4);
+	D_ASSERT(bound_function.arguments.size() == 3 || bound_function.arguments.size() == 4);
+
 	switch (arguments[0]->return_type.id()) {
 	case LogicalTypeId::LIST:
 		// The result is the same type
 		bound_function.return_type = arguments[0]->return_type;
 		break;
 	case LogicalTypeId::VARCHAR:
-		// string slice returns a string, but can only accept 32 bit integers
+		// string slice returns a string
+		if (bound_function.arguments.size() == 4) {
+			throw NotImplementedException(
+			    "Slice with steps has not been implemented for string types, you can consider rewriting your query as "
+			    "follows:\n SELECT array_to_string((str_split(string, '')[begin:end:step], '');");
+		}
 		bound_function.return_type = arguments[0]->return_type;
-		bound_function.arguments[1] = LogicalType::INTEGER;
-		bound_function.arguments[2] = LogicalType::INTEGER;
+		for (idx_t i = 1; i < 3; i++) {
+			if (arguments[i]->return_type.id() != LogicalTypeId::LIST) {
+				bound_function.arguments[i] = LogicalType::BIGINT;
+			}
+		}
 		break;
 	case LogicalTypeId::SQLNULL:
 	case LogicalTypeId::UNKNOWN:
@@ -177,16 +396,29 @@ static unique_ptr<FunctionData> ArraySliceBind(ClientContext &context, ScalarFun
 		throw BinderException("ARRAY_SLICE can only operate on LISTs and VARCHARs");
 	}
 
-	return make_uniq<VariableReturnBindData>(bound_function.return_type);
+	bool begin_is_empty = CheckIfParamIsEmpty(arguments[1]);
+	if (!begin_is_empty) {
+		bound_function.arguments[1] = LogicalType::BIGINT;
+	}
+	bool end_is_empty = CheckIfParamIsEmpty(arguments[2]);
+	if (!end_is_empty) {
+		bound_function.arguments[2] = LogicalType::BIGINT;
+	}
+
+	return make_uniq<ListSliceBindData>(bound_function.return_type, begin_is_empty, end_is_empty);
 }
 
-ScalarFunction ListSliceFun::GetFunction() {
+ScalarFunctionSet ListSliceFun::GetFunctions() {
 	// the arguments and return types are actually set in the binder function
-	ScalarFunction fun({LogicalType::ANY, LogicalType::BIGINT, LogicalType::BIGINT}, LogicalType::ANY,
-	                   ArraySliceFunction, ArraySliceBind);
-	fun.varargs = LogicalType::ANY;
+	ScalarFunction fun({LogicalType::ANY, LogicalType::ANY, LogicalType::ANY}, LogicalType::ANY, ArraySliceFunction,
+	                   ArraySliceBind);
 	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	return fun;
+
+	ScalarFunctionSet set;
+	set.AddFunction(fun);
+	fun.arguments.push_back(LogicalType::BIGINT);
+	set.AddFunction(fun);
+	return set;
 }
 
 } // namespace duckdb

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

@@ -15,8 +15,8 @@ void ExpressionExecutor::Execute(const BoundParameterExpression &expr, Expressio
                                  const SelectionVector *sel, idx_t count, Vector &result) {
 	D_ASSERT(expr.parameter_data);
 	D_ASSERT(expr.parameter_data->return_type == expr.return_type);
-	D_ASSERT(expr.parameter_data->value.type() == expr.return_type);
-	result.Reference(expr.parameter_data->value);
+	D_ASSERT(expr.parameter_data->GetValue().type() == expr.return_type);
+	result.Reference(expr.parameter_data->GetValue());
 }
 
 } // namespace duckdb

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

@@ -33,21 +33,27 @@ struct ARTIndexScanState : public IndexScanState {
 
 ART::ART(const vector<column_t> &column_ids, TableIOManager &table_io_manager,
          const vector<unique_ptr<Expression>> &unbound_expressions, const IndexConstraintType constraint_type,
-         AttachedDatabase &db, const idx_t block_id, const idx_t block_offset)
+         AttachedDatabase &db, const shared_ptr<vector<FixedSizeAllocator>> &allocators_ptr, const idx_t block_id,
+         const idx_t block_offset)
 
-    : Index(db, IndexType::ART, table_io_manager, column_ids, unbound_expressions, constraint_type) {
+    : Index(db, IndexType::ART, table_io_manager, column_ids, unbound_expressions, constraint_type),
+      allocators(allocators_ptr), owns_data(false) {
 
 	if (!Radix::IsLittleEndian()) {
 		throw NotImplementedException("ART indexes are not supported on big endian architectures");
 	}
 
 	// initialize all allocators
-	allocators.emplace_back(make_uniq<FixedSizeAllocator>(sizeof(Prefix), buffer_manager.GetBufferAllocator()));
-	allocators.emplace_back(make_uniq<FixedSizeAllocator>(sizeof(Leaf), buffer_manager.GetBufferAllocator()));
-	allocators.emplace_back(make_uniq<FixedSizeAllocator>(sizeof(Node4), buffer_manager.GetBufferAllocator()));
-	allocators.emplace_back(make_uniq<FixedSizeAllocator>(sizeof(Node16), buffer_manager.GetBufferAllocator()));
-	allocators.emplace_back(make_uniq<FixedSizeAllocator>(sizeof(Node48), buffer_manager.GetBufferAllocator()));
-	allocators.emplace_back(make_uniq<FixedSizeAllocator>(sizeof(Node256), buffer_manager.GetBufferAllocator()));
+	if (!allocators) {
+		owns_data = true;
+		allocators = make_shared<vector<FixedSizeAllocator>>();
+		allocators->emplace_back(FixedSizeAllocator(sizeof(Prefix), buffer_manager.GetBufferAllocator()));
+		allocators->emplace_back(FixedSizeAllocator(sizeof(Leaf), buffer_manager.GetBufferAllocator()));
+		allocators->emplace_back(FixedSizeAllocator(sizeof(Node4), buffer_manager.GetBufferAllocator()));
+		allocators->emplace_back(FixedSizeAllocator(sizeof(Node16), buffer_manager.GetBufferAllocator()));
+		allocators->emplace_back(FixedSizeAllocator(sizeof(Node48), buffer_manager.GetBufferAllocator()));
+		allocators->emplace_back(FixedSizeAllocator(sizeof(Node256), buffer_manager.GetBufferAllocator()));
+	}
 
 	// set the root node of the tree
 	tree = make_uniq<Node>();
@@ -986,26 +992,28 @@ BlockPointer ART::Serialize(MetaBlockWriter &writer) {
 
 void ART::InitializeVacuum(ARTFlags &flags) {
 
-	flags.vacuum_flags.reserve(allocators.size());
-	for (auto &allocator : allocators) {
-		flags.vacuum_flags.push_back(allocator->InitializeVacuum());
+	flags.vacuum_flags.reserve(allocators->size());
+	for (auto &allocator : *allocators) {
+		flags.vacuum_flags.push_back(allocator.InitializeVacuum());
 	}
 }
 
 void ART::FinalizeVacuum(const ARTFlags &flags) {
 
-	for (idx_t i = 0; i < allocators.size(); i++) {
+	for (idx_t i = 0; i < allocators->size(); i++) {
 		if (flags.vacuum_flags[i]) {
-			allocators[i]->FinalizeVacuum();
+			(*allocators)[i].FinalizeVacuum();
 		}
 	}
 }
 
 void ART::Vacuum(IndexLock &state) {
 
+	D_ASSERT(owns_data);
+
 	if (!tree->IsSet()) {
-		for (auto &allocator : allocators) {
-			allocator->Reset();
+		for (auto &allocator : *allocators) {
+			allocator.Reset();
 		}
 		return;
 	}
@@ -1032,8 +1040,8 @@ void ART::Vacuum(IndexLock &state) {
 	// finalize the vacuum operation
 	FinalizeVacuum(flags);
 
-	for (auto &allocator : allocators) {
-		allocator->Verify();
+	for (auto &allocator : *allocators) {
+		allocator.Verify();
 	}
 }
 
@@ -1043,9 +1051,11 @@ void ART::Vacuum(IndexLock &state) {
 
 void ART::InitializeMerge(ARTFlags &flags) {
 
-	flags.merge_buffer_counts.reserve(allocators.size());
-	for (auto &allocator : allocators) {
-		flags.merge_buffer_counts.emplace_back(allocator->buffers.size());
+	D_ASSERT(owns_data);
+
+	flags.merge_buffer_counts.reserve(allocators->size());
+	for (auto &allocator : *allocators) {
+		flags.merge_buffer_counts.emplace_back(allocator.buffers.size());
 	}
 }
 
@@ -1056,16 +1066,18 @@ bool ART::MergeIndexes(IndexLock &state, Index &other_index) {
 		return true;
 	}
 
-	if (tree->IsSet()) {
-		//  fully deserialize other_index, and traverse it to increment its buffer IDs
-		ARTFlags flags;
-		InitializeMerge(flags);
-		other_art.tree->InitializeMerge(other_art, flags);
-	}
+	if (other_art.owns_data) {
+		if (tree->IsSet()) {
+			//  fully deserialize other_index, and traverse it to increment its buffer IDs
+			ARTFlags flags;
+			InitializeMerge(flags);
+			other_art.tree->InitializeMerge(other_art, flags);
+		}
 
-	// merge the node storage
-	for (idx_t i = 0; i < allocators.size(); i++) {
-		allocators[i]->Merge(*other_art.allocators[i]);
+		// merge the node storage
+		for (idx_t i = 0; i < allocators->size(); i++) {
+			(*allocators)[i].Merge((*other_art.allocators)[i]);
+		}
 	}
 
 	// merge the ARTs
@@ -1073,8 +1085,8 @@ bool ART::MergeIndexes(IndexLock &state, Index &other_index) {
 		return false;
 	}
 
-	for (auto &allocator : allocators) {
-		allocator->Verify();
+	for (auto &allocator : *allocators) {
+		allocator.Verify();
 	}
 	return true;
 }