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

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

@@ -12,13 +12,13 @@
 namespace duckdb {
 
 void LogicalOperator::FormatSerialize(FormatSerializer &serializer) const {
-	serializer.WriteProperty("type", type);
-	serializer.WriteProperty("children", children);
+	serializer.WriteProperty(100, "type", type);
+	serializer.WriteProperty(101, "children", children);
 }
 
 unique_ptr<LogicalOperator> LogicalOperator::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto type = deserializer.ReadProperty<LogicalOperatorType>("type");
-	auto children = deserializer.ReadProperty<vector<unique_ptr<LogicalOperator>>>("children");
+	auto type = deserializer.ReadProperty<LogicalOperatorType>(100, "type");
+	auto children = deserializer.ReadProperty<vector<unique_ptr<LogicalOperator>>>(101, "children");
 	deserializer.Set<LogicalOperatorType>(type);
 	unique_ptr<LogicalOperator> result;
 	switch (type) {
@@ -191,138 +191,138 @@ unique_ptr<LogicalOperator> LogicalOperator::FormatDeserialize(FormatDeserialize
 
 void LogicalAggregate::FormatSerialize(FormatSerializer &serializer) const {
 	LogicalOperator::FormatSerialize(serializer);
-	serializer.WriteProperty("expressions", expressions);
-	serializer.WriteProperty("group_index", group_index);
-	serializer.WriteProperty("aggregate_index", aggregate_index);
-	serializer.WriteProperty("groupings_index", groupings_index);
-	serializer.WriteProperty("groups", groups);
-	serializer.WriteProperty("grouping_sets", grouping_sets);
-	serializer.WriteProperty("grouping_functions", grouping_functions);
+	serializer.WriteProperty(200, "expressions", expressions);
+	serializer.WriteProperty(201, "group_index", group_index);
+	serializer.WriteProperty(202, "aggregate_index", aggregate_index);
+	serializer.WriteProperty(203, "groupings_index", groupings_index);
+	serializer.WriteProperty(204, "groups", groups);
+	serializer.WriteProperty(205, "grouping_sets", grouping_sets);
+	serializer.WriteProperty(206, "grouping_functions", grouping_functions);
 }
 
 unique_ptr<LogicalOperator> LogicalAggregate::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto expressions = deserializer.ReadProperty<vector<unique_ptr<Expression>>>("expressions");
-	auto group_index = deserializer.ReadProperty<idx_t>("group_index");
-	auto aggregate_index = deserializer.ReadProperty<idx_t>("aggregate_index");
+	auto expressions = deserializer.ReadProperty<vector<unique_ptr<Expression>>>(200, "expressions");
+	auto group_index = deserializer.ReadProperty<idx_t>(201, "group_index");
+	auto aggregate_index = deserializer.ReadProperty<idx_t>(202, "aggregate_index");
 	auto result = duckdb::unique_ptr<LogicalAggregate>(new LogicalAggregate(group_index, aggregate_index, std::move(expressions)));
-	deserializer.ReadProperty("groupings_index", result->groupings_index);
-	deserializer.ReadProperty("groups", result->groups);
-	deserializer.ReadProperty("grouping_sets", result->grouping_sets);
-	deserializer.ReadProperty("grouping_functions", result->grouping_functions);
+	deserializer.ReadProperty(203, "groupings_index", result->groupings_index);
+	deserializer.ReadProperty(204, "groups", result->groups);
+	deserializer.ReadProperty(205, "grouping_sets", result->grouping_sets);
+	deserializer.ReadProperty(206, "grouping_functions", result->grouping_functions);
 	return std::move(result);
 }
 
 void LogicalAnyJoin::FormatSerialize(FormatSerializer &serializer) const {
 	LogicalOperator::FormatSerialize(serializer);
-	serializer.WriteProperty("join_type", join_type);
-	serializer.WriteProperty("mark_index", mark_index);
-	serializer.WriteProperty("left_projection_map", left_projection_map);
-	serializer.WriteProperty("right_projection_map", right_projection_map);
-	serializer.WriteProperty("condition", *condition);
+	serializer.WriteProperty(200, "join_type", join_type);
+	serializer.WriteProperty(201, "mark_index", mark_index);
+	serializer.WriteProperty(202, "left_projection_map", left_projection_map);
+	serializer.WriteProperty(203, "right_projection_map", right_projection_map);
+	serializer.WriteProperty(204, "condition", *condition);
 }
 
 unique_ptr<LogicalOperator> LogicalAnyJoin::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto join_type = deserializer.ReadProperty<JoinType>("join_type");
+	auto join_type = deserializer.ReadProperty<JoinType>(200, "join_type");
 	auto result = duckdb::unique_ptr<LogicalAnyJoin>(new LogicalAnyJoin(join_type));
-	deserializer.ReadProperty("mark_index", result->mark_index);
-	deserializer.ReadProperty("left_projection_map", result->left_projection_map);
-	deserializer.ReadProperty("right_projection_map", result->right_projection_map);
-	deserializer.ReadProperty("condition", result->condition);
+	deserializer.ReadProperty(201, "mark_index", result->mark_index);
+	deserializer.ReadProperty(202, "left_projection_map", result->left_projection_map);
+	deserializer.ReadProperty(203, "right_projection_map", result->right_projection_map);
+	deserializer.ReadProperty(204, "condition", result->condition);
 	return std::move(result);
 }
 
 void LogicalCTERef::FormatSerialize(FormatSerializer &serializer) const {
 	LogicalOperator::FormatSerialize(serializer);
-	serializer.WriteProperty("table_index", table_index);
-	serializer.WriteProperty("cte_index", cte_index);
-	serializer.WriteProperty("chunk_types", chunk_types);
-	serializer.WriteProperty("bound_columns", bound_columns);
-	serializer.WriteProperty("materialized_cte", materialized_cte);
+	serializer.WriteProperty(200, "table_index", table_index);
+	serializer.WriteProperty(201, "cte_index", cte_index);
+	serializer.WriteProperty(202, "chunk_types", chunk_types);
+	serializer.WriteProperty(203, "bound_columns", bound_columns);
+	serializer.WriteProperty(204, "materialized_cte", materialized_cte);
 }
 
 unique_ptr<LogicalOperator> LogicalCTERef::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto table_index = deserializer.ReadProperty<idx_t>("table_index");
-	auto cte_index = deserializer.ReadProperty<idx_t>("cte_index");
-	auto chunk_types = deserializer.ReadProperty<vector<LogicalType>>("chunk_types");
-	auto bound_columns = deserializer.ReadProperty<vector<string>>("bound_columns");
-	auto materialized_cte = deserializer.ReadProperty<CTEMaterialize>("materialized_cte");
+	auto table_index = deserializer.ReadProperty<idx_t>(200, "table_index");
+	auto cte_index = deserializer.ReadProperty<idx_t>(201, "cte_index");
+	auto chunk_types = deserializer.ReadProperty<vector<LogicalType>>(202, "chunk_types");
+	auto bound_columns = deserializer.ReadProperty<vector<string>>(203, "bound_columns");
+	auto materialized_cte = deserializer.ReadProperty<CTEMaterialize>(204, "materialized_cte");
 	auto result = duckdb::unique_ptr<LogicalCTERef>(new LogicalCTERef(table_index, cte_index, std::move(chunk_types), std::move(bound_columns), materialized_cte));
 	return std::move(result);
 }
 
 void LogicalColumnDataGet::FormatSerialize(FormatSerializer &serializer) const {
 	LogicalOperator::FormatSerialize(serializer);
-	serializer.WriteProperty("table_index", table_index);
-	serializer.WriteProperty("chunk_types", chunk_types);
-	serializer.WriteProperty("collection", *collection);
+	serializer.WriteProperty(200, "table_index", table_index);
+	serializer.WriteProperty(201, "chunk_types", chunk_types);
+	serializer.WriteProperty(202, "collection", *collection);
 }
 
 unique_ptr<LogicalOperator> LogicalColumnDataGet::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto table_index = deserializer.ReadProperty<idx_t>("table_index");
