duckdb 1.0.1-dev21.0 → 1.0.1-dev27.0

package/src/duckdb/src/common/types/vector.cpp

@@ -3,25 +3,26 @@
 #include "duckdb/common/algorithm.hpp"
 #include "duckdb/common/assert.hpp"
 #include "duckdb/common/exception.hpp"
+#include "duckdb/common/fsst.hpp"
 #include "duckdb/common/operator/comparison_operators.hpp"
 #include "duckdb/common/pair.hpp"
 #include "duckdb/common/printer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/type_visitor.hpp"
+#include "duckdb/common/types/bit.hpp"
 #include "duckdb/common/types/null_value.hpp"
 #include "duckdb/common/types/sel_cache.hpp"
+#include "duckdb/common/types/value.hpp"
+#include "duckdb/common/types/value_map.hpp"
 #include "duckdb/common/types/vector_cache.hpp"
 #include "duckdb/common/uhugeint.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/storage/buffer/buffer_handle.hpp"
 #include "duckdb/function/scalar/nested_functions.hpp"
+#include "duckdb/storage/buffer/buffer_handle.hpp"
 #include "duckdb/storage/string_uncompressed.hpp"
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/common/fsst.hpp"
 #include "fsst.h"
-#include "duckdb/common/types/bit.hpp"
-#include "duckdb/common/types/value_map.hpp"
-
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
+#include "duckdb/common/types/varint.hpp"
 
 #include <cstring> // strlen() on Solaris
 
