duckdb 0.8.2-dev2809.0 → 0.8.2-dev2850.0

package/src/duckdb/src/main/relation/aggregate_relation.cpp

@@ -13,11 +13,28 @@ AggregateRelation::AggregateRelation(shared_ptr<Relation> child_p,
 	context.GetContext()->TryBindRelation(*this, this->columns);
 }
 
+AggregateRelation::AggregateRelation(shared_ptr<Relation> child_p,
+                                     vector<unique_ptr<ParsedExpression>> parsed_expressions, GroupByNode groups_p)
+    : Relation(child_p->context, RelationType::AGGREGATE_RELATION), expressions(std::move(parsed_expressions)),
+      groups(std::move(groups_p)), child(std::move(child_p)) {
+	// bind the expressions
+	context.GetContext()->TryBindRelation(*this, this->columns);
+}
+
 AggregateRelation::AggregateRelation(shared_ptr<Relation> child_p,
                                      vector<unique_ptr<ParsedExpression>> parsed_expressions,
                                      vector<unique_ptr<ParsedExpression>> groups_p)
     : Relation(child_p->context, RelationType::AGGREGATE_RELATION), expressions(std::move(parsed_expressions)),
-      groups(std::move(groups_p)), child(std::move(child_p)) {
+      child(std::move(child_p)) {
+	if (!groups_p.empty()) {
+		// explicit groups provided: use standard handling
+		GroupingSet grouping_set;
+		for (idx_t i = 0; i < groups_p.size(); i++) {
+			groups.group_expressions.push_back(std::move(groups_p[i]));
+			grouping_set.insert(i);
+		}
+		groups.grouping_sets.push_back(std::move(grouping_set));
+	}
 	// bind the expressions
 	context.GetContext()->TryBindRelation(*this, this->columns);
 }
@@ -39,16 +56,9 @@ unique_ptr<QueryNode> AggregateRelation::GetQueryNode() {
 	}
 	D_ASSERT(result->type == QueryNodeType::SELECT_NODE);
 	auto &select_node = result->Cast<SelectNode>();
-	if (!groups.empty()) {
-		// explicit groups provided: use standard handling
+	if (!groups.group_expressions.empty()) {
 		select_node.aggregate_handling = AggregateHandling::STANDARD_HANDLING;
-		select_node.groups.group_expressions.clear();
-		GroupingSet grouping_set;
-		for (idx_t i = 0; i < groups.size(); i++) {
-			select_node.groups.group_expressions.push_back(groups[i]->Copy());
-			grouping_set.insert(i);
-		}
-		select_node.groups.grouping_sets.push_back(std::move(grouping_set));
+		select_node.groups = groups.Copy();
 	} else {
 		// no groups provided: automatically figure out groups (if any)
 		select_node.aggregate_handling = AggregateHandling::FORCE_AGGREGATES;

package/src/duckdb/src/main/relation.cpp

@@ -169,7 +169,7 @@ shared_ptr<Relation> Relation::Aggregate(const string &aggregate_list) {
 
 shared_ptr<Relation> Relation::Aggregate(const string &aggregate_list, const string &group_list) {
 	auto expression_list = Parser::ParseExpressionList(aggregate_list, context.GetContext()->GetParserOptions());
-	auto groups = Parser::ParseExpressionList(group_list, context.GetContext()->GetParserOptions());
+	auto groups = Parser::ParseGroupByList(group_list, context.GetContext()->GetParserOptions());
 	return make_shared<AggregateRelation>(shared_from_this(), std::move(expression_list), std::move(groups));
 }
 
@@ -179,9 +179,9 @@ shared_ptr<Relation> Relation::Aggregate(const vector<string> &aggregates) {
 }
 
 shared_ptr<Relation> Relation::Aggregate(const vector<string> &aggregates, const vector<string> &groups) {
-	auto aggregate_list = StringListToExpressionList(*context.GetContext(), aggregates);
-	auto group_list = StringListToExpressionList(*context.GetContext(), groups);
-	return make_shared<AggregateRelation>(shared_from_this(), std::move(aggregate_list), std::move(group_list));
+	auto aggregate_list = StringUtil::Join(aggregates, ", ");
+	auto group_list = StringUtil::Join(groups, ", ");
+	return this->Aggregate(aggregate_list, group_list);
 }
 
 string Relation::GetAlias() {

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

@@ -8,6 +8,7 @@
 #include "duckdb/parser/statement/extension_statement.hpp"
 #include "duckdb/parser/statement/select_statement.hpp"
 #include "duckdb/parser/statement/update_statement.hpp"
+#include "duckdb/parser/group_by_node.hpp"
 #include "duckdb/parser/tableref/expressionlistref.hpp"
 #include "duckdb/parser/transformer.hpp"
 #include "parser/parser.hpp"
@@ -340,6 +341,22 @@ vector<unique_ptr<ParsedExpression>> Parser::ParseExpressionList(const string &s
 	return std::move(select_node.select_list);
 }
 
+GroupByNode Parser::ParseGroupByList(const string &group_by, ParserOptions options) {
+	// construct a mock SELECT query with our group_by expressions
+	string mock_query = StringUtil::Format("SELECT 42 GROUP BY %s", group_by);
+	// parse the query
+	Parser parser(options);
+	parser.ParseQuery(mock_query);
+	// check the result
+	if (parser.statements.size() != 1 || parser.statements[0]->type != StatementType::SELECT_STATEMENT) {
+		throw ParserException("Expected a single SELECT statement");
+	}
+	auto &select = parser.statements[0]->Cast<SelectStatement>();
+	D_ASSERT(select.node->type == QueryNodeType::SELECT_NODE);
+	auto &select_node = select.node->Cast<SelectNode>();
+	return std::move(select_node.groups);
+}
+
 vector<OrderByNode> Parser::ParseOrderList(const string &select_list, ParserOptions options) {
 	// construct a mock query
 	string mock_query = "SELECT * FROM tbl ORDER BY " + select_list;
@@ -351,9 +368,7 @@ vector<OrderByNode> Parser::ParseOrderList(const string &select_list, ParserOpti
 		throw ParserException("Expected a single SELECT statement");
 	}
 	auto &select = parser.statements[0]->Cast<SelectStatement>();
-	if (select.node->type != QueryNodeType::SELECT_NODE) {
-		throw ParserException("Expected a single SELECT node");
-	}
+	D_ASSERT(select.node->type == QueryNodeType::SELECT_NODE);
 	auto &select_node = select.node->Cast<SelectNode>();
 	if (select_node.modifiers.empty() || select_node.modifiers[0]->type != ResultModifierType::ORDER_MODIFIER ||
 	    select_node.modifiers.size() != 1) {

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

@@ -161,9 +161,9 @@ void PivotColumnEntry::Serialize(Serializer &serializer) const {
 }
 
 void PivotColumnEntry::FormatSerialize(FormatSerializer &serializer) const {
-	serializer.WriteProperty("values", values);
-	serializer.WriteOptionalProperty("star_expr", star_expr);
-	serializer.WriteProperty("alias", alias);
+	serializer.WriteProperty(100, "values", values);
+	serializer.WriteOptionalProperty(101, "star_expr", star_expr);
+	serializer.WriteProperty(102, "alias", alias);
 }
 
 PivotColumnEntry PivotColumnEntry::Deserialize(Deserializer &source) {
@@ -178,9 +178,9 @@ PivotColumnEntry PivotColumnEntry::Deserialize(Deserializer &source) {
 
 PivotColumnEntry PivotColumnEntry::FormatDeserialize(FormatDeserializer &source) {
 	PivotColumnEntry result;
-	source.ReadProperty("values", result.values);
-	source.ReadOptionalProperty("star_expr", result.star_expr);
-	source.ReadProperty("alias", result.alias);
+	source.ReadProperty(100, "values", result.values);
+	source.ReadOptionalProperty(101, "star_expr", result.star_expr);
+	source.ReadProperty(102, "alias", result.alias);
 	return result;
 }
 

package/src/duckdb/src/parser/transform/constraint/transform_constraint.cpp

@@ -17,8 +17,58 @@ static void ParseSchemaTableNameFK(duckdb_libpgquery::PGRangeVar *input, Foreign
 	fk_info.table = input->relname;
 }
 
+static bool ForeignKeyActionSupported(char action) {
+	switch (action) {
+	case PG_FKCONSTR_ACTION_NOACTION:
+	case PG_FKCONSTR_ACTION_RESTRICT:
+		return true;
+	case PG_FKCONSTR_ACTION_CASCADE:
+	case PG_FKCONSTR_ACTION_SETDEFAULT:
+	case PG_FKCONSTR_ACTION_SETNULL:
+		return false;
+	default:
+		D_ASSERT(false);
+	}
+	return false;
+}
+
+static unique_ptr<ForeignKeyConstraint>
+TransformForeignKeyConstraint(duckdb_libpgquery::PGConstraint *constraint,
+                              optional_ptr<const string> override_fk_column = nullptr) {
+	D_ASSERT(constraint);
+	if (!ForeignKeyActionSupported(constraint->fk_upd_action) ||
+	    !ForeignKeyActionSupported(constraint->fk_del_action)) {
+		throw ParserException("FOREIGN KEY constraints cannot use CASCADE, SET NULL or SET DEFAULT");
+	}
+	ForeignKeyInfo fk_info;
+	fk_info.type = ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE;
+	ParseSchemaTableNameFK(constraint->pktable, fk_info);
+	vector<string> pk_columns, fk_columns;
+	if (override_fk_column) {
+		D_ASSERT(!constraint->fk_attrs);
+		fk_columns.emplace_back(*override_fk_column);
+	} else if (constraint->fk_attrs) {
+		for (auto kc = constraint->fk_attrs->head; kc; kc = kc->next) {
+			fk_columns.emplace_back(reinterpret_cast<duckdb_libpgquery::PGValue *>(kc->data.ptr_value)->val.str);
+		}
+	}
+	if (constraint->pk_attrs) {
+		for (auto kc = constraint->pk_attrs->head; kc; kc = kc->next) {
+			pk_columns.emplace_back(reinterpret_cast<duckdb_libpgquery::PGValue *>(kc->data.ptr_value)->val.str);
+		}
+	}
+	if (!pk_columns.empty() && pk_columns.size() != fk_columns.size()) {
+		throw ParserException("The number of referencing and referenced columns for foreign keys must be the same");
+	}
+	if (fk_columns.empty()) {
+		throw ParserException("The set of referencing and referenced columns for foreign keys must be not empty");
+	}
+	return make_uniq<ForeignKeyConstraint>(pk_columns, fk_columns, std::move(fk_info));
+}
+
 unique_ptr<Constraint> Transformer::TransformConstraint(duckdb_libpgquery::PGListCell *cell) {
 	auto constraint = reinterpret_cast<duckdb_libpgquery::PGConstraint *>(cell->data.ptr_value);
+	D_ASSERT(constraint);
 	switch (constraint->contype) {
 	case duckdb_libpgquery::PG_CONSTR_UNIQUE:
 	case duckdb_libpgquery::PG_CONSTR_PRIMARY: {
@@ -36,27 +86,9 @@ unique_ptr<Constraint> Transformer::TransformConstraint(duckdb_libpgquery::PGLis
 		}
 		return make_uniq<CheckConstraint>(TransformExpression(constraint->raw_expr));
 	}
-	case duckdb_libpgquery::PG_CONSTR_FOREIGN: {
-		ForeignKeyInfo fk_info;
-		fk_info.type = ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE;
-		ParseSchemaTableNameFK(constraint->pktable, fk_info);
-		vector<string> pk_columns, fk_columns;
-		for (auto kc = constraint->fk_attrs->head; kc; kc = kc->next) {
-			fk_columns.emplace_back(reinterpret_cast<duckdb_libpgquery::PGValue *>(kc->data.ptr_value)->val.str);
-		}
-		if (constraint->pk_attrs) {
-			for (auto kc = constraint->pk_attrs->head; kc; kc = kc->next) {
-				pk_columns.emplace_back(reinterpret_cast<duckdb_libpgquery::PGValue *>(kc->data.ptr_value)->val.str);
-			}
-		}
-		if (!pk_columns.empty() && pk_columns.size() != fk_columns.size()) {
-			throw ParserException("The number of referencing and referenced columns for foreign keys must be the same");
-		}
-		if (fk_columns.empty()) {
-			throw ParserException("The set of referencing and referenced columns for foreign keys must be not empty");
-		}
-		return make_uniq<ForeignKeyConstraint>(pk_columns, fk_columns, std::move(fk_info));
-	}
+	case duckdb_libpgquery::PG_CONSTR_FOREIGN:
+		return TransformForeignKeyConstraint(constraint);
+
 	default:
 		throw NotImplementedException("Constraint type not handled yet!");
 	}
@@ -96,23 +128,8 @@ unique_ptr<Constraint> Transformer::TransformConstraint(duckdb_libpgquery::PGLis
 			                      "dictionary, pfor, bitpacking or fsst");
 		}
 		return nullptr;
-	case duckdb_libpgquery::PG_CONSTR_FOREIGN: {
-		ForeignKeyInfo fk_info;
-		fk_info.type = ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE;
-		ParseSchemaTableNameFK(constraint->pktable, fk_info);
-
-		vector<string> pk_columns, fk_columns;
-		fk_columns.emplace_back(column.Name().c_str());
-		if (constraint->pk_attrs) {
-			for (auto kc = constraint->pk_attrs->head; kc; kc = kc->next) {
-				pk_columns.emplace_back(reinterpret_cast<duckdb_libpgquery::PGValue *>(kc->data.ptr_value)->val.str);
-			}
-		}
-		if (!pk_columns.empty() && pk_columns.size() != fk_columns.size()) {
-			throw ParserException("The number of referencing and referenced columns for foreign keys must be the same");
-		}
-		return make_uniq<ForeignKeyConstraint>(pk_columns, fk_columns, std::move(fk_info));
-	}
+	case duckdb_libpgquery::PG_CONSTR_FOREIGN:
+		return TransformForeignKeyConstraint(constraint, &column.Name());
 	default:
 		throw NotImplementedException("Constraint not implemented!");
 	}

package/src/duckdb/src/planner/expression/bound_aggregate_expression.cpp

@@ -106,24 +106,24 @@ unique_ptr<Expression> BoundAggregateExpression::Deserialize(ExpressionDeseriali
 
 void BoundAggregateExpression::FormatSerialize(FormatSerializer &serializer) const {
 	Expression::FormatSerialize(serializer);
-	serializer.WriteProperty("return_type", return_type);
-	serializer.WriteProperty("children", children);
+	serializer.WriteProperty(200, "return_type", return_type);
+	serializer.WriteProperty(201, "children", children);
 	FunctionSerializer::FormatSerialize(serializer, function, bind_info.get());
-	serializer.WriteProperty("aggregate_type", aggr_type);
-	serializer.WriteOptionalProperty("filter", filter);
-	serializer.WriteOptionalProperty("order_bys", order_bys);
+	serializer.WriteProperty(203, "aggregate_type", aggr_type);
+	serializer.WriteOptionalProperty(204, "filter", filter);
+	serializer.WriteOptionalProperty(205, "order_bys", order_bys);
 }
 
 unique_ptr<Expression> BoundAggregateExpression::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto return_type = deserializer.ReadProperty<LogicalType>("return_type");
-	auto children = deserializer.ReadProperty<vector<unique_ptr<Expression>>>("children");
+	auto return_type = deserializer.ReadProperty<LogicalType>(200, "return_type");
+	auto children = deserializer.ReadProperty<vector<unique_ptr<Expression>>>(201, "children");
 	auto entry = FunctionSerializer::FormatDeserialize<AggregateFunction, AggregateFunctionCatalogEntry>(
 	    deserializer, CatalogType::AGGREGATE_FUNCTION_ENTRY, children);
-	auto aggregate_type = deserializer.ReadProperty<AggregateType>("aggregate_type");
-	auto filter = deserializer.ReadOptionalProperty<unique_ptr<Expression>>("filter");
+	auto aggregate_type = deserializer.ReadProperty<AggregateType>(203, "aggregate_type");
+	auto filter = deserializer.ReadOptionalProperty<unique_ptr<Expression>>(204, "filter");
 	auto result = make_uniq<BoundAggregateExpression>(std::move(entry.first), std::move(children), std::move(filter),
 	                                                  std::move(entry.second), aggregate_type);
-	deserializer.ReadOptionalProperty("order_bys", result->order_bys);
+	deserializer.ReadOptionalProperty(205, "order_bys", result->order_bys);
 	return std::move(result);
 }
 

package/src/duckdb/src/planner/expression/bound_function_expression.cpp

@@ -97,20 +97,20 @@ unique_ptr<Expression> BoundFunctionExpression::Deserialize(ExpressionDeserializ
 
 void BoundFunctionExpression::FormatSerialize(FormatSerializer &serializer) const {
 	Expression::FormatSerialize(serializer);
-	serializer.WriteProperty("return_type", return_type);
-	serializer.WriteProperty("children", children);
+	serializer.WriteProperty(200, "return_type", return_type);
+	serializer.WriteProperty(201, "children", children);
 	FunctionSerializer::FormatSerialize(serializer, function, bind_info.get());
-	serializer.WriteProperty("is_operator", is_operator);
+	serializer.WriteProperty(202, "is_operator", is_operator);
 }
 
 unique_ptr<Expression> BoundFunctionExpression::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto return_type = deserializer.ReadProperty<LogicalType>("return_type");
-	auto children = deserializer.ReadProperty<vector<unique_ptr<Expression>>>("children");
+	auto return_type = deserializer.ReadProperty<LogicalType>(200, "return_type");
+	auto children = deserializer.ReadProperty<vector<unique_ptr<Expression>>>(201, "children");
 	auto entry = FunctionSerializer::FormatDeserialize<ScalarFunction, ScalarFunctionCatalogEntry>(
 	    deserializer, CatalogType::SCALAR_FUNCTION_ENTRY, children);
 	auto result = make_uniq<BoundFunctionExpression>(std::move(return_type), std::move(entry.first),
 	                                                 std::move(children), std::move(entry.second));
-	deserializer.ReadProperty("is_operator", result->is_operator);
+	deserializer.ReadProperty(202, "is_operator", result->is_operator);
 	return std::move(result);
 }
 

package/src/duckdb/src/planner/expression/bound_window_expression.cpp

@@ -164,28 +164,28 @@ unique_ptr<Expression> BoundWindowExpression::Deserialize(ExpressionDeserializat
 
 void BoundWindowExpression::FormatSerialize(FormatSerializer &serializer) const {
 	Expression::FormatSerialize(serializer);
-	serializer.WriteProperty("return_type", return_type);
-	serializer.WriteProperty("children", children);
+	serializer.WriteProperty(200, "return_type", return_type);
+	serializer.WriteProperty(201, "children", children);
 	if (type == ExpressionType::WINDOW_AGGREGATE) {
 		D_ASSERT(aggregate);
 		FunctionSerializer::FormatSerialize(serializer, *aggregate, bind_info.get());
 	}
-	serializer.WriteProperty("partitions", partitions);
-	serializer.WriteProperty("orders", orders);
-	serializer.WriteOptionalProperty("filters", filter_expr);
-	serializer.WriteProperty("ignore_nulls", ignore_nulls);
-	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(202, "partitions", partitions);
+	serializer.WriteProperty(203, "orders", orders);
+	serializer.WriteOptionalProperty(204, "filters", filter_expr);
+	serializer.WriteProperty(205, "ignore_nulls", ignore_nulls);
+	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);
 }
 
 unique_ptr<Expression> BoundWindowExpression::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto expression_type = deserializer.Get<ExpressionType>();
-	auto return_type = deserializer.ReadProperty<LogicalType>("return_type");
-	auto children = deserializer.ReadProperty<vector<unique_ptr<Expression>>>("children");
+	auto return_type = deserializer.ReadProperty<LogicalType>(200, "return_type");
+	auto children = deserializer.ReadProperty<vector<unique_ptr<Expression>>>(201, "children");
 	unique_ptr<AggregateFunction> aggregate;
 	unique_ptr<FunctionData> bind_info;
 	if (expression_type == ExpressionType::WINDOW_AGGREGATE) {
@@ -196,16 +196,16 @@ unique_ptr<Expression> BoundWindowExpression::FormatDeserialize(FormatDeserializ
 	}
 	auto result =
 	    make_uniq<BoundWindowExpression>(expression_type, return_type, std::move(aggregate), std::move(bind_info));
-	deserializer.ReadProperty("partitions", result->partitions);
-	deserializer.ReadProperty("orders", result->orders);
-	deserializer.ReadOptionalProperty("filters", result->filter_expr);
-	deserializer.ReadProperty("ignore_nulls", result->ignore_nulls);
-	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(202, "partitions", result->partitions);
+	deserializer.ReadProperty(203, "orders", result->orders);
+	deserializer.ReadOptionalProperty(204, "filters", result->filter_expr);
+	deserializer.ReadProperty(205, "ignore_nulls", result->ignore_nulls);
+	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);
 	return std::move(result);
 }
 

package/src/duckdb/src/planner/operator/logical_extension_operator.cpp

@@ -20,12 +20,12 @@ unique_ptr<LogicalExtensionOperator> LogicalExtensionOperator::Deserialize(Logic
 
 void LogicalExtensionOperator::FormatSerialize(FormatSerializer &serializer) const {
 	LogicalOperator::FormatSerialize(serializer);
-	serializer.WriteProperty("extension_name", GetExtensionName());
+	serializer.WriteProperty(200, "extension_name", GetExtensionName());
 }
 
 unique_ptr<LogicalOperator> LogicalExtensionOperator::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto &config = DBConfig::GetConfig(deserializer.Get<ClientContext &>());
-	auto extension_name = deserializer.ReadProperty<string>("extension_name");
+	auto extension_name = deserializer.ReadProperty<string>(200, "extension_name");
 	for (auto &extension : config.operator_extensions) {
 		if (extension->GetName() == extension_name) {
 			return extension->FormatDeserialize(deserializer);

package/src/duckdb/src/planner/operator/logical_get.cpp

@@ -210,32 +210,32 @@ unique_ptr<LogicalOperator> LogicalGet::Deserialize(LogicalDeserializationState
 
 void LogicalGet::FormatSerialize(FormatSerializer &serializer) const {
 	LogicalOperator::FormatSerialize(serializer);
-	serializer.WriteProperty("table_index", table_index);
-	serializer.WriteProperty("returned_types", returned_types);
-	serializer.WriteProperty("names", names);
-	serializer.WriteProperty("column_ids", column_ids);
-	serializer.WriteProperty("projection_ids", projection_ids);
-	serializer.WriteProperty("table_filters", table_filters);
+	serializer.WriteProperty(200, "table_index", table_index);
+	serializer.WriteProperty(201, "returned_types", returned_types);
+	serializer.WriteProperty(202, "names", names);
+	serializer.WriteProperty(203, "column_ids", column_ids);
+	serializer.WriteProperty(204, "projection_ids", projection_ids);
+	serializer.WriteProperty(205, "table_filters", table_filters);
 	FunctionSerializer::FormatSerialize(serializer, function, bind_data.get());
 	if (!function.format_serialize) {
 		D_ASSERT(!function.format_deserialize);
 		// no serialize method: serialize input values and named_parameters for rebinding purposes
-		serializer.WriteProperty("parameters", parameters);
-		serializer.WriteProperty("named_parameters", named_parameters);
-		serializer.WriteProperty("input_table_types", input_table_types);
-		serializer.WriteProperty("input_table_names", input_table_names);
+		serializer.WriteProperty(206, "parameters", parameters);
+		serializer.WriteProperty(207, "named_parameters", named_parameters);
+		serializer.WriteProperty(208, "input_table_types", input_table_types);
+		serializer.WriteProperty(209, "input_table_names", input_table_names);
 	}
-	serializer.WriteProperty("projected_input", projected_input);
+	serializer.WriteProperty(210, "projected_input", projected_input);
 }
 
 unique_ptr<LogicalOperator> LogicalGet::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = unique_ptr<LogicalGet>(new LogicalGet());
-	deserializer.ReadProperty("table_index", result->table_index);
-	deserializer.ReadProperty("returned_types", result->returned_types);
-	deserializer.ReadProperty("names", result->names);
-	deserializer.ReadProperty("column_ids", result->column_ids);
-	deserializer.ReadProperty("projection_ids", result->projection_ids);
-	deserializer.ReadProperty("table_filters", result->table_filters);
+	deserializer.ReadProperty(200, "table_index", result->table_index);
+	deserializer.ReadProperty(201, "returned_types", result->returned_types);
+	deserializer.ReadProperty(202, "names", result->names);
+	deserializer.ReadProperty(203, "column_ids", result->column_ids);
+	deserializer.ReadProperty(204, "projection_ids", result->projection_ids);
+	deserializer.ReadProperty(205, "table_filters", result->table_filters);
 	auto entry = FunctionSerializer::FormatDeserializeBase<TableFunction, TableFunctionCatalogEntry>(
 	    deserializer, CatalogType::TABLE_FUNCTION_ENTRY);
 	auto &function = entry.first;
@@ -243,10 +243,10 @@ unique_ptr<LogicalOperator> LogicalGet::FormatDeserialize(FormatDeserializer &de
 
 	unique_ptr<FunctionData> bind_data;
 	if (!has_serialize) {
-		deserializer.ReadProperty("parameters", result->parameters);
-		deserializer.ReadProperty("named_parameters", result->named_parameters);
-		deserializer.ReadProperty("input_table_types", result->input_table_types);
-		deserializer.ReadProperty("input_table_names", result->input_table_names);
+		deserializer.ReadProperty(206, "parameters", result->parameters);
+		deserializer.ReadProperty(207, "named_parameters", result->named_parameters);
+		deserializer.ReadProperty(208, "input_table_types", result->input_table_types);
+		deserializer.ReadProperty(209, "input_table_names", result->input_table_names);
 		TableFunctionBindInput input(result->parameters, result->named_parameters, result->input_table_types,
 		                             result->input_table_names, function.function_info.get());
 
@@ -268,7 +268,7 @@ unique_ptr<LogicalOperator> LogicalGet::FormatDeserialize(FormatDeserializer &de
 	} else {
 		bind_data = FunctionSerializer::FunctionDeserialize(deserializer, function);
 	}
-	deserializer.ReadProperty("projected_input", result->projected_input);
+	deserializer.ReadProperty(210, "projected_input", result->projected_input);
 	return std::move(result);
 }
 

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

@@ -10,11 +10,11 @@
 namespace duckdb {
 
 void Constraint::FormatSerialize(FormatSerializer &serializer) const {
-	serializer.WriteProperty("type", type);
+	serializer.WriteProperty(100, "type", type);
 }
 
 unique_ptr<Constraint> Constraint::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto type = deserializer.ReadProperty<ConstraintType>("type");
+	auto type = deserializer.ReadProperty<ConstraintType>(100, "type");
 	unique_ptr<Constraint> result;
 	switch (type) {
 	case ConstraintType::CHECK:
@@ -37,61 +37,61 @@ unique_ptr<Constraint> Constraint::FormatDeserialize(FormatDeserializer &deseria
 
 void CheckConstraint::FormatSerialize(FormatSerializer &serializer) const {
 	Constraint::FormatSerialize(serializer);
-	serializer.WriteProperty("expression", *expression);
+	serializer.WriteProperty(200, "expression", *expression);
 }
 
 unique_ptr<Constraint> CheckConstraint::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto expression = deserializer.ReadProperty<unique_ptr<ParsedExpression>>("expression");
+	auto expression = deserializer.ReadProperty<unique_ptr<ParsedExpression>>(200, "expression");
 	auto result = duckdb::unique_ptr<CheckConstraint>(new CheckConstraint(std::move(expression)));
 	return std::move(result);
 }
 
 void ForeignKeyConstraint::FormatSerialize(FormatSerializer &serializer) const {
 	Constraint::FormatSerialize(serializer);
-	serializer.WriteProperty("pk_columns", pk_columns);
-	serializer.WriteProperty("fk_columns", fk_columns);
-	serializer.WriteProperty("fk_type", info.type);
-	serializer.WriteProperty("schema", info.schema);
-	serializer.WriteProperty("table", info.table);
-	serializer.WriteProperty("pk_keys", info.pk_keys);
-	serializer.WriteProperty("fk_keys", info.fk_keys);
+	serializer.WriteProperty(200, "pk_columns", pk_columns);
+	serializer.WriteProperty(201, "fk_columns", fk_columns);
+	serializer.WriteProperty(202, "fk_type", info.type);
+	serializer.WriteProperty(203, "schema", info.schema);
+	serializer.WriteProperty(204, "table", info.table);
+	serializer.WriteProperty(205, "pk_keys", info.pk_keys);
+	serializer.WriteProperty(206, "fk_keys", info.fk_keys);
 }
 
 unique_ptr<Constraint> ForeignKeyConstraint::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = duckdb::unique_ptr<ForeignKeyConstraint>(new ForeignKeyConstraint());
-	deserializer.ReadProperty("pk_columns", result->pk_columns);
-	deserializer.ReadProperty("fk_columns", result->fk_columns);
-	deserializer.ReadProperty("fk_type", result->info.type);
-	deserializer.ReadProperty("schema", result->info.schema);
-	deserializer.ReadProperty("table", result->info.table);
-	deserializer.ReadProperty("pk_keys", result->info.pk_keys);
-	deserializer.ReadProperty("fk_keys", result->info.fk_keys);
+	deserializer.ReadProperty(200, "pk_columns", result->pk_columns);
+	deserializer.ReadProperty(201, "fk_columns", result->fk_columns);
+	deserializer.ReadProperty(202, "fk_type", result->info.type);
+	deserializer.ReadProperty(203, "schema", result->info.schema);
+	deserializer.ReadProperty(204, "table", result->info.table);
+	deserializer.ReadProperty(205, "pk_keys", result->info.pk_keys);
+	deserializer.ReadProperty(206, "fk_keys", result->info.fk_keys);
 	return std::move(result);
 }
 
 void NotNullConstraint::FormatSerialize(FormatSerializer &serializer) const {
 	Constraint::FormatSerialize(serializer);
-	serializer.WriteProperty("index", index);
+	serializer.WriteProperty(200, "index", index);
 }
 
 unique_ptr<Constraint> NotNullConstraint::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto index = deserializer.ReadProperty<LogicalIndex>("index");
+	auto index = deserializer.ReadProperty<LogicalIndex>(200, "index");
 	auto result = duckdb::unique_ptr<NotNullConstraint>(new NotNullConstraint(index));
 	return std::move(result);
 }
 
 void UniqueConstraint::FormatSerialize(FormatSerializer &serializer) const {
 	Constraint::FormatSerialize(serializer);
-	serializer.WriteProperty("is_primary_key", is_primary_key);
-	serializer.WriteProperty("index", index);
-	serializer.WriteProperty("columns", columns);
+	serializer.WriteProperty(200, "is_primary_key", is_primary_key);
+	serializer.WriteProperty(201, "index", index);
+	serializer.WriteProperty(202, "columns", columns);
 }
 
 unique_ptr<Constraint> UniqueConstraint::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = duckdb::unique_ptr<UniqueConstraint>(new UniqueConstraint());
-	deserializer.ReadProperty("is_primary_key", result->is_primary_key);
-	deserializer.ReadProperty("index", result->index);
-	deserializer.ReadProperty("columns", result->columns);
+	deserializer.ReadProperty(200, "is_primary_key", result->is_primary_key);
+	deserializer.ReadProperty(201, "index", result->index);
+	deserializer.ReadProperty(202, "columns", result->columns);
 	return std::move(result);
 }