duckdb 0.7.2-dev717.0 → 0.7.2-dev865.0

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

@@ -0,0 +1,126 @@
+#pragma once
+#include <type_traits>
+#include "duckdb/common/vector.hpp"
+#include "duckdb/common/unordered_map.hpp"
+#include "duckdb/common/unordered_set.hpp"
+
+namespace duckdb {
+
+class FormatSerializer;   // Forward declare
+class FormatDeserializer; // Forward declare
+
+// Backport to c++11
+template <class...>
+using void_t = void;
+
+// Check for anything implementing a `void FormatSerialize(FormatSerializer &FormatSerializer)` method
+template <typename T, typename = void_t<>>
+struct has_serialize : std::false_type {};
+
+template <typename T>
+struct has_serialize<T, void_t<decltype(std::declval<T>().FormatSerialize(std::declval<FormatSerializer &>()))>>
+    : std::true_type {};
+
+template <typename T>
+constexpr bool has_serialize_v() {
+	return has_serialize<T>::value;
+}
+
+// Check for anything implementing a static `T FormatDeserialize(FormatDeserializer&)` method
+/*
+template <typename T, typename = void_t<>>
+struct has_deserialize : std::false_type {};
+
+template <typename T>
+struct has_deserialize<T, void_t<decltype(T::FormatDeserialize)>> : std::true_type {};
+
+template <typename T>
+constexpr bool has_deserialize_v() {
+    return has_deserialize<T>::value;
+}*/
+
+template <typename T, typename = T>
+struct has_deserialize : std::false_type {};
+
+// Accept `static unique_ptr<T> FormatDeserialize(FormatDeserializer& deserializer)`
+template <typename T>
+struct has_deserialize<
+    T, typename std::enable_if<std::is_same<decltype(T::FormatDeserialize), unique_ptr<T>(FormatDeserializer &)>::value,
+                               T>::type> : std::true_type {};
+
+// Accept `static shared_ptr<T> FormatDeserialize(FormatDeserializer& deserializer)`
+template <typename T>
+struct has_deserialize<
+    T, typename std::enable_if<std::is_same<decltype(T::FormatDeserialize), shared_ptr<T>(FormatDeserializer &)>::value,
+                               T>::type> : std::true_type {};
+
+// Accept `static T FormatDeserialize(FormatDeserializer& deserializer)`
+template <typename T>
+struct has_deserialize<
+    T, typename std::enable_if<std::is_same<decltype(T::FormatDeserialize), T(FormatDeserializer &)>::value, T>::type>
+    : std::true_type {};
+
+// Check if T is a vector, and provide access to the inner type
+template <typename T>
+struct is_vector : std::false_type {};
+template <typename T>
+struct is_vector<typename std::vector<T>> : std::true_type {
+	typedef T ELEMENT_TYPE;
+};
+
+// Check if T is a unordered map, and provide access to the inner type
+template <typename T>
+struct is_unordered_map : std::false_type {};
+template <typename... Args>
+struct is_unordered_map<typename std::unordered_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 {};
+
+template <typename T, typename D>
+struct is_unique_ptr<unique_ptr<T, D>> : std::true_type {
+	typedef T ELEMENT_TYPE;
+	typedef D DELETER_TYPE;
+};
+
+template <typename T>
+struct is_shared_ptr : std::false_type {};
+
+template <typename T>
+struct is_shared_ptr<shared_ptr<T>> : std::true_type {
+	typedef T ELEMENT_TYPE;
+};
+
+template <typename T>
+struct is_pair : std::false_type {};
+
+template <typename T, typename U>
+struct is_pair<std::pair<T, U>> : std::true_type {
+	typedef T FIRST_TYPE;
+	typedef U SECOND_TYPE;
+};
+
+template <typename T>
+struct is_unordered_set : std::false_type {};
+template <typename... Args>
+struct is_unordered_set<std::unordered_set<Args...>> : std::true_type {
+	typedef typename std::tuple_element<0, std::tuple<Args...>>::type ELEMENT_TYPE;
+	typedef typename std::tuple_element<1, std::tuple<Args...>>::type HASH_TYPE;
+	typedef typename std::tuple_element<2, std::tuple<Args...>>::type EQUAL_TYPE;
+};
+
+template <typename T>
+struct is_set : std::false_type {};
+template <typename... Args>
+struct is_set<std::set<Args...>> : std::true_type {
+	typedef typename std::tuple_element<0, std::tuple<Args...>>::type ELEMENT_TYPE;
+	typedef typename std::tuple_element<1, std::tuple<Args...>>::type HASH_TYPE;
+	typedef typename std::tuple_element<2, std::tuple<Args...>>::type EQUAL_TYPE;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/string_util.hpp

@@ -170,6 +170,18 @@ public:
 	//! Equivalent to calling TopNLevenshtein followed by CandidatesMessage
 	DUCKDB_API static string CandidatesErrorMessage(const vector<string> &strings, const string &target,
 	                                                const string &message_prefix, idx_t n = 5);
+
+	//! Returns true if two null-terminated strings are equal or point to the same address.
+	//! Returns false if only one of the strings is nullptr
+	DUCKDB_API static bool Equals(const char *s1, const char *s2) {
+		if (s1 == s2) {
+			return true;
+		}
+		if (s1 == nullptr || s2 == nullptr) {
+			return false;
+		}
+		return strcmp(s1, s2) == 0;
+	}
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/types/value.hpp

@@ -226,6 +226,8 @@ public:
 
 	//! Serializes a Value to a stand-alone binary blob
 	DUCKDB_API void Serialize(Serializer &serializer) const;
+	DUCKDB_API void FormatSerialize(FormatSerializer &serializer) const;
+	DUCKDB_API static Value FormatDeserialize(FormatDeserializer &deserializer);
 	//! Deserializes a Value from a blob
 	DUCKDB_API static Value Deserialize(Deserializer &source);
 
@@ -529,37 +531,6 @@ DUCKDB_API timestamp_t Value::GetValueUnsafe() const;
 template <>
 DUCKDB_API interval_t Value::GetValueUnsafe() const;
 
-template <>
-DUCKDB_API int8_t &Value::GetReferenceUnsafe();
-template <>
-DUCKDB_API int16_t &Value::GetReferenceUnsafe();
-template <>
-DUCKDB_API int32_t &Value::GetReferenceUnsafe();
-template <>
-DUCKDB_API int64_t &Value::GetReferenceUnsafe();
-template <>
-DUCKDB_API hugeint_t &Value::GetReferenceUnsafe();
-template <>
-DUCKDB_API uint8_t &Value::GetReferenceUnsafe();
-template <>
-DUCKDB_API uint16_t &Value::GetReferenceUnsafe();
-template <>
-DUCKDB_API uint32_t &Value::GetReferenceUnsafe();
-template <>
-DUCKDB_API uint64_t &Value::GetReferenceUnsafe();
-template <>
-DUCKDB_API float &Value::GetReferenceUnsafe();
-template <>
-DUCKDB_API double &Value::GetReferenceUnsafe();
-template <>
-DUCKDB_API date_t &Value::GetReferenceUnsafe();
-template <>
-DUCKDB_API dtime_t &Value::GetReferenceUnsafe();
-template <>
-DUCKDB_API timestamp_t &Value::GetReferenceUnsafe();
-template <>
-DUCKDB_API interval_t &Value::GetReferenceUnsafe();
-
 template <>
 DUCKDB_API bool Value::IsNan(float input);
 template <>

package/src/duckdb/src/include/duckdb/common/types/vector.hpp

@@ -162,6 +162,9 @@ public:
 	//! Deserializes a blob back into a Vector
 	DUCKDB_API void Deserialize(idx_t count, Deserializer &source);
 
+	DUCKDB_API void FormatSerialize(FormatSerializer &serializer, idx_t count);
+	DUCKDB_API void FormatDeserialize(FormatDeserializer &deserializer, idx_t count);
+
 	// Getters
 	inline VectorType GetVectorType() const {
 		return vector_type;

package/src/duckdb/src/include/duckdb/common/types.hpp

@@ -17,6 +17,8 @@
 
 namespace duckdb {
 
+class FormatSerializer;
+class FormatDeserializer;
 class Serializer;
 class Deserializer;
 class Value;
@@ -46,7 +48,7 @@ public:
 public:
 	DUCKDB_API hugeint_t() = default;
 	DUCKDB_API hugeint_t(int64_t value); // NOLINT: Allow implicit conversion from `int64_t`
-	DUCKDB_API constexpr hugeint_t(int64_t upper, uint64_t lower): lower(lower), upper(upper) {};
+	DUCKDB_API constexpr hugeint_t(int64_t upper, uint64_t lower): lower(lower), upper(upper) {}
 	DUCKDB_API constexpr hugeint_t(const hugeint_t &rhs) = default;
 	DUCKDB_API constexpr hugeint_t(hugeint_t &&rhs) = default;
 	DUCKDB_API hugeint_t &operator=(const hugeint_t &rhs) = default;
@@ -288,8 +290,8 @@ enum class LogicalTypeId : uint8_t {
 	UNION = 107
 };
 
-struct ExtraTypeInfo;
 
+struct ExtraTypeInfo;
 
 struct aggregate_state_t;
 
@@ -349,6 +351,10 @@ struct LogicalType {
 	//! Deserializes a blob back into an LogicalType
 	DUCKDB_API static LogicalType Deserialize(Deserializer &source);
 
+	DUCKDB_API void FormatSerialize(FormatSerializer &serializer) const;
+	DUCKDB_API static LogicalType FormatDeserialize(FormatDeserializer &deserializer);
+
+
 	DUCKDB_API static bool TypeIsTimestamp(LogicalTypeId id) {
 		return (id == LogicalTypeId::TIMESTAMP ||
 				id == LogicalTypeId::TIMESTAMP_MS ||

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

@@ -11,9 +11,36 @@
 #include "duckdb/function/function_set.hpp"
 #include "re2/re2.h"
 #include "duckdb/function/built_in_functions.hpp"
+#include "re2/stringpiece.h"
 
 namespace duckdb {
 
+namespace regexp_util {
+
+bool TryParseConstantPattern(ClientContext &context, Expression &expr, string &constant_string);
+void ParseRegexOptions(const string &options, duckdb_re2::RE2::Options &result, bool *global_replace = nullptr);
+void ParseRegexOptions(ClientContext &context, Expression &expr, RE2::Options &target, bool *global_replace = nullptr);
+
+inline duckdb_re2::StringPiece CreateStringPiece(const string_t &input) {
+	return duckdb_re2::StringPiece(input.GetDataUnsafe(), input.GetSize());
+}
+
+inline string_t Extract(const string_t &input, Vector &result, const RE2 &re, const duckdb_re2::StringPiece &rewrite) {
+	string extracted;
+	RE2::Extract(input.GetString(), re, rewrite, &extracted);
+	return StringVector::AddString(result, extracted.c_str(), extracted.size());
+}
+
+} // namespace regexp_util
+
+struct RegexpExtractAll {
+	static void Execute(DataChunk &args, ExpressionState &state, Vector &result);
+	static unique_ptr<FunctionData> Bind(ClientContext &context, ScalarFunction &bound_function,
+	                                     vector<unique_ptr<Expression>> &arguments);
+	static unique_ptr<FunctionLocalState> InitLocalState(ExpressionState &state, const BoundFunctionExpression &expr,
+	                                                     FunctionData *bind_data);
+};
+
 struct RegexpBaseBindData : public FunctionData {
 	RegexpBaseBindData();
 	RegexpBaseBindData(duckdb_re2::RE2::Options options, string constant_string, bool constant_pattern = true);
@@ -61,14 +88,67 @@ struct RegexpExtractBindData : public RegexpBaseBindData {
 	bool Equals(const FunctionData &other_p) const override;
 };
 
+struct RegexStringPieceArgs {
+	RegexStringPieceArgs() : size(0), capacity(0), group_buffer(nullptr) {
+	}
+	void Init(idx_t size) {
+		this->size = size;
+		// Allocate for one extra, for the all-encompassing match group
+		this->capacity = size + 1;
+		group_buffer = AllocateArray<duckdb_re2::StringPiece>(capacity);
+	}
+	void SetSize(idx_t size) {
+		this->size = size;
+		if (size + 1 > capacity) {
+			Clear();
+			Init(size);
+		}
+	}
+
+	RegexStringPieceArgs &operator=(RegexStringPieceArgs &&other) {
+		std::swap(this->size, other.size);
+		std::swap(this->capacity, other.capacity);
+		std::swap(this->group_buffer, other.group_buffer);
+		return *this;
+	}
+
+	~RegexStringPieceArgs() {
+		Clear();
+	}
+
+private:
+	void Clear() {
+		DeleteArray<duckdb_re2::StringPiece>(group_buffer, capacity);
+		group_buffer = nullptr;
+
+		size = 0;
+		capacity = 0;
+	}
+
+public:
+	idx_t size;
+	//! The currently allocated capacity for the groups
+	idx_t capacity;
+	//! Used by ExtractAll to pre-allocate the storage for the groups
+	duckdb_re2::StringPiece *group_buffer;
+};
+
 struct RegexLocalState : public FunctionLocalState {
-	explicit RegexLocalState(RegexpBaseBindData &info)
+	explicit RegexLocalState(RegexpBaseBindData &info, bool extract_all = false)
 	    : constant_pattern(duckdb_re2::StringPiece(info.constant_string.c_str(), info.constant_string.size()),
 	                       info.options) {
+		if (extract_all) {
+			auto group_count_p = constant_pattern.NumberOfCapturingGroups();
+			if (group_count_p != -1) {
+				group_buffer.Init(group_count_p);
+			}
+		}
 		D_ASSERT(info.constant_pattern);
 	}
 
 	RE2 constant_pattern;
+	//! Used by regexp_extract_all to pre-allocate the args
+	RegexStringPieceArgs group_buffer;
 };
 
 unique_ptr<FunctionLocalState> RegexInitLocalState(ExpressionState &state, const BoundFunctionExpression &expr,

package/src/duckdb/src/include/duckdb/main/extension_entries.hpp

@@ -55,6 +55,7 @@ static constexpr ExtensionEntry EXTENSION_FUNCTIONS[] = {
     {"json_transform_strict", "json"},
     {"json_type", "json"},
     {"json_valid", "json"},
+    {"json_serialize_sql", "json"},
     {"make_timestamptz", "icu"},
     {"parquet_metadata", "parquet"},
     {"parquet_scan", "parquet"},

package/src/duckdb/src/include/duckdb/parser/common_table_expression_info.hpp

@@ -18,6 +18,8 @@ struct CommonTableExpressionInfo {
 	vector<string> aliases;
 	unique_ptr<SelectStatement> query;
 
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static unique_ptr<CommonTableExpressionInfo> FormatDeserialize(FormatDeserializer &deserializer);
 	unique_ptr<CommonTableExpressionInfo> Copy();
 };
 

package/src/duckdb/src/include/duckdb/parser/expression/between_expression.hpp

@@ -31,6 +31,9 @@ public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
 
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ParsedExpression> FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer);
+
 public:
 	template <class T, class BASE>
 	static string ToString(const T &entry) {

package/src/duckdb/src/include/duckdb/parser/expression/bound_expression.hpp

@@ -33,6 +33,8 @@ public:
 	unique_ptr<ParsedExpression> Copy() const override;
 
 	void Serialize(FieldWriter &writer) const override;
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/expression/case_expression.hpp

@@ -16,6 +16,9 @@ namespace duckdb {
 struct CaseCheck {
 	unique_ptr<ParsedExpression> when_expr;
 	unique_ptr<ParsedExpression> then_expr;
+
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static CaseCheck FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 //! The CaseExpression represents a CASE expression in the query
@@ -35,6 +38,8 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ParsedExpression> FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer);
 
 public:
 	template <class T, class BASE>

package/src/duckdb/src/include/duckdb/parser/expression/cast_expression.hpp

@@ -34,6 +34,8 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ParsedExpression> FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer);
 
 public:
 	template <class T, class BASE>

package/src/duckdb/src/include/duckdb/parser/expression/collate_expression.hpp

@@ -31,5 +31,7 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ParsedExpression> FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/expression/columnref_expression.hpp

@@ -45,5 +45,7 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ParsedExpression> FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/expression/comparison_expression.hpp

@@ -30,6 +30,8 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ParsedExpression> FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer);
 
 public:
 	template <class T, class BASE>

package/src/duckdb/src/include/duckdb/parser/expression/conjunction_expression.hpp

@@ -34,6 +34,8 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ParsedExpression> FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer);
 
 public:
 	template <class T, class BASE>

package/src/duckdb/src/include/duckdb/parser/expression/constant_expression.hpp

@@ -31,6 +31,9 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ParsedExpression> FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/expression/default_expression.hpp

@@ -27,5 +27,6 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
+	void FormatSerialize(FormatSerializer &serializer) const override;
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/expression/function_expression.hpp

@@ -55,6 +55,8 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ParsedExpression> FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer);
 
 	void Verify() const override;
 

package/src/duckdb/src/include/duckdb/parser/expression/lambda_expression.hpp

@@ -37,6 +37,8 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ParsedExpression> FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/expression/operator_expression.hpp

@@ -32,6 +32,8 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ParsedExpression> FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer);
 
 public:
 	template <class T, class BASE>

package/src/duckdb/src/include/duckdb/parser/expression/parameter_expression.hpp

@@ -34,5 +34,7 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ParsedExpression> FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/expression/positional_reference_expression.hpp

@@ -30,5 +30,7 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ParsedExpression> FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/expression/star_expression.hpp

@@ -38,5 +38,7 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ParsedExpression> FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/expression/subquery_expression.hpp

@@ -45,5 +45,7 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ParsedExpression> FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/expression/window_expression.hpp

@@ -25,6 +25,8 @@ enum class WindowBoundary : uint8_t {
 	EXPR_FOLLOWING_RANGE = 8
 };
 
+const char *ToString(WindowBoundary value);
+
 //! The WindowExpression represents a window function in the query. They are a special case of aggregates which is why
 //! they inherit from them.
 class WindowExpression : public ParsedExpression {
@@ -71,6 +73,8 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ParsedExpression> FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer);
 
 public:
 	template <class T, class BASE, class ORDER_NODE>
@@ -200,4 +204,5 @@ public:
 		return result;
 	}
 };
+
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/parsed_data/sample_options.hpp

@@ -29,6 +29,8 @@ struct SampleOptions {
 	void Serialize(Serializer &serializer);
 	static unique_ptr<SampleOptions> Deserialize(Deserializer &source);
 	static bool Equals(SampleOptions *a, SampleOptions *b);
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static unique_ptr<SampleOptions> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/parsed_expression.hpp

@@ -19,6 +19,8 @@ class Serializer;
 class Deserializer;
 class FieldWriter;
 class FieldReader;
+class FormatDeserializer;
+class FormatSerializer;
 
 //!  The ParsedExpression class is a base class that can represent any expression
 //!  part of a SQL statement.
@@ -60,6 +62,9 @@ public:
 	//! SerializationException]
 	static unique_ptr<ParsedExpression> Deserialize(Deserializer &source);
 
+	virtual void FormatSerialize(FormatSerializer &serializer) const;
+	static unique_ptr<ParsedExpression> FormatDeserialize(FormatDeserializer &deserializer);
+
 protected:
 	//! Copy base Expression properties from another expression to this one,
 	//! used in Copy method

package/src/duckdb/src/include/duckdb/parser/query_node/recursive_cte_node.hpp

@@ -44,6 +44,9 @@ public:
 	void Serialize(FieldWriter &writer) const override;
 	//! Deserializes a blob back into a QueryNode
 	static unique_ptr<QueryNode> Deserialize(FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<QueryNode> FormatDeserialize(FormatDeserializer &source);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/query_node/select_node.hpp

@@ -49,13 +49,18 @@ public:
 	string ToString() const override;
 
 	bool Equals(const QueryNode *other) const override;
+
 	//! Create a copy of this SelectNode
 	unique_ptr<QueryNode> Copy() const override;
 
 	//! Serializes a QueryNode to a stand-alone binary blob
 	void Serialize(FieldWriter &writer) const override;
+
 	//! Deserializes a blob back into a QueryNode
 	static unique_ptr<QueryNode> Deserialize(FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<QueryNode> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/query_node/set_operation_node.hpp

@@ -43,6 +43,9 @@ public:
 	void Serialize(FieldWriter &writer) const override;
 	//! Deserializes a blob back into a QueryNode
 	static unique_ptr<QueryNode> Deserialize(FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<QueryNode> FormatDeserialize(FormatDeserializer &source);
 };
 
 } // namespace duckdb