-	auto chunk_types = deserializer.ReadProperty<vector<LogicalType>>("chunk_types");
-	auto collection = deserializer.ReadProperty<unique_ptr<ColumnDataCollection>>("collection");
+	auto table_index = deserializer.ReadProperty<idx_t>(200, "table_index");
+	auto chunk_types = deserializer.ReadProperty<vector<LogicalType>>(201, "chunk_types");
+	auto collection = deserializer.ReadProperty<unique_ptr<ColumnDataCollection>>(202, "collection");
 	auto result = duckdb::unique_ptr<LogicalColumnDataGet>(new LogicalColumnDataGet(table_index, std::move(chunk_types), std::move(collection)));
 	return std::move(result);
 }
 
 void LogicalComparisonJoin::FormatSerialize(FormatSerializer &serializer) const {
 	LogicalOperator::FormatSerialize(serializer);
-	serializer.WriteProperty("join_type", join_type);
-	serializer.WriteProperty("mark_index", mark_index);
-	serializer.WriteProperty("left_projection_map", left_projection_map);
-	serializer.WriteProperty("right_projection_map", right_projection_map);
-	serializer.WriteProperty("conditions", conditions);
-	serializer.WriteProperty("mark_types", mark_types);
-	serializer.WriteProperty("duplicate_eliminated_columns", duplicate_eliminated_columns);
+	serializer.WriteProperty(200, "join_type", join_type);
+	serializer.WriteProperty(201, "mark_index", mark_index);
+	serializer.WriteProperty(202, "left_projection_map", left_projection_map);
+	serializer.WriteProperty(203, "right_projection_map", right_projection_map);
+	serializer.WriteProperty(204, "conditions", conditions);
+	serializer.WriteProperty(205, "mark_types", mark_types);
+	serializer.WriteProperty(206, "duplicate_eliminated_columns", duplicate_eliminated_columns);
 }
 
 unique_ptr<LogicalOperator> LogicalComparisonJoin::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto join_type = deserializer.ReadProperty<JoinType>("join_type");
+	auto join_type = deserializer.ReadProperty<JoinType>(200, "join_type");
 	auto result = duckdb::unique_ptr<LogicalComparisonJoin>(new LogicalComparisonJoin(join_type, deserializer.Get<LogicalOperatorType>()));
-	deserializer.ReadProperty("mark_index", result->mark_index);
-	deserializer.ReadProperty("left_projection_map", result->left_projection_map);
-	deserializer.ReadProperty("right_projection_map", result->right_projection_map);
-	deserializer.ReadProperty("conditions", result->conditions);
-	deserializer.ReadProperty("mark_types", result->mark_types);
-	deserializer.ReadProperty("duplicate_eliminated_columns", result->duplicate_eliminated_columns);
+	deserializer.ReadProperty(201, "mark_index", result->mark_index);
+	deserializer.ReadProperty(202, "left_projection_map", result->left_projection_map);
+	deserializer.ReadProperty(203, "right_projection_map", result->right_projection_map);
+	deserializer.ReadProperty(204, "conditions", result->conditions);
+	deserializer.ReadProperty(205, "mark_types", result->mark_types);
+	deserializer.ReadProperty(206, "duplicate_eliminated_columns", result->duplicate_eliminated_columns);
 	return std::move(result);
 }
 
 void LogicalCreate::FormatSerialize(FormatSerializer &serializer) const {
 	LogicalOperator::FormatSerialize(serializer);
-	serializer.WriteProperty("info", *info);
+	serializer.WriteProperty(200, "info", *info);
 }
 
 unique_ptr<LogicalOperator> LogicalCreate::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto info = deserializer.ReadProperty<unique_ptr<CreateInfo>>("info");
+	auto info = deserializer.ReadProperty<unique_ptr<CreateInfo>>(200, "info");
 	auto result = duckdb::unique_ptr<LogicalCreate>(new LogicalCreate(deserializer.Get<LogicalOperatorType>(), deserializer.Get<ClientContext &>(), std::move(info)));
 	return std::move(result);
 }
 
 void LogicalCreateIndex::FormatSerialize(FormatSerializer &serializer) const {
 	LogicalOperator::FormatSerialize(serializer);
-	serializer.WriteProperty("info", *info);
-	serializer.WriteProperty("unbound_expressions", unbound_expressions);
+	serializer.WriteProperty(200, "info", *info);
+	serializer.WriteProperty(201, "unbound_expressions", unbound_expressions);
 }
 
 unique_ptr<LogicalOperator> LogicalCreateIndex::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto info = deserializer.ReadProperty<unique_ptr<CreateInfo>>("info");
