duckdb 0.8.2-dev1435.0 → 0.8.2-dev1493.0

package/src/duckdb/src/parser/tableref/joinref.cpp

@@ -91,29 +91,6 @@ void JoinRef::Serialize(FieldWriter &writer) const {
 	writer.WriteList<string>(using_columns);
 }
 
-void JoinRef::FormatSerialize(FormatSerializer &serializer) const {
-	TableRef::FormatSerialize(serializer);
-	serializer.WriteProperty("left", *left);
-	serializer.WriteProperty("right", *right);
-	serializer.WriteOptionalProperty("condition", condition);
-	serializer.WriteProperty("join_type", type);
-	serializer.WriteProperty("ref_type", ref_type);
-	serializer.WriteProperty("using_columns", using_columns);
-}
-
-unique_ptr<TableRef> JoinRef::FormatDeserialize(FormatDeserializer &source) {
-	auto result = make_uniq<JoinRef>(JoinRefType::REGULAR);
-
-	source.ReadProperty("left", result->left);
-	source.ReadProperty("right", result->right);
-	source.ReadOptionalProperty("condition", result->condition);
-	source.ReadProperty("join_type", result->type);
-	source.ReadProperty("ref_type", result->ref_type);
-	source.ReadProperty("using_columns", result->using_columns);
-
-	return std::move(result);
-}
-
 unique_ptr<TableRef> JoinRef::Deserialize(FieldReader &reader) {
 	auto result = make_uniq<JoinRef>(JoinRefType::REGULAR);
 	result->left = reader.ReadRequiredSerializable<TableRef>();

package/src/duckdb/src/parser/tableref/pivotref.cpp

@@ -330,17 +330,6 @@ void PivotRef::Serialize(FieldWriter &writer) const {
 	writer.WriteField<bool>(include_nulls);
 }
 
-void PivotRef::FormatSerialize(FormatSerializer &serializer) const {
-	TableRef::FormatSerialize(serializer);
-	serializer.WriteProperty("source", source);
-	serializer.WriteProperty("aggregates", aggregates);
-	serializer.WriteProperty("unpivot_names", unpivot_names);
-	serializer.WriteProperty("pivots", pivots);
-	serializer.WriteProperty("groups", groups);
-	serializer.WriteProperty("column_name_alias", column_name_alias);
-	serializer.WriteProperty("include_nulls", include_nulls);
-}
-
 unique_ptr<TableRef> PivotRef::Deserialize(FieldReader &reader) {
 	auto result = make_uniq<PivotRef>();
 	result->source = reader.ReadRequiredSerializable<TableRef>();
@@ -353,16 +342,4 @@ unique_ptr<TableRef> PivotRef::Deserialize(FieldReader &reader) {
 	return std::move(result);
 }
 
-unique_ptr<TableRef> PivotRef::FormatDeserialize(FormatDeserializer &source) {
-	auto result = make_uniq<PivotRef>();
-	source.ReadProperty("source", result->source);
-	source.ReadProperty("aggregates", result->aggregates);
-	source.ReadProperty("unpivot_names", result->unpivot_names);
-	source.ReadProperty("pivots", result->pivots);
-	source.ReadProperty("groups", result->groups);
-	source.ReadProperty("column_name_alias", result->column_name_alias);
-	source.ReadProperty("include_nulls", result->include_nulls);
-	return std::move(result);
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/tableref/subqueryref.cpp

@@ -12,6 +12,9 @@ string SubqueryRef::ToString() const {
 	return BaseToString(result, column_name_alias);
 }
 
+SubqueryRef::SubqueryRef() : TableRef(TableReferenceType::SUBQUERY) {
+}
+
 SubqueryRef::SubqueryRef(unique_ptr<SelectStatement> subquery_p, string alias_p)
     : TableRef(TableReferenceType::SUBQUERY), subquery(std::move(subquery_p)) {
 	this->alias = std::move(alias_p);
@@ -37,19 +40,6 @@ void SubqueryRef::Serialize(FieldWriter &writer) const {
 	writer.WriteList<string>(column_name_alias);
 }
 
-void SubqueryRef::FormatSerialize(FormatSerializer &serializer) const {
-	TableRef::FormatSerialize(serializer);
-	serializer.WriteProperty("subquery", subquery);
-	serializer.WriteProperty("column_name_alias", column_name_alias);
-}
-
-unique_ptr<TableRef> SubqueryRef::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto subquery = deserializer.ReadProperty<unique_ptr<SelectStatement>>("subquery");
-	auto result = make_uniq<SubqueryRef>(std::move(subquery));
-	deserializer.ReadProperty("column_name_alias", result->column_name_alias);
-	return std::move(result);
-}
-
 unique_ptr<TableRef> SubqueryRef::Deserialize(FieldReader &reader) {
 	auto subquery = reader.ReadRequiredSerializable<SelectStatement>();
 	auto result = make_uniq<SubqueryRef>(std::move(subquery));

package/src/duckdb/src/parser/tableref/table_function.cpp

@@ -27,21 +27,6 @@ void TableFunctionRef::Serialize(FieldWriter &writer) const {
 	writer.WriteList<string>(column_name_alias);
 }
 
-void TableFunctionRef::FormatSerialize(FormatSerializer &serializer) const {
-	TableRef::FormatSerialize(serializer);
-	serializer.WriteProperty("function", function);
-	serializer.WriteProperty("alias", alias);
-	serializer.WriteProperty("column_name_alias", column_name_alias);
-}
-
-unique_ptr<TableRef> TableFunctionRef::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto result = make_uniq<TableFunctionRef>();
-	deserializer.ReadProperty("function", result->function);
-	deserializer.ReadProperty("alias", result->alias);
-	deserializer.ReadProperty("column_name_alias", result->column_name_alias);
-	return std::move(result);
-}
-
 unique_ptr<TableRef> TableFunctionRef::Deserialize(FieldReader &reader) {
 	auto result = make_uniq<TableFunctionRef>();
 	result->function = reader.ReadRequiredSerializable<ParsedExpression>();

package/src/duckdb/src/parser/tableref.cpp

@@ -53,50 +53,6 @@ void TableRef::Serialize(Serializer &serializer) const {
 	writer.Finalize();
 }
 
-void TableRef::FormatSerialize(FormatSerializer &serializer) const {
-	serializer.WriteProperty("type", type);
-	serializer.WriteProperty("alias", alias);
-	serializer.WriteOptionalProperty("sample", sample);
-}
-
-unique_ptr<TableRef> TableRef::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto type = deserializer.ReadProperty<TableReferenceType>("type");
-	auto alias = deserializer.ReadProperty<string>("alias");
-	auto sample = deserializer.ReadOptionalProperty<unique_ptr<SampleOptions>>("sample");
-
-	unique_ptr<TableRef> result;
-
-	switch (type) {
-	case TableReferenceType::BASE_TABLE:
-		result = BaseTableRef::FormatDeserialize(deserializer);
-		break;
-	case TableReferenceType::JOIN:
-		result = JoinRef::FormatDeserialize(deserializer);
-		break;
-	case TableReferenceType::SUBQUERY:
-		result = SubqueryRef::FormatDeserialize(deserializer);
-		break;
-	case TableReferenceType::TABLE_FUNCTION:
-		result = TableFunctionRef::FormatDeserialize(deserializer);
-		break;
-	case TableReferenceType::EMPTY:
-		result = EmptyTableRef::FormatDeserialize(deserializer);
-		break;
-	case TableReferenceType::EXPRESSION_LIST:
-		result = ExpressionListRef::FormatDeserialize(deserializer);
-		break;
-	case TableReferenceType::PIVOT:
-		result = PivotRef::FormatDeserialize(deserializer);
-		break;
-	case TableReferenceType::CTE:
-	case TableReferenceType::INVALID:
-		throw InternalException("Unsupported type for TableRef::FormatDeserialize");
-	}
-	result->alias = alias;
-	result->sample = std::move(sample);
-	return result;
-}
-
 unique_ptr<TableRef> TableRef::Deserialize(Deserializer &source) {
 	FieldReader reader(source);
 

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

@@ -0,0 +1,340 @@
+//===----------------------------------------------------------------------===//
+// This file is automatically generated by scripts/generate_serialization.py
+// 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/parser/expression/list.hpp"
+
+namespace duckdb {
+
+void ParsedExpression::FormatSerialize(FormatSerializer &serializer) const {
+	serializer.WriteProperty("class", expression_class);
+	serializer.WriteProperty("type", type);
+	serializer.WriteProperty("alias", alias);
+}
+
+unique_ptr<ParsedExpression> ParsedExpression::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto expression_class = deserializer.ReadProperty<ExpressionClass>("class");
+	auto type = deserializer.ReadProperty<ExpressionType>("type");
+	auto alias = deserializer.ReadProperty<string>("alias");
+	unique_ptr<ParsedExpression> result;
+	switch (expression_class) {
+	case ExpressionClass::BETWEEN:
+		result = BetweenExpression::FormatDeserialize(type, deserializer);
+		break;
+	case ExpressionClass::CASE:
+		result = CaseExpression::FormatDeserialize(type, deserializer);
+		break;
+	case ExpressionClass::CAST:
+		result = CastExpression::FormatDeserialize(type, deserializer);
+		break;
+	case ExpressionClass::COLLATE:
+		result = CollateExpression::FormatDeserialize(type, deserializer);
+		break;
+	case ExpressionClass::COLUMN_REF:
+		result = ColumnRefExpression::FormatDeserialize(type, deserializer);
+		break;
+	case ExpressionClass::COMPARISON:
+		result = ComparisonExpression::FormatDeserialize(type, deserializer);
+		break;
+	case ExpressionClass::CONJUNCTION:
+		result = ConjunctionExpression::FormatDeserialize(type, deserializer);
+		break;
+	case ExpressionClass::CONSTANT:
+		result = ConstantExpression::FormatDeserialize(type, deserializer);
+		break;
+	case ExpressionClass::DEFAULT:
+		result = DefaultExpression::FormatDeserialize(type, deserializer);
+		break;
+	case ExpressionClass::FUNCTION:
+		result = FunctionExpression::FormatDeserialize(type, deserializer);
+		break;
+	case ExpressionClass::LAMBDA:
+		result = LambdaExpression::FormatDeserialize(type, deserializer);
+		break;
+	case ExpressionClass::OPERATOR:
+		result = OperatorExpression::FormatDeserialize(type, deserializer);
+		break;
+	case ExpressionClass::PARAMETER:
+		result = ParameterExpression::FormatDeserialize(type, deserializer);
+		break;
+	case ExpressionClass::POSITIONAL_REFERENCE:
+		result = PositionalReferenceExpression::FormatDeserialize(type, deserializer);
+		break;
+	case ExpressionClass::STAR:
+		result = StarExpression::FormatDeserialize(type, deserializer);
+		break;
+	case ExpressionClass::SUBQUERY:
+		result = SubqueryExpression::FormatDeserialize(type, deserializer);
+		break;
+	case ExpressionClass::WINDOW:
+		result = WindowExpression::FormatDeserialize(type, deserializer);
+		break;
+	default:
+		throw SerializationException("Unsupported type for deserialization of ParsedExpression!");
+	}
+	result->alias = std::move(alias);
+	return result;
+}
+
+void BetweenExpression::FormatSerialize(FormatSerializer &serializer) const {
+	ParsedExpression::FormatSerialize(serializer);
+	serializer.WriteProperty("input", *input);
+	serializer.WriteProperty("lower", *lower);
+	serializer.WriteProperty("upper", *upper);
+}
+
+unique_ptr<ParsedExpression> BetweenExpression::FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<BetweenExpression>(new BetweenExpression());
+	deserializer.ReadProperty("input", result->input);
+	deserializer.ReadProperty("lower", result->lower);
+	deserializer.ReadProperty("upper", result->upper);
+	return std::move(result);
+}
+
+void CaseExpression::FormatSerialize(FormatSerializer &serializer) const {
+	ParsedExpression::FormatSerialize(serializer);
+	serializer.WriteProperty("case_checks", case_checks);
+	serializer.WriteProperty("else_expr", *else_expr);
+}
+
+unique_ptr<ParsedExpression> CaseExpression::FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<CaseExpression>(new CaseExpression());
+	deserializer.ReadProperty("case_checks", result->case_checks);
+	deserializer.ReadProperty("else_expr", result->else_expr);
+	return std::move(result);
+}
+
+void CastExpression::FormatSerialize(FormatSerializer &serializer) const {
+	ParsedExpression::FormatSerialize(serializer);
+	serializer.WriteProperty("child", *child);
+	serializer.WriteProperty("cast_type", cast_type);
+	serializer.WriteProperty("try_cast", try_cast);
+}
+
+unique_ptr<ParsedExpression> CastExpression::FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<CastExpression>(new CastExpression());
+	deserializer.ReadProperty("child", result->child);
+	deserializer.ReadProperty("cast_type", result->cast_type);
+	deserializer.ReadProperty("try_cast", result->try_cast);
+	return std::move(result);
+}
+
+void CollateExpression::FormatSerialize(FormatSerializer &serializer) const {
+	ParsedExpression::FormatSerialize(serializer);
+	serializer.WriteProperty("child", *child);
+	serializer.WriteProperty("collation", collation);
+}
+
+unique_ptr<ParsedExpression> CollateExpression::FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<CollateExpression>(new CollateExpression());
+	deserializer.ReadProperty("child", result->child);
+	deserializer.ReadProperty("collation", result->collation);
+	return std::move(result);
+}
+
+void ColumnRefExpression::FormatSerialize(FormatSerializer &serializer) const {
+	ParsedExpression::FormatSerialize(serializer);
+	serializer.WriteProperty("column_names", column_names);
+}
+
+unique_ptr<ParsedExpression> ColumnRefExpression::FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<ColumnRefExpression>(new ColumnRefExpression());
+	deserializer.ReadProperty("column_names", result->column_names);
+	return std::move(result);
+}
+
+void ComparisonExpression::FormatSerialize(FormatSerializer &serializer) const {
+	ParsedExpression::FormatSerialize(serializer);
+	serializer.WriteProperty("left", *left);
+	serializer.WriteProperty("right", *right);
+}
+
+unique_ptr<ParsedExpression> ComparisonExpression::FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<ComparisonExpression>(new ComparisonExpression(type));
+	deserializer.ReadProperty("left", result->left);
+	deserializer.ReadProperty("right", result->right);
+	return std::move(result);
+}
+
+void ConjunctionExpression::FormatSerialize(FormatSerializer &serializer) const {
+	ParsedExpression::FormatSerialize(serializer);
+	serializer.WriteProperty("children", children);
+}
+
+unique_ptr<ParsedExpression> ConjunctionExpression::FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<ConjunctionExpression>(new ConjunctionExpression(type));
+	deserializer.ReadProperty("children", result->children);
+	return std::move(result);
+}
+
+void ConstantExpression::FormatSerialize(FormatSerializer &serializer) const {
+	ParsedExpression::FormatSerialize(serializer);
+	serializer.WriteProperty("value", value);
+}
+
+unique_ptr<ParsedExpression> ConstantExpression::FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<ConstantExpression>(new ConstantExpression());
+	deserializer.ReadProperty("value", result->value);
+	return std::move(result);
+}
+
+void DefaultExpression::FormatSerialize(FormatSerializer &serializer) const {
+	ParsedExpression::FormatSerialize(serializer);
+}
+
+unique_ptr<ParsedExpression> DefaultExpression::FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<DefaultExpression>(new DefaultExpression());
+	return std::move(result);
+}
+
+void FunctionExpression::FormatSerialize(FormatSerializer &serializer) const {
+	ParsedExpression::FormatSerialize(serializer);
+	serializer.WriteProperty("function_name", function_name);
+	serializer.WriteProperty("schema", schema);
+	serializer.WriteProperty("children", children);
+	serializer.WriteOptionalProperty("filter", filter);
+	serializer.WriteProperty("order_bys", (ResultModifier &)*order_bys);
+	serializer.WriteProperty("distinct", distinct);
+	serializer.WriteProperty("is_operator", is_operator);
+	serializer.WriteProperty("export_state", export_state);
+	serializer.WriteProperty("catalog", catalog);
+}
+
+unique_ptr<ParsedExpression> FunctionExpression::FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<FunctionExpression>(new FunctionExpression());
+	deserializer.ReadProperty("function_name", result->function_name);
+	deserializer.ReadProperty("schema", result->schema);
+	deserializer.ReadProperty("children", result->children);
+	deserializer.ReadOptionalProperty("filter", result->filter);
+	auto order_bys = deserializer.ReadProperty<unique_ptr<ResultModifier>>("order_bys");
+	result->order_bys = unique_ptr_cast<ResultModifier, OrderModifier>(std::move(order_bys));
+	deserializer.ReadProperty("distinct", result->distinct);
+	deserializer.ReadProperty("is_operator", result->is_operator);
+	deserializer.ReadProperty("export_state", result->export_state);
+	deserializer.ReadProperty("catalog", result->catalog);
+	return std::move(result);
+}
+
+void LambdaExpression::FormatSerialize(FormatSerializer &serializer) const {
+	ParsedExpression::FormatSerialize(serializer);
+	serializer.WriteProperty("lhs", *lhs);
+	serializer.WriteProperty("expr", *expr);
+}
+
+unique_ptr<ParsedExpression> LambdaExpression::FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<LambdaExpression>(new LambdaExpression());
+	deserializer.ReadProperty("lhs", result->lhs);
+	deserializer.ReadProperty("expr", result->expr);
+	return std::move(result);
+}
+
+void OperatorExpression::FormatSerialize(FormatSerializer &serializer) const {
+	ParsedExpression::FormatSerialize(serializer);
+	serializer.WriteProperty("children", children);
+}
+
+unique_ptr<ParsedExpression> OperatorExpression::FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<OperatorExpression>(new OperatorExpression(type));
+	deserializer.ReadProperty("children", result->children);
+	return std::move(result);
+}
+
+void ParameterExpression::FormatSerialize(FormatSerializer &serializer) const {
+	ParsedExpression::FormatSerialize(serializer);
+	serializer.WriteProperty("parameter_nr", parameter_nr);
+}
+
+unique_ptr<ParsedExpression> ParameterExpression::FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<ParameterExpression>(new ParameterExpression());
+	deserializer.ReadProperty("parameter_nr", result->parameter_nr);
+	return std::move(result);
+}
+
+void PositionalReferenceExpression::FormatSerialize(FormatSerializer &serializer) const {
+	ParsedExpression::FormatSerialize(serializer);
+	serializer.WriteProperty("index", index);
+}
+
+unique_ptr<ParsedExpression> PositionalReferenceExpression::FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<PositionalReferenceExpression>(new PositionalReferenceExpression());
+	deserializer.ReadProperty("index", result->index);
+	return std::move(result);
+}
+
+void StarExpression::FormatSerialize(FormatSerializer &serializer) const {
+	ParsedExpression::FormatSerialize(serializer);
+	serializer.WriteProperty("relation_name", relation_name);
+	serializer.WriteProperty("exclude_list", exclude_list);
+	serializer.WriteProperty("replace_list", replace_list);
+	serializer.WriteProperty("columns", columns);
+	serializer.WriteOptionalProperty("expr", expr);
+}
+
+unique_ptr<ParsedExpression> StarExpression::FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<StarExpression>(new StarExpression());
+	deserializer.ReadProperty("relation_name", result->relation_name);
+	deserializer.ReadProperty("exclude_list", result->exclude_list);
+	deserializer.ReadProperty("replace_list", result->replace_list);
+	deserializer.ReadProperty("columns", result->columns);
+	deserializer.ReadOptionalProperty("expr", result->expr);
+	return std::move(result);
+}
+
+void SubqueryExpression::FormatSerialize(FormatSerializer &serializer) const {
+	ParsedExpression::FormatSerialize(serializer);
+	serializer.WriteProperty("subquery_type", subquery_type);
+	serializer.WriteProperty("subquery", subquery);
+	serializer.WriteOptionalProperty("child", child);
+	serializer.WriteProperty("comparison_type", comparison_type);
+}
+
+unique_ptr<ParsedExpression> SubqueryExpression::FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<SubqueryExpression>(new SubqueryExpression());
+	deserializer.ReadProperty("subquery_type", result->subquery_type);
+	deserializer.ReadProperty("subquery", result->subquery);
+	deserializer.ReadOptionalProperty("child", result->child);
+	deserializer.ReadProperty("comparison_type", result->comparison_type);
+	return std::move(result);
+}
+
+void WindowExpression::FormatSerialize(FormatSerializer &serializer) const {
+	ParsedExpression::FormatSerialize(serializer);
+	serializer.WriteProperty("function_name", function_name);
+	serializer.WriteProperty("schema", schema);
+	serializer.WriteProperty("catalog", catalog);
+	serializer.WriteProperty("children", children);
+	serializer.WriteProperty("partitions", partitions);
+	serializer.WriteProperty("orders", orders);
+	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);
+	serializer.WriteProperty("ignore_nulls", ignore_nulls);
+	serializer.WriteOptionalProperty("filter_expr", filter_expr);
+}
+
+unique_ptr<ParsedExpression> WindowExpression::FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<WindowExpression>(new WindowExpression(type));
+	deserializer.ReadProperty("function_name", result->function_name);
+	deserializer.ReadProperty("schema", result->schema);
+	deserializer.ReadProperty("catalog", result->catalog);
+	deserializer.ReadProperty("children", result->children);
+	deserializer.ReadProperty("partitions", result->partitions);
+	deserializer.ReadProperty("orders", result->orders);
+	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);
+	deserializer.ReadProperty("ignore_nulls", result->ignore_nulls);
+	deserializer.ReadOptionalProperty("filter_expr", result->filter_expr);
+	return std::move(result);
+}
+
+} // namespace duckdb

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

