duckdb 0.8.2-dev2068.0 → 0.8.2-dev2133.0

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

@@ -28,25 +28,11 @@ protected:
 public:
 	// Serialize a value
 	template <class T>
-	typename std::enable_if<!std::is_enum<T>::value, void>::type WriteProperty(const char *tag, const T &value) {
+	void WriteProperty(const char *tag, const T &value) {
 		SetTag(tag);
 		WriteValue(value);
 	}
 
-	// Serialize an enum
-	template <class T>
-	typename std::enable_if<std::is_enum<T>::value, void>::type WriteProperty(const char *tag, T value) {
-		SetTag(tag);
-		if (serialize_enum_as_string) {
-			// Use the enum serializer to lookup tostring function
-			auto str = EnumUtil::ToChars(value);
-			WriteValue(str);
-		} else {
-			// Use the underlying type
-			WriteValue(static_cast<typename std::underlying_type<T>::type>(value));
-		}
-	}
-
 	// Optional pointer
 	template <class POINTER>
 	void WriteOptionalProperty(const char *tag, POINTER &&ptr) {
@@ -67,7 +53,29 @@ public:
 		WriteDataPtr(ptr, count);
 	}
 
+	// Manually begin an object - should be followed by EndObject
+	void BeginObject(const char *tag) {
+		SetTag(tag);
+		OnObjectBegin();
+	}
+
+	void EndObject() {
+		OnObjectEnd();
+	}
+
 protected:
+	template <typename T>
+	typename std::enable_if<std::is_enum<T>::value, void>::type WriteValue(const T value) {
+		if (serialize_enum_as_string) {
+			// Use the enum serializer to lookup tostring function
+			auto str = EnumUtil::ToChars(value);
+			WriteValue(str);
+		} else {
+			// Use the underlying type
+			WriteValue(static_cast<typename std::underlying_type<T>::type>(value));
+		}
+	}
+
 	// Unique Pointer Ref
 	template <typename T>
 	void WriteValue(const unique_ptr<T> &ptr) {
@@ -160,6 +168,24 @@ protected:
 		OnMapEnd(count);
 	}
 
+	// Map
+	template <class K, class V, class HASH, class CMP>
+	void WriteValue(const duckdb::map<K, V, HASH, CMP> &map) {
+		auto count = map.size();
+		OnMapBegin(count);
+		for (auto &item : map) {
+			OnMapEntryBegin();
+			OnMapKeyBegin();
+			WriteValue(item.first);
+			OnMapKeyEnd();
+			OnMapValueBegin();
+			WriteValue(item.second);
+			OnMapValueEnd();
+			OnMapEntryEnd();
+		}
+		OnMapEnd(count);
+	}
+
 	// class or struct implementing `FormatSerialize(FormatSerializer& FormatSerializer)`;
 	template <typename T>
 	typename std::enable_if<has_serialize<T>::value>::type WriteValue(const T &value) {
@@ -247,4 +273,8 @@ protected:
 	}
 };
 
+// We need to special case vector<bool> because elements of vector<bool> cannot be referenced
+template <>
+void FormatSerializer::WriteValue(const vector<bool> &vec);
+
 } // namespace duckdb

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

@@ -70,6 +70,16 @@ struct is_unordered_map<typename duckdb::unordered_map<Args...>> : std::true_typ
 	typedef typename std::tuple_element<3, std::tuple<Args...>>::type EQUAL_TYPE;
 };
 
+template <typename T>
+struct is_map : std::false_type {};
+template <typename... Args>
+struct is_map<typename duckdb::map<Args...>> : std::true_type {
+	typedef typename std::tuple_element<0, std::tuple<Args...>>::type KEY_TYPE;
+	typedef typename std::tuple_element<1, std::tuple<Args...>>::type VALUE_TYPE;
+	typedef typename std::tuple_element<2, std::tuple<Args...>>::type HASH_TYPE;
+	typedef typename std::tuple_element<3, std::tuple<Args...>>::type EQUAL_TYPE;
+};
+
 template <typename T>
 struct is_unique_ptr : std::false_type {};
 