-	auto unbound_expressions = deserializer.ReadProperty<vector<unique_ptr<Expression>>>("unbound_expressions");
+	auto info = deserializer.ReadProperty<unique_ptr<CreateInfo>>(200, "info");
+	auto unbound_expressions = deserializer.ReadProperty<vector<unique_ptr<Expression>>>(201, "unbound_expressions");
 	auto result = duckdb::unique_ptr<LogicalCreateIndex>(new LogicalCreateIndex(deserializer.Get<ClientContext &>(), std::move(info), std::move(unbound_expressions)));
 	return std::move(result);
 }
 
 void LogicalCreateTable::FormatSerialize(FormatSerializer &serializer) const {
 	LogicalOperator::FormatSerialize(serializer);
-	serializer.WriteProperty("catalog", schema.ParentCatalog().GetName());
-	serializer.WriteProperty("schema", schema.name);
-	serializer.WriteProperty("info", *info->base);
+	serializer.WriteProperty(200, "catalog", schema.ParentCatalog().GetName());
+	serializer.WriteProperty(201, "schema", schema.name);
+	serializer.WriteProperty(202, "info", *info->base);
 }
 
 unique_ptr<LogicalOperator> LogicalCreateTable::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto catalog = deserializer.ReadProperty<string>("catalog");
-	auto schema = deserializer.ReadProperty<string>("schema");
-	auto info = deserializer.ReadProperty<unique_ptr<CreateInfo>>("info");
+	auto catalog = deserializer.ReadProperty<string>(200, "catalog");
+	auto schema = deserializer.ReadProperty<string>(201, "schema");
+	auto info = deserializer.ReadProperty<unique_ptr<CreateInfo>>(202, "info");
 	auto result = duckdb::unique_ptr<LogicalCreateTable>(new LogicalCreateTable(deserializer.Get<ClientContext &>(), catalog, schema, std::move(info)));
 	return std::move(result);
 }
@@ -338,241 +338,241 @@ unique_ptr<LogicalOperator> LogicalCrossProduct::FormatDeserialize(FormatDeseria
 
 void LogicalDelete::FormatSerialize(FormatSerializer &serializer) const {
 	LogicalOperator::FormatSerialize(serializer);
-	serializer.WriteProperty("catalog", table.ParentCatalog().GetName());
-	serializer.WriteProperty("schema", table.ParentSchema().name);
-	serializer.WriteProperty("table", table.name);
-	serializer.WriteProperty("table_index", table_index);
-	serializer.WriteProperty("return_chunk", return_chunk);
-	serializer.WriteProperty("expressions", expressions);
+	serializer.WriteProperty(200, "catalog", table.ParentCatalog().GetName());
+	serializer.WriteProperty(201, "schema", table.ParentSchema().name);
+	serializer.WriteProperty(202, "table", table.name);
+	serializer.WriteProperty(203, "table_index", table_index);
+	serializer.WriteProperty(204, "return_chunk", return_chunk);
+	serializer.WriteProperty(205, "expressions", expressions);
 }
 
 unique_ptr<LogicalOperator> LogicalDelete::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto catalog = deserializer.ReadProperty<string>("catalog");
-	auto schema = deserializer.ReadProperty<string>("schema");
-	auto table = deserializer.ReadProperty<string>("table");
+	auto catalog = deserializer.ReadProperty<string>(200, "catalog");
+	auto schema = deserializer.ReadProperty<string>(201, "schema");
+	auto table = deserializer.ReadProperty<string>(202, "table");
 	auto result = duckdb::unique_ptr<LogicalDelete>(new LogicalDelete(deserializer.Get<ClientContext &>(), catalog, schema, table));
-	deserializer.ReadProperty("table_index", result->table_index);
-	deserializer.ReadProperty("return_chunk", result->return_chunk);
-	deserializer.ReadProperty("expressions", result->expressions);
+	deserializer.ReadProperty(203, "table_index", result->table_index);
+	deserializer.ReadProperty(204, "return_chunk", result->return_chunk);
+	deserializer.ReadProperty(205, "expressions", result->expressions);
 	return std::move(result);
 }
 
 void LogicalDelimGet::FormatSerialize(FormatSerializer &serializer) const {
 	LogicalOperator::FormatSerialize(serializer);
-	serializer.WriteProperty("table_index", table_index);
-	serializer.WriteProperty("chunk_types", chunk_types);
+	serializer.WriteProperty(200, "table_index", table_index);
+	serializer.WriteProperty(201, "chunk_types", chunk_types);
 }
 
 unique_ptr<LogicalOperator> LogicalDelimGet::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto table_index = deserializer.ReadProperty<idx_t>("table_index");
-	auto chunk_types = deserializer.ReadProperty<vector<LogicalType>>("chunk_types");
+	auto table_index = deserializer.ReadProperty<idx_t>(200, "table_index");
+	auto chunk_types = deserializer.ReadProperty<vector<LogicalType>>(201, "chunk_types");
 	auto result = duckdb::unique_ptr<LogicalDelimGet>(new LogicalDelimGet(table_index, std::move(chunk_types)));
 	return std::move(result);
 }
 
 void LogicalDistinct::FormatSerialize(FormatSerializer &serializer) const {
 	LogicalOperator::FormatSerialize(serializer);
-	serializer.WriteProperty("distinct_type", distinct_type);
-	serializer.WriteProperty("distinct_targets", distinct_targets);
-	serializer.WriteOptionalProperty("order_by", order_by);
+	serializer.WriteProperty(200, "distinct_type", distinct_type);
+	serializer.WriteProperty(201, "distinct_targets", distinct_targets);
+	serializer.WriteOptionalProperty(202, "order_by", order_by);
 }
 
 unique_ptr<LogicalOperator> LogicalDistinct::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto distinct_type = deserializer.ReadProperty<DistinctType>("distinct_type");
-	auto distinct_targets = deserializer.ReadProperty<vector<unique_ptr<Expression>>>("distinct_targets");
+	auto distinct_type = deserializer.ReadProperty<DistinctType>(200, "distinct_type");
+	auto distinct_targets = deserializer.ReadProperty<vector<unique_ptr<Expression>>>(201, "distinct_targets");
 	auto result = duckdb::unique_ptr<LogicalDistinct>(new LogicalDistinct(std::move(distinct_targets), distinct_type));
