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

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

@@ -6,7 +6,6 @@
 #include "duckdb/common/operator/comparison_operators.hpp"
 #include "duckdb/common/pair.hpp"
 #include "duckdb/common/printer.hpp"
-#include "duckdb/common/serializer.hpp"
 #include "duckdb/common/types/null_value.hpp"
 #include "duckdb/common/types/sel_cache.hpp"
 #include "duckdb/common/types/vector_cache.hpp"
@@ -20,8 +19,8 @@
 #include "duckdb/common/types/bit.hpp"
 #include "duckdb/common/types/value_map.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 <cstring> // strlen() on Solaris
 
@@ -924,75 +923,7 @@ void Vector::Sequence(int64_t start, int64_t increment, idx_t count) {
 	auxiliary.reset();
 }
 
-void Vector::Serialize(idx_t count, Serializer &serializer) {
-	auto &type = GetType();
-
-	UnifiedVectorFormat vdata;
-	ToUnifiedFormat(count, vdata);
-
-	const auto write_validity = (count > 0) && !vdata.validity.AllValid();
-	serializer.Write<bool>(write_validity);
-	if (write_validity) {
-		ValidityMask flat_mask(count);
-		for (idx_t i = 0; i < count; ++i) {
-			auto row_idx = vdata.sel->get_index(i);
-			flat_mask.Set(i, vdata.validity.RowIsValid(row_idx));
-		}
-		serializer.WriteData(const_data_ptr_cast(flat_mask.GetData()), flat_mask.ValidityMaskSize(count));
-	}
-	if (TypeIsConstantSize(type.InternalType())) {
-		// constant size type: simple copy
-		idx_t write_size = GetTypeIdSize(type.InternalType()) * count;
-		auto ptr = make_unsafe_uniq_array<data_t>(write_size);
-		VectorOperations::WriteToStorage(*this, count, ptr.get());
-		serializer.WriteData(ptr.get(), write_size);
-	} else {
-		switch (type.InternalType()) {
-		case PhysicalType::VARCHAR: {
-			auto strings = UnifiedVectorFormat::GetData<string_t>(vdata);
-			for (idx_t i = 0; i < count; i++) {
-				auto idx = vdata.sel->get_index(i);
-				auto source = !vdata.validity.RowIsValid(idx) ? NullValue<string_t>() : strings[idx];
-				serializer.WriteStringLen(const_data_ptr_cast(source.GetData()), source.GetSize());
-			}
-			break;
-		}
-		case PhysicalType::STRUCT: {
-			Flatten(count);
-			auto &entries = StructVector::GetEntries(*this);
-			for (auto &entry : entries) {
-				entry->Serialize(count, serializer);
-			}
-			break;
-		}
-		case PhysicalType::LIST: {
-			auto &child = ListVector::GetEntry(*this);
-			auto list_size = ListVector::GetListSize(*this);
-
-			// serialize the list entries in a flat array
-			auto data = make_unsafe_uniq_array<list_entry_t>(count);
-			auto source_array = UnifiedVectorFormat::GetData<list_entry_t>(vdata);
-			for (idx_t i = 0; i < count; i++) {
-				auto idx = vdata.sel->get_index(i);
-				auto source = source_array[idx];
-				data[i].offset = source.offset;
-				data[i].length = source.length;
-			}
-
-			// write the list size
-			serializer.Write<idx_t>(list_size);
-			serializer.WriteData(const_data_ptr_cast(data.get()), count * sizeof(list_entry_t));
-
-			child.Serialize(list_size, serializer);
-			break;
-		}
-		default:
-			throw InternalException("Unimplemented variable width type for Vector::Serialize!");
-		}
-	}
-}
-
-void Vector::FormatSerialize(FormatSerializer &serializer, idx_t count) {
+void Vector::Serialize(Serializer &serializer, idx_t count) {
 	auto &logical_type = GetType();
 
 	UnifiedVectorFormat vdata;
@@ -1021,7 +952,7 @@ void Vector::FormatSerialize(FormatSerializer &serializer, idx_t count) {
 			auto strings = UnifiedVectorFormat::GetData<string_t>(vdata);
 
 			// Serialize data as a list
-			serializer.WriteList(102, "data", count, [&](FormatSerializer::List &list, idx_t i) {
+			serializer.WriteList(102, "data", count, [&](Serializer::List &list, idx_t i) {
 				auto idx = vdata.sel->get_index(i);
 				auto str = !vdata.validity.RowIsValid(idx) ? NullValue<string_t>() : strings[idx];
 				list.WriteElement(str);
@@ -1033,8 +964,8 @@ void Vector::FormatSerialize(FormatSerializer &serializer, idx_t count) {
 			auto &entries = StructVector::GetEntries(*this);
 
 			// Serialize entries as a list
-			serializer.WriteList(103, "children", count, [&](FormatSerializer::List &list, idx_t i) {
-				list.WriteObject([&](FormatSerializer &object) { entries[i]->FormatSerialize(object, count); });
+			serializer.WriteList(103, "children", entries.size(), [&](Serializer::List &list, idx_t i) {
+				list.WriteObject([&](Serializer &object) { entries[i]->Serialize(object, count); });
 			});
 			break;
 		}
@@ -1052,14 +983,13 @@ void Vector::FormatSerialize(FormatSerializer &serializer, idx_t count) {
 				entries[i].length = source.length;
 			}
 			serializer.WriteProperty(104, "list_size", list_size);
-			serializer.WriteList(105, "entries", count, [&](FormatSerializer::List &list, idx_t i) {
-				list.WriteObject([&](FormatSerializer &object) {
+			serializer.WriteList(105, "entries", count, [&](Serializer::List &list, idx_t i) {
+				list.WriteObject([&](Serializer &object) {
 					object.WriteProperty(100, "offset", entries[i].offset);
 					object.WriteProperty(101, "length", entries[i].length);
 				});
 			});
-			serializer.WriteObject(106, "child",
-			                       [&](FormatSerializer &object) { child.FormatSerialize(object, list_size); });
+			serializer.WriteObject(106, "child", [&](Serializer &object) { child.Serialize(object, list_size); });
 			break;
 		}
 		default:
@@ -1068,7 +998,7 @@ void Vector::FormatSerialize(FormatSerializer &serializer, idx_t count) {
 	}
 }
 
-void Vector::FormatDeserialize(FormatDeserializer &deserializer, idx_t count) {
+void Vector::Deserialize(Deserializer &deserializer, idx_t count) {
 	auto &logical_type = GetType();
 
 	auto &validity = FlatVector::Validity(*this);
@@ -1090,7 +1020,7 @@ void Vector::FormatDeserialize(FormatDeserializer &deserializer, idx_t count) {
 		switch (logical_type.InternalType()) {
 		case PhysicalType::VARCHAR: {
 			auto strings = FlatVector::GetData<string_t>(*this);
-			deserializer.ReadList(102, "data", [&](FormatDeserializer::List &list, idx_t i) {
+			deserializer.ReadList(102, "data", [&](Deserializer::List &list, idx_t i) {
 				auto str = list.ReadElement<string>();
 				if (validity.RowIsValid(i)) {
 					strings[i] = StringVector::AddStringOrBlob(*this, str);
@@ -1101,8 +1031,8 @@ void Vector::FormatDeserialize(FormatDeserializer &deserializer, idx_t count) {
 		case PhysicalType::STRUCT: {
 			auto &entries = StructVector::GetEntries(*this);
 			// Deserialize entries as a list
-			deserializer.ReadList(103, "children", [&](FormatDeserializer::List &list, idx_t i) {
-				list.ReadObject([&](FormatDeserializer &obj) { entries[i]->FormatDeserialize(obj, count); });
+			deserializer.ReadList(103, "children", [&](Deserializer::List &list, idx_t i) {
+				list.ReadObject([&](Deserializer &obj) { entries[i]->Deserialize(obj, count); });
 			});
 			break;
 		}
@@ -1114,17 +1044,17 @@ void Vector::FormatDeserialize(FormatDeserializer &deserializer, idx_t count) {
 
 			// Read the entries
 			auto list_entries = FlatVector::GetData<list_entry_t>(*this);
-			deserializer.ReadList(105, "entries", [&](FormatDeserializer::List &list, idx_t i) {
-				list.ReadObject([&](FormatDeserializer &obj) {
+			deserializer.ReadList(105, "entries", [&](Deserializer::List &list, idx_t i) {
+				list.ReadObject([&](Deserializer &obj) {
 					list_entries[i].offset = obj.ReadProperty<uint64_t>(100, "offset");
 					list_entries[i].length = obj.ReadProperty<uint64_t>(101, "length");
 				});
 			});
 
 			// Read the child vector
-			deserializer.ReadObject(106, "child", [&](FormatDeserializer &obj) {
+			deserializer.ReadObject(106, "child", [&](Deserializer &obj) {
 				auto &child = ListVector::GetEntry(*this);
-				child.FormatDeserialize(obj, list_size);
+				child.Deserialize(obj, list_size);
 			});
 			break;
 		}
@@ -1134,68 +1064,6 @@ void Vector::FormatDeserialize(FormatDeserializer &deserializer, idx_t count) {
 	}
 }
 
-void Vector::Deserialize(idx_t count, Deserializer &source) {
-	auto &type = GetType();
-
-	auto &validity = FlatVector::Validity(*this);
-	validity.Reset();
-	const auto has_validity = source.Read<bool>();
-	if (has_validity) {
-		validity.Initialize(count);
-		source.ReadData(data_ptr_cast(validity.GetData()), validity.ValidityMaskSize(count));
-	}
-
-	if (TypeIsConstantSize(type.InternalType())) {
-		// constant size type: read fixed amount of data from
-		auto column_size = GetTypeIdSize(type.InternalType()) * count;
-		auto ptr = make_unsafe_uniq_array<data_t>(column_size);
-		source.ReadData(ptr.get(), column_size);
-
-		VectorOperations::ReadFromStorage(ptr.get(), count, *this);
-	} else {
-		switch (type.InternalType()) {
-		case PhysicalType::VARCHAR: {
-			auto strings = FlatVector::GetData<string_t>(*this);
-			for (idx_t i = 0; i < count; i++) {
-				// read the strings
-				auto str = source.Read<string>();
-				// now add the string to the StringHeap of the vector
-				// and write the pointer into the vector
-				if (validity.RowIsValid(i)) {
-					strings[i] = StringVector::AddStringOrBlob(*this, str);
-				}
-			}
-			break;
-		}
-		case PhysicalType::STRUCT: {
-			auto &entries = StructVector::GetEntries(*this);
-			for (auto &entry : entries) {
-				entry->Deserialize(count, source);
-			}
-			break;
-		}
-		case PhysicalType::LIST: {
-			// read the list size
-			auto list_size = source.Read<idx_t>();
-			ListVector::Reserve(*this, list_size);
-			ListVector::SetListSize(*this, list_size);
-
-			// read the list entry
-			auto list_entries = FlatVector::GetData(*this);
-			source.ReadData(list_entries, count * sizeof(list_entry_t));
-
-			// deserialize the child vector
-			auto &child = ListVector::GetEntry(*this);
-			child.Deserialize(list_size, source);
-
-			break;
-		}
-		default:
-			throw InternalException("Unimplemented variable width type for Vector::Deserialize!");
-		}
-	}
-}
-
 void Vector::SetVectorType(VectorType vector_type_p) {
 	this->vector_type = vector_type_p;
 	if (TypeIsConstantSize(GetType().InternalType()) &&

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

@@ -4,10 +4,8 @@
 #include "duckdb/catalog/catalog_search_path.hpp"
 #include "duckdb/catalog/default/default_types.hpp"
 #include "duckdb/common/exception.hpp"
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/limits.hpp"
 #include "duckdb/common/operator/comparison_operators.hpp"
-#include "duckdb/common/serializer.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/common/types/decimal.hpp"
 #include "duckdb/common/types/hash.hpp"
@@ -24,9 +22,9 @@
 #include "duckdb/parser/keyword_helper.hpp"
 #include "duckdb/parser/parser.hpp"
 #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/type_catalog_entry.hpp"
 #include <cmath>
 
@@ -1065,22 +1063,6 @@ PhysicalType EnumType::GetPhysicalType(const LogicalType &type) {
 LogicalType::~LogicalType() {
 }
 
-void LogicalType::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteField<LogicalTypeId>(id_);
-	ExtraTypeInfo::Serialize(type_info_.get(), writer);
-	writer.Finalize();
-}
-
-LogicalType LogicalType::Deserialize(Deserializer &source) {
-	FieldReader reader(source);
-	auto id = reader.ReadRequired<LogicalTypeId>();
-	auto info = ExtraTypeInfo::Deserialize(reader);
-	reader.Finalize();
-
-	return LogicalType(id, std::move(info));
-}
-
 bool LogicalType::EqualTypeInfo(const LogicalType &rhs) const {
 	if (type_info_.get() == rhs.type_info_.get()) {
 		return true;

package/src/duckdb/src/core_functions/aggregate/algebraic/avg.cpp

@@ -4,7 +4,6 @@
 #include "duckdb/common/exception.hpp"
 #include "duckdb/function/function_set.hpp"
 #include "duckdb/planner/expression.hpp"
-#include "duckdb/common/field_writer.hpp"
 
 namespace duckdb {
 

package/src/duckdb/src/core_functions/aggregate/distributive/string_agg.cpp

@@ -5,7 +5,8 @@
 #include "duckdb/common/algorithm.hpp"
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/common/field_writer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 
 namespace duckdb {
 
@@ -140,16 +141,14 @@ unique_ptr<FunctionData> StringAggBind(ClientContext &context, AggregateFunction
 	return make_uniq<StringAggBindData>(std::move(separator_string));
 }
 
-static void StringAggSerialize(FieldWriter &writer, const FunctionData *bind_data_p,
+static void StringAggSerialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
                                const AggregateFunction &function) {
-	D_ASSERT(bind_data_p);
 	auto bind_data = bind_data_p->Cast<StringAggBindData>();
-	writer.WriteString(bind_data.sep);
+	serializer.WriteProperty(100, "separator", bind_data.sep);
 }
 
-unique_ptr<FunctionData> StringAggDeserialize(PlanDeserializationState &state, FieldReader &reader,
-                                              AggregateFunction &bound_function) {
-	auto sep = reader.ReadRequired<string>();
+unique_ptr<FunctionData> StringAggDeserialize(Deserializer &deserializer, AggregateFunction &bound_function) {
+	auto sep = deserializer.ReadProperty<string>(100, "separator");
 	return make_uniq<StringAggBindData>(std::move(sep));
 }
 

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

@@ -3,9 +3,8 @@
 #include "t_digest.hpp"
 #include "duckdb/planner/expression.hpp"
 #include "duckdb/common/operator/cast_operators.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 <cmath>
@@ -40,25 +39,13 @@ struct ApproximateQuantileBindData : public FunctionData {
 		return true;
 	}
 
-	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<ApproximateQuantileBindData>();
-		writer.WriteList<float>(bind_data.quantiles);
-	}
-
-	static unique_ptr<FunctionData> Deserialize(PlanDeserializationState &state, FieldReader &reader,
-	                                            AggregateFunction &bound_function) {
-		auto quantiles = reader.ReadRequiredList<float>();
-		return make_uniq<ApproximateQuantileBindData>(std::move(quantiles));
-	}
-
-	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<ApproximateQuantileBindData>();
 		serializer.WriteProperty(100, "quantiles", bind_data.quantiles);
 	}
 
-	static unique_ptr<FunctionData> FormatDeserialize(FormatDeserializer &deserializer, AggregateFunction &function) {
+	static unique_ptr<FunctionData> Deserialize(Deserializer &deserializer, AggregateFunction &function) {
 		auto result = make_uniq<ApproximateQuantileBindData>();
 		deserializer.ReadProperty(100, "quantiles", result->quantiles);
 		return std::move(result);
@@ -208,8 +195,6 @@ unique_ptr<FunctionData> BindApproxQuantileDecimal(ClientContext &context, Aggre
 	function.name = "approx_quantile";
 	function.serialize = ApproximateQuantileBindData::Serialize;
 	function.deserialize = ApproximateQuantileBindData::Deserialize;
-	function.format_serialize = ApproximateQuantileBindData::FormatSerialize;
-	function.format_deserialize = ApproximateQuantileBindData::FormatDeserialize;
 	return bind_data;
 }
 
@@ -218,8 +203,6 @@ AggregateFunction GetApproximateQuantileAggregate(PhysicalType type) {
 	fun.bind = BindApproxQuantile;
 	fun.serialize = ApproximateQuantileBindData::Serialize;
 	fun.deserialize = ApproximateQuantileBindData::Deserialize;
-	fun.format_serialize = ApproximateQuantileBindData::FormatSerialize;
-	fun.format_deserialize = ApproximateQuantileBindData::FormatDeserialize;
 	// temporarily push an argument so we can bind the actual quantile
 	fun.arguments.emplace_back(LogicalType::FLOAT);
 	return fun;
@@ -275,8 +258,6 @@ AggregateFunction GetTypedApproxQuantileListAggregateFunction(const LogicalType
 	auto fun = ApproxQuantileListAggregate<STATE, INPUT_TYPE, list_entry_t, OP>(type, type);
 	fun.serialize = ApproximateQuantileBindData::Serialize;
 	fun.deserialize = ApproximateQuantileBindData::Deserialize;
-	fun.format_serialize = ApproximateQuantileBindData::FormatSerialize;
-	fun.format_deserialize = ApproximateQuantileBindData::FormatDeserialize;
 	return fun;
 }
 
@@ -322,8 +303,6 @@ unique_ptr<FunctionData> BindApproxQuantileDecimalList(ClientContext &context, A
 	function.name = "approx_quantile";
 	function.serialize = ApproximateQuantileBindData::Serialize;
 	function.deserialize = ApproximateQuantileBindData::Deserialize;
-	function.format_serialize = ApproximateQuantileBindData::FormatSerialize;
-	function.format_deserialize = ApproximateQuantileBindData::FormatDeserialize;
 	return bind_data;
 }
 
@@ -332,8 +311,6 @@ AggregateFunction GetApproxQuantileListAggregate(const LogicalType &type) {
 	fun.bind = BindApproxQuantile;
 	fun.serialize = ApproximateQuantileBindData::Serialize;
 	fun.deserialize = ApproximateQuantileBindData::Deserialize;
-	fun.format_serialize = ApproximateQuantileBindData::FormatSerialize;
-	fun.format_deserialize = ApproximateQuantileBindData::FormatDeserialize;
 	// temporarily push an argument so we can bind the actual quantile
 	auto list_of_float = LogicalType::LIST(LogicalType::FLOAT);
 	fun.arguments.push_back(list_of_float);

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

@@ -7,9 +7,8 @@
 #include "duckdb/common/types/chunk_collection.hpp"
 #include "duckdb/common/types/timestamp.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>
@@ -458,15 +457,15 @@ struct QuantileBindData : public FunctionData {
 		return desc == other.desc && quantiles == other.quantiles && order == other.order;
 	}
 
-	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<QuantileBindData>();
 		serializer.WriteProperty(100, "quantiles", bind_data.quantiles);
 		serializer.WriteProperty(101, "order", bind_data.order);
 		serializer.WriteProperty(102, "desc", bind_data.desc);
 	}
 
-	static unique_ptr<FunctionData> FormatDeserialize(FormatDeserializer &deserializer, AggregateFunction &function) {
+	static unique_ptr<FunctionData> Deserialize(Deserializer &deserializer, AggregateFunction &function) {
 		auto result = make_uniq<QuantileBindData>();
 		deserializer.ReadProperty(100, "quantiles", result->quantiles);
 		deserializer.ReadProperty(101, "order", result->order);
@@ -474,9 +473,9 @@ struct QuantileBindData : public FunctionData {
 		return std::move(result);
 	}
 
-	static void FormatSerializeDecimal(FormatSerializer &serializer, const optional_ptr<FunctionData> bind_data_p,
-	                                   const AggregateFunction &function) {
-		throw SerializationException("FIXME: quantile serialize for decimal");
+	static void SerializeDecimal(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
+	                             const AggregateFunction &function) {
+		throw NotImplementedException("FIXME: serializing quantiles with decimals is not supported right now");
 	}
 
 	vector<Value> quantiles;
@@ -1174,31 +1173,6 @@ AggregateFunction GetMedianAbsoluteDeviationAggregateFunction(const LogicalType
 	}
 }
 
-static void QuantileSerialize(FieldWriter &writer, const FunctionData *bind_data_p, const AggregateFunction &function) {
-	D_ASSERT(bind_data_p);
-	auto bind_data = dynamic_cast<const QuantileBindData *>(bind_data_p);
-	D_ASSERT(bind_data);
-	writer.WriteRegularSerializableList<Value>(bind_data->quantiles);
-	writer.WriteList<idx_t>(bind_data->order);
-	writer.WriteField<bool>(bind_data->desc);
-}
-
-unique_ptr<FunctionData> QuantileDeserialize(PlanDeserializationState &state, FieldReader &reader,
-                                             AggregateFunction &bound_function) {
-	auto quantiles = reader.ReadRequiredSerializableList<Value, Value>();
-	auto bind_data = make_uniq<QuantileBindData>(quantiles);
-	bind_data->quantiles = quantiles;
-	bind_data->order = reader.ReadRequiredList<idx_t>();
-	bind_data->desc = reader.ReadRequired<bool>();
-
-	return std::move(bind_data);
-}
-
-static void QuantileDecimalSerialize(FieldWriter &writer, const FunctionData *bind_data_p,
-                                     const AggregateFunction &function) {
-	throw NotImplementedException("FIXME: serializing quantiles with decimals is not supported right now");
-}
-
 unique_ptr<FunctionData> BindMedian(ClientContext &context, AggregateFunction &function,
                                     vector<unique_ptr<Expression>> &arguments) {
 	return make_uniq<QuantileBindData>(Value::DECIMAL(int16_t(5), 2, 1));
@@ -1210,10 +1184,8 @@ unique_ptr<FunctionData> BindMedianDecimal(ClientContext &context, AggregateFunc
 
 	function = GetDiscreteQuantileAggregateFunction(arguments[0]->return_type);
 	function.name = "median";
-	function.serialize = QuantileDecimalSerialize;
-	function.deserialize = QuantileDeserialize;
-	function.format_serialize = QuantileBindData::FormatSerializeDecimal;
-	function.format_deserialize = QuantileBindData::FormatDeserialize;
+	function.serialize = QuantileBindData::SerializeDecimal;
+	function.deserialize = QuantileBindData::Deserialize;
 	function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return bind_data;
 }
@@ -1268,10 +1240,8 @@ unique_ptr<FunctionData> BindDiscreteQuantileDecimal(ClientContext &context, Agg
 	auto bind_data = BindQuantile(context, function, arguments);
 	function = GetDiscreteQuantileAggregateFunction(arguments[0]->return_type);
 	function.name = "quantile_disc";
-	function.serialize = QuantileDecimalSerialize;
-	function.deserialize = QuantileDeserialize;
-	function.format_serialize = QuantileBindData::FormatSerializeDecimal;
-	function.format_deserialize = QuantileBindData::FormatDeserialize;
+	function.serialize = QuantileBindData::SerializeDecimal;
+	function.deserialize = QuantileBindData::Deserialize;
 	function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return bind_data;
 }
@@ -1281,10 +1251,8 @@ unique_ptr<FunctionData> BindDiscreteQuantileDecimalList(ClientContext &context,
 	auto bind_data = BindQuantile(context, function, arguments);
 	function = GetDiscreteQuantileListAggregateFunction(arguments[0]->return_type);
 	function.name = "quantile_disc";
-	function.serialize = QuantileDecimalSerialize;
-	function.deserialize = QuantileDeserialize;
-	function.format_serialize = QuantileBindData::FormatSerializeDecimal;
-	function.format_deserialize = QuantileBindData::FormatDeserialize;
+	function.serialize = QuantileBindData::SerializeDecimal;
+	function.deserialize = QuantileBindData::Deserialize;
 	function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return bind_data;
 }
@@ -1294,10 +1262,8 @@ unique_ptr<FunctionData> BindContinuousQuantileDecimal(ClientContext &context, A
 	auto bind_data = BindQuantile(context, function, arguments);
 	function = GetContinuousQuantileAggregateFunction(arguments[0]->return_type);
 	function.name = "quantile_cont";
-	function.serialize = QuantileDecimalSerialize;
-	function.deserialize = QuantileDeserialize;
-	function.format_serialize = QuantileBindData::FormatSerializeDecimal;
-	function.format_deserialize = QuantileBindData::FormatDeserialize;
+	function.serialize = QuantileBindData::SerializeDecimal;
+	function.deserialize = QuantileBindData::Deserialize;
 	function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return bind_data;
 }
@@ -1307,10 +1273,8 @@ unique_ptr<FunctionData> BindContinuousQuantileDecimalList(ClientContext &contex
 	auto bind_data = BindQuantile(context, function, arguments);
 	function = GetContinuousQuantileListAggregateFunction(arguments[0]->return_type);
 	function.name = "quantile_cont";
-	function.serialize = QuantileDecimalSerialize;
-	function.deserialize = QuantileDeserialize;
-	function.format_serialize = QuantileBindData::FormatSerializeDecimal;
-	function.format_deserialize = QuantileBindData::FormatDeserialize;
+	function.serialize = QuantileBindData::SerializeDecimal;
+	function.deserialize = QuantileBindData::Deserialize;
 	function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return bind_data;
 }
@@ -1329,20 +1293,16 @@ AggregateFunction GetMedianAggregate(const LogicalType &type) {
 	auto fun = CanInterpolate(type) ? GetContinuousQuantileAggregateFunction(type)
 	                                : GetDiscreteQuantileAggregateFunction(type);
 	fun.bind = BindMedian;
-	fun.serialize = QuantileSerialize;
-	fun.deserialize = QuantileDeserialize;
-	fun.format_serialize = QuantileBindData::FormatSerialize;
-	fun.format_deserialize = QuantileBindData::FormatDeserialize;
+	fun.serialize = QuantileBindData::Serialize;
+	fun.deserialize = QuantileBindData::Deserialize;
 	return fun;
 }
 
 AggregateFunction GetDiscreteQuantileAggregate(const LogicalType &type) {
 	auto fun = GetDiscreteQuantileAggregateFunction(type);
 	fun.bind = BindQuantile;
-	fun.serialize = QuantileSerialize;
-	fun.deserialize = QuantileDeserialize;
-	fun.format_serialize = QuantileBindData::FormatSerialize;
-	fun.format_deserialize = QuantileBindData::FormatDeserialize;
+	fun.serialize = QuantileBindData::Serialize;
+	fun.deserialize = QuantileBindData::Deserialize;
 	// temporarily push an argument so we can bind the actual quantile
 	fun.arguments.emplace_back(LogicalType::DOUBLE);
 	fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
@@ -1352,10 +1312,8 @@ AggregateFunction GetDiscreteQuantileAggregate(const LogicalType &type) {
 AggregateFunction GetDiscreteQuantileListAggregate(const LogicalType &type) {
 	auto fun = GetDiscreteQuantileListAggregateFunction(type);
 	fun.bind = BindQuantile;
-	fun.serialize = QuantileSerialize;
-	fun.deserialize = QuantileDeserialize;
-	fun.format_serialize = QuantileBindData::FormatSerialize;
-	fun.format_deserialize = QuantileBindData::FormatDeserialize;
+	fun.serialize = QuantileBindData::Serialize;
+	fun.deserialize = QuantileBindData::Deserialize;
 	// 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);
@@ -1366,10 +1324,8 @@ AggregateFunction GetDiscreteQuantileListAggregate(const LogicalType &type) {
 AggregateFunction GetContinuousQuantileAggregate(const LogicalType &type) {
 	auto fun = GetContinuousQuantileAggregateFunction(type);
 	fun.bind = BindQuantile;
-	fun.serialize = QuantileSerialize;
-	fun.deserialize = QuantileDeserialize;
-	fun.format_serialize = QuantileBindData::FormatSerialize;
-	fun.format_deserialize = QuantileBindData::FormatDeserialize;
+	fun.serialize = QuantileBindData::Serialize;
+	fun.deserialize = QuantileBindData::Deserialize;
 	// temporarily push an argument so we can bind the actual quantile
 	fun.arguments.emplace_back(LogicalType::DOUBLE);
 	fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
@@ -1379,10 +1335,8 @@ AggregateFunction GetContinuousQuantileAggregate(const LogicalType &type) {
 AggregateFunction GetContinuousQuantileListAggregate(const LogicalType &type) {
 	auto fun = GetContinuousQuantileListAggregateFunction(type);
 	fun.bind = BindQuantile;
-	fun.serialize = QuantileSerialize;
-	fun.deserialize = QuantileDeserialize;
-	fun.format_serialize = QuantileBindData::FormatSerialize;
-	fun.format_deserialize = QuantileBindData::FormatDeserialize;
+	fun.serialize = QuantileBindData::Serialize;
+	fun.deserialize = QuantileBindData::Deserialize;
 	// 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);
@@ -1394,10 +1348,8 @@ AggregateFunction GetQuantileDecimalAggregate(const vector<LogicalType> &argumen
                                               bind_aggregate_function_t bind) {
 	AggregateFunction fun(arguments, return_type, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, bind);
 	fun.bind = bind;
-	fun.serialize = QuantileSerialize;
-	fun.deserialize = QuantileDeserialize;
-	fun.format_serialize = QuantileBindData::FormatSerialize;
-	fun.format_deserialize = QuantileBindData::FormatDeserialize;
+	fun.serialize = QuantileBindData::Serialize;
+	fun.deserialize = QuantileBindData::Deserialize;
 	fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return fun;
 }