package/src/duckdb/src/include/duckdb/execution/operator/persistent/csv_reader_options.hpp

@@ -147,6 +147,8 @@ struct BufferedCSVReaderOptions {
 
 	void Serialize(FieldWriter &writer) const;
 	void Deserialize(FieldReader &reader);
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static BufferedCSVReaderOptions FormatDeserialize(FormatDeserializer &deserializer);
 
 	void SetCompression(const string &compression);
 	void SetHeader(bool has_header);

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

@@ -52,6 +52,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 +71,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 +86,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 +138,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/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,85 @@ 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("name", function.name);
+		serializer.WriteProperty("arguments", function.arguments);
+		serializer.WriteProperty("original_arguments", function.original_arguments);
+		bool has_serialize = function.format_serialize;
+		serializer.WriteProperty("has_serialize", has_serialize);
+		if (has_serialize) {
+			serializer.BeginObject("function_data");
+			function.format_serialize(serializer, bind_info, function);
+			serializer.EndObject();
+			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>("name");
+		auto arguments = deserializer.ReadProperty<vector<LogicalType>>("arguments");
+		auto original_arguments = deserializer.ReadProperty<vector<LogicalType>>("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>("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);
+		}
+		deserializer.BeginObject("function_data");
+		auto result = function.format_deserialize(deserializer, function);
+		deserializer.EndObject();
+		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/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
@@ -148,12 +150,18 @@ public:
 	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);
+
+private:
+	explicit StrpTimeFormat(const string &format_string);
 };
 
 } // namespace duckdb

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,6 +105,9 @@ 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;
 

package/src/duckdb/src/include/duckdb/function/table/read_csv.hpp

@@ -76,6 +76,10 @@ struct ColumnInfo {
 		info.types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
 		return info;
 	}
+
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static ColumnInfo FormatDeserialize(FormatDeserializer &deserializer);
+
 	vector<std::string> names;
 	vector<LogicalType> types;
 };
@@ -105,6 +109,9 @@ struct ReadCSVData : public BaseCSVData {
 		this->initial_reader = std::move(reader);
 	}
 	void FinalizeRead(ClientContext &context);