-	deserializer.ReadOptionalProperty("order_by", result->order_by);
+	deserializer.ReadOptionalProperty(202, "order_by", result->order_by);
 	return std::move(result);
 }
 
 void LogicalDummyScan::FormatSerialize(FormatSerializer &serializer) const {
 	LogicalOperator::FormatSerialize(serializer);
-	serializer.WriteProperty("table_index", table_index);
+	serializer.WriteProperty(200, "table_index", table_index);
 }
 
 unique_ptr<LogicalOperator> LogicalDummyScan::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto table_index = deserializer.ReadProperty<idx_t>("table_index");
+	auto table_index = deserializer.ReadProperty<idx_t>(200, "table_index");
 	auto result = duckdb::unique_ptr<LogicalDummyScan>(new LogicalDummyScan(table_index));
 	return std::move(result);
 }
 
 void LogicalEmptyResult::FormatSerialize(FormatSerializer &serializer) const {
 	LogicalOperator::FormatSerialize(serializer);
-	serializer.WriteProperty("return_types", return_types);
-	serializer.WriteProperty("bindings", bindings);
+	serializer.WriteProperty(200, "return_types", return_types);
+	serializer.WriteProperty(201, "bindings", bindings);
 }
 
 unique_ptr<LogicalOperator> LogicalEmptyResult::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = duckdb::unique_ptr<LogicalEmptyResult>(new LogicalEmptyResult());
-	deserializer.ReadProperty("return_types", result->return_types);
-	deserializer.ReadProperty("bindings", result->bindings);
+	deserializer.ReadProperty(200, "return_types", result->return_types);
+	deserializer.ReadProperty(201, "bindings", result->bindings);
 	return std::move(result);
 }
 
 void LogicalExplain::FormatSerialize(FormatSerializer &serializer) const {
 	LogicalOperator::FormatSerialize(serializer);
-	serializer.WriteProperty("explain_type", explain_type);
-	serializer.WriteProperty("physical_plan", physical_plan);
-	serializer.WriteProperty("logical_plan_unopt", logical_plan_unopt);
-	serializer.WriteProperty("logical_plan_opt", logical_plan_opt);
+	serializer.WriteProperty(200, "explain_type", explain_type);
+	serializer.WriteProperty(201, "physical_plan", physical_plan);
+	serializer.WriteProperty(202, "logical_plan_unopt", logical_plan_unopt);
+	serializer.WriteProperty(203, "logical_plan_opt", logical_plan_opt);
 }
 
 unique_ptr<LogicalOperator> LogicalExplain::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto explain_type = deserializer.ReadProperty<ExplainType>("explain_type");
+	auto explain_type = deserializer.ReadProperty<ExplainType>(200, "explain_type");
 	auto result = duckdb::unique_ptr<LogicalExplain>(new LogicalExplain(explain_type));
-	deserializer.ReadProperty("physical_plan", result->physical_plan);
-	deserializer.ReadProperty("logical_plan_unopt", result->logical_plan_unopt);
-	deserializer.ReadProperty("logical_plan_opt", result->logical_plan_opt);
+	deserializer.ReadProperty(201, "physical_plan", result->physical_plan);
+	deserializer.ReadProperty(202, "logical_plan_unopt", result->logical_plan_unopt);
+	deserializer.ReadProperty(203, "logical_plan_opt", result->logical_plan_opt);
 	return std::move(result);
 }
 
 void LogicalExpressionGet::FormatSerialize(FormatSerializer &serializer) const {
 	LogicalOperator::FormatSerialize(serializer);
-	serializer.WriteProperty("table_index", table_index);
-	serializer.WriteProperty("expr_types", expr_types);
-	serializer.WriteProperty("expressions", expressions);
+	serializer.WriteProperty(200, "table_index", table_index);
+	serializer.WriteProperty(201, "expr_types", expr_types);
+	serializer.WriteProperty(202, "expressions", expressions);
 }
 
 unique_ptr<LogicalOperator> LogicalExpressionGet::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto table_index = deserializer.ReadProperty<idx_t>("table_index");
-	auto expr_types = deserializer.ReadProperty<vector<LogicalType>>("expr_types");
-	auto expressions = deserializer.ReadProperty<vector<vector<unique_ptr<Expression>>>>("expressions");
+	auto table_index = deserializer.ReadProperty<idx_t>(200, "table_index");
+	auto expr_types = deserializer.ReadProperty<vector<LogicalType>>(201, "expr_types");
+	auto expressions = deserializer.ReadProperty<vector<vector<unique_ptr<Expression>>>>(202, "expressions");
 	auto result = duckdb::unique_ptr<LogicalExpressionGet>(new LogicalExpressionGet(table_index, std::move(expr_types), std::move(expressions)));
 	return std::move(result);
 }
 
 void LogicalFilter::FormatSerialize(FormatSerializer &serializer) const {
 	LogicalOperator::FormatSerialize(serializer);
-	serializer.WriteProperty("expressions", expressions);
-	serializer.WriteProperty("projection_map", projection_map);
+	serializer.WriteProperty(200, "expressions", expressions);
+	serializer.WriteProperty(201, "projection_map", projection_map);
 }
 
 unique_ptr<LogicalOperator> LogicalFilter::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = duckdb::unique_ptr<LogicalFilter>(new LogicalFilter());
