duckdb 0.8.2-dev2090.0 → 0.8.2-dev2208.0

package/src/duckdb/src/function/cast/string_cast.cpp

@@ -36,7 +36,6 @@ bool StringEnumCastLoop(const string_t *source_data, ValidityMask &source_mask,
 template <class T>
 bool StringEnumCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
 	D_ASSERT(source.GetType().id() == LogicalTypeId::VARCHAR);
-	auto enum_name = EnumType::GetTypeName(result.GetType());
 	switch (source.GetVectorType()) {
 	case VectorType::CONSTANT_VECTOR: {
 		result.SetVectorType(VectorType::CONSTANT_VECTOR);

package/src/duckdb/src/function/scalar/system/aggregate_export.cpp

@@ -286,6 +286,17 @@ static unique_ptr<FunctionData> ExportStateAggregateDeserialize(PlanDeserializat
 	throw NotImplementedException("FIXME: export state deserialize");
 }
 
+static void ExportStateAggregateFormatSerialize(FormatSerializer &serializer,
+                                                const optional_ptr<FunctionData> bind_data_p,
+                                                const AggregateFunction &function) {
+	throw SerializationException("FIXME: export state serialize");
+}
+
+static unique_ptr<FunctionData> ExportStateAggregateFormatDeserialize(FormatDeserializer &deserializer,
+                                                                      AggregateFunction &function) {
+	throw SerializationException("FIXME: export state deserialize");
+}
+
 static void ExportStateScalarSerialize(FieldWriter &writer, const FunctionData *bind_data_p,
                                        const ScalarFunction &function) {
 	throw NotImplementedException("FIXME: export state serialize");
@@ -295,6 +306,16 @@ static unique_ptr<FunctionData> ExportStateScalarDeserialize(PlanDeserialization
 	throw NotImplementedException("FIXME: export state deserialize");
 }
 
+static void ExportStateScalarFormatSerialize(FormatSerializer &serializer, const optional_ptr<FunctionData> bind_data_p,
+                                             const ScalarFunction &function) {
+	throw SerializationException("FIXME: export state serialize");
+}
+
+static unique_ptr<FunctionData> ExportStateScalarFormatDeserialize(FormatDeserializer &deserializer,
+                                                                   ScalarFunction &function) {
+	throw SerializationException("FIXME: export state deserialize");
+}
+
 unique_ptr<BoundAggregateExpression>
 ExportAggregateFunction::Bind(unique_ptr<BoundAggregateExpression> child_aggregate) {
 	auto &bound_function = child_aggregate->function;
@@ -331,6 +352,8 @@ ExportAggregateFunction::Bind(unique_ptr<BoundAggregateExpression> child_aggrega
 	export_function.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
 	export_function.serialize = ExportStateAggregateSerialize;
 	export_function.deserialize = ExportStateAggregateDeserialize;
+	export_function.format_serialize = ExportStateAggregateFormatSerialize;
+	export_function.format_deserialize = ExportStateAggregateFormatDeserialize;
 
 	return make_uniq<BoundAggregateExpression>(export_function, std::move(child_aggregate->children),
 	                                           std::move(child_aggregate->filter), std::move(export_bind_data),
@@ -343,6 +366,8 @@ ScalarFunction ExportAggregateFunction::GetFinalize() {
 	result.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
 	result.serialize = ExportStateScalarSerialize;
 	result.deserialize = ExportStateScalarDeserialize;
+	result.format_serialize = ExportStateScalarFormatSerialize;
+	result.format_deserialize = ExportStateScalarFormatDeserialize;
 	return result;
 }
 
@@ -353,6 +378,8 @@ ScalarFunction ExportAggregateFunction::GetCombine() {
 	result.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
 	result.serialize = ExportStateScalarSerialize;
 	result.deserialize = ExportStateScalarDeserialize;
+	result.format_serialize = ExportStateScalarFormatSerialize;
+	result.format_deserialize = ExportStateScalarFormatDeserialize;
 	return result;
 }
 

package/src/duckdb/src/function/scalar_function.cpp

@@ -13,7 +13,8 @@ ScalarFunction::ScalarFunction(string name, vector<LogicalType> arguments, Logic
     : BaseScalarFunction(std::move(name), std::move(arguments), std::move(return_type), side_effects,
                          std::move(varargs), null_handling),
       function(std::move(function)), bind(bind), init_local_state(init_local_state), dependency(dependency),
-      statistics(statistics), serialize(nullptr), deserialize(nullptr) {
+      statistics(statistics), serialize(nullptr), deserialize(nullptr), format_serialize(nullptr),
+      format_deserialize(nullptr) {
 }
 
 ScalarFunction::ScalarFunction(vector<LogicalType> arguments, LogicalType return_type, scalar_function_t function,
@@ -26,9 +27,10 @@ ScalarFunction::ScalarFunction(vector<LogicalType> arguments, LogicalType return
 }
 
 bool ScalarFunction::operator==(const ScalarFunction &rhs) const {
-	return CompareScalarFunctionT(rhs.function) && bind == rhs.bind && dependency == rhs.dependency &&
-	       statistics == rhs.statistics;
+	return name == rhs.name && arguments == rhs.arguments && return_type == rhs.return_type && varargs == rhs.varargs &&
+	       bind == rhs.bind && dependency == rhs.dependency && statistics == rhs.statistics;
 }
+
 bool ScalarFunction::operator!=(const ScalarFunction &rhs) const {
 	return !(*this == rhs);
 }
@@ -56,23 +58,6 @@ bool ScalarFunction::Equal(const ScalarFunction &rhs) const {
 	return true; // they are equal
 }
 
-bool ScalarFunction::CompareScalarFunctionT(const scalar_function_t &other) const {
-	typedef void(scalar_function_ptr_t)(DataChunk &, ExpressionState &, Vector &);
-
-	auto func_ptr = (scalar_function_ptr_t **)function.template target<scalar_function_ptr_t *>(); // NOLINT
-	auto other_ptr = (scalar_function_ptr_t **)other.template target<scalar_function_ptr_t *>();   // NOLINT
-
-	// Case the functions were created from lambdas the target will return a nullptr
-	if (!func_ptr && !other_ptr) {
-		return true;
-	}
-	if (func_ptr == nullptr || other_ptr == nullptr) {
-		// scalar_function_t (std::functions) from lambdas cannot be compared
-		return false;
-	}
-	return CastPointerToValue(*func_ptr) == CastPointerToValue(*other_ptr);
-}
-
 void ScalarFunction::NopFunction(DataChunk &input, ExpressionState &state, Vector &result) {
 	D_ASSERT(input.ColumnCount() >= 1);
 	result.Reference(input.data[0]);

package/src/duckdb/src/function/table/read_csv.cpp

@@ -15,6 +15,8 @@
 #include "duckdb/main/client_data.hpp"
 #include "duckdb/execution/operator/persistent/csv_line_info.hpp"
 #include "duckdb/execution/operator/persistent/csv_rejects_table.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
 
 #include <limits>
 
@@ -1235,6 +1237,20 @@ static unique_ptr<FunctionData> CSVReaderDeserialize(PlanDeserializationState &s
 	return std::move(result_data);
 }
 
+static void CSVReaderFormatSerialize(FormatSerializer &serializer, const optional_ptr<FunctionData> bind_data_p,
+                                     const TableFunction &function) {
+	auto &bind_data = bind_data_p->Cast<ReadCSVData>();
+	serializer.WriteProperty("extra_info", function.extra_info);
+	serializer.WriteProperty("csv_data", bind_data);
+}
+
+static unique_ptr<FunctionData> CSVReaderFormatDeserialize(FormatDeserializer &deserializer, TableFunction &function) {
+	unique_ptr<ReadCSVData> result;
+	deserializer.ReadProperty("extra_info", function.extra_info);
+	deserializer.ReadProperty("csv_data", result);
+	return std::move(result);
+}
+
 TableFunction ReadCSVTableFunction::GetFunction() {
 	TableFunction read_csv("read_csv", {LogicalType::VARCHAR}, ReadCSVFunction, ReadCSVBind, ReadCSVInitGlobal,
 	                       ReadCSVInitLocal);
@@ -1242,6 +1258,8 @@ TableFunction ReadCSVTableFunction::GetFunction() {
 	read_csv.pushdown_complex_filter = CSVComplexFilterPushdown;
 	read_csv.serialize = CSVReaderSerialize;
 	read_csv.deserialize = CSVReaderDeserialize;
+	read_csv.format_serialize = CSVReaderFormatSerialize;
+	read_csv.format_deserialize = CSVReaderFormatDeserialize;
 	read_csv.get_batch_index = CSVReaderGetBatchIndex;
 	read_csv.cardinality = CSVReaderCardinality;
 	read_csv.projection_pushdown = true;
@@ -1279,7 +1297,8 @@ unique_ptr<TableRef> ReadCSVReplacement(ClientContext &context, const string &ta
 	table_function->function = make_uniq<FunctionExpression>("read_csv_auto", std::move(children));
 
 	if (!FileSystem::HasGlob(table_name)) {
-		table_function->alias = FileSystem::ExtractBaseName(table_name);
+		auto &fs = FileSystem::GetFileSystem(context);
+		table_function->alias = fs.ExtractBaseName(table_name);
 	}
 
 	return std::move(table_function);

package/src/duckdb/src/function/table/system/test_all_types.cpp

@@ -70,14 +70,14 @@ vector<TestType> TestAllTypesFun::GetTestTypes(bool use_large_enum) {
 	auto small_enum_ptr = FlatVector::GetData<string_t>(small_enum);
 	small_enum_ptr[0] = StringVector::AddStringOrBlob(small_enum, "DUCK_DUCK_ENUM");
 	small_enum_ptr[1] = StringVector::AddStringOrBlob(small_enum, "GOOSE");
-	result.emplace_back(LogicalType::ENUM("small_enum", small_enum, 2), "small_enum");
+	result.emplace_back(LogicalType::ENUM(small_enum, 2), "small_enum");
 
 	Vector medium_enum(LogicalType::VARCHAR, 300);
 	auto medium_enum_ptr = FlatVector::GetData<string_t>(medium_enum);
 	for (idx_t i = 0; i < 300; i++) {
 		medium_enum_ptr[i] = StringVector::AddStringOrBlob(medium_enum, string("enum_") + to_string(i));
 	}
-	result.emplace_back(LogicalType::ENUM("medium_enum", medium_enum, 300), "medium_enum");
+	result.emplace_back(LogicalType::ENUM(medium_enum, 300), "medium_enum");
 
 	if (use_large_enum) {
 		// this is a big one... not sure if we should push this one here, but it's required for completeness
@@ -86,13 +86,13 @@ vector<TestType> TestAllTypesFun::GetTestTypes(bool use_large_enum) {
 		for (idx_t i = 0; i < 70000; i++) {
 			large_enum_ptr[i] = StringVector::AddStringOrBlob(large_enum, string("enum_") + to_string(i));
 		}
-		result.emplace_back(LogicalType::ENUM("large_enum", large_enum, 70000), "large_enum");
+		result.emplace_back(LogicalType::ENUM(large_enum, 70000), "large_enum");
 	} else {
 		Vector large_enum(LogicalType::VARCHAR, 2);
 		auto large_enum_ptr = FlatVector::GetData<string_t>(large_enum);
 		large_enum_ptr[0] = StringVector::AddStringOrBlob(large_enum, string("enum_") + to_string(0));
 		large_enum_ptr[1] = StringVector::AddStringOrBlob(large_enum, string("enum_") + to_string(69999));
-		result.emplace_back(LogicalType::ENUM("large_enum", large_enum, 2), "large_enum");
+		result.emplace_back(LogicalType::ENUM(large_enum, 2), "large_enum");
 	}
 
 	// arrays

package/src/duckdb/src/function/table/table_scan.cpp

@@ -15,6 +15,8 @@
 #include "duckdb/catalog/dependency_list.hpp"
 #include "duckdb/function/function_set.hpp"
 #include "duckdb/storage/table/scan_state.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
 
 namespace duckdb {
 
@@ -447,6 +449,35 @@ static unique_ptr<FunctionData> TableScanDeserialize(PlanDeserializationState &s
 	return std::move(result);
 }
 
+static void TableScanFormatSerialize(FormatSerializer &serializer, const optional_ptr<FunctionData> bind_data_p,
+                                     const TableFunction &function) {
+	auto &bind_data = bind_data_p->Cast<TableScanBindData>();
+	serializer.WriteProperty("catalog", bind_data.table.schema.catalog.GetName());
+	serializer.WriteProperty("schema", bind_data.table.schema.name);
+	serializer.WriteProperty("table", bind_data.table.name);
+	serializer.WriteProperty("is_index_scan", bind_data.is_index_scan);
+	serializer.WriteProperty("is_create_index", bind_data.is_create_index);
+	serializer.WriteProperty("result_ids", bind_data.result_ids);
+	serializer.WriteProperty("result_ids", bind_data.result_ids);
+}
+
+static unique_ptr<FunctionData> TableScanFormatDeserialize(FormatDeserializer &deserializer, TableFunction &function) {
+	auto catalog = deserializer.ReadProperty<string>("catalog");
+	auto schema = deserializer.ReadProperty<string>("schema");
+	auto table = deserializer.ReadProperty<string>("table");
+	auto &catalog_entry =
+	    Catalog::GetEntry<TableCatalogEntry>(deserializer.Get<ClientContext &>(), catalog, schema, table);
+	if (catalog_entry.type != CatalogType::TABLE_ENTRY) {
+		throw SerializationException("Cant find table for %s.%s", schema, table);
+	}
+	auto result = make_uniq<TableScanBindData>(catalog_entry.Cast<DuckTableEntry>());
+	deserializer.ReadProperty("is_index_scan", result->is_index_scan);
+	deserializer.ReadProperty("is_create_index", result->is_create_index);
+	deserializer.ReadProperty("result_ids", result->result_ids);
+	deserializer.ReadProperty("result_ids", result->result_ids);
+	return std::move(result);
+}
+
 TableFunction TableScanFunction::GetIndexScanFunction() {
 	TableFunction scan_function("index_scan", {}, IndexScanFunction);
 	scan_function.init_local = nullptr;
@@ -462,6 +493,8 @@ TableFunction TableScanFunction::GetIndexScanFunction() {
 	scan_function.filter_pushdown = false;
 	scan_function.serialize = TableScanSerialize;
 	scan_function.deserialize = TableScanDeserialize;
+	scan_function.format_serialize = TableScanFormatSerialize;
+	scan_function.format_deserialize = TableScanFormatDeserialize;
 	return scan_function;
 }
 
@@ -482,6 +515,8 @@ TableFunction TableScanFunction::GetFunction() {
 	scan_function.filter_prune = true;
 	scan_function.serialize = TableScanSerialize;
 	scan_function.deserialize = TableScanDeserialize;
+	scan_function.format_serialize = TableScanFormatSerialize;
+	scan_function.format_deserialize = TableScanFormatDeserialize;
 	return scan_function;
 }
 

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.8.2-dev2090"
+#define DUCKDB_VERSION "0.8.2-dev2208"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "8d8f9f1b79"
+#define DUCKDB_SOURCE_ID "accdd3edb9"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/function/table_function.cpp

@@ -18,8 +18,8 @@ TableFunction::TableFunction(string name, vector<LogicalType> arguments, table_f
       init_global(init_global), init_local(init_local), function(function), in_out_function(nullptr),
       in_out_function_final(nullptr), statistics(nullptr), dependency(nullptr), cardinality(nullptr),
       pushdown_complex_filter(nullptr), to_string(nullptr), table_scan_progress(nullptr), get_batch_index(nullptr),
-      get_batch_info(nullptr), serialize(nullptr), deserialize(nullptr), projection_pushdown(false),
-      filter_pushdown(false), filter_prune(false) {
+      get_batch_info(nullptr), serialize(nullptr), deserialize(nullptr), format_serialize(nullptr),
+      format_deserialize(nullptr), projection_pushdown(false), filter_pushdown(false), filter_prune(false) {
 }
 
 TableFunction::TableFunction(const vector<LogicalType> &arguments, table_function_t function,
@@ -32,7 +32,8 @@ TableFunction::TableFunction()
       init_local(nullptr), function(nullptr), in_out_function(nullptr), statistics(nullptr), dependency(nullptr),
       cardinality(nullptr), pushdown_complex_filter(nullptr), to_string(nullptr), table_scan_progress(nullptr),
       get_batch_index(nullptr), get_batch_info(nullptr), serialize(nullptr), deserialize(nullptr),
-      projection_pushdown(false), filter_pushdown(false), filter_prune(false) {
+      format_serialize(nullptr), format_deserialize(nullptr), projection_pushdown(false), filter_pushdown(false),
+      filter_prune(false) {
 }
 
 bool TableFunction::Equal(const TableFunction &rhs) const {

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/table_catalog_entry.hpp

@@ -71,8 +71,6 @@ public:
 	DUCKDB_API vector<LogicalType> GetTypes();
 	//! Returns a list of the columns of the table
 	DUCKDB_API const ColumnList &GetColumns() const;
-	//! Returns a mutable list of the columns of the table
-	DUCKDB_API ColumnList &GetColumnsMutable();
 	//! Returns the underlying storage of the table
 	virtual DataTable &GetStorage();
 	//! Returns a list of the bound constraints of the table

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/type_catalog_entry.hpp

@@ -29,10 +29,7 @@ public:
 	LogicalType user_type;
 
 public:
-	//! Serialize the meta information of the TypeCatalogEntry a serializer
-	virtual void Serialize(Serializer &serializer) const;
-	//! Deserializes to a TypeCatalogEntry
-	static unique_ptr<CreateTypeInfo> Deserialize(Deserializer &source);
+	unique_ptr<CreateInfo> GetInfo() const override;
 
 	string ToSQL() const override;
 };

package/src/duckdb/src/include/duckdb/catalog/catalog_set.hpp

@@ -125,12 +125,6 @@ public:
 	void Verify(Catalog &catalog);
 
 private:
-	//! Adjusts table dependencies on the event of an UNDO
-	void AdjustTableDependencies(CatalogEntry &entry);
-	//! Adjust one dependency
-	void AdjustDependency(CatalogEntry &entry, TableCatalogEntry &table, ColumnDefinition &column, bool remove);
-	//! Adjust User dependency
-	void AdjustUserDependency(CatalogEntry &entry, ColumnDefinition &column, bool remove);
 	//! Given a root entry, gets the entry valid for this transaction
 	CatalogEntry &GetEntryForTransaction(CatalogTransaction transaction, CatalogEntry &current);
 	CatalogEntry &GetCommittedEntry(CatalogEntry &current);

package/src/duckdb/src/include/duckdb/common/extra_type_info.hpp

@@ -35,7 +35,6 @@ struct ExtraTypeInfo {
 
 	ExtraTypeInfoType type;
 	string alias;
-	optional_ptr<TypeCatalogEntry> catalog_entry;
 
 public:
 	bool Equals(ExtraTypeInfo *other_p) const;
@@ -184,19 +183,17 @@ private:
 enum EnumDictType : uint8_t { INVALID = 0, VECTOR_DICT = 1 };
 
 struct EnumTypeInfo : public ExtraTypeInfo {
-	explicit EnumTypeInfo(string enum_name_p, Vector &values_insert_order_p, idx_t dict_size_p);
+	explicit EnumTypeInfo(Vector &values_insert_order_p, idx_t dict_size_p);
 	EnumTypeInfo(const EnumTypeInfo &) = delete;
 	EnumTypeInfo &operator=(const EnumTypeInfo &) = delete;
 
 public:
 	const EnumDictType &GetEnumDictType() const;
-	const string &GetEnumName() const;
-	const string GetSchemaName() const;
 	const Vector &GetValuesInsertOrder() const;
 	const idx_t &GetDictSize() const;
 	static PhysicalType DictType(idx_t size);
 
-	static LogicalType CreateType(const string &enum_name, Vector &ordered_data, idx_t size);
+	static LogicalType CreateType(Vector &ordered_data, idx_t size);
 
 	void Serialize(FieldWriter &writer) const override;
 	static shared_ptr<ExtraTypeInfo> Deserialize(FieldReader &reader);
@@ -212,7 +209,6 @@ protected:
 
 private:
 	EnumDictType dict_type;
-	string enum_name;
 	idx_t dict_size;
 };
 

package/src/duckdb/src/include/duckdb/common/field_writer.hpp

@@ -167,10 +167,6 @@ public:
 		return root.GetContext();
 	}
 
-	optional_ptr<Catalog> GetCatalog() override {
-		return root.GetCatalog();
-	}
-
 private:
 	Deserializer &root;
 	idx_t remaining_data;

package/src/duckdb/src/include/duckdb/common/file_system.hpp

@@ -185,21 +185,21 @@ public:
 	DUCKDB_API virtual string ExpandPath(const string &path);
 	//! Returns the system-available memory in bytes. Returns DConstants::INVALID_INDEX if the system function fails.
 	DUCKDB_API static idx_t GetAvailableMemory();
-	//! Path separator for the current file system
-	DUCKDB_API static string PathSeparator();
+	//! Path separator for path
+	DUCKDB_API virtual string PathSeparator(const string &path);
 	//! Checks if path is starts with separator (i.e., '/' on UNIX '\\' on Windows)
-	DUCKDB_API static bool IsPathAbsolute(const string &path);
+	DUCKDB_API bool IsPathAbsolute(const string &path);
 	//! Normalize an absolute path - the goal of normalizing is converting "\test.db" and "C:/test.db" into "C:\test.db"
 	//! so that the database system cache can correctly
-	DUCKDB_API static string NormalizeAbsolutePath(const string &path);
+	DUCKDB_API string NormalizeAbsolutePath(const string &path);
 	//! Join two paths together
-	DUCKDB_API static string JoinPath(const string &a, const string &path);
+	DUCKDB_API string JoinPath(const string &a, const string &path);
 	//! Convert separators in a path to the local separators (e.g. convert "/" into \\ on windows)
-	DUCKDB_API static string ConvertSeparators(const string &path);
+	DUCKDB_API string ConvertSeparators(const string &path);
 	//! Extract the base name of a file (e.g. if the input is lib/example.dll the base name is 'example')
-	DUCKDB_API static string ExtractBaseName(const string &path);
+	DUCKDB_API string ExtractBaseName(const string &path);
 	//! Extract the name of a file (e.g if the input is lib/example.dll the name is 'example.dll')
-	DUCKDB_API static string ExtractName(const string &path);
+	DUCKDB_API string ExtractName(const string &path);
 
 	//! Returns the value of an environment variable - or the empty string if it is not set
 	DUCKDB_API static string GetEnvVariable(const string &name);

package/src/duckdb/src/include/duckdb/common/filename_pattern.hpp

@@ -23,7 +23,7 @@ public:
 
 public:
 	void SetFilenamePattern(const string &pattern);
-	string CreateFilename(const FileSystem &fs, const string &path, const string &extension, idx_t offset) const;
+	string CreateFilename(FileSystem &fs, const string &path, const string &extension, idx_t offset) const;
 
 private:
 	string _base;

package/src/duckdb/src/include/duckdb/common/multi_file_reader.hpp

@@ -8,7 +8,7 @@
 
 #pragma once
 
-#include "duckdb/common/types.hpp"
+#include "duckdb/common/common.hpp"
 #include "duckdb/common/multi_file_reader_options.hpp"
 #include "duckdb/common/enums/file_glob_options.hpp"
 #include "duckdb/common/union_by_name.hpp"
@@ -32,6 +32,8 @@ struct HivePartitioningIndex {
 
 	DUCKDB_API void Serialize(Serializer &serializer) const;
 	DUCKDB_API static HivePartitioningIndex Deserialize(Deserializer &source);
+	DUCKDB_API void FormatSerialize(FormatSerializer &serializer) const;
+	DUCKDB_API static HivePartitioningIndex FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 //! The bind data for the multi-file reader, obtained through MultiFileReader::BindReader
@@ -43,6 +45,8 @@ struct MultiFileReaderBindData {
 
 	DUCKDB_API void Serialize(Serializer &serializer) const;
 	DUCKDB_API static MultiFileReaderBindData Deserialize(Deserializer &source);
+	DUCKDB_API void FormatSerialize(FormatSerializer &serializer) const;
+	DUCKDB_API static MultiFileReaderBindData FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 struct MultiFileFilterEntry {

package/src/duckdb/src/include/duckdb/common/multi_file_reader_options.hpp

@@ -28,9 +28,11 @@ struct MultiFileReaderOptions {
 
 	DUCKDB_API void Serialize(Serializer &serializer) const;
 	DUCKDB_API static MultiFileReaderOptions Deserialize(Deserializer &source);
+	DUCKDB_API void FormatSerialize(FormatSerializer &serializer) const;
+	DUCKDB_API static MultiFileReaderOptions FormatDeserialize(FormatDeserializer &source);
 	DUCKDB_API void AddBatchInfo(BindInfo &bind_info) const;
 	DUCKDB_API void AutoDetectHivePartitioning(const vector<string> &files, ClientContext &context);
-	DUCKDB_API static bool AutoDetectHivePartitioningInternal(const vector<string> &files);
+	DUCKDB_API static bool AutoDetectHivePartitioningInternal(const vector<string> &files, ClientContext &context);
 	DUCKDB_API void AutoDetectHiveTypesInternal(const string &file, ClientContext &context);
 	DUCKDB_API void VerifyHiveTypesArePartitions(const std::map<string, string> &partitions) const;
 	DUCKDB_API LogicalType GetHiveLogicalType(const string &hive_partition_column) const;

package/src/duckdb/src/include/duckdb/common/opener_file_system.hpp

@@ -103,6 +103,10 @@ public:
 		GetFileSystem().RemoveFile(filename);
 	}
 
+	string PathSeparator(const string &path) override {
+		return GetFileSystem().PathSeparator(path);
+	}
+
 	vector<string> Glob(const string &path, FileOpener *opener = nullptr) override {
 		if (opener) {
 			throw InternalException("OpenerFileSystem cannot take an opener - the opener is pushed automatically");

package/src/duckdb/src/include/duckdb/common/serializer/buffered_file_reader.hpp

@@ -37,14 +37,10 @@ public:
 
 	ClientContext &GetContext() override;
 
-	optional_ptr<Catalog> GetCatalog() override;
-	void SetCatalog(Catalog &catalog);
-
 private:
 	idx_t file_size;
 	idx_t total_read;
 	optional_ptr<ClientContext> context;
-	optional_ptr<Catalog> catalog;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/serializer/format_deserializer.hpp

@@ -127,6 +127,16 @@ public:
 		return data.Unset<T>();
 	}
 
+	// Manually begin an object - should be followed by EndObject
+	void BeginObject(const char *tag) {
+		SetTag(tag);
+		OnObjectBegin();
+	}
+
+	void EndObject() {
+		OnObjectEnd();
+	}
+
 private:
 	// Deserialize anything implementing a FormatDeserialize method
 	template <typename T = void>
@@ -208,6 +218,28 @@ private:
 		return map;
 	}
 
+	template <typename T = void>
+	inline typename std::enable_if<is_map<T>::value, T>::type Read() {
+		using KEY_TYPE = typename is_map<T>::KEY_TYPE;
+		using VALUE_TYPE = typename is_map<T>::VALUE_TYPE;
+
+		T map;
+		auto size = OnMapBegin();
+		for (idx_t i = 0; i < size; i++) {
+			OnMapEntryBegin();
+			OnMapKeyBegin();
+			auto key = Read<KEY_TYPE>();
+			OnMapKeyEnd();
+			OnMapValueBegin();
+			auto value = Read<VALUE_TYPE>();
+			OnMapValueEnd();
+			OnMapEntryEnd();
+			map[std::move(key)] = std::move(value);
+		}
+		OnMapEnd();
+		return map;
+	}
+
 	// Deserialize an unordered set
 	template <typename T = void>
 	inline typename std::enable_if<is_unordered_set<T>::value, T>::type Read() {

package/src/duckdb/src/include/duckdb/common/serializer/format_serializer.hpp

@@ -28,25 +28,11 @@ protected:
 public:
 	// Serialize a value
 	template <class T>
-	typename std::enable_if<!std::is_enum<T>::value, void>::type WriteProperty(const char *tag, const T &value) {
+	void WriteProperty(const char *tag, const T &value) {
 		SetTag(tag);
 		WriteValue(value);
 	}
 
-	// Serialize an enum
-	template <class T>
-	typename std::enable_if<std::is_enum<T>::value, void>::type WriteProperty(const char *tag, T value) {
-		SetTag(tag);
-		if (serialize_enum_as_string) {
-			// Use the enum serializer to lookup tostring function
-			auto str = EnumUtil::ToChars(value);
-			WriteValue(str);
-		} else {
-			// Use the underlying type
-			WriteValue(static_cast<typename std::underlying_type<T>::type>(value));
-		}
-	}
-
 	// Optional pointer
 	template <class POINTER>
 	void WriteOptionalProperty(const char *tag, POINTER &&ptr) {
@@ -67,7 +53,29 @@ public:
 		WriteDataPtr(ptr, count);
 	}
 
+	// Manually begin an object - should be followed by EndObject
+	void BeginObject(const char *tag) {
+		SetTag(tag);
+		OnObjectBegin();
+	}
+
+	void EndObject() {
+		OnObjectEnd();
+	}
+
 protected:
+	template <typename T>
+	typename std::enable_if<std::is_enum<T>::value, void>::type WriteValue(const T value) {
+		if (serialize_enum_as_string) {
+			// Use the enum serializer to lookup tostring function
+			auto str = EnumUtil::ToChars(value);
+			WriteValue(str);
+		} else {
+			// Use the underlying type
+			WriteValue(static_cast<typename std::underlying_type<T>::type>(value));
+		}
+	}
+
 	// Unique Pointer Ref
 	template <typename T>
 	void WriteValue(const unique_ptr<T> &ptr) {
@@ -160,6 +168,24 @@ protected:
 		OnMapEnd(count);
 	}
 
+	// Map
+	template <class K, class V, class HASH, class CMP>
+	void WriteValue(const duckdb::map<K, V, HASH, CMP> &map) {
+		auto count = map.size();
+		OnMapBegin(count);
+		for (auto &item : map) {
+			OnMapEntryBegin();
+			OnMapKeyBegin();
+			WriteValue(item.first);
+			OnMapKeyEnd();
+			OnMapValueBegin();
+			WriteValue(item.second);
+			OnMapValueEnd();
+			OnMapEntryEnd();
+		}
+		OnMapEnd(count);
+	}
+
 	// class or struct implementing `FormatSerialize(FormatSerializer& FormatSerializer)`;
 	template <typename T>
 	typename std::enable_if<has_serialize<T>::value>::type WriteValue(const T &value) {
@@ -247,4 +273,8 @@ protected:
 	}
 };
 
+// We need to special case vector<bool> because elements of vector<bool> cannot be referenced
+template <>
+void FormatSerializer::WriteValue(const vector<bool> &vec);
+
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/serializer/serialization_traits.hpp

@@ -70,6 +70,16 @@ struct is_unordered_map<typename duckdb::unordered_map<Args...>> : std::true_typ
 	typedef typename std::tuple_element<3, std::tuple<Args...>>::type EQUAL_TYPE;
 };
 
+template <typename T>
+struct is_map : std::false_type {};
+template <typename... Args>
+struct is_map<typename duckdb::map<Args...>> : std::true_type {
+	typedef typename std::tuple_element<0, std::tuple<Args...>>::type KEY_TYPE;
+	typedef typename std::tuple_element<1, std::tuple<Args...>>::type VALUE_TYPE;
+	typedef typename std::tuple_element<2, std::tuple<Args...>>::type HASH_TYPE;
+	typedef typename std::tuple_element<3, std::tuple<Args...>>::type EQUAL_TYPE;
+};
+
 template <typename T>
 struct is_unique_ptr : std::false_type {};