duckdb 0.8.2-dev2700.0 → 0.8.2-dev2842.0

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

@@ -10,15 +10,15 @@
 namespace duckdb {
 
 void ParsedExpression::FormatSerialize(FormatSerializer &serializer) const {
-	serializer.WriteProperty("class", expression_class);
-	serializer.WriteProperty("type", type);
-	serializer.WriteProperty("alias", alias);
+	serializer.WriteProperty(100, "class", expression_class);
+	serializer.WriteProperty(101, "type", type);
+	serializer.WriteProperty(102, "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");
+	auto expression_class = deserializer.ReadProperty<ExpressionClass>(100, "class");
+	auto type = deserializer.ReadProperty<ExpressionType>(101, "type");
+	auto alias = deserializer.ReadProperty<string>(102, "alias");
 	deserializer.Set<ExpressionType>(type);
 	unique_ptr<ParsedExpression> result;
 	switch (expression_class) {
@@ -83,103 +83,103 @@ unique_ptr<ParsedExpression> ParsedExpression::FormatDeserialize(FormatDeseriali
 
 void BetweenExpression::FormatSerialize(FormatSerializer &serializer) const {
 	ParsedExpression::FormatSerialize(serializer);
-	serializer.WriteProperty("input", *input);
-	serializer.WriteProperty("lower", *lower);
-	serializer.WriteProperty("upper", *upper);
+	serializer.WriteProperty(200, "input", *input);
+	serializer.WriteProperty(201, "lower", *lower);
+	serializer.WriteProperty(202, "upper", *upper);
 }
 
 unique_ptr<ParsedExpression> BetweenExpression::FormatDeserialize(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);
+	deserializer.ReadProperty(200, "input", result->input);
+	deserializer.ReadProperty(201, "lower", result->lower);
+	deserializer.ReadProperty(202, "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);
+	serializer.WriteProperty(200, "case_checks", case_checks);
+	serializer.WriteProperty(201, "else_expr", *else_expr);
 }
 
 unique_ptr<ParsedExpression> CaseExpression::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = duckdb::unique_ptr<CaseExpression>(new CaseExpression());
-	deserializer.ReadProperty("case_checks", result->case_checks);
-	deserializer.ReadProperty("else_expr", result->else_expr);
+	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);
-	serializer.WriteProperty("child", *child);
-	serializer.WriteProperty("cast_type", cast_type);
-	serializer.WriteProperty("try_cast", try_cast);
+	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) {
 	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);
+	deserializer.ReadProperty(200, "child", result->child);
+	deserializer.ReadProperty(201, "cast_type", result->cast_type);
+	deserializer.ReadProperty(202, "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);
+	serializer.WriteProperty(200, "child", *child);
+	serializer.WriteProperty(201, "collation", collation);
 }
 
 unique_ptr<ParsedExpression> CollateExpression::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = duckdb::unique_ptr<CollateExpression>(new CollateExpression());
-	deserializer.ReadProperty("child", result->child);
-	deserializer.ReadProperty("collation", result->collation);
+	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);
-	serializer.WriteProperty("column_names", column_names);
+	serializer.WriteProperty(200, "column_names", column_names);
 }
 
 unique_ptr<ParsedExpression> ColumnRefExpression::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = duckdb::unique_ptr<ColumnRefExpression>(new ColumnRefExpression());
-	deserializer.ReadProperty("column_names", result->column_names);
+	deserializer.ReadProperty(200, "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);
+	serializer.WriteProperty(200, "left", *left);
+	serializer.WriteProperty(201, "right", *right);
 }
 
 unique_ptr<ParsedExpression> ComparisonExpression::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = duckdb::unique_ptr<ComparisonExpression>(new ComparisonExpression(deserializer.Get<ExpressionType>()));