@@ -30,7 +31,7 @@ namespace duckdb {
 UnifiedVectorFormat::UnifiedVectorFormat() : sel(nullptr), data(nullptr) {
 }
 
-UnifiedVectorFormat::UnifiedVectorFormat(UnifiedVectorFormat &&other) noexcept {
+UnifiedVectorFormat::UnifiedVectorFormat(UnifiedVectorFormat &&other) noexcept : sel(nullptr), data(nullptr) {
 	bool refers_to_self = other.sel == &other.owned_sel;
 	std::swap(sel, other.sel);
 	std::swap(data, other.data);
@@ -203,7 +204,9 @@ void Vector::Slice(const Vector &other, idx_t offset, idx_t end) {
 		auto &child_vec = ArrayVector::GetEntry(new_vector);
 		auto &other_child_vec = ArrayVector::GetEntry(other);
 		D_ASSERT(ArrayType::GetSize(GetType()) == ArrayType::GetSize(other.GetType()));
-		child_vec.Slice(other_child_vec, offset, end);
+		const auto array_size = ArrayType::GetSize(GetType());
+		// We need to slice the child vector with the multiplied offset and end
+		child_vec.Slice(other_child_vec, offset * array_size, end * array_size);
 		new_vector.validity.Slice(other.validity, offset, end - offset);
 		Reference(new_vector);
 	} else {
@@ -378,13 +381,20 @@ void Vector::Resize(idx_t current_size, idx_t new_size) {
 		}
 
 		// Copy the data buffer to a resized buffer.
-		auto new_data = make_unsafe_uniq_array<data_t>(target_size);
+		auto new_data = make_unsafe_uniq_array_uninitialized<data_t>(target_size);
 		memcpy(new_data.get(), resize_info_entry.data, old_size);
 		resize_info_entry.buffer->SetData(std::move(new_data));
 		resize_info_entry.vec.data = resize_info_entry.buffer->GetData();
 	}
 }
 
+static bool IsStructOrArrayRecursive(const LogicalType &type) {
+	return TypeVisitor::Contains(type, [](const LogicalType &type) {
+		auto physical_type = type.InternalType();
+		return (physical_type == PhysicalType::STRUCT || physical_type == PhysicalType::ARRAY);
+	});
+}
+
 void Vector::SetValue(idx_t index, const Value &val) {
 	if (GetVectorType() == VectorType::DICTIONARY_VECTOR) {
 		// dictionary: apply dictionary and forward to child
@@ -392,16 +402,16 @@ void Vector::SetValue(idx_t index, const Value &val) {
 		auto &child = DictionaryVector::Child(*this);
 		return child.SetValue(sel_vector.get_index(index), val);
 	}
-	if (val.type() != GetType()) {
+	if (!val.IsNull() && val.type() != GetType()) {
 		SetValue(index, val.DefaultCastAs(GetType()));
 		return;
 	}
-	D_ASSERT(val.type().InternalType() == GetType().InternalType());
+	D_ASSERT(val.IsNull() || (val.type().InternalType() == GetType().InternalType()));
 
 	validity.EnsureWritable();
 	validity.Set(index, !val.IsNull());
 	auto physical_type = GetType().InternalType();
-	if (val.IsNull() && physical_type != PhysicalType::STRUCT && physical_type != PhysicalType::ARRAY) {
+	if (val.IsNull() && !IsStructOrArrayRecursive(GetType())) {
 		// for structs and arrays we still need to set the child-entries to NULL
 		// so we do not bail out yet
 		return;
@@ -450,9 +460,12 @@ void Vector::SetValue(idx_t index, const Value &val) {
 	case PhysicalType::INTERVAL:
 		reinterpret_cast<interval_t *>(data)[index] = val.GetValueUnsafe<interval_t>();
 		break;
-	case PhysicalType::VARCHAR:
-		reinterpret_cast<string_t *>(data)[index] = StringVector::AddStringOrBlob(*this, StringValue::Get(val));
+	case PhysicalType::VARCHAR: {
+		if (!val.IsNull()) {
+			reinterpret_cast<string_t *>(data)[index] = StringVector::AddStringOrBlob(*this, StringValue::Get(val));
+		}
 		break;
+	}
 	case PhysicalType::STRUCT: {
 		D_ASSERT(GetVectorType() == VectorType::CONSTANT_VECTOR || GetVectorType() == VectorType::FLAT_VECTOR);
 
@@ -475,16 +488,23 @@ void Vector::SetValue(idx_t index, const Value &val) {
 	}
 	case PhysicalType::LIST: {
 		auto offset = ListVector::GetListSize(*this);
-		auto &val_children = ListValue::GetChildren(val);
-		if (!val_children.empty()) {
-			for (idx_t i = 0; i < val_children.size(); i++) {
-				ListVector::PushBack(*this, val_children[i]);
+		if (val.IsNull()) {
+			auto &entry = reinterpret_cast<list_entry_t *>(data)[index];
+			ListVector::PushBack(*this, Value());
+			entry.length = 1;
+			entry.offset = offset;
+		} else {
+			auto &val_children = ListValue::GetChildren(val);
+			if (!val_children.empty()) {
+				for (idx_t i = 0; i < val_children.size(); i++) {
+					ListVector::PushBack(*this, val_children[i]);
+				}
 			}
+			//! now set the pointer
+			auto &entry = reinterpret_cast<list_entry_t *>(data)[index];
+			entry.length = val_children.size();
+			entry.offset = offset;
 		}
-		//! now set the pointer
-		auto &entry = reinterpret_cast<list_entry_t *>(data)[index];
-		entry.length = val_children.size();
-		entry.offset = offset;
 		break;
 	}
 	case PhysicalType::ARRAY: {
@@ -553,8 +573,10 @@ Value Vector::GetValueInternal(const Vector &v_p, idx_t index_p) {
 			throw InternalException("FSST Vector with non-string datatype found!");
 		}
 		auto str_compressed = reinterpret_cast<string_t *>(data)[index];
-		Value result = FSSTPrimitives::DecompressValue(FSSTVector::GetDecoder(*vector), str_compressed.GetData(),
-		                                               str_compressed.GetSize());
+		auto decoder = FSSTVector::GetDecoder(*vector);
+		auto &decompress_buffer = FSSTVector::GetDecompressBuffer(*vector);
+		Value result = FSSTPrimitives::DecompressValue(decoder, str_compressed.GetData(), str_compressed.GetSize(),
+		                                               decompress_buffer);
 		return result;
 	}
 
@@ -644,6 +666,10 @@ Value Vector::GetValueInternal(const Vector &v_p, idx_t index_p) {
 		auto str = reinterpret_cast<string_t *>(data)[index];
 		return Value::BLOB(const_data_ptr_cast(str.GetData()), str.GetSize());
 	}
+	case LogicalTypeId::VARINT: {
+		auto str = reinterpret_cast<string_t *>(data)[index];
+		return Value::VARINT(const_data_ptr_cast(str.GetData()), str.GetSize());
+	}
 	case LogicalTypeId::AGGREGATE_STATE: {
 		auto str = reinterpret_cast<string_t *>(data)[index];
 		return Value::AGGREGATE_STATE(vector->GetType(), const_data_ptr_cast(str.GetData()), str.GetSize());
@@ -755,8 +781,10 @@ string Vector::ToString(idx_t count) const {
 	case VectorType::FSST_VECTOR: {
 		for (idx_t i = 0; i < count; i++) {
 			string_t compressed_string = reinterpret_cast<string_t *>(data)[i];
-			Value val = FSSTPrimitives::DecompressValue(FSSTVector::GetDecoder(*this), compressed_string.GetData(),
-			                                            compressed_string.GetSize());
+			auto decoder = FSSTVector::GetDecoder(*this);
+			auto &decompress_buffer = FSSTVector::GetDecompressBuffer(*this);
+			Value val = FSSTPrimitives::DecompressValue(decoder, compressed_string.GetData(),
+			                                            compressed_string.GetSize(), decompress_buffer);
 			retval += GetValue(i).ToString() + (i == count - 1 ? "" : ", ");
 		}
 	} break;
@@ -783,6 +811,44 @@ void Vector::Print(idx_t count) const {
 	Printer::Print(ToString(count));
 }
 
+// TODO: add the size of validity masks to this
+idx_t Vector::GetAllocationSize(idx_t cardinality) const {
+	if (!type.IsNested()) {
+		auto physical_size = GetTypeIdSize(type.InternalType());
+		return cardinality * physical_size;
+	}
+	auto internal_type = type.InternalType();
+	switch (internal_type) {
+	case PhysicalType::LIST: {
+		auto physical_size = GetTypeIdSize(type.InternalType());
+		auto total_size = physical_size * cardinality;
+
+		auto child_cardinality = ListVector::GetListCapacity(*this);
+		auto &child_entry = ListVector::GetEntry(*this);
+		total_size += (child_entry.GetAllocationSize(child_cardinality));
+		return total_size;
+	}
+	case PhysicalType::ARRAY: {
+		auto child_cardinality = ArrayVector::GetTotalSize(*this);
+
+		auto &child_entry = ArrayVector::GetEntry(*this);
+		auto total_size = (child_entry.GetAllocationSize(child_cardinality));
+		return total_size;
+	}
+	case PhysicalType::STRUCT: {
+		idx_t total_size = 0;
+		auto &children = StructVector::GetEntries(*this);
+		for (auto &child : children) {
+			total_size += child->GetAllocationSize(cardinality);
+		}
+		return total_size;
+	}
+	default:
+		throw NotImplementedException("Vector::GetAllocationSize not implemented for type: %s", type.ToString());
+		break;
+	}
+}
+
 string Vector::ToString() const {
 	string retval = VectorTypeToString(GetVectorType()) + " " + GetType().ToString() + ": (UNKNOWN COUNT) [ ";
 	switch (GetVectorType()) {
@@ -860,7 +926,10 @@ void Vector::Flatten(idx_t count) {
 			// constant NULL, set nullmask
 			validity.EnsureWritable();
 			validity.SetAllInvalid(count);
-			return;
+			if (GetType().InternalType() != PhysicalType::STRUCT) {
+				// for structs we still need to flatten the child vectors as well
+				return;
+			}
 		}
 		// non-null constant: have to repeat the constant
 		switch (GetType().InternalType()) {
@@ -925,9 +994,12 @@ void Vector::Flatten(idx_t count) {
 				validity.SetAllInvalid(count);
 				// Also invalidate the new child array
 				new_child.validity.SetAllInvalid(count * array_size);
+				// Recurse
+				new_child.Flatten(count * array_size);
+				// TODO: the fast path should exit here, but the part below it is somehow required for correctness
 				// Attach the flattened buffer and return
-				auxiliary = shared_ptr<VectorBuffer>(flattened_buffer.release());
-				return;
+				// auxiliary = shared_ptr<VectorBuffer>(flattened_buffer.release());
+				// return;
 			}
 
 			// Now we need to "unpack" the child vector.
@@ -959,7 +1031,8 @@ void Vector::Flatten(idx_t count) {
 			VectorOperations::Copy(*child_vec, new_child, sel, count * array_size, 0, 0);
 			auxiliary = shared_ptr<VectorBuffer>(flattened_buffer.release());
 
-		} break;
+			break;
+		}
 		case PhysicalType::STRUCT: {
 			auto normalified_buffer = make_uniq<VectorStructBuffer>();
 
@@ -973,7 +1046,8 @@ void Vector::Flatten(idx_t count) {
 				new_children.push_back(std::move(vector));
 			}
 			auxiliary = shared_ptr<VectorBuffer>(normalified_buffer.release());
-		} break;
+			break;
+		}
 		default:
 			throw InternalException("Unimplemented type for VectorOperations::Flatten");
 		}
@@ -982,10 +1056,11 @@ void Vector::Flatten(idx_t count) {
 	case VectorType::SEQUENCE_VECTOR: {
 		int64_t start, increment, sequence_count;
 		SequenceVector::GetSequence(*this, start, increment, sequence_count);
+		auto seq_count = NumericCast<idx_t>(sequence_count);
 
-		buffer = VectorBuffer::CreateStandardVector(GetType());
+		buffer = VectorBuffer::CreateStandardVector(GetType(), MaxValue<idx_t>(STANDARD_VECTOR_SIZE, seq_count));
 		data = buffer->GetData();
-		VectorOperations::GenerateSequence(*this, NumericCast<idx_t>(sequence_count), start, increment);
+		VectorOperations::GenerateSequence(*this, seq_count, start, increment);
 		break;
 	}
 	default:
@@ -1105,9 +1180,9 @@ void Vector::Serialize(Serializer &serializer, idx_t count) {
 	UnifiedVectorFormat vdata;
 	ToUnifiedFormat(count, vdata);
 
-	const bool all_valid = (count > 0) && !vdata.validity.AllValid();
-	serializer.WriteProperty(100, "all_valid", all_valid);
-	if (all_valid) {
+	const bool has_validity_mask = (count > 0) && !vdata.validity.AllValid();
+	serializer.WriteProperty(100, "has_validity_mask", has_validity_mask);
+	if (has_validity_mask) {
 		ValidityMask flat_mask(count);
 		flat_mask.Initialize();
 		for (idx_t i = 0; i < count; ++i) {
@@ -1120,7 +1195,7 @@ void Vector::Serialize(Serializer &serializer, idx_t count) {
 	if (TypeIsConstantSize(logical_type.InternalType())) {
 		// constant size type: simple copy
 		idx_t write_size = GetTypeIdSize(logical_type.InternalType()) * count;
-		auto ptr = make_unsafe_uniq_array<data_t>(write_size);
+		auto ptr = make_unsafe_uniq_array_uninitialized<data_t>(write_size);
 		VectorOperations::WriteToStorage(*this, count, ptr.get());
 		serializer.WriteProperty(102, "data", ptr.get(), write_size);
 	} else {
@@ -1150,13 +1225,18 @@ void Vector::Serialize(Serializer &serializer, idx_t count) {
 			auto list_size = ListVector::GetListSize(*this);
 
 			// serialize the list entries in a flat array
-			auto entries = make_unsafe_uniq_array<list_entry_t>(count);
+			auto entries = make_unsafe_uniq_array_uninitialized<list_entry_t>(count);
 			auto source_array = UnifiedVectorFormat::GetData<list_entry_t>(vdata);
 			for (idx_t i = 0; i < count; i++) {
 				auto idx = vdata.sel->get_index(i);
 				auto source = source_array[idx];
-				entries[i].offset = source.offset;
-				entries[i].length = source.length;
+				if (vdata.validity.RowIsValid(idx)) {
+					entries[i].offset = source.offset;
+					entries[i].length = source.length;
+				} else {
+					entries[i].offset = 0;
+					entries[i].length = 0;
+				}
 			}
 			serializer.WriteProperty(104, "list_size", list_size);
 			serializer.WriteList(105, "entries", count, [&](Serializer::List &list, idx_t i) {
@@ -1190,8 +1270,8 @@ void Vector::Deserialize(Deserializer &deserializer, idx_t count) {
 
 	auto &validity = FlatVector::Validity(*this);
 	validity.Reset();
-	const auto has_validity = deserializer.ReadProperty<bool>(100, "all_valid");
-	if (has_validity) {
+	const auto has_validity_mask = deserializer.ReadProperty<bool>(100, "has_validity_mask");
+	if (has_validity_mask) {
 		validity.Initialize(MaxValue<idx_t>(count, STANDARD_VECTOR_SIZE));
 		deserializer.ReadProperty(101, "validity", data_ptr_cast(validity.GetData()), validity.ValidityMaskSize(count));
 	}
@@ -1199,7 +1279,7 @@ void Vector::Deserialize(Deserializer &deserializer, idx_t count) {
 	if (TypeIsConstantSize(logical_type.InternalType())) {
 		// constant size type: read fixed amount of data
 		auto column_size = GetTypeIdSize(logical_type.InternalType()) * count;
-		auto ptr = make_unsafe_uniq_array<data_t>(column_size);
+		auto ptr = make_unsafe_uniq_array_uninitialized<data_t>(column_size);
 		deserializer.ReadProperty(102, "data", ptr.get(), column_size);
 
 		VectorOperations::ReadFromStorage(ptr.get(), count, *this);
@@ -1381,6 +1461,23 @@ void Vector::Verify(Vector &vector_p, const SelectionVector &sel_p, idx_t count)
 		}
 	}
 
+	if (type.id() == LogicalTypeId::VARINT) {
+		switch (vtype) {
+		case VectorType::FLAT_VECTOR: {
+			auto &validity = FlatVector::Validity(*vector);
+			auto strings = FlatVector::GetData<string_t>(*vector);
+			for (idx_t i = 0; i < count; i++) {
+				auto oidx = sel->get_index(i);
+				if (validity.RowIsValid(oidx)) {
+					Varint::Verify(strings[oidx]);
+				}
+			}
+		} break;
+		default:
+			break;
+		}
+	}
+
 	if (type.id() == LogicalTypeId::BIT) {
 		switch (vtype) {
 		case VectorType::FLAT_VECTOR: {
@@ -1451,6 +1548,7 @@ void Vector::Verify(Vector &vector_p, const SelectionVector &sel_p, idx_t count)
 	if (type.InternalType() == PhysicalType::STRUCT) {
 		auto &child_types = StructType::GetChildTypes(type);
 		D_ASSERT(!child_types.empty());
+
 		// create a selection vector of the non-null entries of the struct vector
 		auto &children = StructVector::GetEntries(*vector);
 		D_ASSERT(child_types.size() == children.size());
@@ -1837,7 +1935,7 @@ string_t StringVector::AddString(Vector &vector, string_t data) {
 		vector.auxiliary = make_buffer<VectorStringBuffer>();
 	}
 	D_ASSERT(vector.auxiliary->GetBufferType() == VectorBufferType::STRING_BUFFER);
-	auto &string_buffer = vector.auxiliary->Cast<VectorStringBuffer>();
+	auto &string_buffer = vector.auxiliary.get()->Cast<VectorStringBuffer>();
 	return string_buffer.AddString(data);
 }
 
@@ -1851,7 +1949,7 @@ string_t StringVector::AddStringOrBlob(Vector &vector, string_t data) {
 		vector.auxiliary = make_buffer<VectorStringBuffer>();
 	}
 	D_ASSERT(vector.auxiliary->GetBufferType() == VectorBufferType::STRING_BUFFER);
-	auto &string_buffer = vector.auxiliary->Cast<VectorStringBuffer>();
+	auto &string_buffer = vector.auxiliary.get()->Cast<VectorStringBuffer>();
 	return string_buffer.AddBlob(data);
 }
 
@@ -1864,7 +1962,7 @@ string_t StringVector::EmptyString(Vector &vector, idx_t len) {
 		vector.auxiliary = make_buffer<VectorStringBuffer>();
 	}
 	D_ASSERT(vector.auxiliary->GetBufferType() == VectorBufferType::STRING_BUFFER);
-	auto &string_buffer = vector.auxiliary->Cast<VectorStringBuffer>();
+	auto &string_buffer = vector.auxiliary.get()->Cast<VectorStringBuffer>();
 	return string_buffer.EmptyString(len);
 }
 
@@ -1918,7 +2016,7 @@ string_t FSSTVector::AddCompressedString(Vector &vector, string_t data) {
 		vector.auxiliary = make_buffer<VectorFSSTStringBuffer>();
 	}
 	D_ASSERT(vector.auxiliary->GetBufferType() == VectorBufferType::FSST_BUFFER);
-	auto &fsst_string_buffer = vector.auxiliary->Cast<VectorFSSTStringBuffer>();
+	auto &fsst_string_buffer = vector.auxiliary.get()->Cast<VectorFSSTStringBuffer>();
 	return fsst_string_buffer.AddBlob(data);
 }
 
@@ -1932,7 +2030,18 @@ void *FSSTVector::GetDecoder(const Vector &vector) {
 	return fsst_string_buffer.GetDecoder();
 }
 
-void FSSTVector::RegisterDecoder(Vector &vector, buffer_ptr<void> &duckdb_fsst_decoder) {
+vector<unsigned char> &FSSTVector::GetDecompressBuffer(const Vector &vector) {
+	D_ASSERT(vector.GetType().InternalType() == PhysicalType::VARCHAR);
+	if (!vector.auxiliary) {
+		throw InternalException("GetDecompressBuffer called on FSST Vector without registered buffer");
+	}
+	D_ASSERT(vector.auxiliary->GetBufferType() == VectorBufferType::FSST_BUFFER);
+	auto &fsst_string_buffer = vector.auxiliary->Cast<VectorFSSTStringBuffer>();
+	return fsst_string_buffer.GetDecompressBuffer();
+}
+
+void FSSTVector::RegisterDecoder(Vector &vector, buffer_ptr<void> &duckdb_fsst_decoder,
+                                 const idx_t string_block_limit) {
 	D_ASSERT(vector.GetType().InternalType() == PhysicalType::VARCHAR);
 
 	if (!vector.auxiliary) {
@@ -1941,7 +2050,7 @@ void FSSTVector::RegisterDecoder(Vector &vector, buffer_ptr<void> &duckdb_fsst_d
 	D_ASSERT(vector.auxiliary->GetBufferType() == VectorBufferType::FSST_BUFFER);
 
 	auto &fsst_string_buffer = vector.auxiliary->Cast<VectorFSSTStringBuffer>();
-	fsst_string_buffer.AddDecoder(duckdb_fsst_decoder);
+	fsst_string_buffer.AddDecoder(duckdb_fsst_decoder, string_block_limit);
 }
 
 void FSSTVector::SetCount(Vector &vector, idx_t count) {
@@ -1980,8 +2089,10 @@ void FSSTVector::DecompressVector(const Vector &src, Vector &dst, idx_t src_offs
 		auto target_idx = dst_offset + i;
 		string_t compressed_string = ldata[source_idx];
 		if (dst_mask.RowIsValid(target_idx) && compressed_string.GetSize() > 0) {
-			tdata[target_idx] = FSSTPrimitives::DecompressValue(
-			    FSSTVector::GetDecoder(src), dst, compressed_string.GetData(), compressed_string.GetSize());
+			auto decoder = FSSTVector::GetDecoder(src);
+			auto &decompress_buffer = FSSTVector::GetDecompressBuffer(src);
+			tdata[target_idx] = FSSTPrimitives::DecompressValue(decoder, dst, compressed_string.GetData(),
+			                                                    compressed_string.GetSize(), decompress_buffer);
 		} else {
 			tdata[target_idx] = string_t(nullptr, 0);
 		}
@@ -2190,7 +2301,7 @@ void ListVector::Append(Vector &target, const Vector &source, const SelectionVec
 }
 
 void ListVector::PushBack(Vector &target, const Value &insert) {
-	auto &target_buffer = target.auxiliary->Cast<VectorListBuffer>();
+	auto &target_buffer = target.auxiliary.get()->Cast<VectorListBuffer>();
 	target_buffer.PushBack(insert);
 }
 

package/src/duckdb/src/common/types/vector_buffer.cpp

@@ -67,11 +67,12 @@ VectorListBuffer::VectorListBuffer(const LogicalType &list_type, idx_t initial_c
 
 void VectorListBuffer::Reserve(idx_t to_reserve) {
 	if (to_reserve > capacity) {
-		idx_t new_capacity = NextPowerOfTwo(to_reserve);
-		if (new_capacity == 0) {
-			// Overflow: set to_reserve to the maximum value
-			new_capacity = to_reserve;
+		if (to_reserve > DConstants::MAX_VECTOR_SIZE) {
+			// overflow: throw an exception
+			throw OutOfRangeException("Cannot resize vector to %d rows: maximum allowed vector size is %s", to_reserve,
+			                          StringUtil::BytesToHumanReadableString(DConstants::MAX_VECTOR_SIZE));
 		}
+		idx_t new_capacity = NextPowerOfTwo(to_reserve);
 		D_ASSERT(new_capacity >= to_reserve);
 		child->Resize(capacity, new_capacity);
 		capacity = new_capacity;