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

package/src/duckdb/src/core_functions/aggregate/holistic/reservoir_quantile.cpp

@@ -3,9 +3,8 @@
 #include "duckdb/core_functions/aggregate/holistic_functions.hpp"
 #include "duckdb/planner/expression.hpp"
 #include "duckdb/common/queue.hpp"
-#include "duckdb/common/field_writer.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"
 
 #include <algorithm>
 #include <stdlib.h>
@@ -70,28 +69,14 @@ struct ReservoirQuantileBindData : public FunctionData {
 		return quantiles == other.quantiles && sample_size == other.sample_size;
 	}
 
-	static void Serialize(FieldWriter &writer, const FunctionData *bind_data_p, const AggregateFunction &function) {
-		D_ASSERT(bind_data_p);
-		auto &bind_data = bind_data_p->Cast<ReservoirQuantileBindData>();
-		writer.WriteList<double>(bind_data.quantiles);
-		writer.WriteField<int32_t>(bind_data.sample_size);
-	}
-
-	static unique_ptr<FunctionData> Deserialize(PlanDeserializationState &state, FieldReader &reader,
-	                                            AggregateFunction &bound_function) {
-		auto quantiles = reader.ReadRequiredList<double>();
-		auto sample_size = reader.ReadRequired<int32_t>();
-		return make_uniq<ReservoirQuantileBindData>(std::move(quantiles), sample_size);
-	}
-
-	static void FormatSerialize(FormatSerializer &serializer, const optional_ptr<FunctionData> bind_data_p,
-	                            const AggregateFunction &function) {
+	static void Serialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
+	                      const AggregateFunction &function) {
 		auto &bind_data = bind_data_p->Cast<ReservoirQuantileBindData>();
 		serializer.WriteProperty(100, "quantiles", bind_data.quantiles);
 		serializer.WriteProperty(101, "sample_size", bind_data.sample_size);
 	}
 