+
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static unique_ptr<ReadCSVData> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 struct CSVCopyFunction {

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

@@ -207,6 +207,12 @@ typedef void (*table_function_serialize_t)(FieldWriter &writer, const FunctionDa
 typedef unique_ptr<FunctionData> (*table_function_deserialize_t)(PlanDeserializationState &context, FieldReader &reader,
                                                                  TableFunction &function);
 
+typedef void (*table_function_format_serialize_t)(FormatSerializer &serializer,
+                                                  const optional_ptr<FunctionData> bind_data,
+                                                  const TableFunction &function);
+typedef unique_ptr<FunctionData> (*table_function_format_deserialize_t)(FormatDeserializer &deserializer,
+                                                                        TableFunction &function);
+
 class TableFunction : public SimpleNamedParameterFunction {
 public:
 	DUCKDB_API
@@ -265,6 +271,8 @@ public:
 
 	table_function_serialize_t serialize;
 	table_function_deserialize_t deserialize;
+	table_function_format_serialize_t format_serialize;
+	table_function_format_deserialize_t format_deserialize;
 	bool verify_serialization = true;
 
 	//! Whether or not the table function supports projection pushdown. If not supported a projection will be added

package/src/duckdb/src/include/duckdb/planner/expression/bound_aggregate_expression.hpp

@@ -57,5 +57,8 @@ public:
 	unique_ptr<Expression> Copy() override;
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<Expression> Deserialize(ExpressionDeserializationState &state, FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<Expression> FormatDeserialize(FormatDeserializer &deserializer);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/expression/bound_function_expression.hpp

@@ -46,5 +46,9 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<Expression> Deserialize(ExpressionDeserializationState &state, FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<Expression> FormatDeserialize(FormatDeserializer &deserializer);
 };
+
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/expression/bound_window_expression.hpp

@@ -67,5 +67,8 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<Expression> Deserialize(ExpressionDeserializationState &state, FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<Expression> FormatDeserialize(FormatDeserializer &deserializer);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/filter/conjunction_filter.hpp

@@ -45,6 +45,8 @@ public:
 	bool Equals(const TableFilter &other) const override;
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<TableFilter> Deserialize(FieldReader &source);
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<TableFilter> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 class ConjunctionAndFilter : public ConjunctionFilter {
@@ -60,6 +62,8 @@ public:
 	bool Equals(const TableFilter &other) const override;
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<TableFilter> Deserialize(FieldReader &source);
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<TableFilter> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/filter/constant_filter.hpp

@@ -32,6 +32,8 @@ public:
 	bool Equals(const TableFilter &other) const override;
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<TableFilter> Deserialize(FieldReader &source);
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<TableFilter> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/filter/null_filter.hpp

@@ -24,6 +24,8 @@ public:
 	string ToString(const string &column_name) override;
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<TableFilter> Deserialize(FieldReader &source);
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<TableFilter> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 class IsNotNullFilter : public TableFilter {
@@ -38,6 +40,8 @@ public:
 	string ToString(const string &column_name) override;
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<TableFilter> Deserialize(FieldReader &source);
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<TableFilter> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/operator/logical_copy_to_file.hpp

@@ -45,6 +45,8 @@ public:
 	bool SupportSerialization() const override {
 		return false;
 	}
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
 
 protected:
 	void ResolveTypes() override {

package/src/duckdb/src/include/duckdb/planner/operator/logical_get.hpp

@@ -69,9 +69,15 @@ public:
 	//! Skips the serialization check in VerifyPlan
 	bool SupportSerialization() const override {
 		return function.verify_serialization;
-	};
+	}
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
 
 protected:
 	void ResolveTypes() override;
+
+private:
+	LogicalGet();
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/table_filter.hpp

@@ -29,7 +29,7 @@ enum class TableFilterType : uint8_t {
 //! TableFilter represents a filter pushed down into the table scan.
 class TableFilter {
 public:
-	TableFilter(TableFilterType filter_type_p) : filter_type(filter_type_p) {
+	explicit TableFilter(TableFilterType filter_type_p) : filter_type(filter_type_p) {
 	}
 	virtual ~TableFilter() {
 	}
@@ -48,6 +48,9 @@ public:
 	virtual void Serialize(FieldWriter &writer) const = 0;
 	static unique_ptr<TableFilter> Deserialize(Deserializer &source);
 
+	virtual void FormatSerialize(FormatSerializer &serializer) const;
+	static unique_ptr<TableFilter> FormatDeserialize(FormatDeserializer &deserializer);
+
 public:
 	template <class TARGET>
 	TARGET &Cast() {
@@ -100,6 +103,9 @@ public:
 
 	void Serialize(Serializer &serializer) const;
 	static unique_ptr<TableFilterSet> Deserialize(Deserializer &source);
+
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static TableFilterSet FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 } // namespace duckdb

package/src/duckdb/src/main/extension/extension_helper.cpp

@@ -179,6 +179,19 @@ ExtensionLoadResult ExtensionHelper::LoadExtensionInternal(DuckDB &db, const std
 	}
 #endif
 
+#ifdef DUCKDB_EXTENSIONS_TEST_WITH_LOADABLE
+	if (!initial_load && StringUtil::Contains(DUCKDB_EXTENSIONS_TEST_WITH_LOADABLE, extension)) {
+		Connection con(db);
+		auto result = con.Query((string) "LOAD '" + DUCKDB_EXTENSIONS_BUILD_PATH + "/" + extension + "/" + extension +
+		                        ".duckdb_extension'");
+		if (result->HasError()) {
+			result->Print();
+			return ExtensionLoadResult::EXTENSION_UNKNOWN;
+		}
+		return ExtensionLoadResult::LOADED_EXTENSION;
+	}
+#endif
+
 	// This is the main extension loading mechanism that loads the extension that are statically linked.
 #if defined(GENERATED_EXTENSION_HEADERS) && GENERATED_EXTENSION_HEADERS
 	if (TryLoadLinkedExtension(db, extension)) {

package/src/duckdb/src/parallel/executor.cpp

@@ -107,7 +107,7 @@ void Executor::SchedulePipeline(const shared_ptr<MetaPipeline> &meta_pipeline, S
 			                                  group_stack.pipeline_finish_event, base_stack.pipeline_complete_event);
 
 			// dependencies: base_finish -> pipeline_event -> group_finish
-			pipeline_stack.pipeline_event.AddDependency(base_stack.pipeline_event);
+			pipeline_stack.pipeline_event.AddDependency(base_stack.pipeline_finish_event);
 			group_stack.pipeline_finish_event.AddDependency(pipeline_stack.pipeline_event);
 
 			// add pipeline stack to event map

package/src/duckdb/src/planner/expression/bound_aggregate_expression.cpp

@@ -104,4 +104,27 @@ unique_ptr<Expression> BoundAggregateExpression::Deserialize(ExpressionDeseriali
 	return std::move(x);
 }
 
+void BoundAggregateExpression::FormatSerialize(FormatSerializer &serializer) const {
+	Expression::FormatSerialize(serializer);
+	serializer.WriteProperty("return_type", return_type);
+	serializer.WriteProperty("children", children);
+	FunctionSerializer::FormatSerialize(serializer, function, bind_info.get());
+	serializer.WriteProperty("aggregate_type", aggr_type);
+	serializer.WriteOptionalProperty("filter", filter);
+	serializer.WriteOptionalProperty("order_bys", order_bys);
+}
+
+unique_ptr<Expression> BoundAggregateExpression::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto return_type = deserializer.ReadProperty<LogicalType>("return_type");
+	auto children = deserializer.ReadProperty<vector<unique_ptr<Expression>>>("children");
+	auto entry = FunctionSerializer::FormatDeserialize<AggregateFunction, AggregateFunctionCatalogEntry>(
+	    deserializer, CatalogType::AGGREGATE_FUNCTION_ENTRY, children);
+	auto aggregate_type = deserializer.ReadProperty<AggregateType>("aggregate_type");
+	auto filter = deserializer.ReadOptionalProperty<unique_ptr<Expression>>("filter");
+	auto result = make_uniq<BoundAggregateExpression>(std::move(entry.first), std::move(children), std::move(filter),
+	                                                  std::move(entry.second), aggregate_type);
+	deserializer.ReadOptionalProperty("order_bys", result->order_bys);
+	return std::move(result);
+}
+
 } // namespace duckdb

package/src/duckdb/src/planner/expression/bound_function_expression.cpp

@@ -3,6 +3,8 @@
 #include "duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp"
 #include "duckdb/common/types/hash.hpp"
 #include "duckdb/function/function_serialization.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
 
 namespace duckdb {
 
@@ -92,4 +94,24 @@ unique_ptr<Expression> BoundFunctionExpression::Deserialize(ExpressionDeserializ
 	return make_uniq<BoundFunctionExpression>(std::move(return_type), std::move(function), std::move(children),
 	                                          std::move(bind_info), is_operator);
 }
+
+void BoundFunctionExpression::FormatSerialize(FormatSerializer &serializer) const {
+	Expression::FormatSerialize(serializer);
+	serializer.WriteProperty("return_type", return_type);
+	serializer.WriteProperty("children", children);
+	FunctionSerializer::FormatSerialize(serializer, function, bind_info.get());
+	serializer.WriteProperty("is_operator", is_operator);
+}
+
+unique_ptr<Expression> BoundFunctionExpression::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto return_type = deserializer.ReadProperty<LogicalType>("return_type");
+	auto children = deserializer.ReadProperty<vector<unique_ptr<Expression>>>("children");
+	auto entry = FunctionSerializer::FormatDeserialize<ScalarFunction, ScalarFunctionCatalogEntry>(
+	    deserializer, CatalogType::SCALAR_FUNCTION_ENTRY, children);
+	auto result = make_uniq<BoundFunctionExpression>(std::move(return_type), std::move(entry.first),
+	                                                 std::move(children), std::move(entry.second));
+	deserializer.ReadProperty("is_operator", result->is_operator);
+	return std::move(result);
+}
+
 } // namespace duckdb

package/src/duckdb/src/planner/expression/bound_window_expression.cpp

@@ -162,4 +162,51 @@ unique_ptr<Expression> BoundWindowExpression::Deserialize(ExpressionDeserializat
 	return std::move(result);
 }
 
+void BoundWindowExpression::FormatSerialize(FormatSerializer &serializer) const {
+	Expression::FormatSerialize(serializer);
+	serializer.WriteProperty("return_type", return_type);
+	serializer.WriteProperty("children", children);
+	if (type == ExpressionType::WINDOW_AGGREGATE) {
+		D_ASSERT(aggregate);
+		FunctionSerializer::FormatSerialize(serializer, *aggregate, bind_info.get());
+	}
+	serializer.WriteProperty("partitions", partitions);
+	serializer.WriteProperty("orders", orders);
+	serializer.WriteOptionalProperty("filters", filter_expr);
+	serializer.WriteProperty("ignore_nulls", ignore_nulls);
+	serializer.WriteProperty("start", start);
+	serializer.WriteProperty("end", end);
+	serializer.WriteOptionalProperty("start_expr", start_expr);
+	serializer.WriteOptionalProperty("end_expr", end_expr);
+	serializer.WriteOptionalProperty("offset_expr", offset_expr);
+	serializer.WriteOptionalProperty("default_expr", default_expr);
+}
+
+unique_ptr<Expression> BoundWindowExpression::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto expression_type = deserializer.Get<ExpressionType>();
+	auto return_type = deserializer.ReadProperty<LogicalType>("return_type");
+	auto children = deserializer.ReadProperty<vector<unique_ptr<Expression>>>("children");
+	unique_ptr<AggregateFunction> aggregate;
+	unique_ptr<FunctionData> bind_info;
+	if (expression_type == ExpressionType::WINDOW_AGGREGATE) {
+		auto entry = FunctionSerializer::FormatDeserialize<AggregateFunction, AggregateFunctionCatalogEntry>(
+		    deserializer, CatalogType::AGGREGATE_FUNCTION_ENTRY, children);
+		aggregate = make_uniq<AggregateFunction>(std::move(entry.first));
+		bind_info = std::move(entry.second);
+	}
+	auto result =
+	    make_uniq<BoundWindowExpression>(expression_type, return_type, std::move(aggregate), std::move(bind_info));
+	deserializer.ReadProperty("partitions", result->partitions);
+	deserializer.ReadProperty("orders", result->orders);
+	deserializer.ReadOptionalProperty("filters", result->filter_expr);
+	deserializer.ReadProperty("ignore_nulls", result->ignore_nulls);
+	deserializer.ReadProperty("start", result->start);
+	deserializer.ReadProperty("end", result->end);
+	deserializer.ReadOptionalProperty("start_expr", result->start_expr);
+	deserializer.ReadOptionalProperty("end_expr", result->end_expr);
+	deserializer.ReadOptionalProperty("offset_expr", result->offset_expr);
+	deserializer.ReadOptionalProperty("default_expr", result->default_expr);
+	return std::move(result);
+}
+
 } // namespace duckdb

package/src/duckdb/src/planner/operator/logical_copy_to_file.cpp

@@ -59,6 +59,14 @@ unique_ptr<LogicalOperator> LogicalCopyToFile::Deserialize(LogicalDeserializatio
 	return std::move(result);
 }
 
+void LogicalCopyToFile::FormatSerialize(FormatSerializer &serializer) const {
+	throw SerializationException("LogicalCopyToFile not implemented yet");
+}
+
+unique_ptr<LogicalOperator> LogicalCopyToFile::FormatDeserialize(FormatDeserializer &deserializer) {
+	throw SerializationException("LogicalCopyToFile not implemented yet");
+}
+
 idx_t LogicalCopyToFile::EstimateCardinality(ClientContext &context) {
 	return 1;
 }