-	deserializer.ReadProperty("left", result->left);
-	deserializer.ReadProperty("right", result->right);
+	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);
-	serializer.WriteProperty("children", children);
+	serializer.WriteProperty(200, "children", children);
 }
 
 unique_ptr<ParsedExpression> ConjunctionExpression::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = duckdb::unique_ptr<ConjunctionExpression>(new ConjunctionExpression(deserializer.Get<ExpressionType>()));
-	deserializer.ReadProperty("children", result->children);
+	deserializer.ReadProperty(200, "children", result->children);
 	return std::move(result);
 }
 
 void ConstantExpression::FormatSerialize(FormatSerializer &serializer) const {
 	ParsedExpression::FormatSerialize(serializer);
-	serializer.WriteProperty("value", value);
+	serializer.WriteProperty(200, "value", value);
 }
 
 unique_ptr<ParsedExpression> ConstantExpression::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = duckdb::unique_ptr<ConstantExpression>(new ConstantExpression());
-	deserializer.ReadProperty("value", result->value);
+	deserializer.ReadProperty(200, "value", result->value);
 	return std::move(result);
 }
 
@@ -194,148 +194,148 @@ unique_ptr<ParsedExpression> DefaultExpression::FormatDeserialize(FormatDeserial
 
 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);
+	serializer.WriteProperty(200, "function_name", function_name);
+	serializer.WriteProperty(201, "schema", schema);
+	serializer.WriteProperty(202, "children", children);
+	serializer.WriteOptionalProperty(203, "filter", filter);
+	serializer.WriteProperty(204, "order_bys", (ResultModifier &)*order_bys);
+	serializer.WriteProperty(205, "distinct", distinct);
+	serializer.WriteProperty(206, "is_operator", is_operator);
+	serializer.WriteProperty(207, "export_state", export_state);
+	serializer.WriteProperty(208, "catalog", catalog);
 }
 
 unique_ptr<ParsedExpression> FunctionExpression::FormatDeserialize(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");
+	deserializer.ReadProperty(200, "function_name", result->function_name);
+	deserializer.ReadProperty(201, "schema", result->schema);
+	deserializer.ReadProperty(202, "children", result->children);
+	deserializer.ReadOptionalProperty(203, "filter", result->filter);
+	auto order_bys = deserializer.ReadProperty<unique_ptr<ResultModifier>>(204, "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);
+	deserializer.ReadProperty(205, "distinct", result->distinct);
+	deserializer.ReadProperty(206, "is_operator", result->is_operator);
+	deserializer.ReadProperty(207, "export_state", result->export_state);
+	deserializer.ReadProperty(208, "catalog", result->catalog);
 	return std::move(result);
 }
 
 void LambdaExpression::FormatSerialize(FormatSerializer &serializer) const {
 	ParsedExpression::FormatSerialize(serializer);
-	serializer.WriteProperty("lhs", *lhs);
-	serializer.WriteProperty("expr", *expr);
+	serializer.WriteProperty(200, "lhs", *lhs);
+	serializer.WriteProperty(201, "expr", *expr);
 }
 
 unique_ptr<ParsedExpression> LambdaExpression::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = duckdb::unique_ptr<LambdaExpression>(new LambdaExpression());
-	deserializer.ReadProperty("lhs", result->lhs);
-	deserializer.ReadProperty("expr", result->expr);
+	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);
-	serializer.WriteProperty("children", children);
+	serializer.WriteProperty(200, "children", children);
 }
 
 unique_ptr<ParsedExpression> OperatorExpression::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = duckdb::unique_ptr<OperatorExpression>(new OperatorExpression(deserializer.Get<ExpressionType>()));
-	deserializer.ReadProperty("children", result->children);
+	deserializer.ReadProperty(200, "children", result->children);
 	return std::move(result);
 }
 
 void ParameterExpression::FormatSerialize(FormatSerializer &serializer) const {
 	ParsedExpression::FormatSerialize(serializer);
-	serializer.WriteProperty("identifier", identifier);
+	serializer.WriteProperty(200, "identifier", identifier);
 }
 
 unique_ptr<ParsedExpression> ParameterExpression::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = duckdb::unique_ptr<ParameterExpression>(new ParameterExpression());
