duckdb 0.10.2 → 0.10.3-dev10.0

package/src/duckdb/src/common/types/row/tuple_data_collection.cpp

@@ -12,7 +12,7 @@ namespace duckdb {
 using ValidityBytes = TupleDataLayout::ValidityBytes;
 
 TupleDataCollection::TupleDataCollection(BufferManager &buffer_manager, const TupleDataLayout &layout_p)
-    : layout(layout_p.Copy()), allocator(make_shared<TupleDataAllocator>(buffer_manager, layout)) {
+    : layout(layout_p.Copy()), allocator(make_shared_ptr<TupleDataAllocator>(buffer_manager, layout)) {
 	Initialize();
 }
 
@@ -377,7 +377,7 @@ void TupleDataCollection::Reset() {
 	segments.clear();
 
 	// Refreshes the TupleDataAllocator to prevent holding on to allocated data unnecessarily
-	allocator = make_shared<TupleDataAllocator>(*allocator);
+	allocator = make_shared_ptr<TupleDataAllocator>(*allocator);
 }
 
 void TupleDataCollection::InitializeChunk(DataChunk &chunk) const {

package/src/duckdb/src/common/types/row/tuple_data_segment.cpp

@@ -7,6 +7,13 @@ namespace duckdb {
 TupleDataChunkPart::TupleDataChunkPart(mutex &lock_p) : lock(lock_p) {
 }
 
+void TupleDataChunkPart::SetHeapEmpty() {
+	heap_block_index = INVALID_INDEX;
+	heap_block_offset = INVALID_INDEX;
+	total_heap_size = 0;
+	base_heap_ptr = nullptr;
+}
+
 void SwapTupleDataChunkPart(TupleDataChunkPart &a, TupleDataChunkPart &b) {
 	std::swap(a.row_block_index, b.row_block_index);
 	std::swap(a.row_block_offset, b.row_block_offset);

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

@@ -51,6 +51,10 @@ string_t StringHeap::AddBlob(const string_t &data) {
 
 string_t StringHeap::EmptyString(idx_t len) {
 	D_ASSERT(len > string_t::INLINE_LENGTH);
+	if (len > string_t::MAX_STRING_SIZE) {
+		throw OutOfRangeException("Cannot create a string of size: '%d', the maximum supported string size is: '%d'",
+		                          len, string_t::MAX_STRING_SIZE);
+	}
 	auto insert_pos = const_char_ptr_cast(allocator.Allocate(len));
 	return string_t(insert_pos, UnsafeNumericCast<uint32_t>(len));
 }

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

@@ -79,7 +79,14 @@ bool Timestamp::TryConvertTimestampTZ(const char *str, idx_t len, timestamp_t &r
 		pos++;
 	}
 	idx_t time_pos = 0;
-	if (!Time::TryConvertTime(str + pos, len - pos, time_pos, time)) {
+	// TryConvertTime may recursively call us, so we opt for a stricter
+	// operation. Note that we can't pass strict== true here because we
+	// want to process any suffix.
+	if (!Time::TryConvertInterval(str + pos, len - pos, time_pos, time)) {
+		return false;
+	}
+	//	We parsed an interval, so make sure it is in range.
+	if (time.micros > Interval::MICROS_PER_DAY) {
 		return false;
 	}
 	pos += time_pos;
@@ -380,6 +387,21 @@ int64_t Timestamp::GetEpochNanoSeconds(timestamp_t timestamp) {
 	return result;
 }
 
+int64_t Timestamp::GetEpochRounded(timestamp_t input, int64_t power_of_ten) {
+	D_ASSERT(Timestamp::IsFinite(input));
+	//	Round away from the epoch.
+	//	Scale first so we don't overflow.
+	const auto scaling = power_of_ten / 2;
+	input.value /= scaling;
+	if (input.value < 0) {
+		--input.value;
+	} else {
+		++input.value;
+	}
+	input.value /= 2;
+	return input.value;
+}
+
 double Timestamp::GetJulianDay(timestamp_t timestamp) {
 	double result = double(Timestamp::GetTime(timestamp).micros);
 	result /= Interval::MICROS_PER_DAY;

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

@@ -399,7 +399,7 @@ bool Uhugeint::TryCast(uhugeint_t input, hugeint_t &result) {
 	}
 
 	result.lower = input.lower;
-	result.upper = input.upper;
+	result.upper = UnsafeNumericCast<int64_t>(input.upper);
 	return true;
 }
 

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

@@ -6,13 +6,13 @@ namespace duckdb {
 bool UUID::FromString(const string &str, hugeint_t &result) {
 	auto hex2char = [](char ch) -> unsigned char {
 		if (ch >= '0' && ch <= '9') {
-			return ch - '0';
+			return UnsafeNumericCast<unsigned char>(ch - '0');
 		}
 		if (ch >= 'a' && ch <= 'f') {
-			return 10 + ch - 'a';
+			return UnsafeNumericCast<unsigned char>(10 + ch - 'a');
 		}
 		if (ch >= 'A' && ch <= 'F') {
-			return 10 + ch - 'A';
+			return UnsafeNumericCast<unsigned char>(10 + ch - 'A');
 		}
 		return 0;
 	};
@@ -23,7 +23,7 @@ bool UUID::FromString(const string &str, hugeint_t &result) {
 	if (str.empty()) {
 		return false;
 	}
-	int has_braces = 0;
+	idx_t has_braces = 0;
 	if (str.front() == '{') {
 		has_braces = 1;
 	}
@@ -54,14 +54,15 @@ bool UUID::FromString(const string &str, hugeint_t &result) {
 }
 
 void UUID::ToString(hugeint_t input, char *buf) {
-	auto byte_to_hex = [](char byte_val, char *buf, idx_t &pos) {
+	auto byte_to_hex = [](uint64_t byte_val, char *buf, idx_t &pos) {
+		D_ASSERT(byte_val <= 0xFF);
 		static char const HEX_DIGITS[] = "0123456789abcdef";
 		buf[pos++] = HEX_DIGITS[(byte_val >> 4) & 0xf];
 		buf[pos++] = HEX_DIGITS[byte_val & 0xf];
 	};
 
 	// Flip back before convert to string
-	int64_t upper = input.upper ^ (uint64_t(1) << 63);
+	int64_t upper = int64_t(uint64_t(input.upper) ^ (uint64_t(1) << 63));
 	idx_t pos = 0;
 	byte_to_hex(upper >> 56 & 0xFF, buf, pos);
 	byte_to_hex(upper >> 48 & 0xFF, buf, pos);

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

@@ -162,7 +162,7 @@ Value::Value(string val) : type_(LogicalType::VARCHAR), is_null(false) {
 	if (!Value::StringIsValid(val.c_str(), val.size())) {
 		throw ErrorManager::InvalidUnicodeError(val, "value construction");
 	}
-	value_info_ = make_shared<StringValueInfo>(std::move(val));
+	value_info_ = make_shared_ptr<StringValueInfo>(std::move(val));
 }
 
 Value::~Value() {
@@ -230,10 +230,16 @@ Value Value::MinimumValue(const LogicalType &type) {
 	case LogicalTypeId::TIMESTAMP:
 		return Value::TIMESTAMP(Date::FromDate(Timestamp::MIN_YEAR, Timestamp::MIN_MONTH, Timestamp::MIN_DAY),
 		                        dtime_t(0));
-	case LogicalTypeId::TIMESTAMP_SEC:
-		return MinimumValue(LogicalType::TIMESTAMP).DefaultCastAs(LogicalType::TIMESTAMP_S);
-	case LogicalTypeId::TIMESTAMP_MS:
-		return MinimumValue(LogicalType::TIMESTAMP).DefaultCastAs(LogicalType::TIMESTAMP_MS);
+	case LogicalTypeId::TIMESTAMP_SEC: {
+		//	Casting rounds up, which will overflow
+		const auto min_us = MinimumValue(LogicalType::TIMESTAMP).GetValue<timestamp_t>();
+		return Value::TIMESTAMPSEC(timestamp_t(Timestamp::GetEpochSeconds(min_us)));
+	}
+	case LogicalTypeId::TIMESTAMP_MS: {
+		//	Casting rounds up, which will overflow
+		const auto min_us = MinimumValue(LogicalType::TIMESTAMP).GetValue<timestamp_t>();
+		return Value::TIMESTAMPMS(timestamp_t(Timestamp::GetEpochMs(min_us)));
+	}
 	case LogicalTypeId::TIMESTAMP_NS:
 		return Value::TIMESTAMPNS(timestamp_t(NumericLimits<int64_t>::Minimum()));
 	case LogicalTypeId::TIME_TZ:
@@ -303,12 +309,18 @@ Value Value::MaximumValue(const LogicalType &type) {
 		return Value::TIME(dtime_t(Interval::MICROS_PER_DAY));
 	case LogicalTypeId::TIMESTAMP:
 		return Value::TIMESTAMP(timestamp_t(NumericLimits<int64_t>::Maximum() - 1));
-	case LogicalTypeId::TIMESTAMP_MS:
-		return MaximumValue(LogicalType::TIMESTAMP).DefaultCastAs(LogicalType::TIMESTAMP_MS);
+	case LogicalTypeId::TIMESTAMP_MS: {
+		//	Casting rounds up, which will overflow
+		const auto max_us = MaximumValue(LogicalType::TIMESTAMP).GetValue<timestamp_t>();
+		return Value::TIMESTAMPMS(timestamp_t(Timestamp::GetEpochMs(max_us)));
+	}
 	case LogicalTypeId::TIMESTAMP_NS:
 		return Value::TIMESTAMPNS(timestamp_t(NumericLimits<int64_t>::Maximum() - 1));
-	case LogicalTypeId::TIMESTAMP_SEC:
-		return MaximumValue(LogicalType::TIMESTAMP).DefaultCastAs(LogicalType::TIMESTAMP_S);
+	case LogicalTypeId::TIMESTAMP_SEC: {
+		//	Casting rounds up, which will overflow
+		const auto max_us = MaximumValue(LogicalType::TIMESTAMP).GetValue<timestamp_t>();
+		return Value::TIMESTAMPSEC(timestamp_t(Timestamp::GetEpochSeconds(max_us)));
+	}
 	case LogicalTypeId::TIME_TZ:
 		//	"24:00:00-1559" from the PG docs but actually "24:00:00-15:59:59"
 		return Value::TIMETZ(dtime_tz_t(dtime_t(Interval::MICROS_PER_DAY), dtime_tz_t::MIN_OFFSET));
@@ -668,7 +680,7 @@ Value Value::STRUCT(const LogicalType &type, vector<Value> struct_values) {
 	for (size_t i = 0; i < struct_values.size(); i++) {
 		struct_values[i] = struct_values[i].DefaultCastAs(child_types[i].second);
 	}
-	result.value_info_ = make_shared<NestedValueInfo>(std::move(struct_values));
+	result.value_info_ = make_shared_ptr<NestedValueInfo>(std::move(struct_values));
 	result.type_ = type;
 	result.is_null = false;
 	return result;
@@ -711,7 +723,19 @@ Value Value::MAP(const LogicalType &key_type, const LogicalType &value_type, vec
 		new_children.push_back(std::make_pair("value", std::move(values[i])));
 		values[i] = Value::STRUCT(std::move(new_children));
 	}
-	result.value_info_ = make_shared<NestedValueInfo>(std::move(values));
+	result.value_info_ = make_shared_ptr<NestedValueInfo>(std::move(values));
+	return result;
+}
+
+Value Value::MAP(const unordered_map<string, string> &kv_pairs) {
+	Value result;
+	result.type_ = LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR);
+	result.is_null = false;
+	vector<Value> pairs;
+	for (auto &kv : kv_pairs) {
+		pairs.push_back(Value::STRUCT({{"key", Value(kv.first)}, {"value", Value(kv.second)}}));
+	}
+	result.value_info_ = make_shared_ptr<NestedValueInfo>(std::move(pairs));
 	return result;
 }
 
@@ -735,7 +759,7 @@ Value Value::UNION(child_list_t<LogicalType> members, uint8_t tag, Value value)
 		}
 	}
 	union_values[tag + 1] = std::move(value);
-	result.value_info_ = make_shared<NestedValueInfo>(std::move(union_values));
+	result.value_info_ = make_shared_ptr<NestedValueInfo>(std::move(union_values));
 	result.type_ = LogicalType::UNION(std::move(members));
 	return result;
 }
@@ -752,7 +776,7 @@ Value Value::LIST(vector<Value> values) {
 #endif
 	Value result;
 	result.type_ = LogicalType::LIST(values[0].type());
-	result.value_info_ = make_shared<NestedValueInfo>(std::move(values));
+	result.value_info_ = make_shared_ptr<NestedValueInfo>(std::move(values));
 	result.is_null = false;
 	return result;
 }
@@ -770,7 +794,7 @@ Value Value::LIST(const LogicalType &child_type, vector<Value> values) {
 Value Value::EMPTYLIST(const LogicalType &child_type) {
 	Value result;
 	result.type_ = LogicalType::LIST(child_type);
-	result.value_info_ = make_shared<NestedValueInfo>();
+	result.value_info_ = make_shared_ptr<NestedValueInfo>();
 	result.is_null = false;
 	return result;
 }
@@ -787,7 +811,7 @@ Value Value::ARRAY(vector<Value> values) {
 #endif
 	Value result;
 	result.type_ = LogicalType::ARRAY(values[0].type(), values.size());
-	result.value_info_ = make_shared<NestedValueInfo>(std::move(values));
+	result.value_info_ = make_shared_ptr<NestedValueInfo>(std::move(values));
 	result.is_null = false;
 	return result;
 }
@@ -805,7 +829,7 @@ Value Value::ARRAY(const LogicalType &child_type, vector<Value> values) {
 Value Value::EMPTYARRAY(const LogicalType &child_type, uint32_t size) {
 	Value result;
 	result.type_ = LogicalType::ARRAY(child_type, size);
-	result.value_info_ = make_shared<NestedValueInfo>();
+	result.value_info_ = make_shared_ptr<NestedValueInfo>();
 	result.is_null = false;
 	return result;
 }
@@ -813,35 +837,35 @@ Value Value::EMPTYARRAY(const LogicalType &child_type, uint32_t size) {
 Value Value::BLOB(const_data_ptr_t data, idx_t len) {
 	Value result(LogicalType::BLOB);
 	result.is_null = false;
-	result.value_info_ = make_shared<StringValueInfo>(string(const_char_ptr_cast(data), len));
+	result.value_info_ = make_shared_ptr<StringValueInfo>(string(const_char_ptr_cast(data), len));
 	return result;
 }
 
 Value Value::BLOB(const string &data) {
 	Value result(LogicalType::BLOB);
 	result.is_null = false;
-	result.value_info_ = make_shared<StringValueInfo>(Blob::ToBlob(string_t(data)));
+	result.value_info_ = make_shared_ptr<StringValueInfo>(Blob::ToBlob(string_t(data)));
 	return result;
 }
 
 Value Value::AGGREGATE_STATE(const LogicalType &type, const_data_ptr_t data, idx_t len) { // NOLINT
 	Value result(type);
 	result.is_null = false;
-	result.value_info_ = make_shared<StringValueInfo>(string(const_char_ptr_cast(data), len));
+	result.value_info_ = make_shared_ptr<StringValueInfo>(string(const_char_ptr_cast(data), len));
 	return result;
 }
 
 Value Value::BIT(const_data_ptr_t data, idx_t len) {
 	Value result(LogicalType::BIT);
 	result.is_null = false;
-	result.value_info_ = make_shared<StringValueInfo>(string(const_char_ptr_cast(data), len));
+	result.value_info_ = make_shared_ptr<StringValueInfo>(string(const_char_ptr_cast(data), len));
 	return result;
 }
 
 Value Value::BIT(const string &data) {
 	Value result(LogicalType::BIT);
 	result.is_null = false;
-	result.value_info_ = make_shared<StringValueInfo>(Bit::ToBit(string_t(data)));
+	result.value_info_ = make_shared_ptr<StringValueInfo>(Bit::ToBit(string_t(data)));
 	return result;
 }
 
@@ -1209,11 +1233,11 @@ Value Value::Numeric(const LogicalType &type, int64_t value) {
 		return Value::UINTEGER((uint32_t)value);
 	case LogicalTypeId::UBIGINT:
 		D_ASSERT(value >= 0);
-		return Value::UBIGINT(value);
+		return Value::UBIGINT(NumericCast<uint64_t>(value));
 	case LogicalTypeId::HUGEINT:
 		return Value::HUGEINT(value);
 	case LogicalTypeId::UHUGEINT:
-		return Value::UHUGEINT(value);
+		return Value::UHUGEINT(NumericCast<uint64_t>(value));
 	case LogicalTypeId::DECIMAL:
 		return Value::DECIMAL(value, DecimalType::GetWidth(type), DecimalType::GetScale(type));
 	case LogicalTypeId::FLOAT:
@@ -1221,7 +1245,7 @@ Value Value::Numeric(const LogicalType &type, int64_t value) {
 	case LogicalTypeId::DOUBLE:
 		return Value((double)value);
 	case LogicalTypeId::POINTER:
-		return Value::POINTER(value);
+		return Value::POINTER(NumericCast<uintptr_t>(value));
 	case LogicalTypeId::DATE:
 		D_ASSERT(value >= NumericLimits<int32_t>::Minimum() && value <= NumericLimits<int32_t>::Maximum());
 		return Value::DATE(date_t(NumericCast<int32_t>(value)));
@@ -1662,7 +1686,7 @@ hugeint_t IntegralValue::Get(const Value &value) {
 	case PhysicalType::UINT32:
 		return UIntegerValue::Get(value);
 	case PhysicalType::UINT64:
-		return UBigIntValue::Get(value);
+		return NumericCast<int64_t>(UBigIntValue::Get(value));
 	case PhysicalType::UINT128:
 		return static_cast<hugeint_t>(UhugeIntValue::Get(value));
 	default:
@@ -1936,27 +1960,27 @@ Value Value::Deserialize(Deserializer &deserializer) {
 	case PhysicalType::VARCHAR: {
 		auto str = deserializer.ReadProperty<string>(102, "value");
 		if (type.id() == LogicalTypeId::BLOB) {
-			new_value.value_info_ = make_shared<StringValueInfo>(Blob::ToBlob(str));
+			new_value.value_info_ = make_shared_ptr<StringValueInfo>(Blob::ToBlob(str));
 		} else {
-			new_value.value_info_ = make_shared<StringValueInfo>(str);
+			new_value.value_info_ = make_shared_ptr<StringValueInfo>(str);
 		}
 	} break;
 	case PhysicalType::LIST: {
 		deserializer.ReadObject(102, "value", [&](Deserializer &obj) {
 			auto children = obj.ReadProperty<vector<Value>>(100, "children");
-			new_value.value_info_ = make_shared<NestedValueInfo>(children);
+			new_value.value_info_ = make_shared_ptr<NestedValueInfo>(children);
 		});
 	} break;
 	case PhysicalType::STRUCT: {
 		deserializer.ReadObject(102, "value", [&](Deserializer &obj) {
 			auto children = obj.ReadProperty<vector<Value>>(100, "children");
-			new_value.value_info_ = make_shared<NestedValueInfo>(children);
+			new_value.value_info_ = make_shared_ptr<NestedValueInfo>(children);
 		});
 	} break;
 	case PhysicalType::ARRAY: {
 		deserializer.ReadObject(102, "value", [&](Deserializer &obj) {
 			auto children = obj.ReadProperty<vector<Value>>(100, "children");
-			new_value.value_info_ = make_shared<NestedValueInfo>(children);
+			new_value.value_info_ = make_shared_ptr<NestedValueInfo>(children);
 		});
 	} break;
 	default:

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

@@ -306,103 +306,82 @@ void Vector::Initialize(bool zero_data, idx_t capacity) {
 	}
 }
 
-struct DataArrays {
-	Vector &vec;
-	data_ptr_t data;
-	optional_ptr<VectorBuffer> buffer;
-	idx_t type_size;
-	bool is_nested;
-	idx_t nested_multiplier;
-	DataArrays(Vector &vec, data_ptr_t data, optional_ptr<VectorBuffer> buffer, idx_t type_size, bool is_nested,
-	           idx_t nested_multiplier = 1)
-	    : vec(vec), data(data), buffer(buffer), type_size(type_size), is_nested(is_nested),
-	      nested_multiplier(nested_multiplier) {
-	}
-};
-
-void FindChildren(vector<DataArrays> &to_resize, VectorBuffer &auxiliary, idx_t current_multiplier) {
-	if (auxiliary.GetBufferType() == VectorBufferType::LIST_BUFFER) {
-		auto &buffer = auxiliary.Cast<VectorListBuffer>();
-		auto &child = buffer.GetChild();
-		auto data = child.GetData();
-		if (!data) {
-			//! Nested type
-			DataArrays arrays(child, data, child.GetBuffer().get(), GetTypeIdSize(child.GetType().InternalType()),
-			                  true);
-			to_resize.emplace_back(arrays);
-			FindChildren(to_resize, *child.GetAuxiliary(), current_multiplier);
-		} else {
-			DataArrays arrays(child, data, child.GetBuffer().get(), GetTypeIdSize(child.GetType().InternalType()),
-			                  false);
-			to_resize.emplace_back(arrays);
-		}
-	} else if (auxiliary.GetBufferType() == VectorBufferType::STRUCT_BUFFER) {
-		auto &buffer = auxiliary.Cast<VectorStructBuffer>();
-		auto &children = buffer.GetChildren();
+void Vector::FindResizeInfos(vector<ResizeInfo> &resize_infos, const idx_t multiplier) {
+
+	ResizeInfo resize_info(*this, data, buffer.get(), multiplier);
+	resize_infos.emplace_back(resize_info);
+
+	// Base case.
+	if (data) {
+		return;
+	}
+
+	D_ASSERT(auxiliary);
+	switch (GetAuxiliary()->GetBufferType()) {
+	case VectorBufferType::LIST_BUFFER: {
+		auto &vector_list_buffer = auxiliary->Cast<VectorListBuffer>();
+		auto &child = vector_list_buffer.GetChild();
+		child.FindResizeInfos(resize_infos, multiplier);
+		break;
+	}
+	case VectorBufferType::STRUCT_BUFFER: {
+		auto &vector_struct_buffer = auxiliary->Cast<VectorStructBuffer>();
+		auto &children = vector_struct_buffer.GetChildren();
 		for (auto &child : children) {
-			auto data = child->GetData();
-			if (!data) {
-				//! Nested type
-				DataArrays arrays(*child, data, child->GetBuffer().get(),
-				                  GetTypeIdSize(child->GetType().InternalType()), true);
-				to_resize.emplace_back(arrays);
-				FindChildren(to_resize, *child->GetAuxiliary(), current_multiplier);
-			} else {
-				DataArrays arrays(*child, data, child->GetBuffer().get(),
-				                  GetTypeIdSize(child->GetType().InternalType()), false);
-				to_resize.emplace_back(arrays);
-			}
-		}
-	} else if (auxiliary.GetBufferType() == VectorBufferType::ARRAY_BUFFER) {
-		auto &buffer = auxiliary.Cast<VectorArrayBuffer>();
-		auto array_size = buffer.GetArraySize();
-		auto &child = buffer.GetChild();
-		auto data = child.GetData();
-		if (!data) {
-			//! Nested type
-			DataArrays arrays(child, data, child.GetBuffer().get(), GetTypeIdSize(child.GetType().InternalType()), true,
-			                  current_multiplier);
-			to_resize.emplace_back(arrays);
-
-			// The child vectors of ArrayTypes always have to be (size * array_size), so we need to multiply the
-			// multiplier by the array size
-			auto new_multiplier = current_multiplier * array_size;
-			FindChildren(to_resize, *child.GetAuxiliary(), new_multiplier);
-		} else {
-			DataArrays arrays(child, data, child.GetBuffer().get(), GetTypeIdSize(child.GetType().InternalType()),
-			                  false, current_multiplier);
-			to_resize.emplace_back(arrays);
+			child->FindResizeInfos(resize_infos, multiplier);
 		}
+		break;
+	}
+	case VectorBufferType::ARRAY_BUFFER: {
+		// We need to multiply the multiplier by the array size because
+		// the child vectors of ARRAY types are always child_count * array_size.
+		auto &vector_array_buffer = auxiliary->Cast<VectorArrayBuffer>();
+		auto new_multiplier = vector_array_buffer.GetArraySize() * multiplier;
+		auto &child = vector_array_buffer.GetChild();
+		child.FindResizeInfos(resize_infos, new_multiplier);
+		break;
+	}
+	default:
+		break;
 	}
 }
-void Vector::Resize(idx_t cur_size, idx_t new_size) {
-	vector<DataArrays> to_resize;
+
+void Vector::Resize(idx_t current_size, idx_t new_size) {
+	// The vector does not contain any data.
 	if (!buffer) {
 		buffer = make_buffer<VectorBuffer>(0);
 	}
-	if (!data) {
-		//! this is a nested structure
-		DataArrays arrays(*this, data, buffer.get(), GetTypeIdSize(GetType().InternalType()), true);
-		to_resize.emplace_back(arrays);
 
-		// The child vectors of ArrayTypes always have to be (size * array_size), so we need to multiply the
-		// resize amount by the array size recursively for every nested array.
-		auto start_multiplier = GetType().id() == LogicalTypeId::ARRAY ? ArrayType::GetSize(GetType()) : 1;
-		FindChildren(to_resize, *auxiliary, start_multiplier);
-	} else {
-		DataArrays arrays(*this, data, buffer.get(), GetTypeIdSize(GetType().InternalType()), false);
-		to_resize.emplace_back(arrays);
-	}
-	for (auto &data_to_resize : to_resize) {
-		if (!data_to_resize.is_nested) {
-			auto new_data =
-			    make_unsafe_uniq_array<data_t>(new_size * data_to_resize.type_size * data_to_resize.nested_multiplier);
-			memcpy(new_data.get(), data_to_resize.data,
-			       cur_size * data_to_resize.type_size * data_to_resize.nested_multiplier * sizeof(data_t));
-			data_to_resize.buffer->SetData(std::move(new_data));
-			data_to_resize.vec.data = data_to_resize.buffer->GetData();
+	// Obtain the resize information for each (nested) vector.
+	vector<ResizeInfo> resize_infos;
+	FindResizeInfos(resize_infos, 1);
+
+	for (auto &resize_info_entry : resize_infos) {
+		// Resize the validity mask.
+		auto new_validity_size = new_size * resize_info_entry.multiplier;
+		resize_info_entry.vec.validity.Resize(current_size, new_validity_size);
+
+		// For nested data types, we only need to resize the validity mask.
+		if (!resize_info_entry.data) {
+			continue;
 		}
-		data_to_resize.vec.validity.Resize(cur_size, new_size * data_to_resize.nested_multiplier);
+
+		auto type_size = GetTypeIdSize(resize_info_entry.vec.GetType().InternalType());
+		auto old_size = current_size * type_size * resize_info_entry.multiplier * sizeof(data_t);
+		auto target_size = new_size * type_size * resize_info_entry.multiplier * sizeof(data_t);
+
+		// We have an upper limit of 128GB for a single vector.
+		if (target_size > DConstants::MAX_VECTOR_SIZE) {
+			throw OutOfRangeException("Cannot resize vector to %s: maximum allowed vector size is %s",
+			                          StringUtil::BytesToHumanReadableString(target_size),
+			                          StringUtil::BytesToHumanReadableString(DConstants::MAX_VECTOR_SIZE));
+		}
+
+		// Copy the data buffer to a resized buffer.
+		auto new_data = make_unsafe_uniq_array<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();
 	}
 }
 
@@ -555,7 +534,7 @@ Value Vector::GetValueInternal(const Vector &v_p, idx_t index_p) {
 		case VectorType::SEQUENCE_VECTOR: {
 			int64_t start, increment;
 			SequenceVector::GetSequence(*vector, start, increment);
-			return Value::Numeric(vector->GetType(), start + increment * index);
+			return Value::Numeric(vector->GetType(), start + increment * NumericCast<int64_t>(index));
 		}
 		default:
 			throw InternalException("Unimplemented vector type for Vector::GetValue");
@@ -788,7 +767,7 @@ string Vector::ToString(idx_t count) const {
 		int64_t start, increment;
 		SequenceVector::GetSequence(*this, start, increment);
 		for (idx_t i = 0; i < count; i++) {
-			retval += to_string(start + increment * i) + (i == count - 1 ? "" : ", ");
+			retval += to_string(start + increment * UnsafeNumericCast<int64_t>(i)) + (i == count - 1 ? "" : ", ");
 		}
 		break;
 	}
@@ -1006,7 +985,7 @@ void Vector::Flatten(idx_t count) {
 
 		buffer = VectorBuffer::CreateStandardVector(GetType());
 		data = buffer->GetData();
-		VectorOperations::GenerateSequence(*this, sequence_count, start, increment);
+		VectorOperations::GenerateSequence(*this, NumericCast<idx_t>(sequence_count), start, increment);
 		break;
 	}
 	default:
@@ -1213,7 +1192,7 @@ void Vector::Deserialize(Deserializer &deserializer, idx_t count) {
 	validity.Reset();
 	const auto has_validity = deserializer.ReadProperty<bool>(100, "all_valid");
 	if (has_validity) {
-		validity.Initialize(count);
+		validity.Initialize(MaxValue<idx_t>(count, STANDARD_VECTOR_SIZE));
 		deserializer.ReadProperty(101, "validity", data_ptr_cast(validity.GetData()), validity.ValidityMaskSize(count));
 	}
 
@@ -2089,10 +2068,6 @@ void MapVector::EvalMapInvalidReason(MapInvalidReason reason) {
 		throw InvalidInputException("Map keys must be unique.");
 	case MapInvalidReason::NULL_KEY:
 		throw InvalidInputException("Map keys can not be NULL.");
-	case MapInvalidReason::NULL_KEY_LIST:
-		throw InvalidInputException("The list of map keys must not be NULL.");
-	case MapInvalidReason::NULL_VALUE_LIST:
-		throw InvalidInputException("The list of map values must not be NULL.");
 	case MapInvalidReason::NOT_ALIGNED:
 		throw InvalidInputException("The map key list does not align with the map value list.");
 	case MapInvalidReason::INVALID_PARAMS:

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

@@ -68,6 +68,10 @@ 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;
+		}
 		D_ASSERT(new_capacity >= to_reserve);
 		child->Resize(capacity, new_capacity);
 		capacity = new_capacity;

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

@@ -18,7 +18,7 @@ public:
 			auto &child_type = ListType::GetChildType(type);
 			child_caches.push_back(make_buffer<VectorCacheBuffer>(allocator, child_type, capacity));
 			auto child_vector = make_uniq<Vector>(child_type, false, false);
-			auxiliary = make_shared<VectorListBuffer>(std::move(child_vector));
+			auxiliary = make_shared_ptr<VectorListBuffer>(std::move(child_vector));
 			break;
 		}
 		case PhysicalType::ARRAY: {
@@ -26,7 +26,7 @@ public:
 			auto array_size = ArrayType::GetSize(type);
 			child_caches.push_back(make_buffer<VectorCacheBuffer>(allocator, child_type, array_size * capacity));
 			auto child_vector = make_uniq<Vector>(child_type, true, false, array_size * capacity);
-			auxiliary = make_shared<VectorArrayBuffer>(std::move(child_vector), array_size, capacity);
+			auxiliary = make_shared_ptr<VectorArrayBuffer>(std::move(child_vector), array_size, capacity);
 			break;
 		}
 		case PhysicalType::STRUCT: {
@@ -34,7 +34,7 @@ public:
 			for (auto &child_type : child_types) {
 				child_caches.push_back(make_buffer<VectorCacheBuffer>(allocator, child_type.second, capacity));
 			}
-			auto struct_buffer = make_shared<VectorStructBuffer>(type);
+			auto struct_buffer = make_shared_ptr<VectorStructBuffer>(type);
 			auxiliary = std::move(struct_buffer);
 			break;
 		}