@@ -0,0 +1,122 @@
+//===----------------------------------------------------------------------===//
+// This file is automatically generated by scripts/generate_serialization.py
+// 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/parser/query_node/list.hpp"
+
+namespace duckdb {
+
+void QueryNode::FormatSerialize(FormatSerializer &serializer) const {
+	serializer.WriteProperty("type", type);
+	serializer.WriteProperty("modifiers", modifiers);
+	serializer.WriteProperty("cte_map", cte_map);
+}
+
+unique_ptr<QueryNode> QueryNode::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto type = deserializer.ReadProperty<QueryNodeType>("type");
+	auto modifiers = deserializer.ReadProperty<vector<unique_ptr<ResultModifier>>>("modifiers");
+	auto cte_map = deserializer.ReadProperty<CommonTableExpressionMap>("cte_map");
+	unique_ptr<QueryNode> result;
+	switch (type) {
+	case QueryNodeType::CTE_NODE:
+		result = CTENode::FormatDeserialize(deserializer);
+		break;
+	case QueryNodeType::RECURSIVE_CTE_NODE:
+		result = RecursiveCTENode::FormatDeserialize(deserializer);
+		break;
+	case QueryNodeType::SELECT_NODE:
+		result = SelectNode::FormatDeserialize(deserializer);
+		break;
+	case QueryNodeType::SET_OPERATION_NODE:
+		result = SetOperationNode::FormatDeserialize(deserializer);
+		break;
+	default:
+		throw SerializationException("Unsupported type for deserialization of QueryNode!");
+	}
+	result->modifiers = std::move(modifiers);
+	result->cte_map = std::move(cte_map);
+	return result;
+}
+
+void SelectNode::FormatSerialize(FormatSerializer &serializer) const {
+	QueryNode::FormatSerialize(serializer);
+	serializer.WriteProperty("select_list", select_list);
+	serializer.WriteOptionalProperty("from_table", from_table);
+	serializer.WriteOptionalProperty("where_clause", where_clause);
+	serializer.WriteProperty("group_expressions", groups.group_expressions);
+	serializer.WriteProperty("group_sets", groups.grouping_sets);
+	serializer.WriteProperty("aggregate_handling", aggregate_handling);
+	serializer.WriteOptionalProperty("having", having);
+	serializer.WriteOptionalProperty("sample", sample);
+	serializer.WriteOptionalProperty("qualify", qualify);
+}
+
+unique_ptr<QueryNode> SelectNode::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<SelectNode>(new SelectNode());
+	deserializer.ReadProperty("select_list", result->select_list);
+	deserializer.ReadOptionalProperty("from_table", result->from_table);
+	deserializer.ReadOptionalProperty("where_clause", result->where_clause);
+	deserializer.ReadProperty("group_expressions", result->groups.group_expressions);
+	deserializer.ReadProperty("group_sets", result->groups.grouping_sets);
+	deserializer.ReadProperty("aggregate_handling", result->aggregate_handling);
+	deserializer.ReadOptionalProperty("having", result->having);
+	deserializer.ReadOptionalProperty("sample", result->sample);
+	deserializer.ReadOptionalProperty("qualify", result->qualify);
+	return std::move(result);
+}
+
+void SetOperationNode::FormatSerialize(FormatSerializer &serializer) const {
+	QueryNode::FormatSerialize(serializer);
+	serializer.WriteProperty("setop_type", setop_type);
+	serializer.WriteProperty("left", *left);
+	serializer.WriteProperty("right", *right);
+}
+
+unique_ptr<QueryNode> SetOperationNode::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<SetOperationNode>(new SetOperationNode());
+	deserializer.ReadProperty("setop_type", result->setop_type);
+	deserializer.ReadProperty("left", result->left);
+	deserializer.ReadProperty("right", result->right);
+	return std::move(result);
+}
+
+void RecursiveCTENode::FormatSerialize(FormatSerializer &serializer) const {
+	QueryNode::FormatSerialize(serializer);
+	serializer.WriteProperty("cte_name", ctename);
+	serializer.WriteProperty("union_all", union_all);
+	serializer.WriteProperty("left", *left);
+	serializer.WriteProperty("right", *right);
+	serializer.WriteProperty("aliases", aliases);
+}
+
+unique_ptr<QueryNode> RecursiveCTENode::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<RecursiveCTENode>(new RecursiveCTENode());
+	deserializer.ReadProperty("cte_name", result->ctename);
+	deserializer.ReadProperty("union_all", result->union_all);
+	deserializer.ReadProperty("left", result->left);
+	deserializer.ReadProperty("right", result->right);
+	deserializer.ReadProperty("aliases", result->aliases);
+	return std::move(result);
+}
+
+void CTENode::FormatSerialize(FormatSerializer &serializer) const {
+	QueryNode::FormatSerialize(serializer);
+	serializer.WriteProperty("cte_name", ctename);
+	serializer.WriteProperty("query", *query);
+	serializer.WriteProperty("child", *child);
+	serializer.WriteProperty("aliases", aliases);
+}
+
+unique_ptr<QueryNode> CTENode::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<CTENode>(new CTENode());
+	deserializer.ReadProperty("cte_name", result->ctename);
+	deserializer.ReadProperty("query", result->query);
+	deserializer.ReadProperty("child", result->child);
+	deserializer.ReadProperty("aliases", result->aliases);
+	return std::move(result);
+}
+
+} // namespace duckdb