duckdb 0.8.2-dev4126.0 → 0.8.2-dev4203.0

package/src/duckdb/src/storage/serialization/serialize_parsed_expression.cpp

@@ -3,19 +3,19 @@
 // Do not edit this file manually, your changes will be overwritten
 //===----------------------------------------------------------------------===//
 
-#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"
 #include "duckdb/parser/expression/list.hpp"
 
 namespace duckdb {
 
-void ParsedExpression::FormatSerialize(FormatSerializer &serializer) const {
+void ParsedExpression::Serialize(Serializer &serializer) const {
 	serializer.WriteProperty(100, "class", expression_class);
 	serializer.WriteProperty(101, "type", type);
 	serializer.WriteProperty(102, "alias", alias);
 }
 
-unique_ptr<ParsedExpression> ParsedExpression::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<ParsedExpression> ParsedExpression::Deserialize(Deserializer &deserializer) {
 	auto expression_class = deserializer.ReadProperty<ExpressionClass>(100, "class");
 	auto type = deserializer.ReadProperty<ExpressionType>(101, "type");
 	auto alias = deserializer.ReadProperty<string>(102, "alias");
@@ -23,55 +23,55 @@ unique_ptr<ParsedExpression> ParsedExpression::FormatDeserialize(FormatDeseriali
 	unique_ptr<ParsedExpression> result;
 	switch (expression_class) {
 	case ExpressionClass::BETWEEN:
-		result = BetweenExpression::FormatDeserialize(deserializer);
+		result = BetweenExpression::Deserialize(deserializer);
 		break;
 	case ExpressionClass::CASE:
-		result = CaseExpression::FormatDeserialize(deserializer);
+		result = CaseExpression::Deserialize(deserializer);
 		break;
 	case ExpressionClass::CAST:
-		result = CastExpression::FormatDeserialize(deserializer);
+		result = CastExpression::Deserialize(deserializer);
 		break;
 	case ExpressionClass::COLLATE:
-		result = CollateExpression::FormatDeserialize(deserializer);
+		result = CollateExpression::Deserialize(deserializer);
 		break;
 	case ExpressionClass::COLUMN_REF:
-		result = ColumnRefExpression::FormatDeserialize(deserializer);
+		result = ColumnRefExpression::Deserialize(deserializer);
 		break;
 	case ExpressionClass::COMPARISON:
-		result = ComparisonExpression::FormatDeserialize(deserializer);
+		result = ComparisonExpression::Deserialize(deserializer);
 		break;
 	case ExpressionClass::CONJUNCTION:
-		result = ConjunctionExpression::FormatDeserialize(deserializer);
+		result = ConjunctionExpression::Deserialize(deserializer);
 		break;
 	case ExpressionClass::CONSTANT:
-		result = ConstantExpression::FormatDeserialize(deserializer);
+		result = ConstantExpression::Deserialize(deserializer);
 		break;
 	case ExpressionClass::DEFAULT:
-		result = DefaultExpression::FormatDeserialize(deserializer);
+		result = DefaultExpression::Deserialize(deserializer);
 		break;
 	case ExpressionClass::FUNCTION:
-		result = FunctionExpression::FormatDeserialize(deserializer);
+		result = FunctionExpression::Deserialize(deserializer);
 		break;
 	case ExpressionClass::LAMBDA:
-		result = LambdaExpression::FormatDeserialize(deserializer);
+		result = LambdaExpression::Deserialize(deserializer);
 		break;
 	case ExpressionClass::OPERATOR:
-		result = OperatorExpression::FormatDeserialize(deserializer);
+		result = OperatorExpression::Deserialize(deserializer);
 		break;
 	case ExpressionClass::PARAMETER:
-		result = ParameterExpression::FormatDeserialize(deserializer);
+		result = ParameterExpression::Deserialize(deserializer);
 		break;
 	case ExpressionClass::POSITIONAL_REFERENCE:
-		result = PositionalReferenceExpression::FormatDeserialize(deserializer);
+		result = PositionalReferenceExpression::Deserialize(deserializer);
 		break;
 	case ExpressionClass::STAR:
-		result = StarExpression::FormatDeserialize(deserializer);
+		result = StarExpression::Deserialize(deserializer);
 		break;
 	case ExpressionClass::SUBQUERY:
-		result = SubqueryExpression::FormatDeserialize(deserializer);
+		result = SubqueryExpression::Deserialize(deserializer);
 		break;
 	case ExpressionClass::WINDOW:
-		result = WindowExpression::FormatDeserialize(deserializer);
+		result = WindowExpression::Deserialize(deserializer);
 		break;
 	default:
 		throw SerializationException("Unsupported type for deserialization of ParsedExpression!");
@@ -81,14 +81,14 @@ unique_ptr<ParsedExpression> ParsedExpression::FormatDeserialize(FormatDeseriali
 	return result;
 }
 
-void BetweenExpression::FormatSerialize(FormatSerializer &serializer) const {
-	ParsedExpression::FormatSerialize(serializer);
+void BetweenExpression::Serialize(Serializer &serializer) const {
+	ParsedExpression::Serialize(serializer);
 	serializer.WriteProperty(200, "input", input);
 	serializer.WriteProperty(201, "lower", lower);
 	serializer.WriteProperty(202, "upper", upper);
 }
 
-unique_ptr<ParsedExpression> BetweenExpression::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<ParsedExpression> BetweenExpression::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<BetweenExpression>(new BetweenExpression());
 	deserializer.ReadProperty(200, "input", result->input);
 	deserializer.ReadProperty(201, "lower", result->lower);
@@ -96,27 +96,27 @@ unique_ptr<ParsedExpression> BetweenExpression::FormatDeserialize(FormatDeserial
 	return std::move(result);
 }
 
-void CaseExpression::FormatSerialize(FormatSerializer &serializer) const {
-	ParsedExpression::FormatSerialize(serializer);
+void CaseExpression::Serialize(Serializer &serializer) const {
+	ParsedExpression::Serialize(serializer);
 	serializer.WriteProperty(200, "case_checks", case_checks);
 	serializer.WriteProperty(201, "else_expr", else_expr);
 }
 
-unique_ptr<ParsedExpression> CaseExpression::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<ParsedExpression> CaseExpression::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<CaseExpression>(new CaseExpression());
 	deserializer.ReadProperty(200, "case_checks", result->case_checks);
 	deserializer.ReadProperty(201, "else_expr", result->else_expr);
 	return std::move(result);
 }
 
-void CastExpression::FormatSerialize(FormatSerializer &serializer) const {
-	ParsedExpression::FormatSerialize(serializer);
+void CastExpression::Serialize(Serializer &serializer) const {
+	ParsedExpression::Serialize(serializer);
 	serializer.WriteProperty(200, "child", child);
 	serializer.WriteProperty(201, "cast_type", cast_type);
 	serializer.WriteProperty(202, "try_cast", try_cast);
 }
 
-unique_ptr<ParsedExpression> CastExpression::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<ParsedExpression> CastExpression::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<CastExpression>(new CastExpression());
 	deserializer.ReadProperty(200, "child", result->child);
 	deserializer.ReadProperty(201, "cast_type", result->cast_type);
@@ -124,76 +124,76 @@ unique_ptr<ParsedExpression> CastExpression::FormatDeserialize(FormatDeserialize
 	return std::move(result);
 }
 
-void CollateExpression::FormatSerialize(FormatSerializer &serializer) const {
-	ParsedExpression::FormatSerialize(serializer);
+void CollateExpression::Serialize(Serializer &serializer) const {
+	ParsedExpression::Serialize(serializer);
 	serializer.WriteProperty(200, "child", child);
 	serializer.WriteProperty(201, "collation", collation);
 }
 
-unique_ptr<ParsedExpression> CollateExpression::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<ParsedExpression> CollateExpression::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<CollateExpression>(new CollateExpression());
 	deserializer.ReadProperty(200, "child", result->child);
 	deserializer.ReadProperty(201, "collation", result->collation);
 	return std::move(result);
 }
 
-void ColumnRefExpression::FormatSerialize(FormatSerializer &serializer) const {
-	ParsedExpression::FormatSerialize(serializer);
+void ColumnRefExpression::Serialize(Serializer &serializer) const {
+	ParsedExpression::Serialize(serializer);
 	serializer.WriteProperty(200, "column_names", column_names);
 }
 
-unique_ptr<ParsedExpression> ColumnRefExpression::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<ParsedExpression> ColumnRefExpression::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<ColumnRefExpression>(new ColumnRefExpression());
 	deserializer.ReadProperty(200, "column_names", result->column_names);
 	return std::move(result);
 }
 
-void ComparisonExpression::FormatSerialize(FormatSerializer &serializer) const {
-	ParsedExpression::FormatSerialize(serializer);
+void ComparisonExpression::Serialize(Serializer &serializer) const {
+	ParsedExpression::Serialize(serializer);
 	serializer.WriteProperty(200, "left", left);
 	serializer.WriteProperty(201, "right", right);
 }
 
-unique_ptr<ParsedExpression> ComparisonExpression::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<ParsedExpression> ComparisonExpression::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<ComparisonExpression>(new ComparisonExpression(deserializer.Get<ExpressionType>()));
 	deserializer.ReadProperty(200, "left", result->left);
 	deserializer.ReadProperty(201, "right", result->right);
 	return std::move(result);
 }
 
-void ConjunctionExpression::FormatSerialize(FormatSerializer &serializer) const {
-	ParsedExpression::FormatSerialize(serializer);
+void ConjunctionExpression::Serialize(Serializer &serializer) const {
+	ParsedExpression::Serialize(serializer);
 	serializer.WriteProperty(200, "children", children);
 }
 
-unique_ptr<ParsedExpression> ConjunctionExpression::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<ParsedExpression> ConjunctionExpression::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<ConjunctionExpression>(new ConjunctionExpression(deserializer.Get<ExpressionType>()));
 	deserializer.ReadProperty(200, "children", result->children);
 	return std::move(result);
 }
 
-void ConstantExpression::FormatSerialize(FormatSerializer &serializer) const {
-	ParsedExpression::FormatSerialize(serializer);
+void ConstantExpression::Serialize(Serializer &serializer) const {
+	ParsedExpression::Serialize(serializer);
 	serializer.WriteProperty(200, "value", value);
 }
 
-unique_ptr<ParsedExpression> ConstantExpression::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<ParsedExpression> ConstantExpression::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<ConstantExpression>(new ConstantExpression());
 	deserializer.ReadProperty(200, "value", result->value);
 	return std::move(result);
 }
 
-void DefaultExpression::FormatSerialize(FormatSerializer &serializer) const {
-	ParsedExpression::FormatSerialize(serializer);
+void DefaultExpression::Serialize(Serializer &serializer) const {
+	ParsedExpression::Serialize(serializer);
 }
 
-unique_ptr<ParsedExpression> DefaultExpression::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<ParsedExpression> DefaultExpression::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<DefaultExpression>(new DefaultExpression());
 	return std::move(result);
 }
 
-void FunctionExpression::FormatSerialize(FormatSerializer &serializer) const {
-	ParsedExpression::FormatSerialize(serializer);
+void FunctionExpression::Serialize(Serializer &serializer) const {
+	ParsedExpression::Serialize(serializer);
 	serializer.WriteProperty(200, "function_name", function_name);
 	serializer.WriteProperty(201, "schema", schema);
 	serializer.WriteProperty(202, "children", children);
@@ -205,7 +205,7 @@ void FunctionExpression::FormatSerialize(FormatSerializer &serializer) const {
 	serializer.WriteProperty(208, "catalog", catalog);
 }
 
-unique_ptr<ParsedExpression> FunctionExpression::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<ParsedExpression> FunctionExpression::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<FunctionExpression>(new FunctionExpression());
 	deserializer.ReadProperty(200, "function_name", result->function_name);
 	deserializer.ReadProperty(201, "schema", result->schema);
@@ -220,54 +220,54 @@ unique_ptr<ParsedExpression> FunctionExpression::FormatDeserialize(FormatDeseria
 	return std::move(result);
 }
 
-void LambdaExpression::FormatSerialize(FormatSerializer &serializer) const {
-	ParsedExpression::FormatSerialize(serializer);
+void LambdaExpression::Serialize(Serializer &serializer) const {
+	ParsedExpression::Serialize(serializer);
 	serializer.WriteProperty(200, "lhs", lhs);
 	serializer.WriteProperty(201, "expr", expr);
 }
 
-unique_ptr<ParsedExpression> LambdaExpression::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<ParsedExpression> LambdaExpression::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<LambdaExpression>(new LambdaExpression());
 	deserializer.ReadProperty(200, "lhs", result->lhs);
 	deserializer.ReadProperty(201, "expr", result->expr);
 	return std::move(result);
 }
 
-void OperatorExpression::FormatSerialize(FormatSerializer &serializer) const {
-	ParsedExpression::FormatSerialize(serializer);
+void OperatorExpression::Serialize(Serializer &serializer) const {
+	ParsedExpression::Serialize(serializer);
 	serializer.WriteProperty(200, "children", children);
 }
 
-unique_ptr<ParsedExpression> OperatorExpression::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<ParsedExpression> OperatorExpression::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<OperatorExpression>(new OperatorExpression(deserializer.Get<ExpressionType>()));
 	deserializer.ReadProperty(200, "children", result->children);
 	return std::move(result);
 }
 
-void ParameterExpression::FormatSerialize(FormatSerializer &serializer) const {
-	ParsedExpression::FormatSerialize(serializer);
+void ParameterExpression::Serialize(Serializer &serializer) const {
+	ParsedExpression::Serialize(serializer);
 	serializer.WriteProperty(200, "identifier", identifier);
 }
 
-unique_ptr<ParsedExpression> ParameterExpression::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<ParsedExpression> ParameterExpression::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<ParameterExpression>(new ParameterExpression());
 	deserializer.ReadProperty(200, "identifier", result->identifier);
 	return std::move(result);
 }
 
-void PositionalReferenceExpression::FormatSerialize(FormatSerializer &serializer) const {
-	ParsedExpression::FormatSerialize(serializer);
+void PositionalReferenceExpression::Serialize(Serializer &serializer) const {
+	ParsedExpression::Serialize(serializer);
 	serializer.WriteProperty(200, "index", index);
 }
 
-unique_ptr<ParsedExpression> PositionalReferenceExpression::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<ParsedExpression> PositionalReferenceExpression::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<PositionalReferenceExpression>(new PositionalReferenceExpression());
 	deserializer.ReadProperty(200, "index", result->index);
 	return std::move(result);
 }
 
-void StarExpression::FormatSerialize(FormatSerializer &serializer) const {
-	ParsedExpression::FormatSerialize(serializer);
+void StarExpression::Serialize(Serializer &serializer) const {
+	ParsedExpression::Serialize(serializer);
 	serializer.WriteProperty(200, "relation_name", relation_name);
 	serializer.WriteProperty(201, "exclude_list", exclude_list);
 	serializer.WriteProperty(202, "replace_list", replace_list);
@@ -275,7 +275,7 @@ void StarExpression::FormatSerialize(FormatSerializer &serializer) const {
 	serializer.WritePropertyWithDefault(204, "expr", expr, unique_ptr<ParsedExpression>());
 }
 
-unique_ptr<ParsedExpression> StarExpression::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<ParsedExpression> StarExpression::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<StarExpression>(new StarExpression());
 	deserializer.ReadProperty(200, "relation_name", result->relation_name);
 	deserializer.ReadProperty(201, "exclude_list", result->exclude_list);
@@ -285,15 +285,15 @@ unique_ptr<ParsedExpression> StarExpression::FormatDeserialize(FormatDeserialize
 	return std::move(result);
 }
 
-void SubqueryExpression::FormatSerialize(FormatSerializer &serializer) const {
-	ParsedExpression::FormatSerialize(serializer);
+void SubqueryExpression::Serialize(Serializer &serializer) const {
+	ParsedExpression::Serialize(serializer);
 	serializer.WriteProperty(200, "subquery_type", subquery_type);
 	serializer.WriteProperty(201, "subquery", subquery);
 	serializer.WritePropertyWithDefault(202, "child", child, unique_ptr<ParsedExpression>());
 	serializer.WriteProperty(203, "comparison_type", comparison_type);
 }
 
-unique_ptr<ParsedExpression> SubqueryExpression::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<ParsedExpression> SubqueryExpression::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<SubqueryExpression>(new SubqueryExpression());
 	deserializer.ReadProperty(200, "subquery_type", result->subquery_type);
 	deserializer.ReadProperty(201, "subquery", result->subquery);
@@ -302,8 +302,8 @@ unique_ptr<ParsedExpression> SubqueryExpression::FormatDeserialize(FormatDeseria
 	return std::move(result);
 }
 
-void WindowExpression::FormatSerialize(FormatSerializer &serializer) const {
-	ParsedExpression::FormatSerialize(serializer);
+void WindowExpression::Serialize(Serializer &serializer) const {
+	ParsedExpression::Serialize(serializer);
 	serializer.WriteProperty(200, "function_name", function_name);
 	serializer.WriteProperty(201, "schema", schema);
 	serializer.WriteProperty(202, "catalog", catalog);
@@ -320,7 +320,7 @@ void WindowExpression::FormatSerialize(FormatSerializer &serializer) const {
 	serializer.WritePropertyWithDefault(213, "filter_expr", filter_expr, unique_ptr<ParsedExpression>());
 }
 
-unique_ptr<ParsedExpression> WindowExpression::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<ParsedExpression> WindowExpression::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<WindowExpression>(new WindowExpression(deserializer.Get<ExpressionType>()));
 	deserializer.ReadProperty(200, "function_name", result->function_name);
 	deserializer.ReadProperty(201, "schema", result->schema);

package/src/duckdb/src/storage/serialization/serialize_query_node.cpp

@@ -3,35 +3,35 @@
 // Do not edit this file manually, your changes will be overwritten
 //===----------------------------------------------------------------------===//
 
-#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"
 #include "duckdb/parser/query_node/list.hpp"
 
 namespace duckdb {
 
-void QueryNode::FormatSerialize(FormatSerializer &serializer) const {
+void QueryNode::Serialize(Serializer &serializer) const {
 	serializer.WriteProperty(100, "type", type);
 	serializer.WriteProperty(101, "modifiers", modifiers);
 	serializer.WriteProperty(102, "cte_map", cte_map);
 }
 
-unique_ptr<QueryNode> QueryNode::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<QueryNode> QueryNode::Deserialize(Deserializer &deserializer) {
 	auto type = deserializer.ReadProperty<QueryNodeType>(100, "type");
 	auto modifiers = deserializer.ReadProperty<vector<unique_ptr<ResultModifier>>>(101, "modifiers");
 	auto cte_map = deserializer.ReadProperty<CommonTableExpressionMap>(102, "cte_map");
 	unique_ptr<QueryNode> result;
 	switch (type) {
 	case QueryNodeType::CTE_NODE:
-		result = CTENode::FormatDeserialize(deserializer);
+		result = CTENode::Deserialize(deserializer);
 		break;
 	case QueryNodeType::RECURSIVE_CTE_NODE:
-		result = RecursiveCTENode::FormatDeserialize(deserializer);
+		result = RecursiveCTENode::Deserialize(deserializer);
 		break;
 	case QueryNodeType::SELECT_NODE:
-		result = SelectNode::FormatDeserialize(deserializer);
+		result = SelectNode::Deserialize(deserializer);
 		break;
 	case QueryNodeType::SET_OPERATION_NODE:
-		result = SetOperationNode::FormatDeserialize(deserializer);
+		result = SetOperationNode::Deserialize(deserializer);
 		break;
 	default:
 		throw SerializationException("Unsupported type for deserialization of QueryNode!");
@@ -41,15 +41,15 @@ unique_ptr<QueryNode> QueryNode::FormatDeserialize(FormatDeserializer &deseriali
 	return result;
 }
 
-void CTENode::FormatSerialize(FormatSerializer &serializer) const {
-	QueryNode::FormatSerialize(serializer);
+void CTENode::Serialize(Serializer &serializer) const {
+	QueryNode::Serialize(serializer);
 	serializer.WriteProperty(200, "cte_name", ctename);
 	serializer.WriteProperty(201, "query", query);
 	serializer.WriteProperty(202, "child", child);
 	serializer.WriteProperty(203, "aliases", aliases);
 }
 
-unique_ptr<QueryNode> CTENode::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<QueryNode> CTENode::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<CTENode>(new CTENode());
 	deserializer.ReadProperty(200, "cte_name", result->ctename);
 	deserializer.ReadProperty(201, "query", result->query);
@@ -58,8 +58,8 @@ unique_ptr<QueryNode> CTENode::FormatDeserialize(FormatDeserializer &deserialize
 	return std::move(result);
 }
 
-void RecursiveCTENode::FormatSerialize(FormatSerializer &serializer) const {
-	QueryNode::FormatSerialize(serializer);
+void RecursiveCTENode::Serialize(Serializer &serializer) const {
+	QueryNode::Serialize(serializer);
 	serializer.WriteProperty(200, "cte_name", ctename);
 	serializer.WriteProperty(201, "union_all", union_all);
 	serializer.WriteProperty(202, "left", left);
@@ -67,7 +67,7 @@ void RecursiveCTENode::FormatSerialize(FormatSerializer &serializer) const {
 	serializer.WriteProperty(204, "aliases", aliases);
 }
 
-unique_ptr<QueryNode> RecursiveCTENode::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<QueryNode> RecursiveCTENode::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<RecursiveCTENode>(new RecursiveCTENode());
 	deserializer.ReadProperty(200, "cte_name", result->ctename);
 	deserializer.ReadProperty(201, "union_all", result->union_all);
@@ -77,8 +77,8 @@ unique_ptr<QueryNode> RecursiveCTENode::FormatDeserialize(FormatDeserializer &de
 	return std::move(result);
 }
 
-void SelectNode::FormatSerialize(FormatSerializer &serializer) const {
-	QueryNode::FormatSerialize(serializer);
+void SelectNode::Serialize(Serializer &serializer) const {
+	QueryNode::Serialize(serializer);
 	serializer.WriteProperty(200, "select_list", select_list);
 	serializer.WritePropertyWithDefault(201, "from_table", from_table, unique_ptr<TableRef>());
 	serializer.WritePropertyWithDefault(202, "where_clause", where_clause, unique_ptr<ParsedExpression>());
@@ -90,7 +90,7 @@ void SelectNode::FormatSerialize(FormatSerializer &serializer) const {
 	serializer.WritePropertyWithDefault(208, "qualify", qualify, unique_ptr<ParsedExpression>());
 }
 
-unique_ptr<QueryNode> SelectNode::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<QueryNode> SelectNode::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<SelectNode>(new SelectNode());
 	deserializer.ReadProperty(200, "select_list", result->select_list);
 	deserializer.ReadPropertyWithDefault(201, "from_table", result->from_table, unique_ptr<TableRef>());
@@ -104,14 +104,14 @@ unique_ptr<QueryNode> SelectNode::FormatDeserialize(FormatDeserializer &deserial
 	return std::move(result);
 }
 
-void SetOperationNode::FormatSerialize(FormatSerializer &serializer) const {
-	QueryNode::FormatSerialize(serializer);
+void SetOperationNode::Serialize(Serializer &serializer) const {
+	QueryNode::Serialize(serializer);
 	serializer.WriteProperty(200, "setop_type", setop_type);
 	serializer.WriteProperty(201, "left", left);
 	serializer.WriteProperty(202, "right", right);
 }
 
-unique_ptr<QueryNode> SetOperationNode::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<QueryNode> SetOperationNode::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<SetOperationNode>(new SetOperationNode());
 	deserializer.ReadProperty(200, "setop_type", result->setop_type);
 	deserializer.ReadProperty(201, "left", result->left);

package/src/duckdb/src/storage/serialization/serialize_result_modifier.cpp

@@ -3,32 +3,32 @@
 // Do not edit this file manually, your changes will be overwritten
 //===----------------------------------------------------------------------===//
 
-#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"
 #include "duckdb/parser/result_modifier.hpp"
 #include "duckdb/planner/bound_result_modifier.hpp"
 
 namespace duckdb {
 
-void ResultModifier::FormatSerialize(FormatSerializer &serializer) const {
+void ResultModifier::Serialize(Serializer &serializer) const {
 	serializer.WriteProperty(100, "type", type);
 }
 
-unique_ptr<ResultModifier> ResultModifier::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<ResultModifier> ResultModifier::Deserialize(Deserializer &deserializer) {
 	auto type = deserializer.ReadProperty<ResultModifierType>(100, "type");
 	unique_ptr<ResultModifier> result;
 	switch (type) {
 	case ResultModifierType::DISTINCT_MODIFIER:
-		result = DistinctModifier::FormatDeserialize(deserializer);
+		result = DistinctModifier::Deserialize(deserializer);
 		break;
 	case ResultModifierType::LIMIT_MODIFIER:
-		result = LimitModifier::FormatDeserialize(deserializer);
+		result = LimitModifier::Deserialize(deserializer);
 		break;
 	case ResultModifierType::LIMIT_PERCENT_MODIFIER:
-		result = LimitPercentModifier::FormatDeserialize(deserializer);
+		result = LimitPercentModifier::Deserialize(deserializer);
 		break;
 	case ResultModifierType::ORDER_MODIFIER:
-		result = OrderModifier::FormatDeserialize(deserializer);
+		result = OrderModifier::Deserialize(deserializer);
 		break;
 	default:
 		throw SerializationException("Unsupported type for deserialization of ResultModifier!");
@@ -36,59 +36,59 @@ unique_ptr<ResultModifier> ResultModifier::FormatDeserialize(FormatDeserializer
 	return result;
 }
 
-void BoundOrderModifier::FormatSerialize(FormatSerializer &serializer) const {
+void BoundOrderModifier::Serialize(Serializer &serializer) const {
 	serializer.WriteProperty(100, "orders", orders);
 }
 
-unique_ptr<BoundOrderModifier> BoundOrderModifier::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<BoundOrderModifier> BoundOrderModifier::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<BoundOrderModifier>(new BoundOrderModifier());
 	deserializer.ReadProperty(100, "orders", result->orders);
 	return result;
 }
 
-void DistinctModifier::FormatSerialize(FormatSerializer &serializer) const {
-	ResultModifier::FormatSerialize(serializer);
+void DistinctModifier::Serialize(Serializer &serializer) const {
+	ResultModifier::Serialize(serializer);
 	serializer.WriteProperty(200, "distinct_on_targets", distinct_on_targets);
 }
 
-unique_ptr<ResultModifier> DistinctModifier::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<ResultModifier> DistinctModifier::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<DistinctModifier>(new DistinctModifier());
 	deserializer.ReadProperty(200, "distinct_on_targets", result->distinct_on_targets);
 	return std::move(result);
 }
 
-void LimitModifier::FormatSerialize(FormatSerializer &serializer) const {
-	ResultModifier::FormatSerialize(serializer);
+void LimitModifier::Serialize(Serializer &serializer) const {
+	ResultModifier::Serialize(serializer);
 	serializer.WritePropertyWithDefault(200, "limit", limit, unique_ptr<ParsedExpression>());
 	serializer.WritePropertyWithDefault(201, "offset", offset, unique_ptr<ParsedExpression>());
 }
 
-unique_ptr<ResultModifier> LimitModifier::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<ResultModifier> LimitModifier::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<LimitModifier>(new LimitModifier());
 	deserializer.ReadPropertyWithDefault(200, "limit", result->limit, unique_ptr<ParsedExpression>());
 	deserializer.ReadPropertyWithDefault(201, "offset", result->offset, unique_ptr<ParsedExpression>());
 	return std::move(result);
 }
 
-void LimitPercentModifier::FormatSerialize(FormatSerializer &serializer) const {
-	ResultModifier::FormatSerialize(serializer);
+void LimitPercentModifier::Serialize(Serializer &serializer) const {
+	ResultModifier::Serialize(serializer);
 	serializer.WritePropertyWithDefault(200, "limit", limit, unique_ptr<ParsedExpression>());
 	serializer.WritePropertyWithDefault(201, "offset", offset, unique_ptr<ParsedExpression>());
 }
 
-unique_ptr<ResultModifier> LimitPercentModifier::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<ResultModifier> LimitPercentModifier::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<LimitPercentModifier>(new LimitPercentModifier());
 	deserializer.ReadPropertyWithDefault(200, "limit", result->limit, unique_ptr<ParsedExpression>());
 	deserializer.ReadPropertyWithDefault(201, "offset", result->offset, unique_ptr<ParsedExpression>());
 	return std::move(result);
 }
 
-void OrderModifier::FormatSerialize(FormatSerializer &serializer) const {
-	ResultModifier::FormatSerialize(serializer);
+void OrderModifier::Serialize(Serializer &serializer) const {
+	ResultModifier::Serialize(serializer);
 	serializer.WriteProperty(200, "orders", orders);
 }
 
-unique_ptr<ResultModifier> OrderModifier::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<ResultModifier> OrderModifier::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<OrderModifier>(new OrderModifier());
 	deserializer.ReadProperty(200, "orders", result->orders);
 	return std::move(result);

package/src/duckdb/src/storage/serialization/serialize_statement.cpp

@@ -3,17 +3,17 @@
 // Do not edit this file manually, your changes will be overwritten
 //===----------------------------------------------------------------------===//
 
-#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"
 #include "duckdb/parser/statement/select_statement.hpp"
 
 namespace duckdb {
 
-void SelectStatement::FormatSerialize(FormatSerializer &serializer) const {
+void SelectStatement::Serialize(Serializer &serializer) const {
 	serializer.WriteProperty(100, "node", node);
 }
 
-unique_ptr<SelectStatement> SelectStatement::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<SelectStatement> SelectStatement::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<SelectStatement>(new SelectStatement());
 	deserializer.ReadProperty(100, "node", result->node);
 	return result;