-	deserializer.ReadProperty("identifier", result->identifier);
+	deserializer.ReadProperty(200, "identifier", result->identifier);
 	return std::move(result);
 }
 
 void PositionalReferenceExpression::FormatSerialize(FormatSerializer &serializer) const {
 	ParsedExpression::FormatSerialize(serializer);
-	serializer.WriteProperty("index", index);
+	serializer.WriteProperty(200, "index", index);
 }
 
 unique_ptr<ParsedExpression> PositionalReferenceExpression::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = duckdb::unique_ptr<PositionalReferenceExpression>(new PositionalReferenceExpression());
-	deserializer.ReadProperty("index", result->index);
+	deserializer.ReadProperty(200, "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);
+	serializer.WriteProperty(200, "relation_name", relation_name);
+	serializer.WriteProperty(201, "exclude_list", exclude_list);
+	serializer.WriteProperty(202, "replace_list", replace_list);
+	serializer.WriteProperty(203, "columns", columns);
+	serializer.WriteOptionalProperty(204, "expr", expr);
 }
 
 unique_ptr<ParsedExpression> StarExpression::FormatDeserialize(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);
+	deserializer.ReadProperty(200, "relation_name", result->relation_name);
+	deserializer.ReadProperty(201, "exclude_list", result->exclude_list);
+	deserializer.ReadProperty(202, "replace_list", result->replace_list);
+	deserializer.ReadProperty(203, "columns", result->columns);
+	deserializer.ReadOptionalProperty(204, "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);
+	serializer.WriteProperty(200, "subquery_type", subquery_type);
+	serializer.WriteProperty(201, "subquery", subquery);
+	serializer.WriteOptionalProperty(202, "child", child);
+	serializer.WriteProperty(203, "comparison_type", comparison_type);
 }
 
 unique_ptr<ParsedExpression> SubqueryExpression::FormatDeserialize(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);
+	deserializer.ReadProperty(200, "subquery_type", result->subquery_type);
+	deserializer.ReadProperty(201, "subquery", result->subquery);
+	deserializer.ReadOptionalProperty(202, "child", result->child);
+	deserializer.ReadProperty(203, "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);
+	serializer.WriteProperty(200, "function_name", function_name);
+	serializer.WriteProperty(201, "schema", schema);
+	serializer.WriteProperty(202, "catalog", catalog);
+	serializer.WriteProperty(203, "children", children);
+	serializer.WriteProperty(204, "partitions", partitions);
+	serializer.WriteProperty(205, "orders", orders);
+	serializer.WriteProperty(206, "start", start);
+	serializer.WriteProperty(207, "end", end);
+	serializer.WriteOptionalProperty(208, "start_expr", start_expr);
+	serializer.WriteOptionalProperty(209, "end_expr", end_expr);
+	serializer.WriteOptionalProperty(210, "offset_expr", offset_expr);
+	serializer.WriteOptionalProperty(211, "default_expr", default_expr);
+	serializer.WriteProperty(212, "ignore_nulls", ignore_nulls);
+	serializer.WriteOptionalProperty(213, "filter_expr", filter_expr);
 }
 
 unique_ptr<ParsedExpression> WindowExpression::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = duckdb::unique_ptr<WindowExpression>(new WindowExpression(deserializer.Get<ExpressionType>()));