-	static unique_ptr<FunctionData> FormatDeserialize(FormatDeserializer &deserializer, AggregateFunction &function) {
+	static unique_ptr<FunctionData> Deserialize(Deserializer &deserializer, AggregateFunction &function) {
 		auto result = make_uniq<ReservoirQuantileBindData>();
 		deserializer.ReadProperty(100, "quantiles", result->quantiles);
 		deserializer.ReadProperty(101, "sample_size", result->sample_size);
@@ -373,8 +358,6 @@ unique_ptr<FunctionData> BindReservoirQuantileDecimal(ClientContext &context, Ag
 	function.name = "reservoir_quantile";
 	function.serialize = ReservoirQuantileBindData::Serialize;
 	function.deserialize = ReservoirQuantileBindData::Deserialize;
-	function.format_serialize = ReservoirQuantileBindData::FormatSerialize;
-	function.format_deserialize = ReservoirQuantileBindData::FormatDeserialize;
 	return bind_data;
 }
 
@@ -383,8 +366,6 @@ AggregateFunction GetReservoirQuantileAggregate(PhysicalType type) {
 	fun.bind = BindReservoirQuantile;
 	fun.serialize = ReservoirQuantileBindData::Serialize;
 	fun.deserialize = ReservoirQuantileBindData::Deserialize;
-	fun.format_serialize = ReservoirQuantileBindData::FormatSerialize;
-	fun.format_deserialize = ReservoirQuantileBindData::FormatDeserialize;
 	// temporarily push an argument so we can bind the actual quantile
 	fun.arguments.emplace_back(LogicalType::DOUBLE);
 	return fun;
@@ -396,8 +377,6 @@ unique_ptr<FunctionData> BindReservoirQuantileDecimalList(ClientContext &context
 	auto bind_data = BindReservoirQuantile(context, function, arguments);
 	function.serialize = ReservoirQuantileBindData::Serialize;
 	function.deserialize = ReservoirQuantileBindData::Deserialize;
-	function.format_serialize = ReservoirQuantileBindData::FormatSerialize;
-	function.format_deserialize = ReservoirQuantileBindData::FormatDeserialize;
 	function.name = "reservoir_quantile";
 	return bind_data;
 }
@@ -407,8 +386,6 @@ AggregateFunction GetReservoirQuantileListAggregate(const LogicalType &type) {
 	fun.bind = BindReservoirQuantile;
 	fun.serialize = ReservoirQuantileBindData::Serialize;
 	fun.deserialize = ReservoirQuantileBindData::Deserialize;
-	fun.format_serialize = ReservoirQuantileBindData::FormatSerialize;
-	fun.format_deserialize = ReservoirQuantileBindData::FormatDeserialize;
 	// temporarily push an argument so we can bind the actual quantile
 	auto list_of_double = LogicalType::LIST(LogicalType::DOUBLE);
 	fun.arguments.push_back(list_of_double);
@@ -437,8 +414,6 @@ static void GetReservoirQuantileDecimalFunction(AggregateFunctionSet &set, const
 	                      BindReservoirQuantileDecimal);
 	fun.serialize = ReservoirQuantileBindData::Serialize;
 	fun.deserialize = ReservoirQuantileBindData::Deserialize;
-	fun.format_serialize = ReservoirQuantileBindData::FormatSerialize;
-	fun.format_deserialize = ReservoirQuantileBindData::FormatDeserialize;
 	set.AddFunction(fun);
 
 	fun.arguments.emplace_back(LogicalType::INTEGER);

package/src/duckdb/src/core_functions/scalar/date/date_part.cpp

@@ -11,8 +11,6 @@
 #include "duckdb/function/scalar/nested_functions.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 
-#include "duckdb/common/field_writer.hpp"
-
 namespace duckdb {
 
 DatePartSpecifier GetDateTypePartSpecifier(const string &specifier, LogicalType &type) {
@@ -1603,18 +1601,17 @@ struct StructDatePart {
 		result.Verify(count);
 	}
 
-	static void SerializeFunction(FieldWriter &writer, const FunctionData *bind_data_p,
+	static void SerializeFunction(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
 	                              const ScalarFunction &function) {
 		D_ASSERT(bind_data_p);
 		auto &info = bind_data_p->Cast<BindData>();
-		writer.WriteSerializable(info.stype);
-		writer.WriteList<DatePartSpecifier>(info.part_codes);
+		serializer.WriteProperty(100, "stype", info.stype);
+		serializer.WriteProperty(101, "part_codes", info.part_codes);
 	}
 
-	static unique_ptr<FunctionData> DeserializeFunction(PlanDeserializationState &state, FieldReader &reader,
-	                                                    ScalarFunction &bound_function) {
-		auto stype = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
-		auto part_codes = reader.ReadRequiredList<DatePartSpecifier>();
+	static unique_ptr<FunctionData> DeserializeFunction(Deserializer &deserializer, ScalarFunction &bound_function) {
+		auto stype = deserializer.ReadProperty<LogicalType>(100, "stype");
+		auto part_codes = deserializer.ReadProperty<vector<DatePartSpecifier>>(101, "part_codes");
 		return make_uniq<BindData>(std::move(stype), std::move(part_codes));
 	}
 

package/src/duckdb/src/core_functions/scalar/list/list_aggregates.cpp

@@ -36,25 +36,30 @@ struct ListAggregatesBindData : public FunctionData {
 		auto &other = other_p.Cast<ListAggregatesBindData>();
 		return stype == other.stype && aggr_expr->Equals(*other.aggr_expr);
 	}
-	static void Serialize(FieldWriter &writer, const FunctionData *bind_data_p, const ScalarFunction &function) {
-		auto bind_data = dynamic_cast<const ListAggregatesBindData *>(bind_data_p);
-		if (!bind_data) {
-			writer.WriteField<bool>(false);
-		} else {
-			writer.WriteField<bool>(true);
-			writer.WriteSerializable(bind_data->stype);
-			writer.WriteSerializable(*bind_data->aggr_expr);
-		}
+	void Serialize(Serializer &serializer) const {
+		serializer.WriteProperty(1, "stype", stype);
+		serializer.WriteProperty(2, "aggr_expr", aggr_expr);
+	}
+	static unique_ptr<ListAggregatesBindData> Deserialize(Deserializer &deserializer) {
+		auto stype = deserializer.ReadProperty<LogicalType>(1, "stype");
+		auto aggr_expr = deserializer.ReadProperty<unique_ptr<Expression>>(2, "aggr_expr");
+		auto result = make_uniq<ListAggregatesBindData>(std::move(stype), std::move(aggr_expr));
+		return result;
 	}
-	static unique_ptr<FunctionData> Deserialize(PlanDeserializationState &state, FieldReader &reader,
-	                                            ScalarFunction &bound_function) {
-		if (reader.ReadRequired<bool>()) {
-			auto s_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
-			auto expr = reader.ReadRequiredSerializable<Expression>(state);
-			return make_uniq<ListAggregatesBindData>(s_type, std::move(expr));
-		} else {
+
+	static void Serialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
+	                      const ScalarFunction &function) {
+		auto bind_data = dynamic_cast<const ListAggregatesBindData *>(bind_data_p.get());
+		serializer.WritePropertyWithDefault(100, "bind_data", bind_data, (const ListAggregatesBindData *)nullptr);
+	}
+
+	static unique_ptr<FunctionData> Deserialize(Deserializer &deserializer, ScalarFunction &bound_function) {
+		auto result = deserializer.ReadPropertyWithDefault<unique_ptr<ListAggregatesBindData>>(
+		    100, "bind_data", unique_ptr<ListAggregatesBindData>(nullptr));
+		if (!result) {
 			return ListAggregatesBindFailure(bound_function);
 		}
+		return std::move(result);
 	}
 };
 

package/src/duckdb/src/core_functions/scalar/list/list_lambdas.cpp

@@ -8,8 +8,8 @@
 #include "duckdb/planner/expression/bound_lambda_expression.hpp"
 #include "duckdb/planner/expression/bound_cast_expression.hpp"
 #include "duckdb/function/cast/cast_function_set.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 {
 
@@ -23,26 +23,22 @@ struct ListLambdaBindData : public FunctionData {
 public:
 	bool Equals(const FunctionData &other_p) const override;
 	unique_ptr<FunctionData> Copy() const override;
-	static void Serialize(FieldWriter &writer, const FunctionData *bind_data_p, const ScalarFunction &function) {
-		throw NotImplementedException("FIXME: list lambda serialize");
-	}
-	static unique_ptr<FunctionData> Deserialize(PlanDeserializationState &state, FieldReader &reader,
-	                                            ScalarFunction &bound_function) {
-		throw NotImplementedException("FIXME: list lambda deserialize");
-	}
 
-	static void FormatSerialize(FormatSerializer &serializer, const optional_ptr<FunctionData> bind_data_p,
-	                            const ScalarFunction &function) {
-		auto &bind_data = bind_data_p->Cast<ListLambdaBindData>();
-		serializer.WriteProperty(100, "stype", bind_data.stype);
-		serializer.WritePropertyWithDefault(101, "lambda_expr", bind_data.lambda_expr, unique_ptr<Expression>());
+	static void Serialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
+	                      const ScalarFunction &function) {
+		//		auto &bind_data = bind_data_p->Cast<ListLambdaBindData>();
+		//		serializer.WriteProperty(100, "stype", bind_data.stype);
+		//		serializer.WritePropertyWithDefault(101, "lambda_expr", bind_data.lambda_expr,
+		// unique_ptr<Expression>());
+		throw NotImplementedException("FIXME: list lambda serialize");
 	}
 
-	static unique_ptr<FunctionData> FormatDeserialize(FormatDeserializer &deserializer, ScalarFunction &function) {
-		auto stype = deserializer.ReadProperty<LogicalType>(100, "stype");
-		auto lambda_expr =
-		    deserializer.ReadPropertyWithDefault<unique_ptr<Expression>>(101, "lambda_expr", unique_ptr<Expression>());
-		return make_uniq<ListLambdaBindData>(stype, std::move(lambda_expr));
+	static unique_ptr<FunctionData> Deserialize(Deserializer &deserializer, ScalarFunction &function) {
+		//		auto stype = deserializer.ReadProperty<LogicalType>(100, "stype");
+		//		auto lambda_expr =
+		//		    deserializer.ReadPropertyWithDefault<unique_ptr<Expression>>(101, "lambda_expr",
+		// unique_ptr<Expression>()); 		return make_uniq<ListLambdaBindData>(stype, std::move(lambda_expr));
+		throw NotImplementedException("FIXME: list lambda deserialize");
 	}
 };
 
@@ -401,8 +397,6 @@ ScalarFunction ListTransformFun::GetFunction() {
 	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
 	fun.serialize = ListLambdaBindData::Serialize;
 	fun.deserialize = ListLambdaBindData::Deserialize;
-	fun.format_serialize = ListLambdaBindData::FormatSerialize;
-	fun.format_deserialize = ListLambdaBindData::FormatDeserialize;
 	return fun;
 }
 
@@ -412,8 +406,6 @@ ScalarFunction ListFilterFun::GetFunction() {
 	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
 	fun.serialize = ListLambdaBindData::Serialize;
 	fun.deserialize = ListLambdaBindData::Deserialize;
-	fun.format_serialize = ListLambdaBindData::FormatSerialize;
-	fun.format_deserialize = ListLambdaBindData::FormatDeserialize;
 	return fun;
 }
 

package/src/duckdb/src/function/macro_function.cpp

@@ -92,46 +92,4 @@ string MacroFunction::ToSQL(const string &schema, const string &name) const {
 	return StringUtil::Format("CREATE MACRO %s.%s(%s) AS ", schema, name, StringUtil::Join(param_strings, ", "));
 }
 
-void MacroFunction::Serialize(Serializer &main_serializer) const {
-	FieldWriter writer(main_serializer);
-	writer.WriteField(type);
-	writer.WriteSerializableList(parameters);
-	writer.WriteField<uint32_t>((uint32_t)default_parameters.size());
-	auto &serializer = writer.GetSerializer();
-	for (auto &kv : default_parameters) {
-		serializer.WriteString(kv.first);
-		kv.second->Serialize(serializer);
-	}
-	SerializeInternal(writer);
-	writer.Finalize();
-}
-
-unique_ptr<MacroFunction> MacroFunction::Deserialize(Deserializer &main_source) {
-	FieldReader reader(main_source);
-	auto type = reader.ReadRequired<MacroType>();
-	auto parameters = reader.ReadRequiredSerializableList<ParsedExpression>();
-	auto default_param_count = reader.ReadRequired<uint32_t>();
-	unordered_map<string, unique_ptr<ParsedExpression>> default_parameters;
-	auto &source = reader.GetSource();
-	for (idx_t i = 0; i < default_param_count; i++) {
-		auto name = source.Read<string>();
-		default_parameters[name] = ParsedExpression::Deserialize(source);
-	}
-	unique_ptr<MacroFunction> result;
-	switch (type) {
-	case MacroType::SCALAR_MACRO:
-		result = ScalarMacroFunction::Deserialize(reader);
-		break;
-	case MacroType::TABLE_MACRO:
-		result = TableMacroFunction::Deserialize(reader);
-		break;
-	default:
-		throw InternalException("Cannot deserialize macro type");
-	}
-	result->parameters = std::move(parameters);
-	result->default_parameters = std::move(default_parameters);
-	reader.Finalize();
-	return result;
-}
-
 } // namespace duckdb

package/src/duckdb/src/function/scalar/compressed_materialization/compress_integral.cpp

@@ -1,5 +1,7 @@
 #include "duckdb/function/function_set.hpp"
 #include "duckdb/function/scalar/compressed_materialization_functions.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 
 namespace duckdb {
 
@@ -143,17 +145,17 @@ static scalar_function_t GetIntegralDecompressFunctionInputSwitch(const LogicalT
 	}
 }
 
-static void CMIntegralSerialize(FieldWriter &writer, const FunctionData *bind_data_p, const ScalarFunction &function) {
-	writer.WriteRegularSerializableList(function.arguments);
-	writer.WriteSerializable(function.return_type);
+static void CMIntegralSerialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data,
+                                const ScalarFunction &function) {
+	serializer.WriteProperty(100, "arguments", function.arguments);
+	serializer.WriteProperty(101, "return_type", function.return_type);
 }
 
 template <scalar_function_t (*GET_FUNCTION)(const LogicalType &, const LogicalType &)>
-unique_ptr<FunctionData> CMIntegralDeserialize(PlanDeserializationState &state, FieldReader &reader,
-                                               ScalarFunction &function) {
-	function.arguments = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
-	function.function =
-	    GET_FUNCTION(function.arguments[0], reader.ReadRequiredSerializable<LogicalType, LogicalType>());
+unique_ptr<FunctionData> CMIntegralDeserialize(Deserializer &deserializer, ScalarFunction &function) {
+	function.arguments = deserializer.ReadProperty<vector<LogicalType>>(100, "arguments");
+	auto return_type = deserializer.ReadProperty<LogicalType>(101, "return_type");
+	function.function = GET_FUNCTION(function.arguments[0], return_type);
 	return nullptr;
 }
 

package/src/duckdb/src/function/scalar/compressed_materialization/compress_string.cpp

@@ -1,5 +1,7 @@
 #include "duckdb/common/bswap.hpp"
 #include "duckdb/function/scalar/compressed_materialization_functions.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 
 namespace duckdb {
 
@@ -186,16 +188,16 @@ static scalar_function_t GetStringDecompressFunctionSwitch(const LogicalType &in
 	}
 }
 
-static void CMStringCompressSerialize(FieldWriter &writer, const FunctionData *bind_data_p,
+static void CMStringCompressSerialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data,
                                       const ScalarFunction &function) {
-	writer.WriteRegularSerializableList(function.arguments);
-	writer.WriteSerializable(function.return_type);
+	serializer.WriteProperty(100, "arguments", function.arguments);
+	serializer.WriteProperty(101, "return_type", function.return_type);
 }
 
-unique_ptr<FunctionData> CMStringCompressDeserialize(PlanDeserializationState &state, FieldReader &reader,
-                                                     ScalarFunction &function) {
-	function.arguments = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
-	function.function = GetStringCompressFunctionSwitch(reader.ReadRequiredSerializable<LogicalType, LogicalType>());
+unique_ptr<FunctionData> CMStringCompressDeserialize(Deserializer &deserializer, ScalarFunction &function) {
+	function.arguments = deserializer.ReadProperty<vector<LogicalType>>(100, "arguments");
+	auto return_type = deserializer.ReadProperty<LogicalType>(101, "return_type");
+	function.function = GetStringCompressFunctionSwitch(return_type);
 	return nullptr;
 }
 
@@ -213,14 +215,13 @@ void CMStringCompressFun::RegisterFunction(BuiltinFunctions &set) {
 	}
 }
 
-static void CMStringDecompressSerialize(FieldWriter &writer, const FunctionData *bind_data_p,
+static void CMStringDecompressSerialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data,
                                         const ScalarFunction &function) {
-	writer.WriteRegularSerializableList(function.arguments);
+	serializer.WriteProperty(100, "arguments", function.arguments);
 }
 
-unique_ptr<FunctionData> CMStringDecompressDeserialize(PlanDeserializationState &state, FieldReader &reader,
-                                                       ScalarFunction &function) {
-	function.arguments = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
+unique_ptr<FunctionData> CMStringDecompressDeserialize(Deserializer &deserializer, ScalarFunction &function) {
+	function.arguments = deserializer.ReadProperty<vector<LogicalType>>(100, "arguments");
 	function.function = GetStringDecompressFunctionSwitch(function.arguments[0]);
 	return nullptr;
 }

package/src/duckdb/src/function/scalar/operators/arithmetic.cpp

@@ -1,4 +1,3 @@
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/operator/add.hpp"
 #include "duckdb/common/operator/multiply.hpp"
 #include "duckdb/common/operator/numeric_binary_operators.hpp"
@@ -250,23 +249,22 @@ unique_ptr<FunctionData> BindDecimalAddSubtract(ClientContext &context, ScalarFu
 	return std::move(bind_data);
 }
 
-static void SerializeDecimalArithmetic(FieldWriter &writer, const FunctionData *bind_data_p,
+static void SerializeDecimalArithmetic(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
                                        const ScalarFunction &function) {
 	auto &bind_data = bind_data_p->Cast<DecimalArithmeticBindData>();
-	writer.WriteField(bind_data.check_overflow);
-	writer.WriteSerializable(function.return_type);
-	writer.WriteRegularSerializableList(function.arguments);
+	serializer.WriteProperty(100, "check_overflow", bind_data.check_overflow);
+	serializer.WriteProperty(101, "return_type", function.return_type);
+	serializer.WriteProperty(102, "arguments", function.arguments);
 }
 
 // TODO this is partially duplicated from the bind
 template <class OP, class OPOVERFLOWCHECK, bool IS_SUBTRACT = false>
-unique_ptr<FunctionData> DeserializeDecimalArithmetic(PlanDeserializationState &state, FieldReader &reader,
-                                                      ScalarFunction &bound_function) {
-	// re-change the function pointers
-	auto check_overflow = reader.ReadRequired<bool>();
-	auto return_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
-	auto arguments = reader.template ReadRequiredSerializableList<LogicalType, LogicalType>();
+unique_ptr<FunctionData> DeserializeDecimalArithmetic(Deserializer &deserializer, ScalarFunction &bound_function) {
 
+	//	// re-change the function pointers
+	auto check_overflow = deserializer.ReadProperty<bool>(100, "check_overflow");
+	auto return_type = deserializer.ReadProperty<LogicalType>(101, "return_type");
+	auto arguments = deserializer.ReadProperty<vector<LogicalType>>(102, "arguments");
 	if (check_overflow) {
 		bound_function.function = GetScalarBinaryFunction<OPOVERFLOWCHECK>(return_type.InternalType());
 	} else {

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

@@ -277,43 +277,23 @@ bool ExportAggregateFunctionBindData::Equals(const FunctionData &other_p) const
 	return aggregate->Equals(*other.aggregate);
 }
 
-static void ExportStateAggregateSerialize(FieldWriter &writer, const FunctionData *bind_data_p,
+static void ExportStateAggregateSerialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
                                           const AggregateFunction &function) {
 	throw NotImplementedException("FIXME: export state serialize");
 }
-static unique_ptr<FunctionData> ExportStateAggregateDeserialize(PlanDeserializationState &state, FieldReader &reader,
-                                                                AggregateFunction &bound_function) {
-	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 unique_ptr<FunctionData> ExportStateAggregateDeserialize(Deserializer &deserializer,
+                                                                AggregateFunction &function) {
+	throw NotImplementedException("FIXME: export state deserialize");
 }
 
-static void ExportStateScalarSerialize(FieldWriter &writer, const FunctionData *bind_data_p,
+static void ExportStateScalarSerialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
                                        const ScalarFunction &function) {
 	throw NotImplementedException("FIXME: export state serialize");
 }
-static unique_ptr<FunctionData> ExportStateScalarDeserialize(PlanDeserializationState &state, FieldReader &reader,
-                                                             ScalarFunction &bound_function) {
-	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");
+static unique_ptr<FunctionData> ExportStateScalarDeserialize(Deserializer &deserializer, ScalarFunction &function) {
+	throw NotImplementedException("FIXME: export state deserialize");
 }
 
 unique_ptr<BoundAggregateExpression>
@@ -352,8 +332,6 @@ 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),
@@ -366,8 +344,6 @@ 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;
 }
 
@@ -378,8 +354,6 @@ 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,8 +13,7 @@ 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), format_serialize(nullptr),
-      format_deserialize(nullptr) {
+      statistics(statistics), serialize(nullptr), deserialize(nullptr) {
 }
 
 ScalarFunction::ScalarFunction(vector<LogicalType> arguments, LogicalType return_type, scalar_function_t function,

package/src/duckdb/src/function/scalar_macro_function.cpp

@@ -49,14 +49,4 @@ string ScalarMacroFunction::ToSQL(const string &schema, const string &name) cons
 	return MacroFunction::ToSQL(schema, name) + StringUtil::Format("(%s);", expression_copy->ToString());
 }
 
-void ScalarMacroFunction::SerializeInternal(FieldWriter &writer) const {
-	writer.WriteSerializable(*expression);
-}
-
-unique_ptr<MacroFunction> ScalarMacroFunction::Deserialize(FieldReader &reader) {
-	auto result = make_uniq<ScalarMacroFunction>();
-	result->expression = reader.ReadRequiredSerializable<ParsedExpression>();
-	return std::move(result);
-}
-
 } // namespace duckdb