duckdb 0.10.3-dev3.0 → 0.10.3-dev8.0

package/src/duckdb/src/common/extra_type_info.cpp

@@ -17,6 +17,28 @@ ExtraTypeInfo::ExtraTypeInfo(ExtraTypeInfoType type, string alias) : type(type),
 }
 ExtraTypeInfo::~ExtraTypeInfo() {
 }
+shared_ptr<ExtraTypeInfo> ExtraTypeInfo::Copy() const {
+	return make_shared_ptr<ExtraTypeInfo>(*this);
+}
+
+static bool CompareModifiers(const vector<Value> &left, const vector<Value> &right) {
+	// Check if the common prefix of the properties is the same for both types
+	auto common_props = MinValue(left.size(), right.size());
+	for (idx_t i = 0; i < common_props; i++) {
+		if (left[i].type() != right[i].type()) {
+			return false;
+		}
+		// Special case for nulls:
+		// For type modifiers, NULL is equivalent to ANY
+		if (left[i].IsNull() || right[i].IsNull()) {
+			continue;
+		}
+		if (left[i] != right[i]) {
+			return false;
+		}
+	}
+	return true;
+}
 
 bool ExtraTypeInfo::Equals(ExtraTypeInfo *other_p) const {
 	if (type == ExtraTypeInfoType::INVALID_TYPE_INFO || type == ExtraTypeInfoType::STRING_TYPE_INFO ||
@@ -31,6 +53,9 @@ bool ExtraTypeInfo::Equals(ExtraTypeInfo *other_p) const {
 		if (alias != other_p->alias) {
 			return false;
 		}
+		if (!CompareModifiers(modifiers, other_p->modifiers)) {
+			return false;
+		}
 		return true;
 	}
 	if (!other_p) {
@@ -39,7 +64,13 @@ bool ExtraTypeInfo::Equals(ExtraTypeInfo *other_p) const {
 	if (type != other_p->type) {
 		return false;
 	}
-	return alias == other_p->alias && EqualsInternal(other_p);
+	if (alias != other_p->alias) {
+		return false;
+	}
+	if (!CompareModifiers(modifiers, other_p->modifiers)) {
+		return false;
+	}
+	return EqualsInternal(other_p);
 }
 
 bool ExtraTypeInfo::EqualsInternal(ExtraTypeInfo *other_p) const {
@@ -63,6 +94,10 @@ bool DecimalTypeInfo::EqualsInternal(ExtraTypeInfo *other_p) const {
 	return width == other.width && scale == other.scale;
 }
 
+shared_ptr<ExtraTypeInfo> DecimalTypeInfo::Copy() const {
+	return make_shared_ptr<DecimalTypeInfo>(*this);
+}
+
 //===--------------------------------------------------------------------===//
 // String Type Info
 //===--------------------------------------------------------------------===//
@@ -78,6 +113,10 @@ bool StringTypeInfo::EqualsInternal(ExtraTypeInfo *other_p) const {
 	return true;
 }
 
+shared_ptr<ExtraTypeInfo> StringTypeInfo::Copy() const {
+	return make_shared_ptr<StringTypeInfo>(*this);
+}
+
 //===--------------------------------------------------------------------===//
 // List Type Info
 //===--------------------------------------------------------------------===//
@@ -93,6 +132,10 @@ bool ListTypeInfo::EqualsInternal(ExtraTypeInfo *other_p) const {
 	return child_type == other.child_type;
 }
 
+shared_ptr<ExtraTypeInfo> ListTypeInfo::Copy() const {
+	return make_shared_ptr<ListTypeInfo>(*this);
+}
+
 //===--------------------------------------------------------------------===//
 // Struct Type Info
 //===--------------------------------------------------------------------===//
@@ -108,6 +151,10 @@ bool StructTypeInfo::EqualsInternal(ExtraTypeInfo *other_p) const {
 	return child_types == other.child_types;
 }
 
+shared_ptr<ExtraTypeInfo> StructTypeInfo::Copy() const {
+	return make_shared_ptr<StructTypeInfo>(*this);
+}
+
 //===--------------------------------------------------------------------===//
 // Aggregate State Type Info
 //===--------------------------------------------------------------------===//
@@ -125,6 +172,10 @@ bool AggregateStateTypeInfo::EqualsInternal(ExtraTypeInfo *other_p) const {
 	       state_type.bound_argument_types == other.state_type.bound_argument_types;
 }
 
+shared_ptr<ExtraTypeInfo> AggregateStateTypeInfo::Copy() const {
+	return make_shared_ptr<AggregateStateTypeInfo>(*this);
+}
+
 //===--------------------------------------------------------------------===//
 // User Type Info
 //===--------------------------------------------------------------------===//
@@ -135,9 +186,14 @@ UserTypeInfo::UserTypeInfo(string name_p)
     : ExtraTypeInfo(ExtraTypeInfoType::USER_TYPE_INFO), user_type_name(std::move(name_p)) {
 }
 
-UserTypeInfo::UserTypeInfo(string catalog_p, string schema_p, string name_p)
+UserTypeInfo::UserTypeInfo(string name_p, vector<Value> modifiers_p)
+    : ExtraTypeInfo(ExtraTypeInfoType::USER_TYPE_INFO), user_type_name(std::move(name_p)),
+      user_type_modifiers(std::move(modifiers_p)) {
+}
+
+UserTypeInfo::UserTypeInfo(string catalog_p, string schema_p, string name_p, vector<Value> modifiers_p)
     : ExtraTypeInfo(ExtraTypeInfoType::USER_TYPE_INFO), catalog(std::move(catalog_p)), schema(std::move(schema_p)),
-      user_type_name(std::move(name_p)) {
+      user_type_name(std::move(name_p)), user_type_modifiers(std::move(modifiers_p)) {
 }
 
 bool UserTypeInfo::EqualsInternal(ExtraTypeInfo *other_p) const {
@@ -145,6 +201,10 @@ bool UserTypeInfo::EqualsInternal(ExtraTypeInfo *other_p) const {
 	return other.user_type_name == user_type_name;
 }
 
+shared_ptr<ExtraTypeInfo> UserTypeInfo::Copy() const {
+	return make_shared_ptr<UserTypeInfo>(*this);
+}
+
 //===--------------------------------------------------------------------===//
 // Enum Type Info
 //===--------------------------------------------------------------------===//
@@ -190,7 +250,7 @@ struct EnumTypeInfoTemplated : public EnumTypeInfo {
 		deserializer.ReadList(201, "values", [&](Deserializer::List &list, idx_t i) {
 			strings[i] = StringVector::AddStringOrBlob(values_insert_order, list.ReadElement<string>());
 		});
-		return make_shared<EnumTypeInfoTemplated>(values_insert_order, size);
+		return make_shared_ptr<EnumTypeInfoTemplated>(values_insert_order, size);
 	}
 
 	const string_map_t<T> &GetValues() const {
@@ -227,13 +287,13 @@ LogicalType EnumTypeInfo::CreateType(Vector &ordered_data, idx_t size) {
 	auto enum_internal_type = EnumTypeInfo::DictType(size);
 	switch (enum_internal_type) {
 	case PhysicalType::UINT8:
-		info = make_shared<EnumTypeInfoTemplated<uint8_t>>(ordered_data, size);
+		info = make_shared_ptr<EnumTypeInfoTemplated<uint8_t>>(ordered_data, size);
 		break;
 	case PhysicalType::UINT16:
-		info = make_shared<EnumTypeInfoTemplated<uint16_t>>(ordered_data, size);
+		info = make_shared_ptr<EnumTypeInfoTemplated<uint16_t>>(ordered_data, size);
 		break;
 	case PhysicalType::UINT32:
-		info = make_shared<EnumTypeInfoTemplated<uint32_t>>(ordered_data, size);
+		info = make_shared_ptr<EnumTypeInfoTemplated<uint32_t>>(ordered_data, size);
 		break;
 	default:
 		throw InternalException("Invalid Physical Type for ENUMs");
@@ -318,6 +378,12 @@ void EnumTypeInfo::Serialize(Serializer &serializer) const {
 	                     [&](Serializer::List &list, idx_t i) { list.WriteElement(strings[i]); });
 }
 
+shared_ptr<ExtraTypeInfo> EnumTypeInfo::Copy() const {
+	Vector values_insert_order_copy(LogicalType::VARCHAR, false, false, 0);
+	values_insert_order_copy.Reference(values_insert_order);
+	return make_shared_ptr<EnumTypeInfo>(values_insert_order_copy, dict_size);
+}
+
 //===--------------------------------------------------------------------===//
 // ArrayTypeInfo
 //===--------------------------------------------------------------------===//
@@ -331,6 +397,10 @@ bool ArrayTypeInfo::EqualsInternal(ExtraTypeInfo *other_p) const {
 	return child_type == other.child_type && size == other.size;
 }
 
+shared_ptr<ExtraTypeInfo> ArrayTypeInfo::Copy() const {
+	return make_shared_ptr<ArrayTypeInfo>(*this);
+}
+
 //===--------------------------------------------------------------------===//
 // Any Type Info
 //===--------------------------------------------------------------------===//
@@ -346,8 +416,12 @@ bool AnyTypeInfo::EqualsInternal(ExtraTypeInfo *other_p) const {
 	return target_type == other.target_type && cast_score == other.cast_score;
 }
 
+shared_ptr<ExtraTypeInfo> AnyTypeInfo::Copy() const {
+	return make_shared_ptr<AnyTypeInfo>(*this);
+}
+
 //===--------------------------------------------------------------------===//
-// Any Type Info
+// Integer Literal Type Info
 //===--------------------------------------------------------------------===//
 IntegerLiteralTypeInfo::IntegerLiteralTypeInfo() : ExtraTypeInfo(ExtraTypeInfoType::INTEGER_LITERAL_TYPE_INFO) {
 }
@@ -361,4 +435,8 @@ bool IntegerLiteralTypeInfo::EqualsInternal(ExtraTypeInfo *other_p) const {
 	return constant_value == other.constant_value;
 }
 
+shared_ptr<ExtraTypeInfo> IntegerLiteralTypeInfo::Copy() const {
+	return make_shared_ptr<IntegerLiteralTypeInfo>(*this);
+}
+
 } // namespace duckdb

package/src/duckdb/src/common/file_system.cpp

@@ -12,6 +12,7 @@
 #include "duckdb/main/database.hpp"
 #include "duckdb/main/extension_helper.hpp"
 #include "duckdb/common/windows_util.hpp"
+#include "duckdb/common/operator/multiply.hpp"
 
 #include <cstdint>
 #include <cstdio>
@@ -21,6 +22,7 @@
 #include <fcntl.h>
 #include <string.h>
 #include <sys/stat.h>
+#include <sys/statvfs.h>
 #include <sys/types.h>
 #include <unistd.h>
 
@@ -133,6 +135,24 @@ optional_idx FileSystem::GetAvailableMemory() {
 	return max_memory;
 }
 
+optional_idx FileSystem::GetAvailableDiskSpace(const string &path) {
+	struct statvfs vfs;
+
+	auto ret = statvfs(path.c_str(), &vfs);
+	if (ret == -1) {
+		return optional_idx();
+	}
+	auto block_size = vfs.f_frsize;
+	// These are the blocks available for creating new files or extending existing ones
+	auto available_blocks = vfs.f_bfree;
+	idx_t available_disk_space = DConstants::INVALID_INDEX;
+	if (!TryMultiplyOperator::Operation(static_cast<idx_t>(block_size), static_cast<idx_t>(available_blocks),
+	                                    available_disk_space)) {
+		return optional_idx();
+	}
+	return available_disk_space;
+}
+
 string FileSystem::GetWorkingDirectory() {
 	auto buffer = make_unsafe_uniq_array<char>(PATH_MAX);
 	char *ret = getcwd(buffer.get(), PATH_MAX);
@@ -233,6 +253,18 @@ optional_idx FileSystem::GetAvailableMemory() {
 	return optional_idx();
 }
 
+optional_idx FileSystem::GetAvailableDiskSpace(const string &path) {
+	ULARGE_INTEGER available_bytes, total_bytes, free_bytes;
+
+	auto unicode_path = WindowsUtil::UTF8ToUnicode(path.c_str());
+	if (!GetDiskFreeSpaceExW(unicode_path.c_str(), &available_bytes, &total_bytes, &free_bytes)) {
+		return optional_idx();
+	}
+	(void)total_bytes;
+	(void)free_bytes;
+	return NumericCast<idx_t>(available_bytes.QuadPart);
+}
+
 string FileSystem::GetWorkingDirectory() {
 	idx_t count = GetCurrentDirectoryW(0, nullptr);
 	if (count == 0) {
@@ -517,7 +549,7 @@ FileHandle::~FileHandle() {
 }
 
 int64_t FileHandle::Read(void *buffer, idx_t nr_bytes) {
-	return file_system.Read(*this, buffer, nr_bytes);
+	return file_system.Read(*this, buffer, UnsafeNumericCast<int64_t>(nr_bytes));
 }
 
 bool FileHandle::Trim(idx_t offset_bytes, idx_t length_bytes) {
@@ -525,15 +557,15 @@ bool FileHandle::Trim(idx_t offset_bytes, idx_t length_bytes) {
 }
 
 int64_t FileHandle::Write(void *buffer, idx_t nr_bytes) {
-	return file_system.Write(*this, buffer, nr_bytes);
+	return file_system.Write(*this, buffer, UnsafeNumericCast<int64_t>(nr_bytes));
 }
 
 void FileHandle::Read(void *buffer, idx_t nr_bytes, idx_t location) {
-	file_system.Read(*this, buffer, nr_bytes, location);
+	file_system.Read(*this, buffer, UnsafeNumericCast<int64_t>(nr_bytes), location);
 }
 
 void FileHandle::Write(void *buffer, idx_t nr_bytes, idx_t location) {
-	file_system.Write(*this, buffer, nr_bytes, location);
+	file_system.Write(*this, buffer, UnsafeNumericCast<int64_t>(nr_bytes), location);
 }
 
 void FileHandle::Seek(idx_t location) {
@@ -560,7 +592,7 @@ string FileHandle::ReadLine() {
 	string result;
 	char buffer[1];
 	while (true) {
-		idx_t tuples_read = Read(buffer, 1);
+		auto tuples_read = UnsafeNumericCast<idx_t>(Read(buffer, 1));
 		if (tuples_read == 0 || buffer[0] == '\n') {
 			return result;
 		}
@@ -575,7 +607,7 @@ bool FileHandle::OnDiskFile() {
 }
 
 idx_t FileHandle::GetFileSize() {
-	return file_system.GetFileSize(*this);
+	return NumericCast<idx_t>(file_system.GetFileSize(*this));
 }
 
 void FileHandle::Sync() {
@@ -591,7 +623,7 @@ FileType FileHandle::GetType() {
 }
 
 bool FileSystem::IsRemoteFile(const string &path) {
-	const string prefixes[] = {"http://", "https://", "s3://", "s3a://", "s3n://", "gcs://", "gs://", "r2://"};
+	const string prefixes[] = {"http://", "https://", "s3://", "s3a://", "s3n://", "gcs://", "gs://", "r2://", "hf://"};
 	for (auto &prefix : prefixes) {
 		if (StringUtil::StartsWith(path, prefix)) {
 			return true;

package/src/duckdb/src/common/gzip_file_system.cpp

@@ -120,13 +120,13 @@ void MiniZStreamWrapper::Initialize(CompressedFile &file, bool write) {
 	} else {
 		idx_t data_start = GZIP_HEADER_MINSIZE;
 		auto read_count = file.child_handle->Read(gzip_hdr, GZIP_HEADER_MINSIZE);
-		GZipFileSystem::VerifyGZIPHeader(gzip_hdr, read_count);
+		GZipFileSystem::VerifyGZIPHeader(gzip_hdr, NumericCast<idx_t>(read_count));
 		// Skip over the extra field if necessary
 		if (gzip_hdr[3] & GZIP_FLAG_EXTRA) {
 			uint8_t gzip_xlen[2];
 			file.child_handle->Seek(data_start);
 			file.child_handle->Read(gzip_xlen, 2);
-			idx_t xlen = (uint8_t)gzip_xlen[0] | (uint8_t)gzip_xlen[1] << 8;
+			auto xlen = NumericCast<idx_t>((uint8_t)gzip_xlen[0] | (uint8_t)gzip_xlen[1] << 8);
 			data_start += xlen + 2;
 		}
 		// Skip over the file name if necessary
@@ -160,7 +160,7 @@ bool MiniZStreamWrapper::Read(StreamData &sd) {
 		GZipFileSystem::VerifyGZIPHeader(gzip_hdr, GZIP_HEADER_MINSIZE);
 		body_ptr += GZIP_HEADER_MINSIZE;
 		if (gzip_hdr[3] & GZIP_FLAG_EXTRA) {
-			idx_t xlen = (uint8_t)*body_ptr | (uint8_t) * (body_ptr + 1) << 8;
+			auto xlen = NumericCast<idx_t>((uint8_t)*body_ptr | (uint8_t) * (body_ptr + 1) << 8);
 			body_ptr += xlen + 2;
 			if (GZIP_FOOTER_SIZE + GZIP_HEADER_MINSIZE + 2 + xlen >= GZIP_HEADER_MAXSIZE) {
 				throw InternalException("Extra field resulting in GZIP header larger than defined maximum (%d)",
@@ -170,7 +170,7 @@ bool MiniZStreamWrapper::Read(StreamData &sd) {
 		if (gzip_hdr[3] & GZIP_FLAG_NAME) {
 			char c;
 			do {
-				c = *body_ptr;
+				c = UnsafeNumericCast<char>(*body_ptr);
 				body_ptr++;
 			} while (c != '\0' && body_ptr < sd.in_buff_end);
 			if ((idx_t)(body_ptr - sd.in_buff_start) >= GZIP_HEADER_MAXSIZE) {
@@ -217,12 +217,13 @@ bool MiniZStreamWrapper::Read(StreamData &sd) {
 void MiniZStreamWrapper::Write(CompressedFile &file, StreamData &sd, data_ptr_t uncompressed_data,
                                int64_t uncompressed_size) {
 	// update the src and the total size
-	crc = duckdb_miniz::mz_crc32(crc, reinterpret_cast<const unsigned char *>(uncompressed_data), uncompressed_size);
-	total_size += uncompressed_size;
+	crc = duckdb_miniz::mz_crc32(crc, reinterpret_cast<const unsigned char *>(uncompressed_data),
+	                             UnsafeNumericCast<size_t>(uncompressed_size));
+	total_size += UnsafeNumericCast<idx_t>(uncompressed_size);
 
 	auto remaining = uncompressed_size;
 	while (remaining > 0) {
-		idx_t output_remaining = (sd.out_buff.get() + sd.out_buf_size) - sd.out_buff_start;
+		auto output_remaining = UnsafeNumericCast<idx_t>((sd.out_buff.get() + sd.out_buf_size) - sd.out_buff_start);
 
 		mz_stream_ptr->next_in = reinterpret_cast<const unsigned char *>(uncompressed_data);
 		mz_stream_ptr->avail_in = NumericCast<unsigned int>(remaining);
@@ -237,10 +238,11 @@ void MiniZStreamWrapper::Write(CompressedFile &file, StreamData &sd, data_ptr_t
 		sd.out_buff_start += output_remaining - mz_stream_ptr->avail_out;
 		if (mz_stream_ptr->avail_out == 0) {
 			// no more output buffer available: flush
-			file.child_handle->Write(sd.out_buff.get(), sd.out_buff_start - sd.out_buff.get());
+			file.child_handle->Write(sd.out_buff.get(),
+			                         UnsafeNumericCast<idx_t>(sd.out_buff_start - sd.out_buff.get()));
 			sd.out_buff_start = sd.out_buff.get();
 		}
-		idx_t written = remaining - mz_stream_ptr->avail_in;
+		auto written = UnsafeNumericCast<idx_t>(remaining - mz_stream_ptr->avail_in);
 		uncompressed_data += written;
 		remaining = mz_stream_ptr->avail_in;
 	}
@@ -258,7 +260,8 @@ void MiniZStreamWrapper::FlushStream() {
 		auto res = mz_deflate(mz_stream_ptr.get(), duckdb_miniz::MZ_FINISH);
 		sd.out_buff_start += (output_remaining - mz_stream_ptr->avail_out);
 		if (sd.out_buff_start > sd.out_buff.get()) {
-			file->child_handle->Write(sd.out_buff.get(), sd.out_buff_start - sd.out_buff.get());
+			file->child_handle->Write(sd.out_buff.get(),
+			                          UnsafeNumericCast<idx_t>(sd.out_buff_start - sd.out_buff.get()));
 			sd.out_buff_start = sd.out_buff.get();
 		}
 		if (res == duckdb_miniz::MZ_STREAM_END) {
@@ -317,9 +320,30 @@ void GZipFileSystem::VerifyGZIPHeader(uint8_t gzip_hdr[], idx_t read_count) {
 	}
 }
 
+bool GZipFileSystem::CheckIsZip(const char *data, duckdb::idx_t size) {
+	if (size < GZIP_HEADER_MINSIZE) {
+		return false;
+	}
+
+	auto data_ptr = reinterpret_cast<const uint8_t *>(data);
+	if (data_ptr[0] != 0x1F || data_ptr[1] != 0x8B) {
+		return false;
+	}
+
+	if (data_ptr[2] != GZIP_COMPRESSION_DEFLATE) {
+		return false;
+	}
+
+	return true;
+}
+
 string GZipFileSystem::UncompressGZIPString(const string &in) {
+	return UncompressGZIPString(in.data(), in.size());
+}
+
+string GZipFileSystem::UncompressGZIPString(const char *data, idx_t size) {
 	// decompress file
-	auto body_ptr = in.data();
+	auto body_ptr = data;
 
 	auto mz_stream_ptr = make_uniq<duckdb_miniz::mz_stream>();
 	memset(mz_stream_ptr.get(), 0, sizeof(duckdb_miniz::mz_stream));
@@ -329,7 +353,7 @@ string GZipFileSystem::UncompressGZIPString(const string &in) {
 	// check for incorrectly formatted files
 
 	// TODO this is mostly the same as gzip_file_system.cpp
-	if (in.size() < GZIP_HEADER_MINSIZE) {
+	if (size < GZIP_HEADER_MINSIZE) {
 		throw IOException("Input is not a GZIP stream");
 	}
 	memcpy(gzip_hdr, body_ptr, GZIP_HEADER_MINSIZE);
@@ -345,7 +369,7 @@ string GZipFileSystem::UncompressGZIPString(const string &in) {
 		do {
 			c = *body_ptr;
 			body_ptr++;
-		} while (c != '\0' && (idx_t)(body_ptr - in.data()) < in.size());
+		} while (c != '\0' && (idx_t)(body_ptr - data) < size);
 	}
 
 	// stream is now set to beginning of payload data
@@ -354,7 +378,7 @@ string GZipFileSystem::UncompressGZIPString(const string &in) {
 		throw InternalException("Failed to initialize miniz");
 	}
 
-	auto bytes_remaining = in.size() - (body_ptr - in.data());
+	auto bytes_remaining = size - NumericCast<idx_t>(body_ptr - data);
 	mz_stream_ptr->next_in = const_uchar_ptr_cast(body_ptr);
 	mz_stream_ptr->avail_in = NumericCast<unsigned int>(bytes_remaining);
 

package/src/duckdb/src/common/hive_partitioning.cpp

@@ -148,17 +148,6 @@ void HivePartitioning::ApplyFiltersToFileList(ClientContext &context, vector<str
 	files = std::move(pruned_files);
 }
 
-HivePartitionedColumnData::HivePartitionedColumnData(const HivePartitionedColumnData &other)
-    : PartitionedColumnData(other), hashes_v(LogicalType::HASH) {
-	// Synchronize to ensure consistency of shared partition map
-	if (other.global_state) {
-		global_state = other.global_state;
-		unique_lock<mutex> lck(global_state->lock);
-		SynchronizeLocalMap();
-	}
-	InitializeKeys();
-}
-
 void HivePartitionedColumnData::InitializeKeys() {
 	keys.resize(STANDARD_VECTOR_SIZE);
 	for (idx_t i = 0; i < STANDARD_VECTOR_SIZE; i++) {
@@ -320,82 +309,45 @@ std::map<idx_t, const HivePartitionKey *> HivePartitionedColumnData::GetReverseM
 	return ret;
 }
 
-void HivePartitionedColumnData::GrowAllocators() {
-	unique_lock<mutex> lck_gstate(allocators->lock);
-
-	idx_t current_allocator_size = allocators->allocators.size();
-	idx_t required_allocators = local_partition_map.size();
-
-	allocators->allocators.reserve(current_allocator_size);
-	for (idx_t i = current_allocator_size; i < required_allocators; i++) {
-		CreateAllocator();
-	}
-
-	D_ASSERT(allocators->allocators.size() == local_partition_map.size());
-}
-
-void HivePartitionedColumnData::GrowAppendState(PartitionedColumnDataAppendState &state) {
-	idx_t current_append_state_size = state.partition_append_states.size();
-	idx_t required_append_state_size = local_partition_map.size();
-
-	for (idx_t i = current_append_state_size; i < required_append_state_size; i++) {
-		state.partition_append_states.emplace_back(make_uniq<ColumnDataAppendState>());
-		state.partition_buffers.emplace_back(CreatePartitionBuffer());
-	}
+HivePartitionedColumnData::HivePartitionedColumnData(ClientContext &context, vector<LogicalType> types,
+                                                     vector<idx_t> partition_by_cols,
+                                                     shared_ptr<GlobalHivePartitionState> global_state)
+    : PartitionedColumnData(PartitionedColumnDataType::HIVE, context, std::move(types)),
+      global_state(std::move(global_state)), group_by_columns(std::move(partition_by_cols)),
+      hashes_v(LogicalType::HASH) {
+	InitializeKeys();
+	CreateAllocator();
 }
 
-void HivePartitionedColumnData::GrowPartitions(PartitionedColumnDataAppendState &state) {
-	idx_t current_partitions = partitions.size();
-	idx_t required_partitions = local_partition_map.size();
-
-	D_ASSERT(allocators->allocators.size() == required_partitions);
-
-	for (idx_t i = current_partitions; i < required_partitions; i++) {
-		partitions.emplace_back(CreatePartitionCollection(i));
-		partitions[i]->InitializeAppend(*state.partition_append_states[i]);
-	}
-	D_ASSERT(partitions.size() == local_partition_map.size());
-}
+void HivePartitionedColumnData::AddNewPartition(HivePartitionKey key, idx_t partition_id,
+                                                PartitionedColumnDataAppendState &state) {
+	local_partition_map.emplace(std::move(key), partition_id);
 
-void HivePartitionedColumnData::SynchronizeLocalMap() {
-	// Synchronise global map into local, may contain changes from other threads too
-	for (auto it = global_state->partitions.begin() + local_partition_map.size(); it < global_state->partitions.end();
-	     it++) {
-		local_partition_map[(*it)->first] = (*it)->second;
+	if (state.partition_append_states.size() <= partition_id) {
+		state.partition_append_states.resize(partition_id + 1);
+		state.partition_buffers.resize(partition_id + 1);
+		partitions.resize(partition_id + 1);
 	}
+	state.partition_append_states[partition_id] = make_uniq<ColumnDataAppendState>();
+	state.partition_buffers[partition_id] = CreatePartitionBuffer();
+	partitions[partition_id] = CreatePartitionCollection(0);
+	partitions[partition_id]->InitializeAppend(*state.partition_append_states[partition_id]);
 }
 
 idx_t HivePartitionedColumnData::RegisterNewPartition(HivePartitionKey key, PartitionedColumnDataAppendState &state) {
+	idx_t partition_id;
 	if (global_state) {
-		idx_t partition_id;
-
-		// Synchronize Global state with our local state with the newly discoveren partition
-		{
-			unique_lock<mutex> lck_gstate(global_state->lock);
-
-			// Insert into global map, or return partition if already present
-			auto res =
-			    global_state->partition_map.emplace(std::make_pair(std::move(key), global_state->partition_map.size()));
-			auto it = res.first;
-			partition_id = it->second;
-
-			// Add iterator to vector to allow incrementally updating local states from global state
-			global_state->partitions.emplace_back(it);
-			SynchronizeLocalMap();
-		}
-
-		// After synchronizing with the global state, we need to grow the shared allocators to support
-		// the number of partitions, which guarantees that there's always enough allocators available to each thread
-		GrowAllocators();
-
-		// Grow local partition data
-		GrowAppendState(state);
-		GrowPartitions(state);
+		// Synchronize Global state with our local state with the newly discovered partition
+		unique_lock<mutex> lck_gstate(global_state->lock);
 
-		return partition_id;
+		// Insert into global map, or return partition if already present
+		auto res = global_state->partition_map.emplace(std::make_pair(key, global_state->partition_map.size()));
+		partition_id = res.first->second;
 	} else {
-		return local_partition_map.emplace(std::make_pair(std::move(key), local_partition_map.size())).first->second;
+		partition_id = local_partition_map.size();
 	}
+	AddNewPartition(std::move(key), partition_id, state);
+	return partition_id;
 }
 
 } // namespace duckdb

package/src/duckdb/src/common/http_state.cpp

@@ -26,7 +26,7 @@ void CachedFileHandle::AllocateBuffer(idx_t size) {
 	if (file->initialized) {
 		throw InternalException("Cannot allocate a buffer for a cached file that was already initialized");
 	}
-	file->data = std::shared_ptr<char>(new char[size], std::default_delete<char[]>());
+	file->data = shared_ptr<char>(new char[size], std::default_delete<char[]>());
 	file->capacity = size;
 }
 
@@ -62,14 +62,14 @@ shared_ptr<HTTPState> HTTPState::TryGetState(ClientContext &context, bool create
 	auto lookup = context.registered_state.find("http_state");
 
 	if (lookup != context.registered_state.end()) {
-		return std::static_pointer_cast<HTTPState, ClientContextState>(lookup->second);
+		return shared_ptr_cast<ClientContextState, HTTPState>(lookup->second);
 	}
 
 	if (!create_on_missing) {
 		return nullptr;
 	}
 
-	auto http_state = make_shared<HTTPState>();
+	auto http_state = make_shared_ptr<HTTPState>();
 	context.registered_state["http_state"] = http_state;
 	return http_state;
 }
@@ -87,7 +87,7 @@ shared_ptr<CachedFile> &HTTPState::GetCachedFile(const string &path) {
 	lock_guard<mutex> lock(cached_files_mutex);
 	auto &cache_entry_ref = cached_files[path];
 	if (!cache_entry_ref) {
-		cache_entry_ref = make_shared<CachedFile>();
+		cache_entry_ref = make_shared_ptr<CachedFile>();
 	}
 	return cache_entry_ref;
 }