duckdb 0.8.2-dev4142.0 → 0.8.2-dev4314.0

package/src/duckdb/src/catalog/catalog_entry/table_catalog_entry.cpp

@@ -4,8 +4,6 @@
 #include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
 #include "duckdb/common/algorithm.hpp"
 #include "duckdb/common/exception.hpp"
-#include "duckdb/common/field_writer.hpp"
-#include "duckdb/common/serializer.hpp"
 #include "duckdb/main/database.hpp"
 #include "duckdb/parser/constraints/list.hpp"
 #include "duckdb/parser/parsed_data/create_table_info.hpp"

package/src/duckdb/src/catalog/catalog_entry/type_catalog_entry.cpp

@@ -1,11 +1,9 @@
+#include "duckdb/catalog/catalog.hpp"
 #include "duckdb/catalog/catalog_entry/type_catalog_entry.hpp"
-
 #include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/limits.hpp"
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/parser/keyword_helper.hpp"
-#include "duckdb/common/types/vector.hpp"
 #include <algorithm>
 #include <sstream>
 

package/src/duckdb/src/catalog/catalog_entry/view_catalog_entry.cpp

@@ -2,7 +2,6 @@
 
 #include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
 #include "duckdb/common/exception.hpp"
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/parser/parsed_data/alter_table_info.hpp"
 #include "duckdb/parser/parsed_data/create_view_info.hpp"
 #include "duckdb/common/limits.hpp"

package/src/duckdb/src/catalog/catalog_entry.cpp

@@ -55,17 +55,8 @@ void CatalogEntry::Serialize(Serializer &serializer) const {
 	info->Serialize(serializer);
 }
 
