duckdb 0.8.2-dev37.0 → 0.8.2-dev3989.0

package/src/duckdb/src/common/virtual_file_system.cpp

@@ -28,7 +28,7 @@ unique_ptr<FileHandle> VirtualFileSystem::OpenFile(const string &path, uint8_t f
 		}
 	}
 	// open the base file handle
-	auto file_handle = FindFileSystem(path)->OpenFile(path, flags, lock, FileCompressionType::UNCOMPRESSED, opener);
+	auto file_handle = FindFileSystem(path).OpenFile(path, flags, lock, FileCompressionType::UNCOMPRESSED, opener);
 	if (file_handle->GetType() == FileType::FILE_TYPE_FIFO) {
 		file_handle = PipeFileSystem::OpenPipe(std::move(file_handle));
 	} else if (compression != FileCompressionType::UNCOMPRESSED) {
@@ -42,4 +42,145 @@ unique_ptr<FileHandle> VirtualFileSystem::OpenFile(const string &path, uint8_t f
 	return file_handle;
 }
 
+void VirtualFileSystem::Read(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location) {
+	handle.file_system.Read(handle, buffer, nr_bytes, location);
+}
+
+void VirtualFileSystem::Write(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location) {
+	handle.file_system.Write(handle, buffer, nr_bytes, location);
+}
+
+int64_t VirtualFileSystem::Read(FileHandle &handle, void *buffer, int64_t nr_bytes) {
+	return handle.file_system.Read(handle, buffer, nr_bytes);
+}
+
+int64_t VirtualFileSystem::Write(FileHandle &handle, void *buffer, int64_t nr_bytes) {
+	return handle.file_system.Write(handle, buffer, nr_bytes);
+}
+
+int64_t VirtualFileSystem::GetFileSize(FileHandle &handle) {
+	return handle.file_system.GetFileSize(handle);
+}
+time_t VirtualFileSystem::GetLastModifiedTime(FileHandle &handle) {
+	return handle.file_system.GetLastModifiedTime(handle);
+}
+FileType VirtualFileSystem::GetFileType(FileHandle &handle) {
+	return handle.file_system.GetFileType(handle);
+}
+
+void VirtualFileSystem::Truncate(FileHandle &handle, int64_t new_size) {
+	handle.file_system.Truncate(handle, new_size);
+}
+
+void VirtualFileSystem::FileSync(FileHandle &handle) {
+	handle.file_system.FileSync(handle);
+}
+
+// need to look up correct fs for this
+bool VirtualFileSystem::DirectoryExists(const string &directory) {
+	return FindFileSystem(directory).DirectoryExists(directory);
+}
+void VirtualFileSystem::CreateDirectory(const string &directory) {
+	FindFileSystem(directory).CreateDirectory(directory);
+}
+
+void VirtualFileSystem::RemoveDirectory(const string &directory) {
+	FindFileSystem(directory).RemoveDirectory(directory);
+}
+
+bool VirtualFileSystem::ListFiles(const string &directory, const std::function<void(const string &, bool)> &callback,
+                                  FileOpener *opener) {
+	return FindFileSystem(directory).ListFiles(directory, callback, opener);
+}
+
+void VirtualFileSystem::MoveFile(const string &source, const string &target) {
+	FindFileSystem(source).MoveFile(source, target);
+}
+
+bool VirtualFileSystem::FileExists(const string &filename) {
+	return FindFileSystem(filename).FileExists(filename);
+}
+
+bool VirtualFileSystem::IsPipe(const string &filename) {
+	return FindFileSystem(filename).IsPipe(filename);
+}
+void VirtualFileSystem::RemoveFile(const string &filename) {
+	FindFileSystem(filename).RemoveFile(filename);
+}
+
+string VirtualFileSystem::PathSeparator(const string &path) {
+	return FindFileSystem(path).PathSeparator(path);
+}
+
+vector<string> VirtualFileSystem::Glob(const string &path, FileOpener *opener) {
+	return FindFileSystem(path).Glob(path, opener);
+}
+
+void VirtualFileSystem::RegisterSubSystem(unique_ptr<FileSystem> fs) {
+	sub_systems.push_back(std::move(fs));
+}
+
+void VirtualFileSystem::UnregisterSubSystem(const string &name) {
+	for (auto sub_system = sub_systems.begin(); sub_system != sub_systems.end(); sub_system++) {
+		if (sub_system->get()->GetName() == name) {
+			sub_systems.erase(sub_system);
+			return;
+		}
+	}
+	throw InvalidInputException("Could not find filesystem with name %s", name);
+}
+
+void VirtualFileSystem::RegisterSubSystem(FileCompressionType compression_type, unique_ptr<FileSystem> fs) {
+	compressed_fs[compression_type] = std::move(fs);
+}
+
+vector<string> VirtualFileSystem::ListSubSystems() {
+	vector<string> names(sub_systems.size());
+	for (idx_t i = 0; i < sub_systems.size(); i++) {
+		names[i] = sub_systems[i]->GetName();
+	}
+	return names;
+}
+
+std::string VirtualFileSystem::GetName() const {
+	return "VirtualFileSystem";
+}
+
+void VirtualFileSystem::SetDisabledFileSystems(const vector<string> &names) {
+	unordered_set<string> new_disabled_file_systems;
+	for (auto &name : names) {
+		if (name.empty()) {
+			continue;
+		}
+		if (new_disabled_file_systems.find(name) != new_disabled_file_systems.end()) {
+			throw InvalidInputException("Duplicate disabled file system \"%s\"", name);
+		}
+		new_disabled_file_systems.insert(name);
+	}
+	for (auto &disabled_fs : disabled_file_systems) {
+		if (new_disabled_file_systems.find(disabled_fs) == new_disabled_file_systems.end()) {
+			throw InvalidInputException("File system \"%s\" has been disabled previously, it cannot be re-enabled",
+			                            disabled_fs);
+		}
+	}
+	disabled_file_systems = std::move(new_disabled_file_systems);
+}
+
+FileSystem &VirtualFileSystem::FindFileSystem(const string &path) {
+	auto &fs = FindFileSystemInternal(path);
+	if (!disabled_file_systems.empty() && disabled_file_systems.find(fs.GetName()) != disabled_file_systems.end()) {
+		throw PermissionException("File system %s has been disabled by configuration", fs.GetName());
+	}
+	return fs;
+}
+
+FileSystem &VirtualFileSystem::FindFileSystemInternal(const string &path) {
+	for (auto &sub_system : sub_systems) {
+		if (sub_system->CanHandleFile(path)) {
+			return *sub_system;
+		}
+	}
+	return *default_fs;
+}
+
 } // namespace duckdb

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