-	deserializer.ReadProperty("expressions", result->expressions);
-	deserializer.ReadProperty("projection_map", result->projection_map);
+	deserializer.ReadProperty(200, "expressions", result->expressions);
+	deserializer.ReadProperty(201, "projection_map", result->projection_map);
 	return std::move(result);
 }
 
 void LogicalInsert::FormatSerialize(FormatSerializer &serializer) const {
 	LogicalOperator::FormatSerialize(serializer);
-	serializer.WriteProperty("catalog", table.ParentCatalog().GetName());
-	serializer.WriteProperty("schema", table.ParentSchema().name);
-	serializer.WriteProperty("table", table.name);
-	serializer.WriteProperty("insert_values", insert_values);
-	serializer.WriteProperty("column_index_map", column_index_map);
-	serializer.WriteProperty("expected_types", expected_types);
-	serializer.WriteProperty("table_index", table_index);
-	serializer.WriteProperty("return_chunk", return_chunk);
-	serializer.WriteProperty("bound_defaults", bound_defaults);
-	serializer.WriteProperty("action_type", action_type);
-	serializer.WriteProperty("expected_set_types", expected_set_types);
-	serializer.WriteProperty("on_conflict_filter", on_conflict_filter);
-	serializer.WriteOptionalProperty("on_conflict_condition", on_conflict_condition);
-	serializer.WriteOptionalProperty("do_update_condition", do_update_condition);
-	serializer.WriteProperty("set_columns", set_columns);
-	serializer.WriteProperty("set_types", set_types);
-	serializer.WriteProperty("excluded_table_index", excluded_table_index);
-	serializer.WriteProperty("columns_to_fetch", columns_to_fetch);
-	serializer.WriteProperty("source_columns", source_columns);
+	serializer.WriteProperty(200, "catalog", table.ParentCatalog().GetName());
+	serializer.WriteProperty(201, "schema", table.ParentSchema().name);
+	serializer.WriteProperty(202, "table", table.name);
+	serializer.WriteProperty(203, "insert_values", insert_values);
+	serializer.WriteProperty(204, "column_index_map", column_index_map);
+	serializer.WriteProperty(205, "expected_types", expected_types);
+	serializer.WriteProperty(206, "table_index", table_index);
+	serializer.WriteProperty(207, "return_chunk", return_chunk);
+	serializer.WriteProperty(208, "bound_defaults", bound_defaults);
+	serializer.WriteProperty(209, "action_type", action_type);
+	serializer.WriteProperty(210, "expected_set_types", expected_set_types);
+	serializer.WriteProperty(211, "on_conflict_filter", on_conflict_filter);
+	serializer.WriteOptionalProperty(212, "on_conflict_condition", on_conflict_condition);
+	serializer.WriteOptionalProperty(213, "do_update_condition", do_update_condition);
+	serializer.WriteProperty(214, "set_columns", set_columns);
+	serializer.WriteProperty(215, "set_types", set_types);
+	serializer.WriteProperty(216, "excluded_table_index", excluded_table_index);
+	serializer.WriteProperty(217, "columns_to_fetch", columns_to_fetch);
+	serializer.WriteProperty(218, "source_columns", source_columns);
 }
 
 unique_ptr<LogicalOperator> LogicalInsert::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto catalog = deserializer.ReadProperty<string>("catalog");
-	auto schema = deserializer.ReadProperty<string>("schema");
-	auto table = deserializer.ReadProperty<string>("table");
+	auto catalog = deserializer.ReadProperty<string>(200, "catalog");
+	auto schema = deserializer.ReadProperty<string>(201, "schema");
+	auto table = deserializer.ReadProperty<string>(202, "table");
 	auto result = duckdb::unique_ptr<LogicalInsert>(new LogicalInsert(deserializer.Get<ClientContext &>(), catalog, schema, table));
-	deserializer.ReadProperty("insert_values", result->insert_values);
-	deserializer.ReadProperty("column_index_map", result->column_index_map);
-	deserializer.ReadProperty("expected_types", result->expected_types);
-	deserializer.ReadProperty("table_index", result->table_index);
-	deserializer.ReadProperty("return_chunk", result->return_chunk);
-	deserializer.ReadProperty("bound_defaults", result->bound_defaults);
-	deserializer.ReadProperty("action_type", result->action_type);
-	deserializer.ReadProperty("expected_set_types", result->expected_set_types);
-	deserializer.ReadProperty("on_conflict_filter", result->on_conflict_filter);
-	deserializer.ReadOptionalProperty("on_conflict_condition", result->on_conflict_condition);
-	deserializer.ReadOptionalProperty("do_update_condition", result->do_update_condition);
-	deserializer.ReadProperty("set_columns", result->set_columns);
-	deserializer.ReadProperty("set_types", result->set_types);
-	deserializer.ReadProperty("excluded_table_index", result->excluded_table_index);
-	deserializer.ReadProperty("columns_to_fetch", result->columns_to_fetch);
-	deserializer.ReadProperty("source_columns", result->source_columns);
+	deserializer.ReadProperty(203, "insert_values", result->insert_values);
+	deserializer.ReadProperty(204, "column_index_map", result->column_index_map);
+	deserializer.ReadProperty(205, "expected_types", result->expected_types);
+	deserializer.ReadProperty(206, "table_index", result->table_index);
+	deserializer.ReadProperty(207, "return_chunk", result->return_chunk);
+	deserializer.ReadProperty(208, "bound_defaults", result->bound_defaults);
+	deserializer.ReadProperty(209, "action_type", result->action_type);
+	deserializer.ReadProperty(210, "expected_set_types", result->expected_set_types);
+	deserializer.ReadProperty(211, "on_conflict_filter", result->on_conflict_filter);
+	deserializer.ReadOptionalProperty(212, "on_conflict_condition", result->on_conflict_condition);
+	deserializer.ReadOptionalProperty(213, "do_update_condition", result->do_update_condition);
+	deserializer.ReadProperty(214, "set_columns", result->set_columns);
+	deserializer.ReadProperty(215, "set_types", result->set_types);
+	deserializer.ReadProperty(216, "excluded_table_index", result->excluded_table_index);
+	deserializer.ReadProperty(217, "columns_to_fetch", result->columns_to_fetch);
+	deserializer.ReadProperty(218, "source_columns", result->source_columns);
 	return std::move(result);
 }
 
 void LogicalLimit::FormatSerialize(FormatSerializer &serializer) const {
 	LogicalOperator::FormatSerialize(serializer);
-	serializer.WriteProperty("limit_val", limit_val);
-	serializer.WriteProperty("offset_val", offset_val);
-	serializer.WriteOptionalProperty("limit", limit);
-	serializer.WriteOptionalProperty("offset", offset);
+	serializer.WriteProperty(200, "limit_val", limit_val);
+	serializer.WriteProperty(201, "offset_val", offset_val);
+	serializer.WriteOptionalProperty(202, "limit", limit);
+	serializer.WriteOptionalProperty(203, "offset", offset);
 }
 
 unique_ptr<LogicalOperator> LogicalLimit::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto limit_val = deserializer.ReadProperty<int64_t>("limit_val");
