duckdb 0.8.2-dev161.0 → 0.8.2-dev1724.0

package/src/duckdb/src/storage/checkpoint_manager.cpp

@@ -111,6 +111,9 @@ void SingleFileCheckpointWriter::CreateCheckpoint() {
 	// truncate the WAL
 	wal->Truncate(0);
 
+	// truncate the file
+	block_manager.Truncate();
+
 	// mark all blocks written as part of the metadata as modified
 	metadata_writer->MarkWrittenBlocks();
 	table_metadata_writer->MarkWrittenBlocks();

package/src/duckdb/src/storage/compression/rle.cpp

@@ -272,7 +272,6 @@ struct RLEScanState : public SegmentScanState {
 	}
 
 	BufferHandle handle;
-	uint32_t rle_offset;
 	idx_t entry_pos;
 	idx_t position_in_entry;
 	uint32_t rle_count_offset;

package/src/duckdb/src/storage/data_table.cpp

@@ -56,7 +56,7 @@ DataTable::DataTable(AttachedDatabase &db, shared_ptr<TableIOManager> table_io_m
 	row_groups->Verify();
 }
 
-DataTable::DataTable(ClientContext &context, DataTable &parent, ColumnDefinition &new_column, Expression *default_value)
+DataTable::DataTable(ClientContext &context, DataTable &parent, ColumnDefinition &new_column, Expression &default_value)
     : info(parent.info), db(parent.db), is_root(true) {
 	// add the column definitions from this DataTable
 	for (auto &column_def : parent.column_definitions) {

package/src/duckdb/src/storage/local_storage.cpp

@@ -61,11 +61,11 @@ LocalTableStorage::LocalTableStorage(DataTable &new_dt, LocalTableStorage &paren
 }
 
 LocalTableStorage::LocalTableStorage(ClientContext &context, DataTable &new_dt, LocalTableStorage &parent,
-                                     ColumnDefinition &new_column, optional_ptr<Expression> default_value)
+                                     ColumnDefinition &new_column, Expression &default_value)
     : table_ref(new_dt), allocator(Allocator::Get(new_dt.db)), deleted_rows(parent.deleted_rows),
       optimistic_writer(new_dt, parent.optimistic_writer), optimistic_writers(std::move(parent.optimistic_writers)),
       merged_storage(parent.merged_storage) {
-	row_groups = parent.row_groups->AddColumn(context, new_column, default_value.get());
+	row_groups = parent.row_groups->AddColumn(context, new_column, default_value);
 	parent.row_groups.reset();
 	indexes.Move(parent.indexes);
 }
@@ -508,7 +508,7 @@ void LocalStorage::MoveStorage(DataTable &old_dt, DataTable &new_dt) {
 }
 
 void LocalStorage::AddColumn(DataTable &old_dt, DataTable &new_dt, ColumnDefinition &new_column,
-                             optional_ptr<Expression> default_value) {
+                             Expression &default_value) {
 	// check if there are any pending appends for the old version of the table
 	auto storage = table_manager.MoveEntry(old_dt);
 	if (!storage) {

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

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

@@ -0,0 +1,86 @@
+//===----------------------------------------------------------------------===//
+// 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/result_modifier.hpp"
+
+namespace duckdb {
+
+void ResultModifier::FormatSerialize(FormatSerializer &serializer) const {
+	serializer.WriteProperty("type", type);
+}
+
+unique_ptr<ResultModifier> ResultModifier::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto type = deserializer.ReadProperty<ResultModifierType>("type");
+	unique_ptr<ResultModifier> result;
+	switch (type) {
+	case ResultModifierType::DISTINCT_MODIFIER:
+		result = DistinctModifier::FormatDeserialize(deserializer);
+		break;
+	case ResultModifierType::LIMIT_MODIFIER:
+		result = LimitModifier::FormatDeserialize(deserializer);
+		break;
+	case ResultModifierType::LIMIT_PERCENT_MODIFIER:
+		result = LimitPercentModifier::FormatDeserialize(deserializer);
+		break;
+	case ResultModifierType::ORDER_MODIFIER:
+		result = OrderModifier::FormatDeserialize(deserializer);
+		break;
+	default:
+		throw SerializationException("Unsupported type for deserialization of ResultModifier!");
+	}
+	return result;
+}
+
+void LimitModifier::FormatSerialize(FormatSerializer &serializer) const {
+	ResultModifier::FormatSerialize(serializer);
+	serializer.WriteOptionalProperty("limit", limit);
+	serializer.WriteOptionalProperty("offset", offset);
+}
+
+unique_ptr<ResultModifier> LimitModifier::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<LimitModifier>(new LimitModifier());
+	deserializer.ReadOptionalProperty("limit", result->limit);
+	deserializer.ReadOptionalProperty("offset", result->offset);
+	return std::move(result);
+}
+
+void DistinctModifier::FormatSerialize(FormatSerializer &serializer) const {
+	ResultModifier::FormatSerialize(serializer);
+	serializer.WriteProperty("distinct_on_targets", distinct_on_targets);
+}
+
+unique_ptr<ResultModifier> DistinctModifier::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<DistinctModifier>(new DistinctModifier());
+	deserializer.ReadProperty("distinct_on_targets", result->distinct_on_targets);
+	return std::move(result);
+}
+
+void OrderModifier::FormatSerialize(FormatSerializer &serializer) const {
+	ResultModifier::FormatSerialize(serializer);
+	serializer.WriteProperty("orders", orders);
+}
+
+unique_ptr<ResultModifier> OrderModifier::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<OrderModifier>(new OrderModifier());
+	deserializer.ReadProperty("orders", result->orders);
+	return std::move(result);
+}
+
+void LimitPercentModifier::FormatSerialize(FormatSerializer &serializer) const {
+	ResultModifier::FormatSerialize(serializer);
+	serializer.WriteOptionalProperty("limit", limit);
+	serializer.WriteOptionalProperty("offset", offset);
+}
+
+unique_ptr<ResultModifier> LimitPercentModifier::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<LimitPercentModifier>(new LimitPercentModifier());
+	deserializer.ReadOptionalProperty("limit", result->limit);
+	deserializer.ReadOptionalProperty("offset", result->offset);
+	return std::move(result);
+}
+
+} // namespace duckdb