duckdb 1.1.4-dev9.0 → 1.2.1-dev4.0

package/src/duckdb/src/common/arrow/arrow_type_extension.cpp

@@ -14,6 +14,11 @@ ArrowTypeExtension::ArrowTypeExtension(string extension_name, string arrow_forma
     : extension_metadata(std::move(extension_name), {}, {}, std::move(arrow_format)), type_extension(std::move(type)) {
 }
 
+ArrowTypeExtension::ArrowTypeExtension(ArrowExtensionMetadata &extension_metadata, unique_ptr<ArrowType> type)
+    : extension_metadata(extension_metadata) {
+	type_extension = make_shared_ptr<ArrowTypeExtensionData>(type->GetDuckType());
+}
+
 ArrowExtensionMetadata::ArrowExtensionMetadata(string extension_name, string vendor_name, string type_name,
                                                string arrow_format)
     : extension_name(std::move(extension_name)), vendor_name(std::move(vendor_name)), type_name(std::move(type_name)),
@@ -121,14 +126,14 @@ ArrowExtensionMetadata ArrowTypeExtension::GetInfo() const {
 	return extension_metadata;
 }
 
-shared_ptr<ArrowType> ArrowTypeExtension::GetType(const ArrowSchema &schema,
+unique_ptr<ArrowType> ArrowTypeExtension::GetType(const ArrowSchema &schema,
                                                   const ArrowSchemaMetadata &schema_metadata) const {
 	if (get_type) {
 		return get_type(schema, schema_metadata);
 	}
 	// FIXME: THis is not good
 	auto duckdb_type = type_extension->GetDuckDBType();
-	return make_shared_ptr<ArrowType>(duckdb_type);
+	return make_uniq<ArrowType>(duckdb_type);
 }
 
 shared_ptr<ArrowTypeExtensionData> ArrowTypeExtension::GetTypeExtension() const {
@@ -177,7 +182,7 @@ void ArrowTypeExtension::PopulateArrowSchema(DuckDBArrowSchemaHolder &root_holde
 }
 
 void DBConfig::RegisterArrowExtension(const ArrowTypeExtension &extension) const {
-	lock_guard<mutex> l(encoding_functions->lock);
+	lock_guard<mutex> l(arrow_extensions->lock);
 	auto extension_info = extension.GetInfo();
 	if (arrow_extensions->type_extensions.find(extension_info) != arrow_extensions->type_extensions.end()) {
 		throw NotImplementedException("Arrow Extension with configuration %s is already registered",
@@ -193,27 +198,39 @@ void DBConfig::RegisterArrowExtension(const ArrowTypeExtension &extension) const
 	arrow_extensions->type_to_info[type_info].push_back(extension_info);
 }
 
-ArrowTypeExtension DBConfig::GetArrowExtension(ArrowExtensionMetadata info) const {
-	if (arrow_extensions->type_extensions.find(info) == arrow_extensions->type_extensions.end()) {
+ArrowTypeExtension GetArrowExtensionInternal(
+    unordered_map<ArrowExtensionMetadata, ArrowTypeExtension, HashArrowTypeExtension> &type_extensions,
+    ArrowExtensionMetadata info) {
+	if (type_extensions.find(info) == type_extensions.end()) {
+		auto og_info = info;
 		info.SetArrowFormat("");
-		if (arrow_extensions->type_extensions.find(info) == arrow_extensions->type_extensions.end()) {
-			throw NotImplementedException("Arrow Extension with configuration:\n%s not yet registered",
-			                              info.ToString());
+		if (type_extensions.find(info) == type_extensions.end()) {
+			auto format = og_info.GetArrowFormat();
+			auto type = ArrowType::GetTypeFromFormat(format);
+			return ArrowTypeExtension(og_info, std::move(type));
 		}
 	}
-	return arrow_extensions->type_extensions[info];
+	return type_extensions[info];
+}
+ArrowTypeExtension DBConfig::GetArrowExtension(ArrowExtensionMetadata info) const {
+	lock_guard<mutex> l(arrow_extensions->lock);
+	return GetArrowExtensionInternal(arrow_extensions->type_extensions, std::move(info));
 }
 
 ArrowTypeExtension DBConfig::GetArrowExtension(const LogicalType &type) const {
+	lock_guard<mutex> l(arrow_extensions->lock);
 	TypeInfo type_info(type);
 	if (!arrow_extensions->type_to_info[type_info].empty()) {
-		return GetArrowExtension(arrow_extensions->type_to_info[type_info].front());
+		return GetArrowExtensionInternal(arrow_extensions->type_extensions,
+		                                 arrow_extensions->type_to_info[type_info].front());
 	}
 	type_info.type = LogicalTypeId::ANY;
-	return GetArrowExtension(arrow_extensions->type_to_info[type_info].front());
+	return GetArrowExtensionInternal(arrow_extensions->type_extensions,
+	                                 arrow_extensions->type_to_info[type_info].front());
 }
 
 bool DBConfig::HasArrowExtension(const LogicalType &type) const {
+	lock_guard<mutex> l(arrow_extensions->lock);
 	TypeInfo type_info(type);
 	if (!arrow_extensions->type_to_info[type_info].empty()) {
 		return true;
@@ -222,18 +239,33 @@ bool DBConfig::HasArrowExtension(const LogicalType &type) const {
 	return !arrow_extensions->type_to_info[type_info].empty();
 }
 
+bool DBConfig::HasArrowExtension(ArrowExtensionMetadata info) const {
+	lock_guard<mutex> l(arrow_extensions->lock);
+	auto type_extensions = arrow_extensions->type_extensions;
+
+	if (type_extensions.find(info) != type_extensions.end()) {
+		return true;
+	}
+
+	auto og_info = info;
+	info.SetArrowFormat("");
+	if (type_extensions.find(info) != type_extensions.end()) {
+		return true;
+	}
+
+	return false;
+}
+
 struct ArrowJson {
-	static shared_ptr<ArrowType> GetType(const ArrowSchema &schema, const ArrowSchemaMetadata &schema_metadata) {
+	static unique_ptr<ArrowType> GetType(const ArrowSchema &schema, const ArrowSchemaMetadata &schema_metadata) {
 		const auto format = string(schema.format);
 		if (format == "u") {
-			return make_shared_ptr<ArrowType>(LogicalType::JSON(),
-			                                  make_uniq<ArrowStringInfo>(ArrowVariableSizeType::NORMAL));
+			return make_uniq<ArrowType>(LogicalType::JSON(), make_uniq<ArrowStringInfo>(ArrowVariableSizeType::NORMAL));
 		} else if (format == "U") {
-			return make_shared_ptr<ArrowType>(LogicalType::JSON(),
-			                                  make_uniq<ArrowStringInfo>(ArrowVariableSizeType::NORMAL));
+			return make_uniq<ArrowType>(LogicalType::JSON(),
+			                            make_uniq<ArrowStringInfo>(ArrowVariableSizeType::SUPER_SIZE));
 		} else if (format == "vu") {
-			return make_shared_ptr<ArrowType>(LogicalType::JSON(),
-			                                  make_uniq<ArrowStringInfo>(ArrowVariableSizeType::NORMAL));
+			return make_uniq<ArrowType>(LogicalType::JSON(), make_uniq<ArrowStringInfo>(ArrowVariableSizeType::VIEW));
 		}
 		throw InvalidInputException("Arrow extension type \"%s\" not supported for arrow.json", format.c_str());
 	}
@@ -258,14 +290,13 @@ struct ArrowJson {
 };
 
 struct ArrowBit {
-	static shared_ptr<ArrowType> GetType(const ArrowSchema &schema, const ArrowSchemaMetadata &schema_metadata) {
+	static unique_ptr<ArrowType> GetType(const ArrowSchema &schema, const ArrowSchemaMetadata &schema_metadata) {
 		const auto format = string(schema.format);
 		if (format == "z") {
-			return make_shared_ptr<ArrowType>(LogicalType::BIT,
-			                                  make_uniq<ArrowStringInfo>(ArrowVariableSizeType::NORMAL));
+			return make_uniq<ArrowType>(LogicalType::BIT, make_uniq<ArrowStringInfo>(ArrowVariableSizeType::NORMAL));
 		} else if (format == "Z") {
-			return make_shared_ptr<ArrowType>(LogicalType::BIT,
-			                                  make_uniq<ArrowStringInfo>(ArrowVariableSizeType::SUPER_SIZE));
+			return make_uniq<ArrowType>(LogicalType::BIT,
+			                            make_uniq<ArrowStringInfo>(ArrowVariableSizeType::SUPER_SIZE));
 		}
 		throw InvalidInputException("Arrow extension type \"%s\" not supported for BIT type", format.c_str());
 	}
@@ -286,14 +317,13 @@ struct ArrowBit {
 };
 
 struct ArrowVarint {
-	static shared_ptr<ArrowType> GetType(const ArrowSchema &schema, const ArrowSchemaMetadata &schema_metadata) {
+	static unique_ptr<ArrowType> GetType(const ArrowSchema &schema, const ArrowSchemaMetadata &schema_metadata) {
 		const auto format = string(schema.format);
 		if (format == "z") {
-			return make_shared_ptr<ArrowType>(LogicalType::VARINT,
-			                                  make_uniq<ArrowStringInfo>(ArrowVariableSizeType::NORMAL));
+			return make_uniq<ArrowType>(LogicalType::VARINT, make_uniq<ArrowStringInfo>(ArrowVariableSizeType::NORMAL));
 		} else if (format == "Z") {
-			return make_shared_ptr<ArrowType>(LogicalType::VARINT,
-			                                  make_uniq<ArrowStringInfo>(ArrowVariableSizeType::SUPER_SIZE));
+			return make_uniq<ArrowType>(LogicalType::VARINT,
+			                            make_uniq<ArrowStringInfo>(ArrowVariableSizeType::SUPER_SIZE));
 		}
 		throw InvalidInputException("Arrow extension type \"%s\" not supported for Varint", format.c_str());
 	}

package/src/duckdb/src/common/arrow/schema_metadata.cpp

@@ -66,7 +66,7 @@ ArrowSchemaMetadata ArrowSchemaMetadata::NonCanonicalType(const string &type_nam
 
 bool ArrowSchemaMetadata::HasExtension() const {
 	auto arrow_extension = GetOption(ArrowSchemaMetadata::ARROW_EXTENSION_NAME);
-	return !arrow_extension.empty() && !StringUtil::StartsWith(arrow_extension, "ogc");
+	return !arrow_extension.empty();
 }
 
 ArrowExtensionMetadata ArrowSchemaMetadata::GetExtensionInfo(string format) {

package/src/duckdb/src/common/compressed_file_system.cpp

@@ -11,7 +11,11 @@ CompressedFile::CompressedFile(CompressedFileSystem &fs, unique_ptr<FileHandle>
 }
 
 CompressedFile::~CompressedFile() {
-	CompressedFile::Close();
+	try {
+		// stream_wrapper->Close() might throw
+		CompressedFile::Close();
+	} catch (...) { // NOLINT - cannot throw in exception
+	}
 }
 
 void CompressedFile::Initialize(bool write) {
@@ -44,7 +48,7 @@ int64_t CompressedFile::ReadData(void *buffer, int64_t remaining) {
 			auto available =
 			    MinValue<idx_t>(UnsafeNumericCast<idx_t>(remaining),
 			                    UnsafeNumericCast<idx_t>(stream_data.out_buff_end - stream_data.out_buff_start));
-			memcpy(data_ptr_t(buffer) + total_read, stream_data.out_buff_start, available);
+			memcpy(static_cast<data_ptr_t>(buffer) + total_read, stream_data.out_buff_start, available);
 
 			// increment the total read variables as required
 			stream_data.out_buff_start += available;

package/src/duckdb/src/common/enum_util.cpp

@@ -83,6 +83,7 @@
 #include "duckdb/common/types/vector_buffer.hpp"
 #include "duckdb/execution/index/art/art.hpp"
 #include "duckdb/execution/index/art/node.hpp"
+#include "duckdb/execution/index/bound_index.hpp"
 #include "duckdb/execution/operator/csv_scanner/csv_option.hpp"
 #include "duckdb/execution/operator/csv_scanner/csv_state.hpp"
 #include "duckdb/execution/operator/csv_scanner/quote_rules.hpp"
@@ -150,25 +151,6 @@
 
 namespace duckdb {
 
-const StringUtil::EnumStringLiteral *GetARTAppendModeValues() {
-	static constexpr StringUtil::EnumStringLiteral values[] {
-		{ static_cast<uint32_t>(ARTAppendMode::DEFAULT), "DEFAULT" },
-		{ static_cast<uint32_t>(ARTAppendMode::IGNORE_DUPLICATES), "IGNORE_DUPLICATES" },
-		{ static_cast<uint32_t>(ARTAppendMode::INSERT_DUPLICATES), "INSERT_DUPLICATES" }
-	};
-	return values;
-}
-
-template<>
-const char* EnumUtil::ToChars<ARTAppendMode>(ARTAppendMode value) {
-	return StringUtil::EnumToString(GetARTAppendModeValues(), 3, "ARTAppendMode", static_cast<uint32_t>(value));
-}
-
-template<>
-ARTAppendMode EnumUtil::FromString<ARTAppendMode>(const char *value) {
-	return static_cast<ARTAppendMode>(StringUtil::StringToEnum(GetARTAppendModeValues(), 3, "ARTAppendMode", value));
-}
-
 const StringUtil::EnumStringLiteral *GetARTConflictTypeValues() {
 	static constexpr StringUtil::EnumStringLiteral values[] {
 		{ static_cast<uint32_t>(ARTConflictType::NO_CONFLICT), "NO_CONFLICT" },
@@ -1878,6 +1860,25 @@ HLLStorageType EnumUtil::FromString<HLLStorageType>(const char *value) {
 	return static_cast<HLLStorageType>(StringUtil::StringToEnum(GetHLLStorageTypeValues(), 2, "HLLStorageType", value));
 }
 
+const StringUtil::EnumStringLiteral *GetIndexAppendModeValues() {
+	static constexpr StringUtil::EnumStringLiteral values[] {
+		{ static_cast<uint32_t>(IndexAppendMode::DEFAULT), "DEFAULT" },
+		{ static_cast<uint32_t>(IndexAppendMode::IGNORE_DUPLICATES), "IGNORE_DUPLICATES" },
+		{ static_cast<uint32_t>(IndexAppendMode::INSERT_DUPLICATES), "INSERT_DUPLICATES" }
+	};
+	return values;
+}
+
+template<>
+const char* EnumUtil::ToChars<IndexAppendMode>(IndexAppendMode value) {
+	return StringUtil::EnumToString(GetIndexAppendModeValues(), 3, "IndexAppendMode", static_cast<uint32_t>(value));
+}
+
+template<>
+IndexAppendMode EnumUtil::FromString<IndexAppendMode>(const char *value) {
+	return static_cast<IndexAppendMode>(StringUtil::StringToEnum(GetIndexAppendModeValues(), 3, "IndexAppendMode", value));
+}
+
 const StringUtil::EnumStringLiteral *GetIndexConstraintTypeValues() {
 	static constexpr StringUtil::EnumStringLiteral values[] {
 		{ static_cast<uint32_t>(IndexConstraintType::NONE), "NONE" },
@@ -4283,19 +4284,22 @@ const StringUtil::EnumStringLiteral *GetWindowBoundaryValues() {
 		{ static_cast<uint32_t>(WindowBoundary::EXPR_PRECEDING_ROWS), "EXPR_PRECEDING_ROWS" },
 		{ static_cast<uint32_t>(WindowBoundary::EXPR_FOLLOWING_ROWS), "EXPR_FOLLOWING_ROWS" },
 		{ static_cast<uint32_t>(WindowBoundary::EXPR_PRECEDING_RANGE), "EXPR_PRECEDING_RANGE" },
-		{ static_cast<uint32_t>(WindowBoundary::EXPR_FOLLOWING_RANGE), "EXPR_FOLLOWING_RANGE" }
+		{ static_cast<uint32_t>(WindowBoundary::EXPR_FOLLOWING_RANGE), "EXPR_FOLLOWING_RANGE" },
+		{ static_cast<uint32_t>(WindowBoundary::CURRENT_ROW_GROUPS), "CURRENT_ROW_GROUPS" },
+		{ static_cast<uint32_t>(WindowBoundary::EXPR_PRECEDING_GROUPS), "EXPR_PRECEDING_GROUPS" },
+		{ static_cast<uint32_t>(WindowBoundary::EXPR_FOLLOWING_GROUPS), "EXPR_FOLLOWING_GROUPS" }
 	};
 	return values;
 }
 
 template<>
 const char* EnumUtil::ToChars<WindowBoundary>(WindowBoundary value) {
-	return StringUtil::EnumToString(GetWindowBoundaryValues(), 9, "WindowBoundary", static_cast<uint32_t>(value));
+	return StringUtil::EnumToString(GetWindowBoundaryValues(), 12, "WindowBoundary", static_cast<uint32_t>(value));
 }
 
 template<>
 WindowBoundary EnumUtil::FromString<WindowBoundary>(const char *value) {
-	return static_cast<WindowBoundary>(StringUtil::StringToEnum(GetWindowBoundaryValues(), 9, "WindowBoundary", value));
+	return static_cast<WindowBoundary>(StringUtil::StringToEnum(GetWindowBoundaryValues(), 12, "WindowBoundary", value));
 }
 
 const StringUtil::EnumStringLiteral *GetWindowExcludeModeValues() {

package/src/duckdb/src/common/error_data.cpp

@@ -95,7 +95,7 @@ bool ErrorData::operator==(const ErrorData &other) const {
 }
 
 void ErrorData::ConvertErrorToJSON() {
-	if (raw_message.empty() || raw_message[0] == '{') {
+	if (!raw_message.empty() && raw_message[0] == '{') {
 		// empty or already JSON
 		return;
 	}
@@ -121,8 +121,9 @@ void ErrorData::AddErrorLocation(const string &query) {
 	}
 	{
 		auto entry = extra_info.find("stack_trace");
-		if (entry != extra_info.end()) {
+		if (entry != extra_info.end() && !entry->second.empty()) {
 			raw_message += "\n\nStack Trace:\n" + entry->second;
+			entry->second = "";
 		}
 	}
 	final_message = ConstructFinalMessage();

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

@@ -82,7 +82,7 @@ public:
 
 	void Close() override;
 
-	void FlushStream();
+	void FlushStream() const;
 };
 
 MiniZStreamWrapper::~MiniZStreamWrapper() {
@@ -146,7 +146,7 @@ void MiniZStreamWrapper::Initialize(CompressedFile &file, bool write) {
 bool MiniZStreamWrapper::Read(StreamData &sd) {
 	// Handling for the concatenated files
 	if (sd.refresh) {
-		auto available = (uint32_t)(sd.in_buff_end - sd.in_buff_start);
+		auto available = static_cast<uint32_t>(sd.in_buff_end - sd.in_buff_start);
 		if (available <= GZIP_FOOTER_SIZE) {
 			// Only footer is available so we just close and return finished
 			Close();
@@ -173,7 +173,7 @@ bool MiniZStreamWrapper::Read(StreamData &sd) {
 				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) {
+			if (static_cast<idx_t>(body_ptr - sd.in_buff_start) >= GZIP_HEADER_MAXSIZE) {
 				throw InternalException("Filename resulting in GZIP header larger than defined maximum (%d)",
 				                        GZIP_HEADER_MAXSIZE);
 			}
@@ -193,9 +193,9 @@ bool MiniZStreamWrapper::Read(StreamData &sd) {
 	// actually decompress
 	mz_stream_ptr->next_in = sd.in_buff_start;
 	D_ASSERT(sd.in_buff_end - sd.in_buff_start < NumericLimits<int32_t>::Maximum());
-	mz_stream_ptr->avail_in = (uint32_t)(sd.in_buff_end - sd.in_buff_start);
+	mz_stream_ptr->avail_in = static_cast<uint32_t>(sd.in_buff_end - sd.in_buff_start);
 	mz_stream_ptr->next_out = data_ptr_cast(sd.out_buff_end);
-	mz_stream_ptr->avail_out = (uint32_t)((sd.out_buff.get() + sd.out_buf_size) - sd.out_buff_end);
+	mz_stream_ptr->avail_out = static_cast<uint32_t>((sd.out_buff.get() + sd.out_buf_size) - sd.out_buff_end);
 	auto ret = duckdb_miniz::mz_inflate(mz_stream_ptr.get(), duckdb_miniz::MZ_NO_FLUSH);
 	if (ret != duckdb_miniz::MZ_OK && ret != duckdb_miniz::MZ_STREAM_END) {
 		throw IOException("Failed to decode gzip stream: %s", duckdb_miniz::mz_error(ret));
@@ -248,7 +248,7 @@ void MiniZStreamWrapper::Write(CompressedFile &file, StreamData &sd, data_ptr_t
 	}
 }
 
-void MiniZStreamWrapper::FlushStream() {
+void MiniZStreamWrapper::FlushStream() const {
 	auto &sd = file->stream_data;
 	mz_stream_ptr->next_in = nullptr;
 	mz_stream_ptr->avail_in = 0;
@@ -371,7 +371,7 @@ string GZipFileSystem::UncompressGZIPString(const char *data, idx_t size) {
 		do {
 			c = *body_ptr;
 			body_ptr++;
-		} while (c != '\0' && (idx_t)(body_ptr - data) < size);
+		} while (c != '\0' && static_cast<idx_t>(body_ptr - data) < size);
 	}
 
 	// stream is now set to beginning of payload data
@@ -384,10 +384,10 @@ string GZipFileSystem::UncompressGZIPString(const char *data, idx_t size) {
 	mz_stream_ptr->next_in = const_uchar_ptr_cast(body_ptr);
 	mz_stream_ptr->avail_in = NumericCast<unsigned int>(bytes_remaining);
 
-	unsigned char decompress_buffer[BUFSIZ];
 	string decompressed;
 
 	while (status == duckdb_miniz::MZ_OK) {
+		unsigned char decompress_buffer[BUFSIZ];
 		mz_stream_ptr->next_out = decompress_buffer;
 		mz_stream_ptr->avail_out = sizeof(decompress_buffer);
 		status = mz_inflate(mz_stream_ptr.get(), duckdb_miniz::MZ_NO_FLUSH);

package/src/duckdb/src/common/local_file_system.cpp

@@ -302,7 +302,7 @@ unique_ptr<FileHandle> LocalFileSystem::OpenFile(const string &path_p, FileOpenF
 	}
 
 	if (opener) {
-		Logger::Info("duckdb.FileSystem.LocalFileSystem.OpenFile", *opener, path_p);
+		DUCKDB_LOG_INFO(*opener, "duckdb.FileSystem.LocalFileSystem.OpenFile", path_p);
 	}
 
 	flags.Verify();
@@ -842,7 +842,7 @@ unique_ptr<FileHandle> LocalFileSystem::OpenFile(const string &path_p, FileOpenF
 	flags.Verify();
 
 	if (opener) {
-		Logger::Info("duckdb.FileSystem.LocalFileSystem.OpenFile", *opener, path_p);
+		DUCKDB_LOG_INFO(*opener, "duckdb.FileSystem.LocalFileSystem.OpenFile", path_p);
 	}
 
 	DWORD desired_access;

package/src/duckdb/src/common/multi_file_reader.cpp

@@ -125,7 +125,7 @@ bool MultiFileReader::ParseOption(const string &key, const Value &val, MultiFile
 			    "'hive_types' only accepts a STRUCT('name':VARCHAR, ...), but '%s' was provided",
 			    val.type().ToString());
 		}
-		// verify that that all the children of the struct value are VARCHAR
+		// verify that all the children of the struct value are VARCHAR
 		auto &children = StructValue::GetChildren(val);
 		for (idx_t i = 0; i < children.size(); i++) {
 			const Value &child = children[i];

package/src/duckdb/src/common/random_engine.cpp

@@ -21,7 +21,10 @@ RandomEngine::RandomEngine(int64_t seed) : random_state(make_uniq<RandomState>()
 	if (seed < 0) {
 #ifdef __linux__
 		idx_t random_seed = 0;
-		auto result = syscall(SYS_getrandom, &random_seed, sizeof(random_seed), 0);
+		int result = -1;
+#if defined(SYS_getrandom)
+		result = static_cast<int>(syscall(SYS_getrandom, &random_seed, sizeof(random_seed), 0));
+#endif
 		if (result == -1) {
 			// Something went wrong with the syscall, we use chrono
 			const auto now = std::chrono::high_resolution_clock::now();

package/src/duckdb/src/common/serializer/memory_stream.cpp

@@ -1,23 +1,24 @@
 #include "duckdb/common/serializer/memory_stream.hpp"
 
+#include "duckdb/common/allocator.hpp"
+
 namespace duckdb {
 
-MemoryStream::MemoryStream(idx_t capacity) : position(0), capacity(capacity), owns_data(true) {
+MemoryStream::MemoryStream(Allocator &allocator_p, idx_t capacity)
+    : allocator(&allocator_p), position(0), capacity(capacity) {
 	D_ASSERT(capacity != 0 && IsPowerOfTwo(capacity));
-	auto data_malloc_result = malloc(capacity);
-	if (!data_malloc_result) {
-		throw std::bad_alloc();
-	}
-	data = static_cast<data_ptr_t>(data_malloc_result);
+	data = allocator_p.AllocateData(capacity);
 }
 
-MemoryStream::MemoryStream(data_ptr_t buffer, idx_t capacity)
-    : position(0), capacity(capacity), owns_data(false), data(buffer) {
+MemoryStream::MemoryStream(idx_t capacity) : MemoryStream(Allocator::DefaultAllocator(), capacity) {
+}
+
+MemoryStream::MemoryStream(data_ptr_t buffer, idx_t capacity) : position(0), capacity(capacity), data(buffer) {
 }
 
 MemoryStream::~MemoryStream() {
-	if (owns_data) {
-		free(data);
+	if (allocator && data) {
+		allocator->FreeData(data, capacity);
 	}
 }
 
@@ -26,46 +27,49 @@ MemoryStream::MemoryStream(MemoryStream &&other) noexcept {
 	data = other.data;
 	position = other.position;
 	capacity = other.capacity;
-	owns_data = other.owns_data;
+	allocator = other.allocator;
 
 	// Reset the other stream
 	other.data = nullptr;
 	other.position = 0;
 	other.capacity = 0;
-	other.owns_data = false;
+	other.allocator = nullptr;
 }
 
 MemoryStream &MemoryStream::operator=(MemoryStream &&other) noexcept {
 	if (this != &other) {
 		// Free the current data
-		if (owns_data) {
-			free(data);
+		if (allocator) {
+			allocator->FreeData(data, capacity);
 		}
 
 		// Move the data from the other stream into this stream
 		data = other.data;
 		position = other.position;
 		capacity = other.capacity;
-		owns_data = other.owns_data;
+		allocator = other.allocator;
 
 		// Reset the other stream
 		other.data = nullptr;
 		other.position = 0;
 		other.capacity = 0;
-		other.owns_data = false;
+		other.allocator = nullptr;
 	}
 	return *this;
 }
 
 void MemoryStream::WriteData(const_data_ptr_t source, idx_t write_size) {
+	const auto old_capacity = capacity;
 	while (position + write_size > capacity) {
-		if (owns_data) {
+		if (allocator) {
 			capacity *= 2;
-			data = static_cast<data_ptr_t>(realloc(data, capacity));
 		} else {
 			throw SerializationException("Failed to serialize: not enough space in buffer to fulfill write request");
 		}
 	}
+	if (capacity != old_capacity) {
+		data = allocator->ReallocateData(data, old_capacity, capacity);
+	}
 	memcpy(data + position, source, write_size);
 	position += write_size;
 }
@@ -83,7 +87,7 @@ void MemoryStream::Rewind() {
 }
 
 void MemoryStream::Release() {
-	owns_data = false;
+	allocator = nullptr;
 }
 
 data_ptr_t MemoryStream::GetData() const {

package/src/duckdb/src/common/serializer/serializer.cpp

@@ -15,7 +15,7 @@ void Serializer::WriteValue(const vector<bool> &vec) {
 
 template <>
 void Serializer::WritePropertyWithDefault<Value>(const field_id_t field_id, const char *tag, const Value &value,
-                                                 const Value &&default_value) {
+                                                 const Value &default_value) {
 	// If current value is default, don't write it
 	if (!options.serialize_default_values && ValueOperations::NotDistinctFrom(value, default_value)) {
 		OnOptionalPropertyBegin(field_id, tag, false);

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

@@ -179,7 +179,7 @@ void Bit::BitToBlob(bitstring_t bit, string_t &output_blob) {
 	auto output = output_blob.GetDataWriteable();
 	idx_t size = output_blob.GetSize();
 
-	output[0] = UnsafeNumericCast<char>(GetFirstByte(bit));
+	output[0] = static_cast<char>(GetFirstByte(bit));
 	if (size >= 2) {
 		++output;
 		// First byte in bitstring contains amount of padded bits,

package/src/duckdb/src/common/types/column/column_data_allocator.cpp

@@ -54,12 +54,7 @@ ColumnDataAllocator::~ColumnDataAllocator() {
 	for (auto &block : blocks) {
 		block.handle->SetDestroyBufferUpon(DestroyBufferUpon::UNPIN);
 	}
-	const auto data_size = SizeInBytes();
 	blocks.clear();
-	if (Allocator::SupportsFlush() &&
-	    data_size > alloc.buffer_manager->GetBufferPool().GetAllocatorBulkDeallocationFlushThreshold()) {
-		Allocator::FlushAll();
-	}
 }
 
 BufferHandle ColumnDataAllocator::Pin(uint32_t block_id) {

package/src/duckdb/src/common/types/column/column_data_collection.cpp

@@ -799,7 +799,10 @@ static bool IsComplexType(const LogicalType &type) {
 
 void ColumnDataCollection::Append(ColumnDataAppendState &state, DataChunk &input) {
 	D_ASSERT(!finished_append);
-	D_ASSERT(types == input.GetTypes());
+	{
+		auto input_types = input.GetTypes();
+		D_ASSERT(types == input_types);
+	}
 
 	auto &segment = *segments.back();
 	for (idx_t vector_idx = 0; vector_idx < types.size(); vector_idx++) {

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

@@ -369,7 +369,8 @@ void DataChunk::Verify() {
 	}
 
 	// verify that we can round-trip chunk serialization
-	MemoryStream mem_stream;
+	Allocator allocator;
+	MemoryStream mem_stream(allocator);
 	BinarySerializer serializer(mem_stream);
 
 	serializer.Begin();

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

@@ -119,10 +119,6 @@ TupleDataSegment::~TupleDataSegment() {
 	}
 	pinned_row_handles.clear();
 	pinned_heap_handles.clear();
-	if (Allocator::SupportsFlush() && allocator &&
-	    data_size > allocator->GetBufferManager().GetBufferPool().GetAllocatorBulkDeallocationFlushThreshold()) {
-		Allocator::FlushAll();
-	}
 	allocator.reset();
 }
 

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

@@ -1314,7 +1314,7 @@ void LogicalType::Verify() const {
 	switch (id_) {
 	case LogicalTypeId::DECIMAL:
 		D_ASSERT(DecimalType::GetWidth(*this) >= 1 && DecimalType::GetWidth(*this) <= Decimal::MAX_WIDTH_DECIMAL);
-		D_ASSERT(DecimalType::GetScale(*this) >= 0 && DecimalType::GetScale(*this) <= DecimalType::GetWidth(*this));
+		D_ASSERT(DecimalType::GetScale(*this) <= DecimalType::GetWidth(*this));
 		break;
 	case LogicalTypeId::STRUCT: {
 		// verify child types