-	auto offset_val = deserializer.ReadProperty<int64_t>("offset_val");
-	auto limit = deserializer.ReadOptionalProperty<unique_ptr<Expression>>("limit");
-	auto offset = deserializer.ReadOptionalProperty<unique_ptr<Expression>>("offset");
+	auto limit_val = deserializer.ReadProperty<int64_t>(200, "limit_val");
+	auto offset_val = deserializer.ReadProperty<int64_t>(201, "offset_val");
+	auto limit = deserializer.ReadOptionalProperty<unique_ptr<Expression>>(202, "limit");
+	auto offset = deserializer.ReadOptionalProperty<unique_ptr<Expression>>(203, "offset");
 	auto result = duckdb::unique_ptr<LogicalLimit>(new LogicalLimit(limit_val, offset_val, std::move(limit), std::move(offset)));
 	return std::move(result);
 }
 
 void LogicalLimitPercent::FormatSerialize(FormatSerializer &serializer) const {
 	LogicalOperator::FormatSerialize(serializer);
-	serializer.WriteProperty("limit_percent", limit_percent);
-	serializer.WriteProperty("offset_val", offset_val);
-	serializer.WriteOptionalProperty("limit", limit);
-	serializer.WriteOptionalProperty("offset", offset);
+	serializer.WriteProperty(200, "limit_percent", limit_percent);
+	serializer.WriteProperty(201, "offset_val", offset_val);
+	serializer.WriteOptionalProperty(202, "limit", limit);
+	serializer.WriteOptionalProperty(203, "offset", offset);
 }
 
 unique_ptr<LogicalOperator> LogicalLimitPercent::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto limit_percent = deserializer.ReadProperty<double>("limit_percent");
-	auto offset_val = deserializer.ReadProperty<int64_t>("offset_val");
-	auto limit = deserializer.ReadOptionalProperty<unique_ptr<Expression>>("limit");
-	auto offset = deserializer.ReadOptionalProperty<unique_ptr<Expression>>("offset");
+	auto limit_percent = deserializer.ReadProperty<double>(200, "limit_percent");
+	auto offset_val = deserializer.ReadProperty<int64_t>(201, "offset_val");
+	auto limit = deserializer.ReadOptionalProperty<unique_ptr<Expression>>(202, "limit");
+	auto offset = deserializer.ReadOptionalProperty<unique_ptr<Expression>>(203, "offset");
 	auto result = duckdb::unique_ptr<LogicalLimitPercent>(new LogicalLimitPercent(limit_percent, offset_val, std::move(limit), std::move(offset)));
 	return std::move(result);
 }
 
 void LogicalMaterializedCTE::FormatSerialize(FormatSerializer &serializer) const {
 	LogicalOperator::FormatSerialize(serializer);
-	serializer.WriteProperty("table_index", table_index);
-	serializer.WriteProperty("column_count", column_count);
-	serializer.WriteProperty("ctename", ctename);
+	serializer.WriteProperty(200, "table_index", table_index);
+	serializer.WriteProperty(201, "column_count", column_count);
+	serializer.WriteProperty(202, "ctename", ctename);
 }
 
 unique_ptr<LogicalOperator> LogicalMaterializedCTE::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = duckdb::unique_ptr<LogicalMaterializedCTE>(new LogicalMaterializedCTE());
-	deserializer.ReadProperty("table_index", result->table_index);
-	deserializer.ReadProperty("column_count", result->column_count);
-	deserializer.ReadProperty("ctename", result->ctename);
+	deserializer.ReadProperty(200, "table_index", result->table_index);
+	deserializer.ReadProperty(201, "column_count", result->column_count);
+	deserializer.ReadProperty(202, "ctename", result->ctename);
 	return std::move(result);
 }
 
 void LogicalOrder::FormatSerialize(FormatSerializer &serializer) const {
 	LogicalOperator::FormatSerialize(serializer);
-	serializer.WriteProperty("orders", orders);
-	serializer.WriteProperty("projections", projections);
+	serializer.WriteProperty(200, "orders", orders);
+	serializer.WriteProperty(201, "projections", projections);
 }
 
 unique_ptr<LogicalOperator> LogicalOrder::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto orders = deserializer.ReadProperty<vector<BoundOrderByNode>>("orders");
+	auto orders = deserializer.ReadProperty<vector<BoundOrderByNode>>(200, "orders");
 	auto result = duckdb::unique_ptr<LogicalOrder>(new LogicalOrder(std::move(orders)));
-	deserializer.ReadProperty("projections", result->projections);
+	deserializer.ReadProperty(201, "projections", result->projections);
 	return std::move(result);
 }
 
 void LogicalPivot::FormatSerialize(FormatSerializer &serializer) const {
 	LogicalOperator::FormatSerialize(serializer);
-	serializer.WriteProperty("pivot_index", pivot_index);
-	serializer.WriteProperty("bound_pivot", bound_pivot);
+	serializer.WriteProperty(200, "pivot_index", pivot_index);
+	serializer.WriteProperty(201, "bound_pivot", bound_pivot);
 }
 
 unique_ptr<LogicalOperator> LogicalPivot::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = duckdb::unique_ptr<LogicalPivot>(new LogicalPivot());
-	deserializer.ReadProperty("pivot_index", result->pivot_index);
-	deserializer.ReadProperty("bound_pivot", result->bound_pivot);
+	deserializer.ReadProperty(200, "pivot_index", result->pivot_index);
+	deserializer.ReadProperty(201, "bound_pivot", result->bound_pivot);
 	return std::move(result);
 }
 