-	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);
+	deserializer.ReadProperty(200, "function_name", result->function_name);
+	deserializer.ReadProperty(201, "schema", result->schema);
+	deserializer.ReadProperty(202, "catalog", result->catalog);
+	deserializer.ReadProperty(203, "children", result->children);
+	deserializer.ReadProperty(204, "partitions", result->partitions);
+	deserializer.ReadProperty(205, "orders", result->orders);
+	deserializer.ReadProperty(206, "start", result->start);
+	deserializer.ReadProperty(207, "end", result->end);
+	deserializer.ReadOptionalProperty(208, "start_expr", result->start_expr);
+	deserializer.ReadOptionalProperty(209, "end_expr", result->end_expr);
+	deserializer.ReadOptionalProperty(210, "offset_expr", result->offset_expr);
+	deserializer.ReadOptionalProperty(211, "default_expr", result->default_expr);
+	deserializer.ReadProperty(212, "ignore_nulls", result->ignore_nulls);
+	deserializer.ReadOptionalProperty(213, "filter_expr", result->filter_expr);
 	return std::move(result);
 }
 

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

@@ -10,15 +10,15 @@
 namespace duckdb {
 
 void QueryNode::FormatSerialize(FormatSerializer &serializer) const {
-	serializer.WriteProperty("type", type);
-	serializer.WriteProperty("modifiers", modifiers);
-	serializer.WriteProperty("cte_map", cte_map);
+	serializer.WriteProperty(100, "type", type);
+	serializer.WriteProperty(101, "modifiers", modifiers);
+	serializer.WriteProperty(102, "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");
+	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:
@@ -43,79 +43,79 @@ unique_ptr<QueryNode> QueryNode::FormatDeserialize(FormatDeserializer &deseriali
 
 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);
+	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) {
 	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);
+	deserializer.ReadProperty(200, "cte_name", result->ctename);
+	deserializer.ReadProperty(201, "query", result->query);
+	deserializer.ReadProperty(202, "child", result->child);
+	deserializer.ReadProperty(203, "aliases", result->aliases);
 	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);