@@ -4,6 +4,8 @@
 #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 <algorithm>
 #include <cmath>
@@ -17,6 +19,8 @@ struct ApproxQuantileState {
 };
 
 struct ApproximateQuantileBindData : public FunctionData {
+	ApproximateQuantileBindData() {
+	}
 	explicit ApproximateQuantileBindData(float quantile_p) : quantiles(1, quantile_p) {
 	}
 
@@ -48,6 +52,18 @@ struct ApproximateQuantileBindData : public FunctionData {
 		return make_uniq<ApproximateQuantileBindData>(std::move(quantiles));
 	}
 
+	static void FormatSerialize(FormatSerializer &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) {
+		auto result = make_uniq<ApproximateQuantileBindData>();
+		deserializer.ReadProperty(100, "quantiles", result->quantiles);
+		return std::move(result);
+	}
+
 	vector<float> quantiles;
 };
 
@@ -192,6 +208,8 @@ 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;
 }
 
@@ -200,6 +218,8 @@ 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;
@@ -255,6 +275,8 @@ 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;
 }
 
@@ -300,6 +322,8 @@ 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;
 }
 
@@ -308,6 +332,8 @@ 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/mode.cpp

@@ -31,8 +31,6 @@ struct hash<duckdb::hugeint_t> {
 
 namespace duckdb {
 
-using FrameBounds = std::pair<idx_t, idx_t>;
-
 template <class KEY_TYPE>
 struct ModeState {
 	struct ModeAttr {
@@ -225,31 +223,31 @@ struct ModeFunction {
 		if (state.nonzero <= tau * state.frequency_map->size()) {
 			state.Reset();
 			// for f ∈ F do
-			for (auto f = frame.first; f < frame.second; ++f) {
+			for (auto f = frame.start; f < frame.end; ++f) {
 				if (included(f)) {
 					state.ModeAdd(KEY_TYPE(data[f]), f);
 				}
 			}
 		} else {
 			// for f ∈ P \ F do
-			for (auto p = prev.first; p < frame.first; ++p) {
+			for (auto p = prev.start; p < frame.start; ++p) {
 				if (included(p)) {
 					state.ModeRm(KEY_TYPE(data[p]), p);
 				}
 			}
-			for (auto p = frame.second; p < prev.second; ++p) {
+			for (auto p = frame.end; p < prev.end; ++p) {
 				if (included(p)) {
 					state.ModeRm(KEY_TYPE(data[p]), p);
 				}
 			}
 
 			// for f ∈ F \ P do
-			for (auto f = frame.first; f < prev.first; ++f) {
+			for (auto f = frame.start; f < prev.start; ++f) {
 				if (included(f)) {
 					state.ModeAdd(KEY_TYPE(data[f]), f);
 				}
 			}
-			for (auto f = prev.second; f < frame.second; ++f) {
+			for (auto f = prev.end; f < frame.end; ++f) {
 				if (included(f)) {
 					state.ModeAdd(KEY_TYPE(data[f]), f);
 				}

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

@@ -8,6 +8,8 @@
 #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 <algorithm>
 #include <stdlib.h>
@@ -35,8 +37,6 @@ inline interval_t operator-(const interval_t &lhs, const interval_t &rhs) {
 	return Interval::FromMicro(Interval::GetMicro(lhs) - Interval::GetMicro(rhs));
 }
 
-using FrameBounds = std::pair<idx_t, idx_t>;
-
 template <typename SAVE_TYPE>
 struct QuantileState {
 	using SaveType = SAVE_TYPE;
@@ -87,7 +87,7 @@ void ReuseIndexes(idx_t *index, const FrameBounds &frame, const FrameBounds &pre
 	idx_t j = 0;
 
 	//  Copy overlapping indices
-	for (idx_t p = 0; p < (prev.second - prev.first); ++p) {
+	for (idx_t p = 0; p < (prev.end - prev.start); ++p) {
 		auto idx = index[p];
 
 		//  Shift down into any hole
@@ -96,7 +96,7 @@ void ReuseIndexes(idx_t *index, const FrameBounds &frame, const FrameBounds &pre
 		}
 
 		//  Skip overlapping values
-		if (frame.first <= idx && idx < frame.second) {
+		if (frame.start <= idx && idx < frame.end) {
 			++j;
 		}
 	}
@@ -104,15 +104,15 @@ void ReuseIndexes(idx_t *index, const FrameBounds &frame, const FrameBounds &pre
 	//  Insert new indices
 	if (j > 0) {
 		// Overlap: append the new ends
-		for (auto f = frame.first; f < prev.first; ++f, ++j) {
+		for (auto f = frame.start; f < prev.start; ++f, ++j) {
 			index[j] = f;
 		}
-		for (auto f = prev.second; f < frame.second; ++f, ++j) {
+		for (auto f = prev.end; f < frame.end; ++f, ++j) {
 			index[j] = f;
 		}
 	} else {
 		//  No overlap: overwrite with new values
-		for (auto f = frame.first; f < frame.second; ++f, ++j) {
+		for (auto f = frame.start; f < frame.end; ++f, ++j) {
 			index[j] = f;
 		}
 	}
@@ -122,17 +122,17 @@ static idx_t ReplaceIndex(idx_t *index, const FrameBounds &frame, const FrameBou
 	D_ASSERT(index);
 
 	idx_t j = 0;
-	for (idx_t p = 0; p < (prev.second - prev.first); ++p) {
+	for (idx_t p = 0; p < (prev.end - prev.start); ++p) {
 		auto idx = index[p];
 		if (j != p) {
 			break;
 		}
 
-		if (frame.first <= idx && idx < frame.second) {
+		if (frame.start <= idx && idx < frame.end) {
 			++j;
 		}
 	}
-	index[j] = frame.second - 1;
+	index[j] = frame.end - 1;
 
 	return j;
 }
@@ -417,6 +417,8 @@ inline Value QuantileAbs(const Value &v) {
 }
 
 struct QuantileBindData : public FunctionData {
+	QuantileBindData() {
+	}
 
 	explicit QuantileBindData(const Value &quantile_p)
 	    : quantiles(1, QuantileAbs(quantile_p)), order(1, 0), desc(quantile_p < 0) {
@@ -456,6 +458,27 @@ 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) {
+		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) {
+		auto result = make_uniq<QuantileBindData>();
+		deserializer.ReadProperty(100, "quantiles", result->quantiles);
+		deserializer.ReadProperty(101, "order", result->order);
+		deserializer.ReadProperty(102, "desc", result->desc);
+		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");
+	}
+
 	vector<Value> quantiles;
 	vector<idx_t> order;
 	bool desc;
@@ -535,7 +558,7 @@ struct QuantileScalarOperation : public QuantileOperation {
 
 		//  Lazily initialise frame state
 		auto prev_pos = state.pos;
-		state.SetPos(frame.second - frame.first);
+		state.SetPos(frame.end - frame.start);
 
 		auto index = state.w.data();
 		D_ASSERT(index);
@@ -547,11 +570,11 @@ struct QuantileScalarOperation : public QuantileOperation {
 		const auto q = bind_data.quantiles[0];
 
 		bool replace = false;
-		if (frame.first == prev.first + 1 && frame.second == prev.second + 1) {
+		if (frame.start == prev.start + 1 && frame.end == prev.end + 1) {
 			//  Fixed frame size
 			const auto j = ReplaceIndex(index, frame, prev);
 			//	We can only replace if the number of NULLs has not changed
-			if (included.AllValid() || included(prev.first) == included(prev.second)) {
+			if (included.AllValid() || included(prev.start) == included(prev.end)) {
 				Interpolator<DISCRETE> interp(q, prev_pos, false);
 				replace = CanReplace(index, data, j, interp.FRN, interp.CRN, included);
 				if (replace) {
@@ -695,7 +718,7 @@ struct QuantileListOperation : public QuantileOperation {
 
 		//  Lazily initialise frame state
 		auto prev_pos = state.pos;
-		state.SetPos(frame.second - frame.first);
+		state.SetPos(frame.end - frame.start);
 
 		auto index = state.w.data();
 
@@ -706,11 +729,11 @@ struct QuantileListOperation : public QuantileOperation {
 		// then Q25 must be recomputed, but Q50 and Q75 are unaffected.
 		// For a single element list, this reduces to the scalar case.
 		std::pair<idx_t, idx_t> replaceable {state.pos, 0};
-		if (frame.first == prev.first + 1 && frame.second == prev.second + 1) {
+		if (frame.start == prev.start + 1 && frame.end == prev.end + 1) {
 			//  Fixed frame size
 			const auto j = ReplaceIndex(index, frame, prev);
 			//	We can only replace if the number of NULLs has not changed
-			if (included.AllValid() || included(prev.first) == included(prev.second)) {
+			if (included.AllValid() || included(prev.start) == included(prev.end)) {
 				for (const auto &q : bind_data.order) {
 					const auto &quantile = bind_data.quantiles[q];
 					Interpolator<DISCRETE> interp(quantile, prev_pos, false);
@@ -1037,7 +1060,7 @@ struct MedianAbsoluteDeviationOperation : public QuantileOperation {
 
 		//  Lazily initialise frame state
 		auto prev_pos = state.pos;
-		state.SetPos(frame.second - frame.first);
+		state.SetPos(frame.end - frame.start);
 
 		auto index = state.w.data();
 		D_ASSERT(index);
@@ -1060,11 +1083,11 @@ struct MedianAbsoluteDeviationOperation : public QuantileOperation {
 		const float q = 0.5;
 
 		bool replace = false;
-		if (frame.first == prev.first + 1 && frame.second == prev.second + 1) {
+		if (frame.start == prev.start + 1 && frame.end == prev.end + 1) {
 			//  Fixed frame size
 			const auto j = ReplaceIndex(index, frame, prev);
 			//	We can only replace if the number of NULLs has not changed
-			if (included.AllValid() || included(prev.first) == included(prev.second)) {
+			if (included.AllValid() || included(prev.start) == included(prev.end)) {
 				Interpolator<false> interp(q, prev_pos, false);
 				replace = CanReplace(index, data, j, interp.FRN, interp.CRN, included);
 				if (replace) {
@@ -1189,6 +1212,8 @@ unique_ptr<FunctionData> BindMedianDecimal(ClientContext &context, AggregateFunc
 	function.name = "median";
 	function.serialize = QuantileDecimalSerialize;
 	function.deserialize = QuantileDeserialize;
+	function.format_serialize = QuantileBindData::FormatSerializeDecimal;
+	function.format_deserialize = QuantileBindData::FormatDeserialize;
 	function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return bind_data;
 }
@@ -1245,6 +1270,8 @@ unique_ptr<FunctionData> BindDiscreteQuantileDecimal(ClientContext &context, Agg
 	function.name = "quantile_disc";
 	function.serialize = QuantileDecimalSerialize;
 	function.deserialize = QuantileDeserialize;
+	function.format_serialize = QuantileBindData::FormatSerializeDecimal;
+	function.format_deserialize = QuantileBindData::FormatDeserialize;
 	function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return bind_data;
 }
@@ -1256,6 +1283,8 @@ unique_ptr<FunctionData> BindDiscreteQuantileDecimalList(ClientContext &context,
 	function.name = "quantile_disc";
 	function.serialize = QuantileDecimalSerialize;
 	function.deserialize = QuantileDeserialize;
+	function.format_serialize = QuantileBindData::FormatSerializeDecimal;
+	function.format_deserialize = QuantileBindData::FormatDeserialize;
 	function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return bind_data;
 }
@@ -1267,6 +1296,8 @@ unique_ptr<FunctionData> BindContinuousQuantileDecimal(ClientContext &context, A
 	function.name = "quantile_cont";
 	function.serialize = QuantileDecimalSerialize;
 	function.deserialize = QuantileDeserialize;
+	function.format_serialize = QuantileBindData::FormatSerializeDecimal;
+	function.format_deserialize = QuantileBindData::FormatDeserialize;
 	function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return bind_data;
 }
@@ -1278,6 +1309,8 @@ unique_ptr<FunctionData> BindContinuousQuantileDecimalList(ClientContext &contex
 	function.name = "quantile_cont";
 	function.serialize = QuantileDecimalSerialize;
 	function.deserialize = QuantileDeserialize;
+	function.format_serialize = QuantileBindData::FormatSerializeDecimal;
+	function.format_deserialize = QuantileBindData::FormatDeserialize;
 	function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return bind_data;
 }
@@ -1298,6 +1331,8 @@ AggregateFunction GetMedianAggregate(const LogicalType &type) {
 	fun.bind = BindMedian;
 	fun.serialize = QuantileSerialize;
 	fun.deserialize = QuantileDeserialize;
+	fun.format_serialize = QuantileBindData::FormatSerialize;
+	fun.format_deserialize = QuantileBindData::FormatDeserialize;
 	return fun;
 }
 
@@ -1306,6 +1341,8 @@ AggregateFunction GetDiscreteQuantileAggregate(const LogicalType &type) {
 	fun.bind = BindQuantile;
 	fun.serialize = QuantileSerialize;
 	fun.deserialize = QuantileDeserialize;
+	fun.format_serialize = QuantileBindData::FormatSerialize;
+	fun.format_deserialize = QuantileBindData::FormatDeserialize;
 	// temporarily push an argument so we can bind the actual quantile
 	fun.arguments.emplace_back(LogicalType::DOUBLE);
 	fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
@@ -1317,6 +1354,8 @@ AggregateFunction GetDiscreteQuantileListAggregate(const LogicalType &type) {
 	fun.bind = BindQuantile;
 	fun.serialize = QuantileSerialize;
 	fun.deserialize = QuantileDeserialize;
+	fun.format_serialize = QuantileBindData::FormatSerialize;
+	fun.format_deserialize = QuantileBindData::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);
@@ -1329,6 +1368,8 @@ AggregateFunction GetContinuousQuantileAggregate(const LogicalType &type) {
 	fun.bind = BindQuantile;
 	fun.serialize = QuantileSerialize;
 	fun.deserialize = QuantileDeserialize;
+	fun.format_serialize = QuantileBindData::FormatSerialize;
+	fun.format_deserialize = QuantileBindData::FormatDeserialize;
 	// temporarily push an argument so we can bind the actual quantile
 	fun.arguments.emplace_back(LogicalType::DOUBLE);
 	fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
@@ -1340,6 +1381,8 @@ AggregateFunction GetContinuousQuantileListAggregate(const LogicalType &type) {
 	fun.bind = BindQuantile;
 	fun.serialize = QuantileSerialize;
 	fun.deserialize = QuantileDeserialize;
+	fun.format_serialize = QuantileBindData::FormatSerialize;
+	fun.format_deserialize = QuantileBindData::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);
@@ -1353,6 +1396,8 @@ AggregateFunction GetQuantileDecimalAggregate(const vector<LogicalType> &argumen
 	fun.bind = bind;
 	fun.serialize = QuantileSerialize;
 	fun.deserialize = QuantileDeserialize;
+	fun.format_serialize = QuantileBindData::FormatSerialize;
+	fun.format_deserialize = QuantileBindData::FormatDeserialize;
 	fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return fun;
 }

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

@@ -4,6 +4,8 @@
 #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 <algorithm>
 #include <stdlib.h>
@@ -21,8 +23,10 @@ struct ReservoirQuantileState {
 		if (new_len <= len) {
 			return;
 		}
+		T *old_v = v;
 		v = (T *)realloc(v, new_len * sizeof(T));
 		if (!v) {
+			free(old_v);
 			throw InternalException("Memory allocation failure");
 		}
 		len = new_len;
@@ -47,6 +51,8 @@ struct ReservoirQuantileState {
 };
 
 struct ReservoirQuantileBindData : public FunctionData {
+	ReservoirQuantileBindData() {
+	}
 	ReservoirQuantileBindData(double quantile_p, int32_t sample_size_p)
 	    : quantiles(1, quantile_p), sample_size(sample_size_p) {
 	}
@@ -78,6 +84,20 @@ struct ReservoirQuantileBindData : public FunctionData {
 		return make_uniq<ReservoirQuantileBindData>(std::move(quantiles), sample_size);
 	}
 
+	static void FormatSerialize(FormatSerializer &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) {
+		auto result = make_uniq<ReservoirQuantileBindData>();
+		deserializer.ReadProperty(100, "quantiles", result->quantiles);
+		deserializer.ReadProperty(101, "sample_size", result->sample_size);
+		return std::move(result);
+	}
+
 	vector<double> quantiles;
 	int32_t sample_size;
 };
@@ -353,6 +373,8 @@ 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;
 }
 
@@ -361,6 +383,8 @@ 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;
@@ -372,6 +396,8 @@ 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;
 }
@@ -381,6 +407,8 @@ 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);
@@ -409,6 +437,8 @@ 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/aggregate/nested/histogram.cpp

@@ -142,6 +142,7 @@ static void HistogramFinalizeFunction(Vector &state_vector, AggregateInputData &
 		list_struct_data[rid].offset = old_len;
 		old_len += list_struct_data[rid].length;
 	}
+	result.Verify(count);
 }
 
 unique_ptr<FunctionData> HistogramBindFunction(ClientContext &context, AggregateFunction &function,