@@ -587,175 +587,175 @@ unique_ptr<LogicalOperator> LogicalPositionalJoin::FormatDeserialize(FormatDeser
 
 void LogicalProjection::FormatSerialize(FormatSerializer &serializer) const {
 	LogicalOperator::FormatSerialize(serializer);
-	serializer.WriteProperty("table_index", table_index);
-	serializer.WriteProperty("expressions", expressions);
+	serializer.WriteProperty(200, "table_index", table_index);
+	serializer.WriteProperty(201, "expressions", expressions);
 }
 
 unique_ptr<LogicalOperator> LogicalProjection::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto table_index = deserializer.ReadProperty<idx_t>("table_index");
-	auto expressions = deserializer.ReadProperty<vector<unique_ptr<Expression>>>("expressions");
+	auto table_index = deserializer.ReadProperty<idx_t>(200, "table_index");
+	auto expressions = deserializer.ReadProperty<vector<unique_ptr<Expression>>>(201, "expressions");
 	auto result = duckdb::unique_ptr<LogicalProjection>(new LogicalProjection(table_index, std::move(expressions)));
 	return std::move(result);
 }
 
 void LogicalRecursiveCTE::FormatSerialize(FormatSerializer &serializer) const {
 	LogicalOperator::FormatSerialize(serializer);
-	serializer.WriteProperty("union_all", union_all);
-	serializer.WriteProperty("ctename", ctename);
-	serializer.WriteProperty("table_index", table_index);
-	serializer.WriteProperty("column_count", column_count);
+	serializer.WriteProperty(200, "union_all", union_all);
+	serializer.WriteProperty(201, "ctename", ctename);
+	serializer.WriteProperty(202, "table_index", table_index);
+	serializer.WriteProperty(203, "column_count", column_count);
 }
 
 unique_ptr<LogicalOperator> LogicalRecursiveCTE::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = duckdb::unique_ptr<LogicalRecursiveCTE>(new LogicalRecursiveCTE());
-	deserializer.ReadProperty("union_all", result->union_all);
-	deserializer.ReadProperty("ctename", result->ctename);
-	deserializer.ReadProperty("table_index", result->table_index);
-	deserializer.ReadProperty("column_count", result->column_count);
+	deserializer.ReadProperty(200, "union_all", result->union_all);
+	deserializer.ReadProperty(201, "ctename", result->ctename);
+	deserializer.ReadProperty(202, "table_index", result->table_index);
+	deserializer.ReadProperty(203, "column_count", result->column_count);
 	return std::move(result);
 }
 
 void LogicalReset::FormatSerialize(FormatSerializer &serializer) const {
 	LogicalOperator::FormatSerialize(serializer);
-	serializer.WriteProperty("name", name);
-	serializer.WriteProperty("scope", scope);
+	serializer.WriteProperty(200, "name", name);
+	serializer.WriteProperty(201, "scope", scope);
 }
 
 unique_ptr<LogicalOperator> LogicalReset::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto name = deserializer.ReadProperty<string>("name");
-	auto scope = deserializer.ReadProperty<SetScope>("scope");
+	auto name = deserializer.ReadProperty<string>(200, "name");
+	auto scope = deserializer.ReadProperty<SetScope>(201, "scope");
 	auto result = duckdb::unique_ptr<LogicalReset>(new LogicalReset(std::move(name), scope));
 	return std::move(result);
 }
 
 void LogicalSample::FormatSerialize(FormatSerializer &serializer) const {
 	LogicalOperator::FormatSerialize(serializer);
-	serializer.WriteProperty("sample_options", sample_options);
+	serializer.WriteProperty(200, "sample_options", sample_options);
 }
 
 unique_ptr<LogicalOperator> LogicalSample::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = duckdb::unique_ptr<LogicalSample>(new LogicalSample());
-	deserializer.ReadProperty("sample_options", result->sample_options);
+	deserializer.ReadProperty(200, "sample_options", result->sample_options);
 	return std::move(result);
 }
 
 void LogicalSet::FormatSerialize(FormatSerializer &serializer) const {
 	LogicalOperator::FormatSerialize(serializer);
-	serializer.WriteProperty("name", name);
-	serializer.WriteProperty("value", value);
-	serializer.WriteProperty("scope", scope);
+	serializer.WriteProperty(200, "name", name);
+	serializer.WriteProperty(201, "value", value);
+	serializer.WriteProperty(202, "scope", scope);
 }
 
 unique_ptr<LogicalOperator> LogicalSet::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto name = deserializer.ReadProperty<string>("name");
-	auto value = deserializer.ReadProperty<Value>("value");
-	auto scope = deserializer.ReadProperty<SetScope>("scope");
+	auto name = deserializer.ReadProperty<string>(200, "name");
+	auto value = deserializer.ReadProperty<Value>(201, "value");
+	auto scope = deserializer.ReadProperty<SetScope>(202, "scope");
 	auto result = duckdb::unique_ptr<LogicalSet>(new LogicalSet(std::move(name), value, scope));
 	return std::move(result);
 }
 
 void LogicalSetOperation::FormatSerialize(FormatSerializer &serializer) const {
 	LogicalOperator::FormatSerialize(serializer);
-	serializer.WriteProperty("table_index", table_index);
-	serializer.WriteProperty("column_count", column_count);
+	serializer.WriteProperty(200, "table_index", table_index);
+	serializer.WriteProperty(201, "column_count", column_count);
 }
 
 unique_ptr<LogicalOperator> LogicalSetOperation::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto table_index = deserializer.ReadProperty<idx_t>("table_index");
-	auto column_count = deserializer.ReadProperty<idx_t>("column_count");
+	auto table_index = deserializer.ReadProperty<idx_t>(200, "table_index");
+	auto column_count = deserializer.ReadProperty<idx_t>(201, "column_count");
 	auto result = duckdb::unique_ptr<LogicalSetOperation>(new LogicalSetOperation(table_index, column_count, deserializer.Get<LogicalOperatorType>()));
 	return std::move(result);
 }
 
 void LogicalShow::FormatSerialize(FormatSerializer &serializer) const {
 	LogicalOperator::FormatSerialize(serializer);
-	serializer.WriteProperty("types_select", types_select);
-	serializer.WriteProperty("aliases", aliases);
+	serializer.WriteProperty(200, "types_select", types_select);
+	serializer.WriteProperty(201, "aliases", aliases);
 }
 
 unique_ptr<LogicalOperator> LogicalShow::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = duckdb::unique_ptr<LogicalShow>(new LogicalShow());
-	deserializer.ReadProperty("types_select", result->types_select);
-	deserializer.ReadProperty("aliases", result->aliases);
+	deserializer.ReadProperty(200, "types_select", result->types_select);
+	deserializer.ReadProperty(201, "aliases", result->aliases);
 	return std::move(result);
 }
 
 void LogicalSimple::FormatSerialize(FormatSerializer &serializer) const {
 	LogicalOperator::FormatSerialize(serializer);
-	serializer.WriteProperty("info", *info);
+	serializer.WriteProperty(200, "info", *info);
 }
 
 unique_ptr<LogicalOperator> LogicalSimple::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto info = deserializer.ReadProperty<unique_ptr<ParseInfo>>("info");
