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

package/src/duckdb/src/include/duckdb/execution/operator/scan/csv/csv_reader_options.hpp

@@ -12,7 +12,6 @@
 #include "duckdb/common/map.hpp"
 #include "duckdb/function/scalar/strftime_format.hpp"
 #include "duckdb/common/types/value.hpp"
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/case_insensitive_map.hpp"
 #include "duckdb/common/types.hpp"
 #include "duckdb/common/multi_file_reader_options.hpp"
@@ -45,9 +44,6 @@ struct CSVStateMachineOptions {
 	bool operator==(const CSVStateMachineOptions &other) const {
 		return delimiter == other.delimiter && quote == other.quote && escape == other.escape;
 	}
-
-	void Serialize(FieldWriter &writer) const;
-	void Deserialize(FieldReader &reader);
 };
 
 struct DialectOptions {
@@ -66,9 +62,6 @@ struct DialectOptions {
 	idx_t skip_rows = 0;
 	//! True start of the first CSV Buffer (After skipping empty lines, headers, notes and so on)
 	idx_t true_start = 0;
-
-	void Serialize(FieldWriter &writer) const;
-	void Deserialize(FieldReader &reader);
 };
 
 struct CSVReaderOptions {
@@ -169,10 +162,8 @@ struct CSVReaderOptions {
 	//! The date format to use for writing (if any is specified)
 	map<LogicalTypeId, StrfTimeFormat> write_date_format = {{LogicalTypeId::DATE, {}}, {LogicalTypeId::TIMESTAMP, {}}};
 
-	void Serialize(FieldWriter &writer) const;
-	void Deserialize(FieldReader &reader);
-	void FormatSerialize(FormatSerializer &serializer) const;
-	static CSVReaderOptions FormatDeserialize(FormatDeserializer &deserializer);
+	void Serialize(Serializer &serializer) const;
+	static CSVReaderOptions Deserialize(Deserializer &deserializer);
 
 	void SetCompression(const string &compression);
 	void SetHeader(bool has_header);

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

@@ -46,15 +46,9 @@ typedef void (*aggregate_window_t)(Vector inputs[], const ValidityMask &filter_m
                                    const FrameBounds &frame, const FrameBounds &prev, Vector &result, idx_t rid,
                                    idx_t bias);
 
-typedef void (*aggregate_serialize_t)(FieldWriter &writer, const FunctionData *bind_data,
+typedef void (*aggregate_serialize_t)(Serializer &serializer, const optional_ptr<FunctionData> bind_data,
                                       const AggregateFunction &function);
-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);
+typedef unique_ptr<FunctionData> (*aggregate_deserialize_t)(Deserializer &deserializer, AggregateFunction &function);
 
 class AggregateFunction : public BaseScalarFunction {
 public:
@@ -70,8 +64,7 @@ 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), format_serialize(nullptr), format_deserialize(nullptr),
-	      order_dependent(AggregateOrderDependent::ORDER_DEPENDENT) {
+	      serialize(serialize), deserialize(deserialize), order_dependent(AggregateOrderDependent::ORDER_DEPENDENT) {
 	}
 
 	AggregateFunction(const string &name, const vector<LogicalType> &arguments, const LogicalType &return_type,
@@ -85,8 +78,7 @@ 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), format_serialize(nullptr), format_deserialize(nullptr),
-	      order_dependent(AggregateOrderDependent::ORDER_DEPENDENT) {
+	      serialize(serialize), deserialize(deserialize), order_dependent(AggregateOrderDependent::ORDER_DEPENDENT) {
 	}
 
 	AggregateFunction(const vector<LogicalType> &arguments, const LogicalType &return_type, aggregate_size_t state_size,
@@ -137,8 +129,6 @@ 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/copy_function.hpp

@@ -82,10 +82,10 @@ typedef void (*copy_to_combine_t)(ExecutionContext &context, FunctionData &bind_
                                   LocalFunctionData &lstate);
 typedef void (*copy_to_finalize_t)(ClientContext &context, FunctionData &bind_data, GlobalFunctionData &gstate);
 
-typedef void (*copy_to_serialize_t)(FieldWriter &writer, const FunctionData &bind_data, const CopyFunction &function);
+typedef void (*copy_to_serialize_t)(Serializer &serializer, const FunctionData &bind_data,
+                                    const CopyFunction &function);
 
-typedef unique_ptr<FunctionData> (*copy_to_deserialize_t)(ClientContext &context, FieldReader &reader,
-                                                          CopyFunction &function);
+typedef unique_ptr<FunctionData> (*copy_to_deserialize_t)(Deserializer &deserializer, CopyFunction &function);
 
 typedef unique_ptr<FunctionData> (*copy_from_bind_t)(ClientContext &context, CopyInfo &info,
                                                      vector<string> &expected_names,

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

@@ -8,111 +8,27 @@
 
 #pragma once
 
-#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"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 
 namespace duckdb {
 
 class FunctionSerializer {
 public:
 	template <class FUNC>
-	static void SerializeBase(FieldWriter &writer, const FUNC &function, FunctionData *bind_info) {
-		D_ASSERT(!function.name.empty());
-		writer.WriteString(function.name);
-		writer.WriteRegularSerializableList(function.arguments);
-		writer.WriteRegularSerializableList(function.original_arguments);
-		bool serialize = function.serialize;
-		writer.WriteField(serialize);
-		if (serialize) {
-			function.serialize(writer, bind_info, function);
-			// First check if serialize throws a NotImplementedException, in which case it doesn't require a deserialize
-			// function
-			D_ASSERT(function.deserialize);
-		}
-	}
-
-	template <class FUNC>
-	static void Serialize(FieldWriter &writer, const FUNC &function, const LogicalType &return_type,
-	                      const vector<unique_ptr<Expression>> &children, FunctionData *bind_info) {
-		SerializeBase(writer, function, bind_info);
-		writer.WriteSerializable(return_type);
-		writer.WriteSerializableList(children);
-	}
-
-	template <class FUNC, class CATALOG_ENTRY>
-	static FUNC DeserializeBaseInternal(FieldReader &reader, PlanDeserializationState &state, CatalogType type,
-	                                    unique_ptr<FunctionData> &bind_info, bool &has_deserialize) {
-		auto &context = state.context;
-		auto name = reader.ReadRequired<string>();
-		auto arguments = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
-		// note: original_arguments are optional (can be list of size 0)
-		auto original_arguments = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
-
-		auto &func_catalog = Catalog::GetEntry(context, type, SYSTEM_CATALOG, DEFAULT_SCHEMA, name);
-		if (func_catalog.type != type) {
-			throw InternalException("Cant find catalog entry for function %s", name);
-		}
-
-		auto &functions = func_catalog.Cast<CATALOG_ENTRY>();
-		auto function = functions.functions.GetFunctionByArguments(
-		    state.context, original_arguments.empty() ? arguments : original_arguments);
-		function.arguments = std::move(arguments);
-		function.original_arguments = std::move(original_arguments);
-
-		has_deserialize = reader.ReadRequired<bool>();
-		if (has_deserialize) {
-			if (!function.deserialize) {
-				throw SerializationException("Function requires deserialization but no deserialization function for %s",
-				                             function.name);
-			}
-			bind_info = function.deserialize(state, reader, function);
-		} else {
-			D_ASSERT(!function.serialize);
-			D_ASSERT(!function.deserialize);
-		}
-		return function;
-	}
-	template <class FUNC, class CATALOG_ENTRY>
-	static FUNC DeserializeBase(FieldReader &reader, PlanDeserializationState &state, CatalogType type,
-	                            unique_ptr<FunctionData> &bind_info) {
-		bool has_deserialize;
-		return DeserializeBaseInternal<FUNC, CATALOG_ENTRY>(reader, state, type, bind_info, has_deserialize);
-	}
-
-	template <class FUNC, class CATALOG_ENTRY>
-	static FUNC Deserialize(FieldReader &reader, ExpressionDeserializationState &state, CatalogType type,
-	                        vector<unique_ptr<Expression>> &children, unique_ptr<FunctionData> &bind_info) {
-		bool has_deserialize;
-		auto function =
-		    DeserializeBaseInternal<FUNC, CATALOG_ENTRY>(reader, state.gstate, type, bind_info, has_deserialize);
-		auto return_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
-		children = reader.ReadRequiredSerializableList<Expression>(state.gstate);
-
-		// we re-bind the function only if the function did not have an explicit deserialize method
-		auto &context = state.gstate.context;
-		if (!has_deserialize && function.bind) {
-			bind_info = function.bind(context, function, children);
-		}
-		function.return_type = return_type;
-		return function;
-	}
-
-	template <class FUNC>
-	static void FormatSerialize(FormatSerializer &serializer, const FUNC &function,
-	                            optional_ptr<FunctionData> bind_info) {
+	static void Serialize(Serializer &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;
+		bool has_serialize = function.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);
+			                       [&](Serializer &obj) { function.serialize(obj, bind_info, function); });
+			D_ASSERT(function.deserialize);
 		}
 	}
 
@@ -132,7 +48,7 @@ public:
 	}
 
 	template <class FUNC, class CATALOG_ENTRY>
-	static pair<FUNC, bool> FormatDeserializeBase(FormatDeserializer &deserializer, CatalogType catalog_type) {
+	static pair<FUNC, bool> DeserializeBase(Deserializer &deserializer, CatalogType catalog_type) {
 		auto &context = deserializer.Get<ClientContext &>();
 		auto name = deserializer.ReadProperty<string>(500, "name");
 		auto arguments = deserializer.ReadProperty<vector<LogicalType>>(501, "arguments");
@@ -144,23 +60,23 @@ public:
 	}
 
 	template <class FUNC>
-	static unique_ptr<FunctionData> FunctionDeserialize(FormatDeserializer &deserializer, FUNC &function) {
-		if (!function.format_deserialize) {
+	static unique_ptr<FunctionData> FunctionDeserialize(Deserializer &deserializer, FUNC &function) {
+		if (!function.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); });
+		                        [&](Deserializer &obj) { result = function.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) {
+	static pair<FUNC, unique_ptr<FunctionData>> Deserialize(Deserializer &deserializer, CatalogType catalog_type,
+	                                                        vector<unique_ptr<Expression>> &children,
+	                                                        LogicalType return_type) {
 		auto &context = deserializer.Get<ClientContext &>();
-		auto entry = FormatDeserializeBase<FUNC, CATALOG_ENTRY>(deserializer, catalog_type);
+		auto entry = DeserializeBase<FUNC, CATALOG_ENTRY>(deserializer, catalog_type);
 		auto &function = entry.first;
 		auto has_serialize = entry.second;
 
@@ -175,6 +91,7 @@ public:
 				throw SerializationException("Error during bind of function in deserialization: %s", ex.what());
 			}
 		}
+		function.return_type = std::move(return_type);
 		return make_pair(std::move(function), std::move(bind_data));
 	}
 };

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

@@ -45,15 +45,9 @@ public:
 
 	virtual string ToSQL(const string &schema, const string &name) const;
 
-	void Serialize(Serializer &serializer) const;
+	virtual 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;
-
 public:
 	template <class TARGET>
 	TARGET &Cast() {

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

@@ -12,9 +12,10 @@
 #include "duckdb/function/scalar_function.hpp"
 #include "duckdb/common/map.hpp"
 #include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/function/built_in_functions.hpp"
 #include "duckdb/function/scalar/list/contains_or_position.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 
 namespace duckdb {
 
@@ -58,19 +59,17 @@ struct VariableReturnBindData : public FunctionData {
 		return make_uniq<VariableReturnBindData>(stype);
 	}
 	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (const VariableReturnBindData &)other_p;
+		auto &other = other_p.Cast<VariableReturnBindData>();
 		return stype == other.stype;
 	}
-
-	static void Serialize(FieldWriter &writer, const FunctionData *bind_data_p, const ScalarFunction &function) {
-		D_ASSERT(bind_data_p);
-		auto &info = bind_data_p->Cast<VariableReturnBindData>();
-		writer.WriteSerializable(info.stype);
+	static void Serialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data,
+	                      const ScalarFunction &function) {
+		auto &info = bind_data->Cast<VariableReturnBindData>();
+		serializer.WriteProperty(100, "variable_return_type", info.stype);
 	}
 
-	static unique_ptr<FunctionData> Deserialize(PlanDeserializationState &context, FieldReader &reader,
-	                                            ScalarFunction &bound_function) {
-		auto stype = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
+	static unique_ptr<FunctionData> Deserialize(Deserializer &deserializer, ScalarFunction &bound_function) {
+		auto stype = deserializer.ReadProperty<LogicalType>(100, "variable_return_type");
 		return make_uniq<VariableReturnBindData>(std::move(stype));
 	}
 };

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

@@ -150,8 +150,8 @@ public:
 	date_t ParseDate(string_t str);
 	timestamp_t ParseTimestamp(string_t str);
 
-	void FormatSerialize(FormatSerializer &serializer) const;
-	static StrpTimeFormat FormatDeserialize(FormatDeserializer &deserializer);
+	void Serialize(Serializer &serializer) const;
+	static StrpTimeFormat Deserialize(Deserializer &deserializer);
 
 protected:
 	static string FormatStrpTimeError(const string &input, idx_t position);

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

@@ -14,7 +14,6 @@
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/execution/expression_executor_state.hpp"
 #include "duckdb/function/function.hpp"
-#include "duckdb/planner/plan_serialization.hpp"
 #include "duckdb/storage/statistics/base_statistics.hpp"
 #include "duckdb/common/optional_ptr.hpp"
 
@@ -64,15 +63,9 @@ typedef unique_ptr<BaseStatistics> (*function_statistics_t)(ClientContext &conte
 //! Adds the dependencies of this BoundFunctionExpression to the set of dependencies
 typedef void (*dependency_function_t)(BoundFunctionExpression &expr, DependencyList &dependencies);
 
-typedef void (*function_serialize_t)(FieldWriter &writer, const FunctionData *bind_data,
+typedef void (*function_serialize_t)(Serializer &serializer, const optional_ptr<FunctionData> bind_data,
                                      const ScalarFunction &function);
-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);
+typedef unique_ptr<FunctionData> (*function_deserialize_t)(Deserializer &deserializer, ScalarFunction &function);
 
 class ScalarFunction : public BaseScalarFunction {
 public:
@@ -105,9 +98,6 @@ 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/scalar_macro_function.hpp

@@ -34,13 +34,8 @@ public:
 
 	string ToSQL(const string &schema, const string &name) const override;
 
-	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;
+	void Serialize(Serializer &serializer) const override;
+	static unique_ptr<MacroFunction> Deserialize(Deserializer &deserializer);
 };
 
 } // namespace duckdb

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

@@ -65,20 +65,8 @@ struct ColumnInfo {
 		names = std::move(names_p);
 		types = std::move(types_p);
 	}
-	void Serialize(FieldWriter &writer) const {
-		writer.WriteList<string>(names);
-		writer.WriteRegularSerializableList<LogicalType>(types);
-	}
-
-	static ColumnInfo Deserialize(FieldReader &reader) {
-		ColumnInfo info;
-		info.names = reader.ReadRequiredList<string>();
-		info.types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
-		return info;
-	}
-
-	void FormatSerialize(FormatSerializer &serializer) const;
-	static ColumnInfo FormatDeserialize(FormatDeserializer &deserializer);
+	void Serialize(Serializer &serializer) const;
+	static ColumnInfo Deserialize(Deserializer &deserializer);
 
 	vector<std::string> names;
 	vector<LogicalType> types;
@@ -115,8 +103,8 @@ struct ReadCSVData : public BaseCSVData {
 	}
 	void FinalizeRead(ClientContext &context);
 
-	void FormatSerialize(FormatSerializer &serializer) const;
-	static unique_ptr<ReadCSVData> FormatDeserialize(FormatDeserializer &deserializer);
+	void Serialize(Serializer &serializer) const;
+	static unique_ptr<ReadCSVData> Deserialize(Deserializer &deserializer);
 };
 
 struct CSVCopyFunction {

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

@@ -202,16 +202,9 @@ typedef void (*table_function_pushdown_complex_filter_t)(ClientContext &context,
                                                          vector<unique_ptr<Expression>> &filters);
 typedef string (*table_function_to_string_t)(const FunctionData *bind_data);
 
-typedef void (*table_function_serialize_t)(FieldWriter &writer, const FunctionData *bind_data,
+typedef void (*table_function_serialize_t)(Serializer &serializer, const optional_ptr<FunctionData> bind_data,
                                            const TableFunction &function);
-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);
+typedef unique_ptr<FunctionData> (*table_function_deserialize_t)(Deserializer &deserializer, TableFunction &function);
 
 class TableFunction : public SimpleNamedParameterFunction {
 public:
@@ -271,8 +264,6 @@ 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/function/table_macro_function.hpp

@@ -34,13 +34,8 @@ public:
 
 	string ToSQL(const string &schema, const string &name) const override;
 
-	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;
+	void Serialize(Serializer &serializer) const override;
+	static unique_ptr<MacroFunction> Deserialize(Deserializer &deserializer);
 };
 
 } // namespace duckdb

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

@@ -19,8 +19,11 @@
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/main/external_dependencies.hpp"
 #include "duckdb/parser/statement/explain_statement.hpp"
-
-#include <memory>
+#include "duckdb/parser/parsed_expression.hpp"
+#include "duckdb/parser/result_modifier.hpp"
+#include "duckdb/common/unique_ptr.hpp"
+#include "duckdb/common/vector.hpp"
+#include "duckdb/common/helper.hpp"
 
 namespace duckdb {
 struct BoundStatement;
@@ -81,9 +84,12 @@ public:
 	DUCKDB_API shared_ptr<Relation> Project(const string &select_list, const vector<string> &aliases);
 	DUCKDB_API shared_ptr<Relation> Project(const vector<string> &expressions);
 	DUCKDB_API shared_ptr<Relation> Project(const vector<string> &expressions, const vector<string> &aliases);
+	DUCKDB_API shared_ptr<Relation> Project(vector<unique_ptr<ParsedExpression>> expressions,
+	                                        const vector<string> &aliases);
 
 	// FILTER
 	DUCKDB_API shared_ptr<Relation> Filter(const string &expression);
+	DUCKDB_API shared_ptr<Relation> Filter(unique_ptr<ParsedExpression> expression);
 	DUCKDB_API shared_ptr<Relation> Filter(const vector<string> &expressions);
 
 	// LIMIT
@@ -92,6 +98,7 @@ public:
 	// ORDER
 	DUCKDB_API shared_ptr<Relation> Order(const string &expression);
 	DUCKDB_API shared_ptr<Relation> Order(const vector<string> &expressions);
+	DUCKDB_API shared_ptr<Relation> Order(vector<OrderByNode> expressions);
 
 	// JOIN operation
 	DUCKDB_API shared_ptr<Relation> Join(const shared_ptr<Relation> &other, const string &condition,

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

@@ -65,10 +65,7 @@ public:
 	DUCKDB_API ColumnDefinition Copy() const;
 
 	DUCKDB_API void Serialize(Serializer &serializer) const;
-	DUCKDB_API static ColumnDefinition Deserialize(Deserializer &source);
-
-	DUCKDB_API void FormatSerialize(FormatSerializer &serializer) const;
-	DUCKDB_API static ColumnDefinition FormatDeserialize(FormatDeserializer &deserializer);
+	DUCKDB_API static ColumnDefinition Deserialize(Deserializer &deserializer);
 
 	//===--------------------------------------------------------------------===//
 	// Generated Columns (VIRTUAL)

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

@@ -9,7 +9,6 @@
 #pragma once
 
 #include "duckdb/parser/column_definition.hpp"
-#include "duckdb/common/field_writer.hpp"
 
 namespace duckdb {
 
@@ -51,11 +50,8 @@ public:
 	}
 
 	ColumnList Copy() const;
-	void Serialize(FieldWriter &writer) const;
-	static ColumnList Deserialize(FieldReader &reader);
-
-	void FormatSerialize(FormatSerializer &serializer) const;
-	static ColumnList FormatDeserialize(FormatDeserializer &deserializer);
+	void Serialize(Serializer &serializer) const;
+	static ColumnList Deserialize(Deserializer &deserializer);
 
 	DUCKDB_API ColumnListIterator Logical() const;
 	DUCKDB_API ColumnListIterator Physical() const;

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

@@ -20,8 +20,8 @@ struct CommonTableExpressionInfo {
 	unique_ptr<SelectStatement> query;
 	CTEMaterialize materialized = CTEMaterialize::CTE_MATERIALIZE_DEFAULT;
 
-	void FormatSerialize(FormatSerializer &serializer) const;
-	static unique_ptr<CommonTableExpressionInfo> FormatDeserialize(FormatDeserializer &deserializer);
+	void Serialize(Serializer &serializer) const;
+	static unique_ptr<CommonTableExpressionInfo> Deserialize(Deserializer &deserializer);
 	unique_ptr<CommonTableExpressionInfo> Copy();
 };
 

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

@@ -16,10 +16,6 @@ namespace duckdb {
 
 class Serializer;
 class Deserializer;
-class FormatSerializer;
-class FormatDeserializer;
-class FieldWriter;
-class FieldReader;
 
 //===--------------------------------------------------------------------===//
 // Constraint Types
@@ -63,15 +59,9 @@ public:
 	DUCKDB_API void Print() const;
 
 	DUCKDB_API virtual unique_ptr<Constraint> Copy() const = 0;
-	//! Serializes a Constraint to a stand-alone binary blob
-	DUCKDB_API void Serialize(Serializer &serializer) const;
-	//! Serializes a Constraint to a stand-alone binary blob
-	DUCKDB_API virtual void Serialize(FieldWriter &writer) const = 0;
-	//! Deserializes a blob back into a Constraint
-	DUCKDB_API static unique_ptr<Constraint> Deserialize(Deserializer &source);
 
-	DUCKDB_API virtual void FormatSerialize(FormatSerializer &serializer) const;
-	DUCKDB_API static unique_ptr<Constraint> FormatDeserialize(FormatDeserializer &deserializer);
+	DUCKDB_API virtual void Serialize(Serializer &serializer) const;
+	DUCKDB_API static unique_ptr<Constraint> Deserialize(Deserializer &deserializer);
 
 public:
 	template <class TARGET>

package/src/duckdb/src/include/duckdb/parser/constraints/check_constraint.hpp

@@ -30,11 +30,8 @@ public:
 
 	DUCKDB_API unique_ptr<Constraint> Copy() const override;
 
-	DUCKDB_API void Serialize(FieldWriter &writer) const override;
-	DUCKDB_API static unique_ptr<Constraint> Deserialize(FieldReader &source);
-
-	DUCKDB_API void FormatSerialize(FormatSerializer &serializer) const override;
-	DUCKDB_API static unique_ptr<Constraint> FormatDeserialize(FormatDeserializer &deserializer);
+	DUCKDB_API void Serialize(Serializer &serializer) const override;
+	DUCKDB_API static unique_ptr<Constraint> Deserialize(Deserializer &deserializer);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/constraints/foreign_key_constraint.hpp

@@ -31,13 +31,8 @@ public:
 
 	DUCKDB_API unique_ptr<Constraint> Copy() const override;
 
-	//! Serialize to a stand-alone binary blob
-	DUCKDB_API void Serialize(FieldWriter &writer) const override;
-	//! Deserializes a ParsedConstraint
-	DUCKDB_API static unique_ptr<Constraint> Deserialize(FieldReader &source);
-
-	DUCKDB_API void FormatSerialize(FormatSerializer &serializer) const override;
-	DUCKDB_API static unique_ptr<Constraint> FormatDeserialize(FormatDeserializer &deserializer);
+	DUCKDB_API void Serialize(Serializer &serializer) const override;
+	DUCKDB_API static unique_ptr<Constraint> Deserialize(Deserializer &deserializer);
 
 private:
 	ForeignKeyConstraint();

package/src/duckdb/src/include/duckdb/parser/constraints/not_null_constraint.hpp

@@ -28,13 +28,8 @@ public:
 
 	DUCKDB_API unique_ptr<Constraint> Copy() const override;
 
-	//! Serialize to a stand-alone binary blob
-	DUCKDB_API void Serialize(FieldWriter &writer) const override;
-	//! Deserializes a NotNullConstraint
-	DUCKDB_API static unique_ptr<Constraint> Deserialize(FieldReader &source);
-
-	DUCKDB_API void FormatSerialize(FormatSerializer &serializer) const override;
-	DUCKDB_API static unique_ptr<Constraint> FormatDeserialize(FormatDeserializer &deserializer);
+	DUCKDB_API void Serialize(Serializer &serializer) const override;
+	DUCKDB_API static unique_ptr<Constraint> Deserialize(Deserializer &deserializer);
 };
 
 } // namespace duckdb