duckdb 0.8.2-dev4126.0 → 0.8.2-dev4203.0

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

@@ -0,0 +1,38 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/serializer/read_stream.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/catalog/catalog.hpp"
+#include "duckdb/common/common.hpp"
+#include "duckdb/common/exception.hpp"
+#include "duckdb/common/vector.hpp"
+#include <type_traits>
+
+namespace duckdb {
+
+class ReadStream {
+public:
+	// Reads a set amount of data from the stream into the specified buffer and moves the stream forward accordingly
+	virtual void ReadData(data_ptr_t buffer, idx_t read_size) = 0;
+
+	// Reads a type from the stream and moves the stream forward sizeof(T) bytes
+	// The type must be a standard layout type
+	template <class T>
+	T Read() {
+		static_assert(std::is_standard_layout<T>(), "Read element must be a standard layout data type");
+		T value;
+		ReadData(data_ptr_cast(&value), sizeof(T));
+		return value;
+	}
+
+	virtual ~ReadStream() {
+	}
+};
+
+} // namespace duckdb

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

@@ -7,10 +7,12 @@
 #include "duckdb/common/unordered_set.hpp"
 #include "duckdb/common/set.hpp"
 #include "duckdb/common/shared_ptr.hpp"
+#include "duckdb/common/unique_ptr.hpp"
+
 namespace duckdb {
 
-class FormatSerializer;   // Forward declare
-class FormatDeserializer; // Forward declare
+class Serializer;   // Forward declare
+class Deserializer; // Forward declare
 
 typedef uint16_t field_id_t;
 const field_id_t MESSAGE_TERMINATOR_FIELD_ID = 0xFFFF;
@@ -19,34 +21,34 @@ const field_id_t MESSAGE_TERMINATOR_FIELD_ID = 0xFFFF;
 template <class...>
 using void_t = void;
 
-// Check for anything implementing a `void FormatSerialize(FormatSerializer &FormatSerializer)` method
+// Check for anything implementing a `void Serialize(Serializer &Serializer)` method
 template <typename T, typename = T>
 struct has_serialize : std::false_type {};
 template <typename T>
 struct has_serialize<
     T, typename std::enable_if<
-           std::is_same<decltype(std::declval<T>().FormatSerialize(std::declval<FormatSerializer &>())), void>::value,
-           T>::type> : std::true_type {};
+           std::is_same<decltype(std::declval<T>().Serialize(std::declval<Serializer &>())), void>::value, T>::type>
+    : std::true_type {};
 
 template <typename T, typename = T>
 struct has_deserialize : std::false_type {};
 
-// Accept `static unique_ptr<T> FormatDeserialize(FormatDeserializer& deserializer)`
+// Accept `static unique_ptr<T> Deserialize(Deserializer& deserializer)`
 template <typename T>
 struct has_deserialize<
-    T, typename std::enable_if<std::is_same<decltype(T::FormatDeserialize), unique_ptr<T>(FormatDeserializer &)>::value,
-                               T>::type> : std::true_type {};
+    T, typename std::enable_if<std::is_same<decltype(T::Deserialize), unique_ptr<T>(Deserializer &)>::value, T>::type>
+    : std::true_type {};
 
-// Accept `static shared_ptr<T> FormatDeserialize(FormatDeserializer& deserializer)`
+// Accept `static shared_ptr<T> Deserialize(Deserializer& deserializer)`
 template <typename T>
 struct has_deserialize<
-    T, typename std::enable_if<std::is_same<decltype(T::FormatDeserialize), shared_ptr<T>(FormatDeserializer &)>::value,
-                               T>::type> : std::true_type {};
+    T, typename std::enable_if<std::is_same<decltype(T::Deserialize), shared_ptr<T>(Deserializer &)>::value, T>::type>
+    : std::true_type {};
 
-// Accept `static T FormatDeserialize(FormatDeserializer& deserializer)`
+// Accept `static T Deserialize(Deserializer& deserializer)`
 template <typename T>
 struct has_deserialize<
-    T, typename std::enable_if<std::is_same<decltype(T::FormatDeserialize), T(FormatDeserializer &)>::value, T>::type>
+    T, typename std::enable_if<std::is_same<decltype(T::Deserialize), T(Deserializer &)>::value, T>::type>
     : std::true_type {};
 
 // Check if T is a vector, and provide access to the inner type

package/src/duckdb/src/include/duckdb/common/serializer/{format_serializer.hpp → serializer.hpp}

@@ -1,7 +1,7 @@
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/common/serializer/format_serializer.hpp
+// duckdb/common/serializer/serializer.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -9,8 +9,6 @@
 #pragma once
 
 #include "duckdb/common/enum_util.hpp"
-#include "duckdb/common/field_writer.hpp"
-#include "duckdb/common/serializer.hpp"
 #include "duckdb/common/serializer/serialization_traits.hpp"
 #include "duckdb/common/types/interval.hpp"
 #include "duckdb/common/types/string_type.hpp"
@@ -19,18 +17,21 @@
 
 namespace duckdb {
 
-class FormatSerializer {
+class Serializer {
 protected:
 	bool serialize_enum_as_string = false;
 	bool serialize_default_values = false;
 
 public:
+	virtual ~Serializer() {
+	}
+
 	class List {
-		friend FormatSerializer;
+		friend Serializer;
 
 	private:
-		FormatSerializer &serializer;
-		explicit List(FormatSerializer &serializer) : serializer(serializer) {
+		Serializer &serializer;
+		explicit List(Serializer &serializer) : serializer(serializer) {
 		}
 
 	public:
@@ -223,11 +224,11 @@ protected:
 		OnListEnd();
 	}
 
-	// class or struct implementing `FormatSerialize(FormatSerializer& FormatSerializer)`;
+	// class or struct implementing `Serialize(Serializer& Serializer)`;
 	template <typename T>
 	typename std::enable_if<has_serialize<T>::value>::type WriteValue(const T &value) {
 		OnObjectBegin();
-		value.FormatSerialize(*this);
+		value.Serialize(*this);
 		OnObjectEnd();
 	}
 
@@ -275,18 +276,18 @@ protected:
 
 // We need to special case vector<bool> because elements of vector<bool> cannot be referenced
 template <>
-void FormatSerializer::WriteValue(const vector<bool> &vec);
+void Serializer::WriteValue(const vector<bool> &vec);
 
 // List Impl
 template <class FUNC>
-void FormatSerializer::List::WriteObject(FUNC f) {
+void Serializer::List::WriteObject(FUNC f) {
 	serializer.OnObjectBegin();
 	f(serializer);
 	serializer.OnObjectEnd();
 }
 
 template <class T>
-void FormatSerializer::List::WriteElement(const T &value) {
+void Serializer::List::WriteElement(const T &value) {
 	serializer.WriteValue(value);
 }
 

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

@@ -0,0 +1,36 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/serializer/write_stream.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/catalog/catalog.hpp"
+#include "duckdb/common/common.hpp"
+#include "duckdb/common/exception.hpp"
+#include "duckdb/common/vector.hpp"
+#include <type_traits>
+
+namespace duckdb {
+
+class WriteStream {
+public:
+	// Writes a set amount of data from the specified buffer into the stream and moves the stream forward accordingly
+	virtual void WriteData(const_data_ptr_t buffer, idx_t write_size) = 0;
+
+	// Writes a type into the stream and moves the stream forward sizeof(T) bytes
+	// The type must be a standard layout type
+	template <class T>
+	void Write(T element) {
+		static_assert(std::is_standard_layout<T>(), "Write element must be a standard layout data type");
+		WriteData(const_data_ptr_cast(&element), sizeof(T));
+	}
+
+	virtual ~WriteStream() {
+	}
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/types/column/column_data_collection.hpp

@@ -154,8 +154,8 @@ public:
 	//! Get a vector of the segments in this ColumnDataCollection
 	const vector<unique_ptr<ColumnDataCollectionSegment>> &GetSegments() const;
 
-	void FormatSerialize(FormatSerializer &serializer) const;
-	static unique_ptr<ColumnDataCollection> FormatDeserialize(FormatDeserializer &deserializer);
+	void Serialize(Serializer &serializer) const;
+	static unique_ptr<ColumnDataCollection> Deserialize(Deserializer &deserializer);
 
 private:
 	//! Creates a new segment within the ColumnDataCollection

package/src/duckdb/src/include/duckdb/common/types/data_chunk.hpp

@@ -19,8 +19,8 @@ class Allocator;
 class ClientContext;
 class ExecutionContext;
 class VectorCache;
-class FormatSerializer;
-class FormatDeserializer;
+class Serializer;
+class Deserializer;
 
 //!  A Data Chunk represents a set of vectors.
 /*!
@@ -138,14 +138,9 @@ public:
 	//! Vector to point back to the data owned by this DataChunk.
 	DUCKDB_API void Reset();
 
-	//! Serializes a DataChunk to a stand-alone binary blob
-	DUCKDB_API void Serialize(Serializer &serializer);
-	//! Deserializes a blob back into a DataChunk
+	DUCKDB_API void Serialize(Serializer &serializer) const;
 	DUCKDB_API void Deserialize(Deserializer &source);
 
-	DUCKDB_API void FormatSerialize(FormatSerializer &serializer) const;
-	DUCKDB_API void FormatDeserialize(FormatDeserializer &source);
-
 	//! Hashes the DataChunk to the target vector
 	DUCKDB_API void Hash(Vector &result);
 	//! Hashes specific vectors of the DataChunk to the target vector

package/src/duckdb/src/include/duckdb/common/types/hyperloglog.hpp

@@ -20,11 +20,8 @@ namespace duckdb {
 
 enum class HLLStorageType : uint8_t { UNCOMPRESSED = 1 };
 
-class FieldWriter;
-class FieldReader;
-
-class FormatSerializer;
-class FormatDeserializer;
+class Serializer;
+class Deserializer;
 
 //! The HyperLogLog class holds a HyperLogLog counter for approximate cardinality counting
 class HyperLogLog {
@@ -49,12 +46,9 @@ public:
 	data_ptr_t GetPtr() const;
 	//! Get copy of the HLL
 	unique_ptr<HyperLogLog> Copy();
-	//! (De)Serialize the HLL
-	void Serialize(FieldWriter &writer) const;
-	static unique_ptr<HyperLogLog> Deserialize(FieldReader &reader);
 
-	void FormatSerialize(FormatSerializer &serializer) const;
-	static unique_ptr<HyperLogLog> FormatDeserialize(FormatDeserializer &deserializer);
+	void Serialize(Serializer &serializer) const;
+	static unique_ptr<HyperLogLog> Deserialize(Deserializer &deserializer);
 
 public:
 	//! Compute HLL hashes over vdata, and store them in 'hashes'

package/src/duckdb/src/include/duckdb/common/types/interval.hpp

@@ -16,8 +16,8 @@ struct dtime_t;
 struct date_t;
 struct timestamp_t;
 
-class FormatSerializer;
-class FormatDeserializer;
+class Serializer;
+class Deserializer;
 
 struct interval_t {
 	int32_t months;
@@ -29,8 +29,8 @@ struct interval_t {
 	}
 
 	// Serialization
-	void FormatSerialize(FormatSerializer &serializer) const;
-	static interval_t FormatDeserialize(FormatDeserializer &source);
+	void Serialize(Serializer &serializer) const;
+	static interval_t Deserialize(Deserializer &source);
 };
 
 //! The Interval class is a static class that holds helper functions for the Interval

package/src/duckdb/src/include/duckdb/common/types/value.hpp

@@ -20,8 +20,6 @@
 namespace duckdb {
 
 class CastFunctionSet;
-class Deserializer;
-class Serializer;
 struct GetCastFunctionInput;
 struct ExtraValueInfo;
 
@@ -225,10 +223,8 @@ public:
 
 	//! Serializes a Value to a stand-alone binary blob
 	DUCKDB_API void Serialize(Serializer &serializer) const;
-	DUCKDB_API void FormatSerialize(FormatSerializer &serializer) const;
-	DUCKDB_API static Value FormatDeserialize(FormatDeserializer &deserializer);
 	//! Deserializes a Value from a blob
-	DUCKDB_API static Value Deserialize(Deserializer &source);
+	DUCKDB_API static Value Deserialize(Deserializer &deserializer);
 
 	//===--------------------------------------------------------------------===//
 	// Comparison Operators

package/src/duckdb/src/include/duckdb/common/types/vector.hpp

@@ -173,13 +173,8 @@ public:
 	//! This functions resizes the vector
 	DUCKDB_API void Resize(idx_t cur_size, idx_t new_size);
 
-	//! Serializes a Vector to a stand-alone binary blob
-	DUCKDB_API void Serialize(idx_t count, Serializer &serializer);
-	//! Deserializes a blob back into a Vector
-	DUCKDB_API void Deserialize(idx_t count, Deserializer &source);
-
-	DUCKDB_API void FormatSerialize(FormatSerializer &serializer, idx_t count);
-	DUCKDB_API void FormatDeserialize(FormatDeserializer &deserializer, idx_t count);
+	DUCKDB_API void Serialize(Serializer &serializer, idx_t count);
+	DUCKDB_API void Deserialize(Deserializer &deserializer, idx_t count);
 
 	// Getters
 	inline VectorType GetVectorType() const {

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

@@ -17,15 +17,12 @@
 
 namespace duckdb {
 
-class FormatSerializer;
-class FormatDeserializer;
 class Serializer;
 class Deserializer;
 class Value;
 class TypeCatalogEntry;
 class Vector;
 class ClientContext;
-class FieldWriter;
 
 struct string_t;
 
@@ -283,14 +280,8 @@ struct LogicalType {
 		return !(*this == rhs);
 	}
 
-	//! Serializes a LogicalType to a stand-alone binary blob
 	DUCKDB_API void Serialize(Serializer &serializer) const;
-
-	//! Deserializes a blob back into an LogicalType
-	DUCKDB_API static LogicalType Deserialize(Deserializer &source);
-
-	DUCKDB_API void FormatSerialize(FormatSerializer &serializer) const;
-	DUCKDB_API static LogicalType FormatDeserialize(FormatDeserializer &deserializer);
+	DUCKDB_API static LogicalType Deserialize(Deserializer &deserializer);
 
 
 	static bool TypeIsTimestamp(LogicalTypeId id) {

package/src/duckdb/src/include/duckdb/execution/operator/scan/csv/csv_reader_options.hpp

@@ -12,7 +12,6 @@
 #include "duckdb/common/map.hpp"
 #include "duckdb/function/scalar/strftime_format.hpp"
 #include "duckdb/common/types/value.hpp"
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/case_insensitive_map.hpp"
 #include "duckdb/common/types.hpp"
 #include "duckdb/common/multi_file_reader_options.hpp"
@@ -45,9 +44,6 @@ struct CSVStateMachineOptions {
 	bool operator==(const CSVStateMachineOptions &other) const {
 		return delimiter == other.delimiter && quote == other.quote && escape == other.escape;
 	}
-
-	void Serialize(FieldWriter &writer) const;
-	void Deserialize(FieldReader &reader);
 };
 
 struct DialectOptions {
@@ -66,9 +62,6 @@ struct DialectOptions {
 	idx_t skip_rows = 0;
 	//! True start of the first CSV Buffer (After skipping empty lines, headers, notes and so on)
 	idx_t true_start = 0;
-
-	void Serialize(FieldWriter &writer) const;
-	void Deserialize(FieldReader &reader);
 };
 
 struct CSVReaderOptions {
@@ -169,10 +162,8 @@ struct CSVReaderOptions {
 	//! The date format to use for writing (if any is specified)
 	map<LogicalTypeId, StrfTimeFormat> write_date_format = {{LogicalTypeId::DATE, {}}, {LogicalTypeId::TIMESTAMP, {}}};
 
-	void Serialize(FieldWriter &writer) const;
-	void Deserialize(FieldReader &reader);
-	void FormatSerialize(FormatSerializer &serializer) const;
-	static CSVReaderOptions FormatDeserialize(FormatDeserializer &deserializer);
+	void Serialize(Serializer &serializer) const;
+	static CSVReaderOptions Deserialize(Deserializer &deserializer);
 
 	void SetCompression(const string &compression);
 	void SetHeader(bool has_header);

package/src/duckdb/src/include/duckdb/function/aggregate_function.hpp

@@ -46,15 +46,9 @@ typedef void (*aggregate_window_t)(Vector inputs[], const ValidityMask &filter_m
                                    const FrameBounds &frame, const FrameBounds &prev, Vector &result, idx_t rid,
                                    idx_t bias);
 
-typedef void (*aggregate_serialize_t)(FieldWriter &writer, const FunctionData *bind_data,
+typedef void (*aggregate_serialize_t)(Serializer &serializer, const optional_ptr<FunctionData> bind_data,
                                       const AggregateFunction &function);
-typedef unique_ptr<FunctionData> (*aggregate_deserialize_t)(PlanDeserializationState &context, FieldReader &reader,
-                                                            AggregateFunction &function);
-
-typedef void (*aggregate_format_serialize_t)(FormatSerializer &serializer, const optional_ptr<FunctionData> bind_data,
-                                             const AggregateFunction &function);
-typedef unique_ptr<FunctionData> (*aggregate_format_deserialize_t)(FormatDeserializer &deserializer,
-                                                                   AggregateFunction &function);
+typedef unique_ptr<FunctionData> (*aggregate_deserialize_t)(Deserializer &deserializer, AggregateFunction &function);
 
 class AggregateFunction : public BaseScalarFunction {
 public:
@@ -70,8 +64,7 @@ public:
 	                         LogicalType(LogicalTypeId::INVALID), null_handling),
 	      state_size(state_size), initialize(initialize), update(update), combine(combine), finalize(finalize),
 	      simple_update(simple_update), window(window), bind(bind), destructor(destructor), statistics(statistics),
-	      serialize(serialize), deserialize(deserialize), format_serialize(nullptr), format_deserialize(nullptr),
-	      order_dependent(AggregateOrderDependent::ORDER_DEPENDENT) {
+	      serialize(serialize), deserialize(deserialize), order_dependent(AggregateOrderDependent::ORDER_DEPENDENT) {
 	}
 
 	AggregateFunction(const string &name, const vector<LogicalType> &arguments, const LogicalType &return_type,
@@ -85,8 +78,7 @@ public:
 	                         LogicalType(LogicalTypeId::INVALID)),
 	      state_size(state_size), initialize(initialize), update(update), combine(combine), finalize(finalize),
 	      simple_update(simple_update), window(window), bind(bind), destructor(destructor), statistics(statistics),
-	      serialize(serialize), deserialize(deserialize), format_serialize(nullptr), format_deserialize(nullptr),
-	      order_dependent(AggregateOrderDependent::ORDER_DEPENDENT) {
+	      serialize(serialize), deserialize(deserialize), order_dependent(AggregateOrderDependent::ORDER_DEPENDENT) {
 	}
 
 	AggregateFunction(const vector<LogicalType> &arguments, const LogicalType &return_type, aggregate_size_t state_size,
@@ -137,8 +129,6 @@ public:
 
 	aggregate_serialize_t serialize;
 	aggregate_deserialize_t deserialize;
-	aggregate_format_serialize_t format_serialize;
-	aggregate_format_deserialize_t format_deserialize;
 	//! Whether or not the aggregate is order dependent
 	AggregateOrderDependent order_dependent;
 

package/src/duckdb/src/include/duckdb/function/copy_function.hpp

@@ -82,10 +82,10 @@ typedef void (*copy_to_combine_t)(ExecutionContext &context, FunctionData &bind_
                                   LocalFunctionData &lstate);
 typedef void (*copy_to_finalize_t)(ClientContext &context, FunctionData &bind_data, GlobalFunctionData &gstate);
 
-typedef void (*copy_to_serialize_t)(FieldWriter &writer, const FunctionData &bind_data, const CopyFunction &function);
+typedef void (*copy_to_serialize_t)(Serializer &serializer, const FunctionData &bind_data,
+                                    const CopyFunction &function);
 
-typedef unique_ptr<FunctionData> (*copy_to_deserialize_t)(ClientContext &context, FieldReader &reader,
-                                                          CopyFunction &function);
+typedef unique_ptr<FunctionData> (*copy_to_deserialize_t)(Deserializer &deserializer, CopyFunction &function);
 
 typedef unique_ptr<FunctionData> (*copy_from_bind_t)(ClientContext &context, CopyInfo &info,
                                                      vector<string> &expected_names,

package/src/duckdb/src/include/duckdb/function/function_serialization.hpp

@@ -8,111 +8,27 @@
 
 #pragma once
 
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/catalog/catalog_entry/table_function_catalog_entry.hpp"
-#include "duckdb/common/serializer/format_serializer.hpp"
-#include "duckdb/common/serializer/format_deserializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 
 namespace duckdb {
 
 class FunctionSerializer {
 public:
 	template <class FUNC>
-	static void SerializeBase(FieldWriter &writer, const FUNC &function, FunctionData *bind_info) {
-		D_ASSERT(!function.name.empty());
-		writer.WriteString(function.name);
-		writer.WriteRegularSerializableList(function.arguments);
-		writer.WriteRegularSerializableList(function.original_arguments);
-		bool serialize = function.serialize;
-		writer.WriteField(serialize);
-		if (serialize) {
-			function.serialize(writer, bind_info, function);
-			// First check if serialize throws a NotImplementedException, in which case it doesn't require a deserialize
-			// function
-			D_ASSERT(function.deserialize);
-		}
-	}
-
-	template <class FUNC>
-	static void Serialize(FieldWriter &writer, const FUNC &function, const LogicalType &return_type,
-	                      const vector<unique_ptr<Expression>> &children, FunctionData *bind_info) {
-		SerializeBase(writer, function, bind_info);
-		writer.WriteSerializable(return_type);
-		writer.WriteSerializableList(children);
-	}
-
-	template <class FUNC, class CATALOG_ENTRY>
-	static FUNC DeserializeBaseInternal(FieldReader &reader, PlanDeserializationState &state, CatalogType type,
-	                                    unique_ptr<FunctionData> &bind_info, bool &has_deserialize) {
-		auto &context = state.context;
-		auto name = reader.ReadRequired<string>();
-		auto arguments = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
-		// note: original_arguments are optional (can be list of size 0)
-		auto original_arguments = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
-
-		auto &func_catalog = Catalog::GetEntry(context, type, SYSTEM_CATALOG, DEFAULT_SCHEMA, name);
-		if (func_catalog.type != type) {
-			throw InternalException("Cant find catalog entry for function %s", name);
-		}
-
-		auto &functions = func_catalog.Cast<CATALOG_ENTRY>();
-		auto function = functions.functions.GetFunctionByArguments(
-		    state.context, original_arguments.empty() ? arguments : original_arguments);
-		function.arguments = std::move(arguments);
-		function.original_arguments = std::move(original_arguments);
-
-		has_deserialize = reader.ReadRequired<bool>();
-		if (has_deserialize) {
-			if (!function.deserialize) {
-				throw SerializationException("Function requires deserialization but no deserialization function for %s",
-				                             function.name);
-			}
-			bind_info = function.deserialize(state, reader, function);
-		} else {
-			D_ASSERT(!function.serialize);
-			D_ASSERT(!function.deserialize);
-		}
-		return function;
-	}
-	template <class FUNC, class CATALOG_ENTRY>
-	static FUNC DeserializeBase(FieldReader &reader, PlanDeserializationState &state, CatalogType type,
-	                            unique_ptr<FunctionData> &bind_info) {
-		bool has_deserialize;
-		return DeserializeBaseInternal<FUNC, CATALOG_ENTRY>(reader, state, type, bind_info, has_deserialize);
-	}
-
-	template <class FUNC, class CATALOG_ENTRY>
-	static FUNC Deserialize(FieldReader &reader, ExpressionDeserializationState &state, CatalogType type,
-	                        vector<unique_ptr<Expression>> &children, unique_ptr<FunctionData> &bind_info) {
-		bool has_deserialize;
-		auto function =
-		    DeserializeBaseInternal<FUNC, CATALOG_ENTRY>(reader, state.gstate, type, bind_info, has_deserialize);
-		auto return_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
-		children = reader.ReadRequiredSerializableList<Expression>(state.gstate);
-
-		// we re-bind the function only if the function did not have an explicit deserialize method
-		auto &context = state.gstate.context;
-		if (!has_deserialize && function.bind) {
-			bind_info = function.bind(context, function, children);
-		}
-		function.return_type = return_type;
-		return function;
-	}
-
-	template <class FUNC>
-	static void FormatSerialize(FormatSerializer &serializer, const FUNC &function,
-	                            optional_ptr<FunctionData> bind_info) {
+	static void Serialize(Serializer &serializer, const FUNC &function, optional_ptr<FunctionData> bind_info) {
 		D_ASSERT(!function.name.empty());
 		serializer.WriteProperty(500, "name", function.name);
 		serializer.WriteProperty(501, "arguments", function.arguments);
 		serializer.WriteProperty(502, "original_arguments", function.original_arguments);
-		bool has_serialize = function.format_serialize;
+		bool has_serialize = function.serialize;
 		serializer.WriteProperty(503, "has_serialize", has_serialize);
 		if (has_serialize) {
 			serializer.WriteObject(504, "function_data",
-			                       [&](FormatSerializer &obj) { function.format_serialize(obj, bind_info, function); });
-			D_ASSERT(function.format_deserialize);
+			                       [&](Serializer &obj) { function.serialize(obj, bind_info, function); });
+			D_ASSERT(function.deserialize);
 		}
 	}
 
@@ -132,7 +48,7 @@ public:
 	}
 
 	template <class FUNC, class CATALOG_ENTRY>
-	static pair<FUNC, bool> FormatDeserializeBase(FormatDeserializer &deserializer, CatalogType catalog_type) {
+	static pair<FUNC, bool> DeserializeBase(Deserializer &deserializer, CatalogType catalog_type) {
 		auto &context = deserializer.Get<ClientContext &>();
 		auto name = deserializer.ReadProperty<string>(500, "name");
 		auto arguments = deserializer.ReadProperty<vector<LogicalType>>(501, "arguments");
@@ -144,23 +60,23 @@ public:
 	}
 
 	template <class FUNC>
-	static unique_ptr<FunctionData> FunctionDeserialize(FormatDeserializer &deserializer, FUNC &function) {
-		if (!function.format_deserialize) {
+	static unique_ptr<FunctionData> FunctionDeserialize(Deserializer &deserializer, FUNC &function) {
+		if (!function.deserialize) {
 			throw SerializationException("Function requires deserialization but no deserialization function for %s",
 			                             function.name);
 		}
 		unique_ptr<FunctionData> result;
 		deserializer.ReadObject(504, "function_data",
-		                        [&](FormatDeserializer &obj) { result = function.format_deserialize(obj, function); });
+		                        [&](Deserializer &obj) { result = function.deserialize(obj, function); });
 		return result;
 	}
 
 	template <class FUNC, class CATALOG_ENTRY>
-	static pair<FUNC, unique_ptr<FunctionData>> FormatDeserialize(FormatDeserializer &deserializer,
-	                                                              CatalogType catalog_type,
-	                                                              vector<unique_ptr<Expression>> &children) {
+	static pair<FUNC, unique_ptr<FunctionData>> Deserialize(Deserializer &deserializer, CatalogType catalog_type,
+	                                                        vector<unique_ptr<Expression>> &children,
+	                                                        LogicalType return_type) {
 		auto &context = deserializer.Get<ClientContext &>();
-		auto entry = FormatDeserializeBase<FUNC, CATALOG_ENTRY>(deserializer, catalog_type);
+		auto entry = DeserializeBase<FUNC, CATALOG_ENTRY>(deserializer, catalog_type);
 		auto &function = entry.first;
 		auto has_serialize = entry.second;
 
@@ -175,6 +91,7 @@ public:
 				throw SerializationException("Error during bind of function in deserialization: %s", ex.what());
 			}
 		}
+		function.return_type = std::move(return_type);
 		return make_pair(std::move(function), std::move(bind_data));
 	}
 };