+	auto info = deserializer.ReadProperty<unique_ptr<ParseInfo>>(200, "info");
 	auto result = duckdb::unique_ptr<LogicalSimple>(new LogicalSimple(deserializer.Get<LogicalOperatorType>(), std::move(info)));
 	return std::move(result);
 }
 
 void LogicalTopN::FormatSerialize(FormatSerializer &serializer) const {
 	LogicalOperator::FormatSerialize(serializer);
-	serializer.WriteProperty("orders", orders);
-	serializer.WriteProperty("limit", limit);
-	serializer.WriteProperty("offset", offset);
+	serializer.WriteProperty(200, "orders", orders);
+	serializer.WriteProperty(201, "limit", limit);
+	serializer.WriteProperty(202, "offset", offset);
 }
 
 unique_ptr<LogicalOperator> LogicalTopN::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto orders = deserializer.ReadProperty<vector<BoundOrderByNode>>("orders");
-	auto limit = deserializer.ReadProperty<idx_t>("limit");
-	auto offset = deserializer.ReadProperty<idx_t>("offset");
+	auto orders = deserializer.ReadProperty<vector<BoundOrderByNode>>(200, "orders");
+	auto limit = deserializer.ReadProperty<idx_t>(201, "limit");
+	auto offset = deserializer.ReadProperty<idx_t>(202, "offset");
 	auto result = duckdb::unique_ptr<LogicalTopN>(new LogicalTopN(std::move(orders), limit, offset));
 	return std::move(result);
 }
 
 void LogicalUnnest::FormatSerialize(FormatSerializer &serializer) const {
 	LogicalOperator::FormatSerialize(serializer);
-	serializer.WriteProperty("unnest_index", unnest_index);
-	serializer.WriteProperty("expressions", expressions);
+	serializer.WriteProperty(200, "unnest_index", unnest_index);
+	serializer.WriteProperty(201, "expressions", expressions);
 }
 
 unique_ptr<LogicalOperator> LogicalUnnest::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto unnest_index = deserializer.ReadProperty<idx_t>("unnest_index");
+	auto unnest_index = deserializer.ReadProperty<idx_t>(200, "unnest_index");
 	auto result = duckdb::unique_ptr<LogicalUnnest>(new LogicalUnnest(unnest_index));
-	deserializer.ReadProperty("expressions", result->expressions);
+	deserializer.ReadProperty(201, "expressions", result->expressions);
 	return std::move(result);
 }
 
 void LogicalUpdate::FormatSerialize(FormatSerializer &serializer) const {
 	LogicalOperator::FormatSerialize(serializer);
-	serializer.WriteProperty("catalog", table.ParentCatalog().GetName());
-	serializer.WriteProperty("schema", table.ParentSchema().name);
-	serializer.WriteProperty("table", table.name);
-	serializer.WriteProperty("table_index", table_index);
-	serializer.WriteProperty("return_chunk", return_chunk);
-	serializer.WriteProperty("expressions", expressions);
-	serializer.WriteProperty("columns", columns);
-	serializer.WriteProperty("bound_defaults", bound_defaults);
-	serializer.WriteProperty("update_is_del_and_insert", update_is_del_and_insert);
+	serializer.WriteProperty(200, "catalog", table.ParentCatalog().GetName());
+	serializer.WriteProperty(201, "schema", table.ParentSchema().name);
+	serializer.WriteProperty(202, "table", table.name);
+	serializer.WriteProperty(203, "table_index", table_index);
+	serializer.WriteProperty(204, "return_chunk", return_chunk);
+	serializer.WriteProperty(205, "expressions", expressions);
+	serializer.WriteProperty(206, "columns", columns);
+	serializer.WriteProperty(207, "bound_defaults", bound_defaults);
+	serializer.WriteProperty(208, "update_is_del_and_insert", update_is_del_and_insert);
 }
 
 unique_ptr<LogicalOperator> LogicalUpdate::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto catalog = deserializer.ReadProperty<string>("catalog");
-	auto schema = deserializer.ReadProperty<string>("schema");
-	auto table = deserializer.ReadProperty<string>("table");
+	auto catalog = deserializer.ReadProperty<string>(200, "catalog");
+	auto schema = deserializer.ReadProperty<string>(201, "schema");
+	auto table = deserializer.ReadProperty<string>(202, "table");
 	auto result = duckdb::unique_ptr<LogicalUpdate>(new LogicalUpdate(deserializer.Get<ClientContext &>(), catalog, schema, table));
-	deserializer.ReadProperty("table_index", result->table_index);
-	deserializer.ReadProperty("return_chunk", result->return_chunk);
-	deserializer.ReadProperty("expressions", result->expressions);
-	deserializer.ReadProperty("columns", result->columns);
-	deserializer.ReadProperty("bound_defaults", result->bound_defaults);
-	deserializer.ReadProperty("update_is_del_and_insert", result->update_is_del_and_insert);
+	deserializer.ReadProperty(203, "table_index", result->table_index);
+	deserializer.ReadProperty(204, "return_chunk", result->return_chunk);
+	deserializer.ReadProperty(205, "expressions", result->expressions);
+	deserializer.ReadProperty(206, "columns", result->columns);
+	deserializer.ReadProperty(207, "bound_defaults", result->bound_defaults);
+	deserializer.ReadProperty(208, "update_is_del_and_insert", result->update_is_del_and_insert);
 	return std::move(result);
 }
 
 void LogicalWindow::FormatSerialize(FormatSerializer &serializer) const {
 	LogicalOperator::FormatSerialize(serializer);
-	serializer.WriteProperty("window_index", window_index);
-	serializer.WriteProperty("expressions", expressions);
+	serializer.WriteProperty(200, "window_index", window_index);
+	serializer.WriteProperty(201, "expressions", expressions);
 }
 
 unique_ptr<LogicalOperator> LogicalWindow::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto window_index = deserializer.ReadProperty<idx_t>("window_index");
+	auto window_index = deserializer.ReadProperty<idx_t>(200, "window_index");
 	auto result = duckdb::unique_ptr<LogicalWindow>(new LogicalWindow(window_index));
-	deserializer.ReadProperty("expressions", result->expressions);
+	deserializer.ReadProperty(201, "expressions", result->expressions);
 	return std::move(result);
 }