+	serializer.WriteProperty(200, "cte_name", ctename);
+	serializer.WriteProperty(201, "union_all", union_all);
+	serializer.WriteProperty(202, "left", *left);
+	serializer.WriteProperty(203, "right", *right);
+	serializer.WriteProperty(204, "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);
+	deserializer.ReadProperty(200, "cte_name", result->ctename);
+	deserializer.ReadProperty(201, "union_all", result->union_all);
+	deserializer.ReadProperty(202, "left", result->left);
+	deserializer.ReadProperty(203, "right", result->right);
+	deserializer.ReadProperty(204, "aliases", result->aliases);
 	return std::move(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);
+	serializer.WriteProperty(200, "select_list", select_list);
+	serializer.WriteOptionalProperty(201, "from_table", from_table);
+	serializer.WriteOptionalProperty(202, "where_clause", where_clause);
+	serializer.WriteProperty(203, "group_expressions", groups.group_expressions);
+	serializer.WriteProperty(204, "group_sets", groups.grouping_sets);
+	serializer.WriteProperty(205, "aggregate_handling", aggregate_handling);
+	serializer.WriteOptionalProperty(206, "having", having);
+	serializer.WriteOptionalProperty(207, "sample", sample);
+	serializer.WriteOptionalProperty(208, "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);
+	deserializer.ReadProperty(200, "select_list", result->select_list);
+	deserializer.ReadOptionalProperty(201, "from_table", result->from_table);
+	deserializer.ReadOptionalProperty(202, "where_clause", result->where_clause);
+	deserializer.ReadProperty(203, "group_expressions", result->groups.group_expressions);
+	deserializer.ReadProperty(204, "group_sets", result->groups.grouping_sets);
+	deserializer.ReadProperty(205, "aggregate_handling", result->aggregate_handling);
+	deserializer.ReadOptionalProperty(206, "having", result->having);
+	deserializer.ReadOptionalProperty(207, "sample", result->sample);
+	deserializer.ReadOptionalProperty(208, "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);
+	serializer.WriteProperty(200, "setop_type", setop_type);
+	serializer.WriteProperty(201, "left", *left);
+	serializer.WriteProperty(202, "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);
+	deserializer.ReadProperty(200, "setop_type", result->setop_type);
+	deserializer.ReadProperty(201, "left", result->left);
+	deserializer.ReadProperty(202, "right", result->right);
 	return std::move(result);
 }
 

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

@@ -11,11 +11,11 @@
 namespace duckdb {
 
 void ResultModifier::FormatSerialize(FormatSerializer &serializer) const {
-	serializer.WriteProperty("type", type);
+	serializer.WriteProperty(100, "type", type);
 }
 
 unique_ptr<ResultModifier> ResultModifier::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto type = deserializer.ReadProperty<ResultModifierType>("type");
+	auto type = deserializer.ReadProperty<ResultModifierType>(100, "type");
 	unique_ptr<ResultModifier> result;
 	switch (type) {
 	case ResultModifierType::DISTINCT_MODIFIER:
@@ -37,60 +37,60 @@ unique_ptr<ResultModifier> ResultModifier::FormatDeserialize(FormatDeserializer
 }
 
 void BoundOrderModifier::FormatSerialize(FormatSerializer &serializer) const {
-	serializer.WriteProperty("orders", orders);
+	serializer.WriteProperty(100, "orders", orders);
 }
 
 unique_ptr<BoundOrderModifier> BoundOrderModifier::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = duckdb::unique_ptr<BoundOrderModifier>(new BoundOrderModifier());
-	deserializer.ReadProperty("orders", result->orders);
+	deserializer.ReadProperty(100, "orders", result->orders);
 	return result;
 }
 
 void DistinctModifier::FormatSerialize(FormatSerializer &serializer) const {
 	ResultModifier::FormatSerialize(serializer);
-	serializer.WriteProperty("distinct_on_targets", distinct_on_targets);
+	serializer.WriteProperty(200, "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);
+	deserializer.ReadProperty(200, "distinct_on_targets", result->distinct_on_targets);
 	return std::move(result);
 }
 
 void LimitModifier::FormatSerialize(FormatSerializer &serializer) const {
 	ResultModifier::FormatSerialize(serializer);
-	serializer.WriteOptionalProperty("limit", limit);
-	serializer.WriteOptionalProperty("offset", offset);
+	serializer.WriteOptionalProperty(200, "limit", limit);
+	serializer.WriteOptionalProperty(201, "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);
+	deserializer.ReadOptionalProperty(200, "limit", result->limit);
+	deserializer.ReadOptionalProperty(201, "offset", result->offset);
 	return std::move(result);
 }
 
 void LimitPercentModifier::FormatSerialize(FormatSerializer &serializer) const {
 	ResultModifier::FormatSerialize(serializer);
-	serializer.WriteOptionalProperty("limit", limit);
-	serializer.WriteOptionalProperty("offset", offset);
+	serializer.WriteOptionalProperty(200, "limit", limit);
+	serializer.WriteOptionalProperty(201, "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);
+	deserializer.ReadOptionalProperty(200, "limit", result->limit);
+	deserializer.ReadOptionalProperty(201, "offset", result->offset);
 	return std::move(result);
 }
 
 void OrderModifier::FormatSerialize(FormatSerializer &serializer) const {
 	ResultModifier::FormatSerialize(serializer);
-	serializer.WriteProperty("orders", orders);
+	serializer.WriteProperty(200, "orders", orders);
 }
 
 unique_ptr<ResultModifier> OrderModifier::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = duckdb::unique_ptr<OrderModifier>(new OrderModifier());
-	deserializer.ReadProperty("orders", result->orders);
+	deserializer.ReadProperty(200, "orders", result->orders);
 	return std::move(result);
 }
 

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

@@ -10,12 +10,12 @@
 namespace duckdb {
 
 void SelectStatement::FormatSerialize(FormatSerializer &serializer) const {
-	serializer.WriteProperty("node", *node);
+	serializer.WriteProperty(100, "node", *node);
 }
 
 unique_ptr<SelectStatement> SelectStatement::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = duckdb::unique_ptr<SelectStatement>(new SelectStatement());
-	deserializer.ReadProperty("node", result->node);
+	deserializer.ReadProperty(100, "node", result->node);
 	return result;
 }