-unique_ptr<CreateInfo> CatalogEntry::Deserialize(Deserializer &source) {
-	return CreateInfo::Deserialize(source);
-}
-
-void CatalogEntry::FormatSerialize(FormatSerializer &serializer) const {
-	const auto info = GetInfo();
-	info->FormatSerialize(serializer);
-}
-
-unique_ptr<CreateInfo> CatalogEntry::FormatDeserialize(FormatDeserializer &deserializer) {
-	return CreateInfo::FormatDeserialize(deserializer);
+unique_ptr<CreateInfo> CatalogEntry::Deserialize(Deserializer &deserializer) {
+	return CreateInfo::Deserialize(deserializer);
 }
 
 void CatalogEntry::Verify(Catalog &catalog_p) {

package/src/duckdb/src/catalog/catalog_set.cpp

@@ -1,18 +1,18 @@
 #include "duckdb/catalog/catalog_set.hpp"
 
+#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
+#include "duckdb/catalog/catalog_entry/type_catalog_entry.hpp"
+#include "duckdb/catalog/dependency_manager.hpp"
 #include "duckdb/catalog/duck_catalog.hpp"
+#include "duckdb/catalog/mapping_value.hpp"
 #include "duckdb/common/exception.hpp"
-#include "duckdb/transaction/transaction_manager.hpp"
-#include "duckdb/transaction/duck_transaction.hpp"
-#include "duckdb/common/serializer/buffered_serializer.hpp"
-#include "duckdb/parser/parsed_data/alter_table_info.hpp"
-#include "duckdb/catalog/dependency_manager.hpp"
+#include "duckdb/common/serializer/memory_stream.hpp"
+#include "duckdb/common/serializer/binary_serializer.hpp"
 #include "duckdb/common/string_util.hpp"
-#include "duckdb/parser/column_definition.hpp"
 #include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/catalog/mapping_value.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/type_catalog_entry.hpp"
+#include "duckdb/parser/parsed_data/alter_table_info.hpp"
+#include "duckdb/transaction/duck_transaction.hpp"
+#include "duckdb/transaction/transaction_manager.hpp"
 
 namespace duckdb {
 
@@ -252,15 +252,17 @@ bool CatalogSet::AlterEntry(CatalogTransaction transaction, const string &name,
 	PutEntry(std::move(entry_index), std::move(value));
 
 	// serialize the AlterInfo into a temporary buffer
-	BufferedSerializer serializer;
-	serializer.WriteString(alter_info.GetColumnName());
-	alter_info.Serialize(serializer);
-	BinaryData serialized_alter = serializer.GetData();
+	MemoryStream stream;
+	BinarySerializer serializer(stream);
+	serializer.Begin();
+	serializer.WriteProperty(100, "column_name", alter_info.GetColumnName());
+	serializer.WriteProperty(101, "alter_info", &alter_info);
+	serializer.End();
 
 	// push the old entry in the undo buffer for this transaction
 	if (transaction.transaction) {
 		auto &dtransaction = transaction.transaction->Cast<DuckTransaction>();
-		dtransaction.PushCatalogEntry(*new_entry->child, serialized_alter.data.get(), serialized_alter.size);
+		dtransaction.PushCatalogEntry(*new_entry->child, stream.GetData(), stream.GetPosition());
 	}
 
 	// Check the dependency manager to verify that there are no conflicting dependencies with this alter

package/src/duckdb/src/catalog/default/default_functions.cpp

@@ -165,12 +165,12 @@ unique_ptr<CreateMacroInfo> DefaultFunctionGenerator::CreateInternalTableMacroIn
 		    make_uniq<ColumnRefExpression>(default_macro.parameters[param_idx]));
 	}
 
-	auto bind_info = make_uniq<CreateMacroInfo>();
+	auto type = function->type == MacroType::TABLE_MACRO ? CatalogType::TABLE_MACRO_ENTRY : CatalogType::MACRO_ENTRY;
+	auto bind_info = make_uniq<CreateMacroInfo>(type);
 	bind_info->schema = default_macro.schema;
 	bind_info->name = default_macro.name;
 	bind_info->temporary = true;
 	bind_info->internal = true;
-	bind_info->type = function->type == MacroType::TABLE_MACRO ? CatalogType::TABLE_MACRO_ENTRY : CatalogType::MACRO_ENTRY;
 	bind_info->function = std::move(function);
 	return bind_info;
 

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

@@ -4,7 +4,6 @@
 #include "duckdb/common/arrow/arrow_converter.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/helper.hpp"
-#include "duckdb/common/serializer.hpp"
 #include "duckdb/common/types/interval.hpp"
 #include "duckdb/common/types/sel_cache.hpp"
 #include "duckdb/common/types/vector_cache.hpp"

package/src/duckdb/src/common/constants.cpp

@@ -2,7 +2,6 @@
 
 #include "duckdb/common/limits.hpp"
 #include "duckdb/common/vector_size.hpp"
-#include "duckdb/common/serializer.hpp"
 
 namespace duckdb {
 

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

@@ -6114,10 +6114,6 @@ const char* EnumUtil::ToChars<VerificationType>(VerificationType value) {
 		return "COPIED";
 	case VerificationType::DESERIALIZED:
 		return "DESERIALIZED";
-	case VerificationType::DESERIALIZED_V2:
-		return "DESERIALIZED_V2";
-	case VerificationType::DESERIALIZED_V2_NO_DEFAULT:
-		return "DESERIALIZED_V2_NO_DEFAULT";
 	case VerificationType::PARSED:
 		return "PARSED";
 	case VerificationType::UNOPTIMIZED:
@@ -6146,12 +6142,6 @@ VerificationType EnumUtil::FromString<VerificationType>(const char *value) {
 	if (StringUtil::Equals(value, "DESERIALIZED")) {
 		return VerificationType::DESERIALIZED;
 	}
-	if (StringUtil::Equals(value, "DESERIALIZED_V2")) {
-		return VerificationType::DESERIALIZED_V2;
-	}
-	if (StringUtil::Equals(value, "DESERIALIZED_V2_NO_DEFAULT")) {
-		return VerificationType::DESERIALIZED_V2_NO_DEFAULT;
-	}
 	if (StringUtil::Equals(value, "PARSED")) {
 		return VerificationType::PARSED;
 	}

package/src/duckdb/src/common/exception.cpp

@@ -355,7 +355,7 @@ MissingExtensionException::MissingExtensionException(const string &msg)
 
 AutoloadException::AutoloadException(const string &extension_name, Exception &e)
     : Exception(ExceptionType::AUTOLOAD,
-                "An error occured while trying to automatically install the required extension '" + extension_name +
+                "An error occurred while trying to automatically install the required extension '" + extension_name +
                     "':\n" + e.RawMessage()),
       wrapped_exception(e) {
 }

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

@@ -1,9 +1,8 @@
 #include "duckdb/common/extra_type_info.hpp"
-#include "duckdb/common/serializer/format_deserializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 #include "duckdb/common/enum_util.hpp"
-#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
 #include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/type_catalog_entry.hpp"
 #include "duckdb/common/string_map_set.hpp"
 
 namespace duckdb {
@@ -42,63 +41,6 @@ bool ExtraTypeInfo::Equals(ExtraTypeInfo *other_p) const {
 	return alias == other_p->alias && EqualsInternal(other_p);
 }
 
-void ExtraTypeInfo::Serialize(FieldWriter &writer) const {
-}
-
-void ExtraTypeInfo::Serialize(ExtraTypeInfo *info, FieldWriter &writer) {
-	if (!info) {
-		writer.WriteField<ExtraTypeInfoType>(ExtraTypeInfoType::INVALID_TYPE_INFO);
-		writer.WriteString(string());
-	} else {
-		writer.WriteField<ExtraTypeInfoType>(info->type);
-		info->Serialize(writer);
-		writer.WriteString(info->alias);
-	}
-}
-
-shared_ptr<ExtraTypeInfo> ExtraTypeInfo::Deserialize(FieldReader &reader) {
-	auto type = reader.ReadRequired<ExtraTypeInfoType>();
-	shared_ptr<ExtraTypeInfo> extra_info;
-	switch (type) {
-	case ExtraTypeInfoType::INVALID_TYPE_INFO: {
-		auto alias = reader.ReadField<string>(string());
-		if (!alias.empty()) {
-			return make_shared<ExtraTypeInfo>(type, alias);
-		}
-		return nullptr;
-	}
-	case ExtraTypeInfoType::GENERIC_TYPE_INFO: {
-		extra_info = make_shared<ExtraTypeInfo>(type);
-	} break;
-	case ExtraTypeInfoType::DECIMAL_TYPE_INFO:
-		extra_info = DecimalTypeInfo::Deserialize(reader);
-		break;
-	case ExtraTypeInfoType::STRING_TYPE_INFO:
-		extra_info = StringTypeInfo::Deserialize(reader);
-		break;
-	case ExtraTypeInfoType::LIST_TYPE_INFO:
-		extra_info = ListTypeInfo::Deserialize(reader);
-		break;
-	case ExtraTypeInfoType::STRUCT_TYPE_INFO:
-		extra_info = StructTypeInfo::Deserialize(reader);
-		break;
-	case ExtraTypeInfoType::USER_TYPE_INFO:
-		extra_info = UserTypeInfo::Deserialize(reader);
-		break;
-	case ExtraTypeInfoType::ENUM_TYPE_INFO:
-		extra_info = EnumTypeInfo::Deserialize(reader);
-		break;
-	case ExtraTypeInfoType::AGGREGATE_STATE_TYPE_INFO:
-		extra_info = AggregateStateTypeInfo::Deserialize(reader);
-		break;
-	default:
-		throw InternalException("Unimplemented type info in ExtraTypeInfo::Deserialize");
-	}
-	auto alias = reader.ReadField<string>(string());
-	extra_info->alias = alias;
-	return extra_info;
-}
-
 bool ExtraTypeInfo::EqualsInternal(ExtraTypeInfo *other_p) const {
 	// Do nothing
 	return true;
@@ -115,17 +57,6 @@ DecimalTypeInfo::DecimalTypeInfo(uint8_t width_p, uint8_t scale_p)
 	D_ASSERT(width_p >= scale_p);
 }
 
-void DecimalTypeInfo::Serialize(FieldWriter &writer) const {
-	writer.WriteField<uint8_t>(width);
-	writer.WriteField<uint8_t>(scale);
-}
-
-shared_ptr<ExtraTypeInfo> DecimalTypeInfo::Deserialize(FieldReader &reader) {
-	auto width = reader.ReadRequired<uint8_t>();
-	auto scale = reader.ReadRequired<uint8_t>();
-	return make_shared<DecimalTypeInfo>(width, scale);
-}
-
 bool DecimalTypeInfo::EqualsInternal(ExtraTypeInfo *other_p) const {
 	auto &other = other_p->Cast<DecimalTypeInfo>();
 	return width == other.width && scale == other.scale;
@@ -141,15 +72,6 @@ StringTypeInfo::StringTypeInfo(string collation_p)
     : ExtraTypeInfo(ExtraTypeInfoType::STRING_TYPE_INFO), collation(std::move(collation_p)) {
 }
 
-void StringTypeInfo::Serialize(FieldWriter &writer) const {
-	writer.WriteString(collation);
-}
-
-shared_ptr<ExtraTypeInfo> StringTypeInfo::Deserialize(FieldReader &reader) {
-	auto collation = reader.ReadRequired<string>();
-	return make_shared<StringTypeInfo>(std::move(collation));
-}
-
 bool StringTypeInfo::EqualsInternal(ExtraTypeInfo *other_p) const {
 	// collation info has no impact on equality
 	return true;
@@ -165,15 +87,6 @@ ListTypeInfo::ListTypeInfo(LogicalType child_type_p)
     : ExtraTypeInfo(ExtraTypeInfoType::LIST_TYPE_INFO), child_type(std::move(child_type_p)) {
 }
 
-void ListTypeInfo::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializable(child_type);
-}
-
-shared_ptr<ExtraTypeInfo> ListTypeInfo::Deserialize(FieldReader &reader) {
-	auto child_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
-	return make_shared<ListTypeInfo>(std::move(child_type));
-}
-
 bool ListTypeInfo::EqualsInternal(ExtraTypeInfo *other_p) const {
 	auto &other = other_p->Cast<ListTypeInfo>();
 	return child_type == other.child_type;
@@ -189,27 +102,6 @@ StructTypeInfo::StructTypeInfo(child_list_t<LogicalType> child_types_p)
     : ExtraTypeInfo(ExtraTypeInfoType::STRUCT_TYPE_INFO), child_types(std::move(child_types_p)) {
 }
 
-void StructTypeInfo::Serialize(FieldWriter &writer) const {
-	writer.WriteField<uint32_t>(child_types.size());
-	auto &serializer = writer.GetSerializer();
-	for (idx_t i = 0; i < child_types.size(); i++) {
-		serializer.WriteString(child_types[i].first);
-		child_types[i].second.Serialize(serializer);
-	}
-}
-
-shared_ptr<ExtraTypeInfo> StructTypeInfo::Deserialize(FieldReader &reader) {
-	child_list_t<LogicalType> child_list;
-	auto child_types_size = reader.ReadRequired<uint32_t>();
-	auto &source = reader.GetSource();
-	for (uint32_t i = 0; i < child_types_size; i++) {
-		auto name = source.Read<string>();
-		auto type = LogicalType::Deserialize(source);
-		child_list.emplace_back(std::move(name), std::move(type));
-	}
-	return make_shared<StructTypeInfo>(std::move(child_list));
-}
-
 bool StructTypeInfo::EqualsInternal(ExtraTypeInfo *other_p) const {
 	auto &other = other_p->Cast<StructTypeInfo>();
 	return child_types == other.child_types;
@@ -225,32 +117,6 @@ AggregateStateTypeInfo::AggregateStateTypeInfo(aggregate_state_t state_type_p)
     : ExtraTypeInfo(ExtraTypeInfoType::AGGREGATE_STATE_TYPE_INFO), state_type(std::move(state_type_p)) {
 }
 
-void AggregateStateTypeInfo::Serialize(FieldWriter &writer) const {
-	auto &serializer = writer.GetSerializer();
-	writer.WriteString(state_type.function_name);
-	state_type.return_type.Serialize(serializer);
-	writer.WriteField<uint32_t>(state_type.bound_argument_types.size());
-	for (idx_t i = 0; i < state_type.bound_argument_types.size(); i++) {
-		state_type.bound_argument_types[i].Serialize(serializer);
-	}
-}
-
-shared_ptr<ExtraTypeInfo> AggregateStateTypeInfo::Deserialize(FieldReader &reader) {
-	auto &source = reader.GetSource();
-
-	auto function_name = reader.ReadRequired<string>();
-	auto return_type = LogicalType::Deserialize(source);
-	auto bound_argument_types_size = reader.ReadRequired<uint32_t>();
-	vector<LogicalType> bound_argument_types;
-
-	for (uint32_t i = 0; i < bound_argument_types_size; i++) {
-		auto type = LogicalType::Deserialize(source);
-		bound_argument_types.push_back(std::move(type));
-	}
-	return make_shared<AggregateStateTypeInfo>(
-	    aggregate_state_t(std::move(function_name), std::move(return_type), std::move(bound_argument_types)));
-}
-
 bool AggregateStateTypeInfo::EqualsInternal(ExtraTypeInfo *other_p) const {
 	auto &other = other_p->Cast<AggregateStateTypeInfo>();
 	return state_type.function_name == other.state_type.function_name &&
@@ -268,15 +134,6 @@ UserTypeInfo::UserTypeInfo(string name_p)
     : ExtraTypeInfo(ExtraTypeInfoType::USER_TYPE_INFO), user_type_name(std::move(name_p)) {
 }
 
-void UserTypeInfo::Serialize(FieldWriter &writer) const {
-	writer.WriteString(user_type_name);
-}
-
-shared_ptr<ExtraTypeInfo> UserTypeInfo::Deserialize(FieldReader &reader) {
-	auto enum_name = reader.ReadRequired<string>();
-	return make_shared<UserTypeInfo>(std::move(enum_name));
-}
-
 bool UserTypeInfo::EqualsInternal(ExtraTypeInfo *other_p) const {
 	auto &other = other_p->Cast<UserTypeInfo>();
 	return other.user_type_name == user_type_name;
@@ -320,16 +177,12 @@ struct EnumTypeInfoTemplated : public EnumTypeInfo {
 		}
 	}
 
-	static shared_ptr<EnumTypeInfoTemplated> Deserialize(FieldReader &reader, uint32_t size) {
+	static shared_ptr<EnumTypeInfoTemplated> Deserialize(Deserializer &deserializer, uint32_t size) {
 		Vector values_insert_order(LogicalType::VARCHAR, size);
-		values_insert_order.Deserialize(size, reader.GetSource());
-		return make_shared<EnumTypeInfoTemplated>(values_insert_order, size);
-	}
+		auto strings = FlatVector::GetData<string_t>(values_insert_order);
 
-	static shared_ptr<EnumTypeInfoTemplated> FormatDeserialize(FormatDeserializer &deserializer, uint32_t size) {
-		Vector values_insert_order(LogicalType::VARCHAR, size);
-		deserializer.ReadObject(201, "values_insert_order", [&](FormatDeserializer &source) {
-			values_insert_order.FormatDeserialize(source, size);
+		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);
 	}
@@ -411,32 +264,16 @@ string_t EnumType::GetString(const LogicalType &type, idx_t pos) {
 	return FlatVector::GetData<string_t>(EnumType::GetValuesInsertOrder(type))[pos];
 }
 
-shared_ptr<ExtraTypeInfo> EnumTypeInfo::Deserialize(FieldReader &reader) {
-	// deserialize the enum data
-	auto enum_size = reader.ReadRequired<uint32_t>();
-	auto enum_internal_type = EnumTypeInfo::DictType(enum_size);
+shared_ptr<ExtraTypeInfo> EnumTypeInfo::Deserialize(Deserializer &deserializer) {
+	auto values_count = deserializer.ReadProperty<idx_t>(200, "values_count");
+	auto enum_internal_type = EnumTypeInfo::DictType(values_count);
 	switch (enum_internal_type) {
 	case PhysicalType::UINT8:
-		return EnumTypeInfoTemplated<uint8_t>::Deserialize(reader, enum_size);
+		return EnumTypeInfoTemplated<uint8_t>::Deserialize(deserializer, values_count);
 	case PhysicalType::UINT16:
-		return EnumTypeInfoTemplated<uint16_t>::Deserialize(reader, enum_size);
+		return EnumTypeInfoTemplated<uint16_t>::Deserialize(deserializer, values_count);
 	case PhysicalType::UINT32:
-		return EnumTypeInfoTemplated<uint32_t>::Deserialize(reader, enum_size);
-	default:
-		throw InternalException("Invalid Physical Type for ENUMs");
-	}
-}
-
-shared_ptr<ExtraTypeInfo> EnumTypeInfo::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto enum_size = deserializer.ReadProperty<idx_t>(200, "enum_size");
-	auto enum_internal_type = EnumTypeInfo::DictType(enum_size);
-	switch (enum_internal_type) {
-	case PhysicalType::UINT8:
-		return EnumTypeInfoTemplated<uint8_t>::FormatDeserialize(deserializer, enum_size);
-	case PhysicalType::UINT16:
-		return EnumTypeInfoTemplated<uint16_t>::FormatDeserialize(deserializer, enum_size);
-	case PhysicalType::UINT32:
-		return EnumTypeInfoTemplated<uint32_t>::FormatDeserialize(deserializer, enum_size);
+		return EnumTypeInfoTemplated<uint32_t>::Deserialize(deserializer, values_count);
 	default:
 		throw InternalException("Invalid Physical Type for ENUMs");
 	}
@@ -465,23 +302,14 @@ bool EnumTypeInfo::EqualsInternal(ExtraTypeInfo *other_p) const {
 	return true;
 }
 
-void EnumTypeInfo::Serialize(FieldWriter &writer) const {
-	if (dict_type != EnumDictType::VECTOR_DICT) {
-		throw InternalException("Cannot serialize non-vector dictionary ENUM types");
-	}
-	auto dict_size = GetDictSize();
-	// Store Dictionary Size
-	writer.WriteField<uint32_t>(dict_size);
-	// Store Vector Order By Insertion
-	((Vector &)GetValuesInsertOrder()).Serialize(dict_size, writer.GetSerializer()); // NOLINT - FIXME
-}
-
-void EnumTypeInfo::FormatSerialize(FormatSerializer &serializer) const {
-	ExtraTypeInfo::FormatSerialize(serializer);
-	serializer.WriteProperty(200, "dict_size", dict_size);
-	serializer.WriteObject(201, "values_insert_order", [&](FormatSerializer &serializer) {
-		((Vector &)GetValuesInsertOrder()).FormatSerialize(serializer, dict_size); // NOLINT - FIXME
-	});
+void EnumTypeInfo::Serialize(Serializer &serializer) const {
+	ExtraTypeInfo::Serialize(serializer);
+
+	// Enums are special in that we serialize their values as a list instead of dumping the whole vector
+	auto strings = FlatVector::GetData<string_t>(values_insert_order);
+	serializer.WriteProperty(200, "values_count", dict_size);
+	serializer.WriteList(201, "values", dict_size,
+	                     [&](Serializer::List &list, idx_t i) { list.WriteElement(strings[i]); });
 }
 
 } // namespace duckdb

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

@@ -339,77 +339,9 @@ TableFunctionSet MultiFileReader::CreateFunctionSet(TableFunction table_function
 	return function_set;
 }
 
-void MultiFileReaderOptions::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteField<bool>(filename);
-	writer.WriteField<bool>(hive_partitioning);
-	writer.WriteField<bool>(auto_detect_hive_partitioning);
-	writer.WriteField<bool>(union_by_name);
-	writer.WriteField<bool>(hive_types_autocast);
-	// serialize hive_types_schema
-	const uint32_t schema_size = hive_types_schema.size();
-	writer.WriteField<uint32_t>(schema_size);
-	for (auto &hive_type : hive_types_schema) {
-		writer.WriteString(hive_type.first);
-		writer.WriteString(hive_type.second.ToString());
-	}
-	writer.Finalize();
-}
-
-MultiFileReaderOptions MultiFileReaderOptions::Deserialize(Deserializer &source) {
-	MultiFileReaderOptions result;
-	FieldReader reader(source);
-	result.filename = reader.ReadRequired<bool>();
-	result.hive_partitioning = reader.ReadRequired<bool>();
-	result.auto_detect_hive_partitioning = reader.ReadRequired<bool>();
-	result.union_by_name = reader.ReadRequired<bool>();
-	result.hive_types_autocast = reader.ReadRequired<bool>();
-	// deserialize hive_types_schema
-	const uint32_t schema_size = reader.ReadRequired<uint32_t>();
-	for (idx_t i = 0; i < schema_size; i++) {
-		const string name = reader.ReadRequired<string>();
-		const LogicalType type = TransformStringToLogicalType(reader.ReadRequired<string>());
-		result.hive_types_schema[name] = type;
-	}
-	reader.Finalize();
-	return result;
-}
-
-void MultiFileReaderBindData::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteField(filename_idx);
-	writer.WriteRegularSerializableList<HivePartitioningIndex>(hive_partitioning_indexes);
-	writer.Finalize();
-}
-
-MultiFileReaderBindData MultiFileReaderBindData::Deserialize(Deserializer &source) {
-	MultiFileReaderBindData result;
-	FieldReader reader(source);
-	result.filename_idx = reader.ReadRequired<idx_t>();
-	result.hive_partitioning_indexes =
-	    reader.ReadRequiredSerializableList<HivePartitioningIndex, HivePartitioningIndex>();
-	reader.Finalize();
-	return result;
-}
-
 HivePartitioningIndex::HivePartitioningIndex(string value_p, idx_t index) : value(std::move(value_p)), index(index) {
 }
 
-void HivePartitioningIndex::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteString(value);
-	writer.WriteField<idx_t>(index);
-	writer.Finalize();
-}
-
-HivePartitioningIndex HivePartitioningIndex::Deserialize(Deserializer &source) {
-	FieldReader reader(source);
-	auto value = reader.ReadRequired<string>();
-	auto index = reader.ReadRequired<idx_t>();
-	reader.Finalize();
-	return HivePartitioningIndex(std::move(value), index);
-}
-
 void MultiFileReaderOptions::AddBatchInfo(BindInfo &bind_info) const {
 	bind_info.InsertOption("filename", Value::BOOLEAN(filename));
 	bind_info.InsertOption("hive_partitioning", Value::BOOLEAN(hive_partitioning));

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

@@ -10,6 +10,11 @@ void BinarySerializer::OnPropertyBegin(const field_id_t field_id, const char *ta
 	// Just write the field id straight up
 	Write<field_id_t>(field_id);
 #ifdef DEBUG
+	// First of check that we are inside an object
+	if (debug_stack.empty()) {
+		throw InternalException("OnPropertyBegin called outside of object");
+	}
+
 	// Check that the tag is unique
 	auto &state = debug_stack.back();
 	auto &seen_field_ids = state.seen_field_ids;
@@ -142,24 +147,24 @@ void BinarySerializer::WriteValue(double value) {
 void BinarySerializer::WriteValue(const string &value) {
 	uint32_t len = value.length();
 	VarIntEncode(len);
-	WriteDataInternal(value.c_str(), len);
+	WriteData(value.c_str(), len);
 }
 
 void BinarySerializer::WriteValue(const string_t value) {
 	uint32_t len = value.GetSize();
 	VarIntEncode(len);
-	WriteDataInternal(value.GetDataUnsafe(), len);
+	WriteData(value.GetDataUnsafe(), len);
 }
 
 void BinarySerializer::WriteValue(const char *value) {
 	uint32_t len = strlen(value);
 	VarIntEncode(len);
-	WriteDataInternal(value, len);
+	WriteData(value, len);
 }
 
 void BinarySerializer::WriteDataPtr(const_data_ptr_t ptr, idx_t count) {
 	VarIntEncode(static_cast<uint64_t>(count));
-	WriteDataInternal(ptr, count);
+	WriteData(ptr, count);
 }
 
 } // namespace duckdb

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

@@ -7,10 +7,9 @@
 
 namespace duckdb {
 
-BufferedFileReader::BufferedFileReader(FileSystem &fs, const char *path, optional_ptr<ClientContext> context,
-                                       FileLockType lock_type, optional_ptr<FileOpener> opener)
-    : fs(fs), data(make_unsafe_uniq_array<data_t>(FILE_BUFFER_SIZE)), offset(0), read_data(0), total_read(0),
-      context(context) {
+BufferedFileReader::BufferedFileReader(FileSystem &fs, const char *path, FileLockType lock_type,
+                                       optional_ptr<FileOpener> opener)
+    : fs(fs), data(make_unsafe_uniq_array<data_t>(FILE_BUFFER_SIZE)), offset(0), read_data(0), total_read(0) {
 	handle = fs.OpenFile(path, FileFlags::FILE_FLAGS_READ, lock_type, FileSystem::DEFAULT_COMPRESSION, opener.get());
 	file_size = fs.GetFileSize(*handle);
 }
@@ -56,11 +55,4 @@ uint64_t BufferedFileReader::CurrentOffset() {
 	return total_read + offset;
 }
 
-ClientContext &BufferedFileReader::GetContext() {
-	if (!context) {
-		throw InternalException("Trying to acquire a client context that does not exist");
-	}
-	return *context;
-}
-
 } // namespace duckdb

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

@@ -21,7 +21,7 @@ idx_t BufferedFileWriter::GetTotalWritten() {
 	return total_written + offset;
 }
 
-void BufferedFileWriter::WriteData(const_data_ptr_t buffer, uint64_t write_size) {
+void BufferedFileWriter::WriteData(const_data_ptr_t buffer, idx_t write_size) {
 	// first copy anything we can from the buffer
 	const_data_ptr_t end_ptr = buffer + write_size;
 	while (buffer < end_ptr) {