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

package/src/duckdb/src/include/duckdb/execution/window_segment_tree.hpp

@@ -16,47 +16,79 @@
 
 namespace duckdb {
 
-class WindowAggregateState {
+class WindowAggregatorState {
 public:
-	WindowAggregateState(AggregateObject aggr, const LogicalType &result_type_p);
-	virtual ~WindowAggregateState();
+	WindowAggregatorState();
+	virtual ~WindowAggregatorState() {
+	}
+
+	template <class TARGET>
+	TARGET &Cast() {
+		D_ASSERT(dynamic_cast<TARGET *>(this));
+		return reinterpret_cast<TARGET &>(*this);
+	}
+	template <class TARGET>
+	const TARGET &Cast() const {
+		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		return reinterpret_cast<const TARGET &>(*this);
+	}
+
+	//! Allocator for aggregates
+	ArenaAllocator allocator;
+};
+
+class WindowAggregator {
+public:
+	WindowAggregator(AggregateObject aggr, const LogicalType &result_type_p, idx_t partition_count);
+	virtual ~WindowAggregator();
 
+	//	Build
 	virtual void Sink(DataChunk &payload_chunk, SelectionVector *filter_sel, idx_t filtered);
 	virtual void Finalize();
-	virtual void Compute(Vector &result, idx_t rid, idx_t start, idx_t end);
 
-protected:
-	void AggregateInit();
-	void AggegateFinal(Vector &result, idx_t rid);
+	//	Probe
+	virtual unique_ptr<WindowAggregatorState> GetLocalState() const = 0;
+	virtual void Evaluate(WindowAggregatorState &lstate, const idx_t *begins, const idx_t *ends, Vector &result,
+	                      idx_t count) const = 0;
 
+protected:
 	AggregateObject aggr;
 	//! The result type of the window function
 	LogicalType result_type;
 
-	//! Data pointer that contains a single state, used for intermediate window segment aggregation
-	vector<data_t> state;
-	//! Reused result state container for the window functions
-	Vector statev;
-	//! A vector of pointers to "state", used for intermediate window segment aggregation
-	Vector statep;
-	//! Input data chunk, used for intermediate window segment aggregation
+	//! The cardinality of the partition
+	const idx_t partition_count;
+	//! The size of a single aggregate state
+	const idx_t state_size;
+	//! Partition data chunk
 	DataChunk inputs;
+
+	//! The filtered rows in inputs.
+	vector<validity_t> filter_bits;
+	ValidityMask filter_mask;
+	idx_t filter_pos;
+	//! The state used by the aggregator to build.
+	unique_ptr<WindowAggregatorState> gstate;
 };
 
-class WindowConstantAggregate : public WindowAggregateState {
+class WindowConstantAggregator : public WindowAggregator {
 public:
-	static bool IsConstantAggregate(const BoundWindowExpression &wexpr);
-
-	WindowConstantAggregate(AggregateObject aggr, const LogicalType &result_type_p, const ValidityMask &partition_mask,
-	                        const idx_t count);
-	~WindowConstantAggregate() override {
+	WindowConstantAggregator(AggregateObject aggr, const LogicalType &result_type_p, const ValidityMask &partition_mask,
+	                         const idx_t count);
+	~WindowConstantAggregator() override {
 	}
 
 	void Sink(DataChunk &payload_chunk, SelectionVector *filter_sel, idx_t filtered) override;
 	void Finalize() override;
-	void Compute(Vector &result, idx_t rid, idx_t start, idx_t end) override;
+
+	unique_ptr<WindowAggregatorState> GetLocalState() const override;
+	void Evaluate(WindowAggregatorState &lstate, const idx_t *begins, const idx_t *ends, Vector &result,
+	              idx_t count) const override;
 
 private:
+	void AggregateInit();
+	void AggegateFinal(Vector &result, idx_t rid);
+
 	//! Partition starts
 	vector<idx_t> partition_offsets;
 	//! Aggregate results
@@ -65,53 +97,43 @@ private:
 	idx_t partition;
 	//! The current input row being built/read
 	idx_t row;
+	//! Data pointer that contains a single state, used for intermediate window segment aggregation
+	vector<data_t> state;
+	//! A vector of pointers to "state", used for intermediate window segment aggregation
+	Vector statep;
+	//! Reused result state container for the window functions
+	Vector statef;
 };
 
-class WindowSegmentTree {
+class WindowCustomAggregator : public WindowAggregator {
 public:
-	using FrameBounds = std::pair<idx_t, idx_t>;
+	WindowCustomAggregator(AggregateObject aggr, const LogicalType &result_type_p, idx_t partition_count);
+	~WindowCustomAggregator() override;
 
-	WindowSegmentTree(AggregateObject aggr, const LogicalType &result_type, DataChunk *input,
-	                  const ValidityMask &filter_mask, WindowAggregationMode mode);
-	~WindowSegmentTree();
+	unique_ptr<WindowAggregatorState> GetLocalState() const override;
+	void Evaluate(WindowAggregatorState &lstate, const idx_t *begins, const idx_t *ends, Vector &result,
+	              idx_t count) const override;
+};
 
-	//! First row contains the result.
-	void Compute(Vector &result, idx_t rid, idx_t start, idx_t end);
+class WindowSegmentTree : public WindowAggregator {
+public:
+	WindowSegmentTree(AggregateObject aggr, const LogicalType &result_type, idx_t count, WindowAggregationMode mode_p);
+	~WindowSegmentTree() override;
 
-private:
+	void Finalize() override;
+
+	unique_ptr<WindowAggregatorState> GetLocalState() const override;
+	void Evaluate(WindowAggregatorState &lstate, const idx_t *begins, const idx_t *ends, Vector &result,
+	              idx_t count) const override;
+
+public:
 	void ConstructTree();
-	void ExtractFrame(idx_t begin, idx_t end);
-	void WindowSegmentValue(idx_t l_idx, idx_t begin, idx_t end);
-	void AggregateInit();
-	void AggegateFinal(Vector &result, idx_t rid);
 
-	//! Use the window API, if available
-	inline bool UseWindowAPI() const {
-		return mode < WindowAggregationMode::COMBINE;
-	}
 	//! Use the combine API, if available
 	inline bool UseCombineAPI() const {
 		return mode < WindowAggregationMode::SEPARATE;
 	}
 
-	//! The aggregate that the window function is computed over
-	AggregateObject aggr;
-	//! The result type of the window function
-	LogicalType result_type;
-
-	//! Data pointer that contains a single state, used for intermediate window segment aggregation
-	vector<data_t> state;
-	//! Input data chunk, used for intermediate window segment aggregation
-	DataChunk inputs;
-	//! The filtered rows in inputs.
-	SelectionVector filter_sel;
-	//! A vector of pointers to "state", used for intermediate window segment aggregation
-	Vector statep;
-	//! The frame boundaries, used for the window functions
-	FrameBounds frame;
-	//! Reused result state container for the window functions
-	Vector statev;
-
 	//! The actual window segment tree: an array of aggregate states that represent all the intermediate nodes
 	unsafe_unique_array<data_t> levels_flat_native;
 	//! For each level, the starting location in the levels_flat_native array
@@ -120,17 +142,11 @@ private:
 	//! The total number of internal nodes of the tree, stored in levels_flat_native
 	idx_t internal_nodes;
 
-	//! The (sorted) input chunk collection on which the tree is built
-	DataChunk *input_ref;
-
-	//! The filtered rows in input_ref.
-	const ValidityMask &filter_mask;
-
-	//! Use the window API, if available
+	//! Use the combine API, if available
 	WindowAggregationMode mode;
 
 	// TREE_FANOUT needs to cleanly divide STANDARD_VECTOR_SIZE
-	static constexpr idx_t TREE_FANOUT = 64;
+	static constexpr idx_t TREE_FANOUT = 16;
 };
 
 } // namespace duckdb

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

@@ -8,10 +8,10 @@
 
 #pragma once
 
+#include "duckdb/common/vector_operations/aggregate_executor.hpp"
 #include "duckdb/function/aggregate_state.hpp"
 #include "duckdb/planner/bound_result_modifier.hpp"
 #include "duckdb/planner/expression.hpp"
-#include "duckdb/common/vector_operations/aggregate_executor.hpp"
 
 namespace duckdb {
 
@@ -41,7 +41,6 @@ typedef void (*aggregate_simple_update_t)(Vector inputs[], AggregateInputData &a
                                           data_ptr_t state, idx_t count);
 
 //! The type used for updating complex windowed aggregate functions (optional)
-typedef std::pair<idx_t, idx_t> FrameBounds;
 typedef void (*aggregate_window_t)(Vector inputs[], const ValidityMask &filter_mask,
                                    AggregateInputData &aggr_input_data, idx_t input_count, data_ptr_t state,
                                    const FrameBounds &frame, const FrameBounds &prev, Vector &result, idx_t rid,
@@ -52,6 +51,11 @@ typedef void (*aggregate_serialize_t)(FieldWriter &writer, const FunctionData *b
 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);
+
 class AggregateFunction : public BaseScalarFunction {
 public:
 	AggregateFunction(const string &name, const vector<LogicalType> &arguments, const LogicalType &return_type,
@@ -66,7 +70,8 @@ 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), order_dependent(AggregateOrderDependent::ORDER_DEPENDENT) {
+	      serialize(serialize), deserialize(deserialize), format_serialize(nullptr), format_deserialize(nullptr),
+	      order_dependent(AggregateOrderDependent::ORDER_DEPENDENT) {
 	}
 
 	AggregateFunction(const string &name, const vector<LogicalType> &arguments, const LogicalType &return_type,
@@ -80,7 +85,8 @@ 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), order_dependent(AggregateOrderDependent::ORDER_DEPENDENT) {
+	      serialize(serialize), deserialize(deserialize), format_serialize(nullptr), format_deserialize(nullptr),
+	      order_dependent(AggregateOrderDependent::ORDER_DEPENDENT) {
 	}
 
 	AggregateFunction(const vector<LogicalType> &arguments, const LogicalType &return_type, aggregate_size_t state_size,
@@ -131,6 +137,8 @@ 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/aggregate_state.hpp

@@ -21,11 +21,11 @@ enum class AggregateOrderDependent : uint8_t { ORDER_DEPENDENT = 1, NOT_ORDER_DE
 class BoundAggregateExpression;
 
 struct AggregateInputData {
-	AggregateInputData(optional_ptr<FunctionData> bind_data_p, Allocator &allocator_p)
+	AggregateInputData(optional_ptr<FunctionData> bind_data_p, ArenaAllocator &allocator_p)
 	    : bind_data(bind_data_p), allocator(allocator_p) {
 	}
 	optional_ptr<FunctionData> bind_data;
-	Allocator &allocator;
+	ArenaAllocator &allocator;
 };
 
 struct AggregateUnaryInput {

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

@@ -57,6 +57,7 @@ private:
 	void RegisterDistributiveAggregates();
 
 	// scalar functions
+	void RegisterCompressedMaterializationFunctions();
 	void RegisterGenericFunctions();
 	void RegisterOperators();
 	void RegisterStringFunctions();

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

@@ -99,13 +99,16 @@ typedef void (*copy_flush_batch_t)(ClientContext &context, FunctionData &bind_da
                                    PreparedBatchData &batch);
 typedef idx_t (*copy_desired_batch_size_t)(ClientContext &context, FunctionData &bind_data);
 
+typedef bool (*copy_supports_type_t)(const LogicalType &type);
+
 class CopyFunction : public Function {
 public:
 	explicit CopyFunction(string name)
 	    : Function(name), plan(nullptr), copy_to_bind(nullptr), copy_to_initialize_local(nullptr),
 	      copy_to_initialize_global(nullptr), copy_to_sink(nullptr), copy_to_combine(nullptr),
 	      copy_to_finalize(nullptr), execution_mode(nullptr), prepare_batch(nullptr), flush_batch(nullptr),
-	      desired_batch_size(nullptr), serialize(nullptr), deserialize(nullptr), copy_from_bind(nullptr) {
+	      desired_batch_size(nullptr), serialize(nullptr), deserialize(nullptr), supports_type(nullptr),
+	      copy_from_bind(nullptr) {
 	}
 
 	//! Plan rewrite copy function
@@ -126,6 +129,8 @@ public:
 	copy_to_serialize_t serialize;
 	copy_to_deserialize_t deserialize;
 
+	copy_supports_type_t supports_type;
+
 	copy_from_bind_t copy_from_bind;
 	TableFunction copy_from_function;
 

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

@@ -11,6 +11,8 @@
 #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"
 
 namespace duckdb {
 
@@ -97,6 +99,84 @@ public:
 		function.return_type = return_type;
 		return function;
 	}
+
+	template <class FUNC>
+	static void FormatSerialize(FormatSerializer &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;
+		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);
+		}
+	}
+
+	template <class FUNC, class CATALOG_ENTRY>
+	static FUNC DeserializeFunction(ClientContext &context, CatalogType catalog_type, const string &name,
+	                                vector<LogicalType> arguments, vector<LogicalType> original_arguments) {
+		auto &func_catalog = Catalog::GetEntry(context, catalog_type, SYSTEM_CATALOG, DEFAULT_SCHEMA, name);
+		if (func_catalog.type != catalog_type) {
+			throw InternalException("DeserializeFunction - cant find catalog entry for function %s", name);
+		}
+		auto &functions = func_catalog.Cast<CATALOG_ENTRY>();
+		auto function = functions.functions.GetFunctionByArguments(
+		    context, original_arguments.empty() ? arguments : original_arguments);
+		function.arguments = std::move(arguments);
+		function.original_arguments = std::move(original_arguments);
+		return function;
+	}
+
+	template <class FUNC, class CATALOG_ENTRY>
+	static pair<FUNC, bool> FormatDeserializeBase(FormatDeserializer &deserializer, CatalogType catalog_type) {
+		auto &context = deserializer.Get<ClientContext &>();
+		auto name = deserializer.ReadProperty<string>(500, "name");
+		auto arguments = deserializer.ReadProperty<vector<LogicalType>>(501, "arguments");
+		auto original_arguments = deserializer.ReadProperty<vector<LogicalType>>(502, "original_arguments");
+		auto function = DeserializeFunction<FUNC, CATALOG_ENTRY>(context, catalog_type, name, std::move(arguments),
+		                                                         std::move(original_arguments));
+		auto has_serialize = deserializer.ReadProperty<bool>(503, "has_serialize");
+		return make_pair(std::move(function), has_serialize);
+	}
+
+	template <class FUNC>
+	static unique_ptr<FunctionData> FunctionDeserialize(FormatDeserializer &deserializer, FUNC &function) {
+		if (!function.format_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); });
+		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) {
+		auto &context = deserializer.Get<ClientContext &>();
+		auto entry = FormatDeserializeBase<FUNC, CATALOG_ENTRY>(deserializer, catalog_type);
+		auto &function = entry.first;
+		auto has_serialize = entry.second;
+
+		unique_ptr<FunctionData> bind_data;
+		if (has_serialize) {
+			bind_data = FunctionDeserialize<FUNC>(deserializer, function);
+		} else if (function.bind) {
+			try {
+				bind_data = function.bind(context, function, children);
+			} catch (Exception &ex) {
+				// FIXME
+				throw SerializationException("Error during bind of function in deserialization: %s", ex.what());
+			}
+		}
+		return make_pair(std::move(function), std::move(bind_data));
+	}
 };
 
 } // namespace duckdb

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

@@ -48,6 +48,9 @@ public:
 	void Serialize(Serializer &serializer) const;
 	static unique_ptr<MacroFunction> Deserialize(Deserializer &deserializer);
 
+	virtual void FormatSerialize(FormatSerializer &serializer) const;
+	static unique_ptr<MacroFunction> FormatDeserialize(FormatDeserializer &deserializer);
+
 protected:
 	virtual void SerializeInternal(FieldWriter &writer) const = 0;
 

package/src/duckdb/src/include/duckdb/function/scalar/compressed_materialization_functions.hpp

@@ -0,0 +1,49 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/function/scalar/compressed_materialization_functions.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/function/built_in_functions.hpp"
+#include "duckdb/function/function_set.hpp"
+
+namespace duckdb {
+
+struct CompressedMaterializationFunctions {
+	//! The types we compress integral types to
+	static const vector<LogicalType> IntegralTypes();
+	//! The types we compress strings to
+	static const vector<LogicalType> StringTypes();
+
+	static unique_ptr<FunctionData> Bind(ClientContext &context, ScalarFunction &bound_function,
+	                                     vector<unique_ptr<Expression>> &arguments);
+};
+
+//! Needed for (de)serialization without binding
+enum class CompressedMaterializationDirection : uint8_t { INVALID = 0, COMPRESS = 1, DECOMPRESS = 2 };
+
+struct CMIntegralCompressFun {
+	static ScalarFunction GetFunction(const LogicalType &input_type, const LogicalType &result_type);
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
+struct CMIntegralDecompressFun {
+	static ScalarFunction GetFunction(const LogicalType &input_type, const LogicalType &result_type);
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
+struct CMStringCompressFun {
+	static ScalarFunction GetFunction(const LogicalType &result_type);
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
+struct CMStringDecompressFun {
+	static ScalarFunction GetFunction(const LogicalType &input_type);
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/function/scalar/list/contains_or_position.hpp

@@ -130,7 +130,7 @@ void ListContainsOrPosition(DataChunk &args, Vector &result) {
 		TemplatedContainsOrPosition<int8_t, T, OP, LIST_ACCESSOR>(args, result, true);
 		break;
 	default:
-		throw NotImplementedException("This function has not been implemented for physical type %s",
+		throw NotImplementedException("This function has not been implemented for logical type %s",
 		                              TypeIdToString(physical_type));
 	}
 }

package/src/duckdb/src/include/duckdb/function/scalar/nested_functions.hpp

@@ -99,6 +99,11 @@ struct ListPositionFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
+struct ListResizeFun {
+	static ScalarFunction GetFunction();
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
 struct StructExtractFun {
 	static ScalarFunction GetFunction();
 	static void RegisterFunction(BuiltinFunctions &set);

package/src/duckdb/src/include/duckdb/function/scalar/strftime_format.hpp

@@ -121,6 +121,8 @@ protected:
 
 struct StrpTimeFormat : public StrTimeFormat {
 public:
+	StrpTimeFormat();
+
 	//! Type-safe parsing argument
 	struct ParseResult {
 		int32_t data[8]; // year, month, day, hour, min, sec, µs, offset
@@ -140,20 +142,26 @@ public:
 public:
 	DUCKDB_API static ParseResult Parse(const string &format, const string &text);
 
-	DUCKDB_API bool Parse(string_t str, ParseResult &result);
+	DUCKDB_API bool Parse(string_t str, ParseResult &result) const;
 
-	DUCKDB_API bool TryParseDate(string_t str, date_t &result, string &error_message);
-	DUCKDB_API bool TryParseTimestamp(string_t str, timestamp_t &result, string &error_message);
+	DUCKDB_API bool TryParseDate(string_t str, date_t &result, string &error_message) const;
+	DUCKDB_API bool TryParseTimestamp(string_t str, timestamp_t &result, string &error_message) const;
 
 	date_t ParseDate(string_t str);
 	timestamp_t ParseTimestamp(string_t str);
 
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static StrpTimeFormat FormatDeserialize(FormatDeserializer &deserializer);
+
 protected:
 	static string FormatStrpTimeError(const string &input, idx_t position);
 	DUCKDB_API void AddFormatSpecifier(string preceding_literal, StrTimeSpecifier specifier) override;
 	int NumericSpecifierWidth(StrTimeSpecifier specifier);
 	int32_t TryParseCollection(const char *data, idx_t &pos, idx_t size, const string_t collection[],
-	                           idx_t collection_count);
+	                           idx_t collection_count) const;
+
+private:
+	explicit StrpTimeFormat(const string &format_string);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/function/scalar/string_functions.hpp

@@ -83,12 +83,14 @@ struct LengthFun {
 };
 
 struct LikeFun {
+	static ScalarFunction GetLikeFunction();
 	static void RegisterFunction(BuiltinFunctions &set);
 	DUCKDB_API static bool Glob(const char *s, idx_t slen, const char *pattern, idx_t plen,
 	                            bool allow_question_mark = true);
 };
 
 struct LikeEscapeFun {
+	static ScalarFunction GetLikeEscapeFun();
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 

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

@@ -69,6 +69,11 @@ typedef void (*function_serialize_t)(FieldWriter &writer, const FunctionData *bi
 typedef unique_ptr<FunctionData> (*function_deserialize_t)(PlanDeserializationState &state, FieldReader &reader,
                                                            ScalarFunction &function);
 
+typedef void (*function_format_serialize_t)(FormatSerializer &serializer, const optional_ptr<FunctionData> bind_data,
+                                            const ScalarFunction &function);
+typedef unique_ptr<FunctionData> (*function_format_deserialize_t)(FormatDeserializer &deserializer,
+                                                                  ScalarFunction &function);
+
 class ScalarFunction : public BaseScalarFunction {
 public:
 	DUCKDB_API ScalarFunction(string name, vector<LogicalType> arguments, LogicalType return_type,
@@ -100,14 +105,14 @@ public:
 	function_serialize_t serialize;
 	function_deserialize_t deserialize;
 
+	function_format_serialize_t format_serialize;
+	function_format_deserialize_t format_deserialize;
+
 	DUCKDB_API bool operator==(const ScalarFunction &rhs) const;
 	DUCKDB_API bool operator!=(const ScalarFunction &rhs) const;
 
 	DUCKDB_API bool Equal(const ScalarFunction &rhs) const;
 
-private:
-	bool CompareScalarFunctionT(const scalar_function_t &other) const;
-
 public:
 	DUCKDB_API static void NopFunction(DataChunk &input, ExpressionState &state, Vector &result);
 

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

@@ -36,6 +36,9 @@ public:
 
 	static unique_ptr<MacroFunction> Deserialize(FieldReader &reader);
 
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<MacroFunction> FormatDeserialize(FormatDeserializer &deserializer);
+
 protected:
 	void SerializeInternal(FieldWriter &writer) const override;
 };