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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (100) hide show
  1. package/package.json +1 -1
  2. package/src/duckdb/extension/icu/icu-makedate.cpp +12 -6
  3. package/src/duckdb/extension/json/include/json_deserializer.hpp +1 -1
  4. package/src/duckdb/extension/json/include/json_serializer.hpp +1 -1
  5. package/src/duckdb/extension/json/json_deserializer.cpp +10 -10
  6. package/src/duckdb/extension/json/json_scan.cpp +2 -2
  7. package/src/duckdb/extension/json/json_serializer.cpp +11 -10
  8. package/src/duckdb/extension/json/serialize_json.cpp +44 -44
  9. package/src/duckdb/extension/parquet/parquet_extension.cpp +11 -10
  10. package/src/duckdb/extension/parquet/serialize_parquet.cpp +6 -6
  11. package/src/duckdb/src/common/adbc/adbc.cpp +52 -21
  12. package/src/duckdb/src/common/adbc/driver_manager.cpp +12 -2
  13. package/src/duckdb/src/common/enum_util.cpp +5 -0
  14. package/src/duckdb/src/common/extra_type_info.cpp +2 -2
  15. package/src/duckdb/src/common/serializer/binary_deserializer.cpp +5 -3
  16. package/src/duckdb/src/common/serializer/binary_serializer.cpp +10 -5
  17. package/src/duckdb/src/common/types/column/column_data_collection.cpp +4 -4
  18. package/src/duckdb/src/common/types/row/row_data_collection_scanner.cpp +35 -5
  19. package/src/duckdb/src/common/types/value.cpp +33 -33
  20. package/src/duckdb/src/common/types/vector.cpp +20 -20
  21. package/src/duckdb/src/core_functions/aggregate/holistic/approximate_quantile.cpp +2 -2
  22. package/src/duckdb/src/core_functions/aggregate/holistic/quantile.cpp +6 -6
  23. package/src/duckdb/src/core_functions/aggregate/holistic/reservoir_quantile.cpp +4 -4
  24. package/src/duckdb/src/core_functions/scalar/list/list_lambdas.cpp +4 -4
  25. package/src/duckdb/src/execution/operator/aggregate/physical_window.cpp +283 -91
  26. package/src/duckdb/src/execution/operator/filter/physical_filter.cpp +1 -1
  27. package/src/duckdb/src/execution/operator/join/physical_comparison_join.cpp +1 -2
  28. package/src/duckdb/src/execution/operator/scan/physical_table_scan.cpp +1 -1
  29. package/src/duckdb/src/execution/physical_plan_generator.cpp +1 -6
  30. package/src/duckdb/src/execution/window_executor.cpp +10 -1
  31. package/src/duckdb/src/function/table/read_csv.cpp +4 -4
  32. package/src/duckdb/src/function/table/table_scan.cpp +14 -14
  33. package/src/duckdb/src/function/table/version/pragma_version.cpp +5 -2
  34. package/src/duckdb/src/include/duckdb/common/adbc/adbc.hpp +2 -0
  35. package/src/duckdb/src/include/duckdb/common/enums/pending_execution_result.hpp +1 -1
  36. package/src/duckdb/src/include/duckdb/common/index_vector.hpp +2 -2
  37. package/src/duckdb/src/include/duckdb/common/serializer/binary_deserializer.hpp +7 -3
  38. package/src/duckdb/src/include/duckdb/common/serializer/binary_serializer.hpp +2 -1
  39. package/src/duckdb/src/include/duckdb/common/serializer/format_deserializer.hpp +18 -17
  40. package/src/duckdb/src/include/duckdb/common/serializer/format_serializer.hpp +10 -9
  41. package/src/duckdb/src/include/duckdb/common/serializer/serialization_traits.hpp +4 -0
  42. package/src/duckdb/src/include/duckdb/common/types/row/row_data_collection_scanner.hpp +5 -1
  43. package/src/duckdb/src/include/duckdb/execution/physical_operator.hpp +0 -2
  44. package/src/duckdb/src/include/duckdb/function/function_serialization.hpp +10 -10
  45. package/src/duckdb/src/include/duckdb/main/pending_query_result.hpp +5 -0
  46. package/src/duckdb/src/include/duckdb/main/relation/aggregate_relation.hpp +4 -1
  47. package/src/duckdb/src/include/duckdb/optimizer/join_order/cardinality_estimator.hpp +37 -63
  48. package/src/duckdb/src/include/duckdb/optimizer/join_order/cost_model.hpp +37 -0
  49. package/src/duckdb/src/include/duckdb/optimizer/join_order/join_node.hpp +14 -29
  50. package/src/duckdb/src/include/duckdb/optimizer/join_order/join_order_optimizer.hpp +7 -21
  51. package/src/duckdb/src/include/duckdb/optimizer/join_order/join_relation.hpp +0 -11
  52. package/src/duckdb/src/include/duckdb/optimizer/join_order/plan_enumerator.hpp +89 -0
  53. package/src/duckdb/src/include/duckdb/optimizer/join_order/query_graph.hpp +17 -31
  54. package/src/duckdb/src/include/duckdb/optimizer/join_order/query_graph_manager.hpp +113 -0
  55. package/src/duckdb/src/include/duckdb/optimizer/join_order/relation_manager.hpp +73 -0
  56. package/src/duckdb/src/include/duckdb/optimizer/join_order/relation_statistics_helper.hpp +73 -0
  57. package/src/duckdb/src/include/duckdb/parallel/task_scheduler.hpp +4 -1
  58. package/src/duckdb/src/include/duckdb/parser/group_by_node.hpp +11 -0
  59. package/src/duckdb/src/include/duckdb/parser/parser.hpp +4 -0
  60. package/src/duckdb/src/include/duckdb/planner/logical_operator.hpp +0 -2
  61. package/src/duckdb/src/include/duckdb.h +11 -1
  62. package/src/duckdb/src/main/capi/pending-c.cpp +17 -0
  63. package/src/duckdb/src/main/pending_query_result.cpp +9 -1
  64. package/src/duckdb/src/main/relation/aggregate_relation.cpp +20 -10
  65. package/src/duckdb/src/main/relation.cpp +4 -4
  66. package/src/duckdb/src/optimizer/join_order/cardinality_estimator.cpp +79 -325
  67. package/src/duckdb/src/optimizer/join_order/cost_model.cpp +19 -0
  68. package/src/duckdb/src/optimizer/join_order/join_node.cpp +5 -37
  69. package/src/duckdb/src/optimizer/join_order/join_order_optimizer.cpp +48 -1078
  70. package/src/duckdb/src/optimizer/join_order/plan_enumerator.cpp +552 -0
  71. package/src/duckdb/src/optimizer/join_order/query_graph.cpp +32 -29
  72. package/src/duckdb/src/optimizer/join_order/query_graph_manager.cpp +409 -0
  73. package/src/duckdb/src/optimizer/join_order/relation_manager.cpp +356 -0
  74. package/src/duckdb/src/optimizer/join_order/relation_statistics_helper.cpp +351 -0
  75. package/src/duckdb/src/parallel/executor.cpp +6 -0
  76. package/src/duckdb/src/parallel/task_scheduler.cpp +7 -0
  77. package/src/duckdb/src/parser/parser.cpp +18 -3
  78. package/src/duckdb/src/parser/tableref/pivotref.cpp +6 -6
  79. package/src/duckdb/src/planner/binder/statement/bind_execute.cpp +1 -1
  80. package/src/duckdb/src/planner/expression/bound_aggregate_expression.cpp +10 -10
  81. package/src/duckdb/src/planner/expression/bound_function_expression.cpp +6 -6
  82. package/src/duckdb/src/planner/expression/bound_window_expression.cpp +24 -24
  83. package/src/duckdb/src/planner/operator/logical_extension_operator.cpp +2 -2
  84. package/src/duckdb/src/planner/operator/logical_get.cpp +26 -22
  85. package/src/duckdb/src/storage/serialization/serialize_constraint.cpp +26 -26
  86. package/src/duckdb/src/storage/serialization/serialize_create_info.cpp +66 -66
  87. package/src/duckdb/src/storage/serialization/serialize_expression.cpp +78 -78
  88. package/src/duckdb/src/storage/serialization/serialize_logical_operator.cpp +250 -250
  89. package/src/duckdb/src/storage/serialization/serialize_macro_function.cpp +10 -10
  90. package/src/duckdb/src/storage/serialization/serialize_nodes.cpp +206 -206
  91. package/src/duckdb/src/storage/serialization/serialize_parse_info.cpp +116 -116
  92. package/src/duckdb/src/storage/serialization/serialize_parsed_expression.cpp +110 -110
  93. package/src/duckdb/src/storage/serialization/serialize_query_node.cpp +48 -48
  94. package/src/duckdb/src/storage/serialization/serialize_result_modifier.cpp +16 -16
  95. package/src/duckdb/src/storage/serialization/serialize_statement.cpp +2 -2
  96. package/src/duckdb/src/storage/serialization/serialize_table_filter.cpp +10 -10
  97. package/src/duckdb/src/storage/serialization/serialize_tableref.cpp +54 -54
  98. package/src/duckdb/src/storage/serialization/serialize_types.cpp +22 -22
  99. package/src/duckdb/src/storage/table/update_segment.cpp +1 -1
  100. package/src/duckdb/ub_src_optimizer_join_order.cpp +10 -0
@@ -12,13 +12,13 @@
12
12
  namespace duckdb {
13
13
 
14
14
  void LogicalOperator::FormatSerialize(FormatSerializer &serializer) const {
15
- serializer.WriteProperty("type", type);
16
- serializer.WriteProperty("children", children);
15
+ serializer.WriteProperty(100, "type", type);
16
+ serializer.WriteProperty(101, "children", children);
17
17
  }
18
18
 
19
19
  unique_ptr<LogicalOperator> LogicalOperator::FormatDeserialize(FormatDeserializer &deserializer) {
20
- auto type = deserializer.ReadProperty<LogicalOperatorType>("type");
21
- auto children = deserializer.ReadProperty<vector<unique_ptr<LogicalOperator>>>("children");
20
+ auto type = deserializer.ReadProperty<LogicalOperatorType>(100, "type");
21
+ auto children = deserializer.ReadProperty<vector<unique_ptr<LogicalOperator>>>(101, "children");
22
22
  deserializer.Set<LogicalOperatorType>(type);
23
23
  unique_ptr<LogicalOperator> result;
24
24
  switch (type) {
@@ -191,138 +191,138 @@ unique_ptr<LogicalOperator> LogicalOperator::FormatDeserialize(FormatDeserialize
191
191
 
192
192
  void LogicalAggregate::FormatSerialize(FormatSerializer &serializer) const {
193
193
  LogicalOperator::FormatSerialize(serializer);
194
- serializer.WriteProperty("expressions", expressions);
195
- serializer.WriteProperty("group_index", group_index);
196
- serializer.WriteProperty("aggregate_index", aggregate_index);
197
- serializer.WriteProperty("groupings_index", groupings_index);
198
- serializer.WriteProperty("groups", groups);
199
- serializer.WriteProperty("grouping_sets", grouping_sets);
200
- serializer.WriteProperty("grouping_functions", grouping_functions);
194
+ serializer.WriteProperty(200, "expressions", expressions);
195
+ serializer.WriteProperty(201, "group_index", group_index);
196
+ serializer.WriteProperty(202, "aggregate_index", aggregate_index);
197
+ serializer.WriteProperty(203, "groupings_index", groupings_index);
198
+ serializer.WriteProperty(204, "groups", groups);
199
+ serializer.WriteProperty(205, "grouping_sets", grouping_sets);
200
+ serializer.WriteProperty(206, "grouping_functions", grouping_functions);
201
201
  }
202
202
 
203
203
  unique_ptr<LogicalOperator> LogicalAggregate::FormatDeserialize(FormatDeserializer &deserializer) {
204
- auto expressions = deserializer.ReadProperty<vector<unique_ptr<Expression>>>("expressions");
205
- auto group_index = deserializer.ReadProperty<idx_t>("group_index");
206
- auto aggregate_index = deserializer.ReadProperty<idx_t>("aggregate_index");
204
+ auto expressions = deserializer.ReadProperty<vector<unique_ptr<Expression>>>(200, "expressions");
205
+ auto group_index = deserializer.ReadProperty<idx_t>(201, "group_index");
206
+ auto aggregate_index = deserializer.ReadProperty<idx_t>(202, "aggregate_index");
207
207
  auto result = duckdb::unique_ptr<LogicalAggregate>(new LogicalAggregate(group_index, aggregate_index, std::move(expressions)));
208
- deserializer.ReadProperty("groupings_index", result->groupings_index);
209
- deserializer.ReadProperty("groups", result->groups);
210
- deserializer.ReadProperty("grouping_sets", result->grouping_sets);
211
- deserializer.ReadProperty("grouping_functions", result->grouping_functions);
208
+ deserializer.ReadProperty(203, "groupings_index", result->groupings_index);
209
+ deserializer.ReadProperty(204, "groups", result->groups);
210
+ deserializer.ReadProperty(205, "grouping_sets", result->grouping_sets);
211
+ deserializer.ReadProperty(206, "grouping_functions", result->grouping_functions);
212
212
  return std::move(result);
213
213
  }
214
214
 
215
215
  void LogicalAnyJoin::FormatSerialize(FormatSerializer &serializer) const {
216
216
  LogicalOperator::FormatSerialize(serializer);
217
- serializer.WriteProperty("join_type", join_type);
218
- serializer.WriteProperty("mark_index", mark_index);
219
- serializer.WriteProperty("left_projection_map", left_projection_map);
220
- serializer.WriteProperty("right_projection_map", right_projection_map);
221
- serializer.WriteProperty("condition", *condition);
217
+ serializer.WriteProperty(200, "join_type", join_type);
218
+ serializer.WriteProperty(201, "mark_index", mark_index);
219
+ serializer.WriteProperty(202, "left_projection_map", left_projection_map);
220
+ serializer.WriteProperty(203, "right_projection_map", right_projection_map);
221
+ serializer.WriteProperty(204, "condition", *condition);
222
222
  }
223
223
 
224
224
  unique_ptr<LogicalOperator> LogicalAnyJoin::FormatDeserialize(FormatDeserializer &deserializer) {
225
- auto join_type = deserializer.ReadProperty<JoinType>("join_type");
225
+ auto join_type = deserializer.ReadProperty<JoinType>(200, "join_type");
226
226
  auto result = duckdb::unique_ptr<LogicalAnyJoin>(new LogicalAnyJoin(join_type));
227
- deserializer.ReadProperty("mark_index", result->mark_index);
228
- deserializer.ReadProperty("left_projection_map", result->left_projection_map);
229
- deserializer.ReadProperty("right_projection_map", result->right_projection_map);
230
- deserializer.ReadProperty("condition", result->condition);
227
+ deserializer.ReadProperty(201, "mark_index", result->mark_index);
228
+ deserializer.ReadProperty(202, "left_projection_map", result->left_projection_map);
229
+ deserializer.ReadProperty(203, "right_projection_map", result->right_projection_map);
230
+ deserializer.ReadProperty(204, "condition", result->condition);
231
231
  return std::move(result);
232
232
  }
233
233
 
234
234
  void LogicalCTERef::FormatSerialize(FormatSerializer &serializer) const {
235
235
  LogicalOperator::FormatSerialize(serializer);
236
- serializer.WriteProperty("table_index", table_index);
237
- serializer.WriteProperty("cte_index", cte_index);
238
- serializer.WriteProperty("chunk_types", chunk_types);
239
- serializer.WriteProperty("bound_columns", bound_columns);
240
- serializer.WriteProperty("materialized_cte", materialized_cte);
236
+ serializer.WriteProperty(200, "table_index", table_index);
237
+ serializer.WriteProperty(201, "cte_index", cte_index);
238
+ serializer.WriteProperty(202, "chunk_types", chunk_types);
239
+ serializer.WriteProperty(203, "bound_columns", bound_columns);
240
+ serializer.WriteProperty(204, "materialized_cte", materialized_cte);
241
241
  }
242
242
 
243
243
  unique_ptr<LogicalOperator> LogicalCTERef::FormatDeserialize(FormatDeserializer &deserializer) {
244
- auto table_index = deserializer.ReadProperty<idx_t>("table_index");
245
- auto cte_index = deserializer.ReadProperty<idx_t>("cte_index");
246
- auto chunk_types = deserializer.ReadProperty<vector<LogicalType>>("chunk_types");
247
- auto bound_columns = deserializer.ReadProperty<vector<string>>("bound_columns");
248
- auto materialized_cte = deserializer.ReadProperty<CTEMaterialize>("materialized_cte");
244
+ auto table_index = deserializer.ReadProperty<idx_t>(200, "table_index");
245
+ auto cte_index = deserializer.ReadProperty<idx_t>(201, "cte_index");
246
+ auto chunk_types = deserializer.ReadProperty<vector<LogicalType>>(202, "chunk_types");
247
+ auto bound_columns = deserializer.ReadProperty<vector<string>>(203, "bound_columns");
248
+ auto materialized_cte = deserializer.ReadProperty<CTEMaterialize>(204, "materialized_cte");
249
249
  auto result = duckdb::unique_ptr<LogicalCTERef>(new LogicalCTERef(table_index, cte_index, std::move(chunk_types), std::move(bound_columns), materialized_cte));
250
250
  return std::move(result);
251
251
  }
252
252
 
253
253
  void LogicalColumnDataGet::FormatSerialize(FormatSerializer &serializer) const {
254
254
  LogicalOperator::FormatSerialize(serializer);
255
- serializer.WriteProperty("table_index", table_index);
256
- serializer.WriteProperty("chunk_types", chunk_types);
257
- serializer.WriteProperty("collection", *collection);
255
+ serializer.WriteProperty(200, "table_index", table_index);
256
+ serializer.WriteProperty(201, "chunk_types", chunk_types);
257
+ serializer.WriteProperty(202, "collection", *collection);
258
258
  }
259
259
 
260
260
  unique_ptr<LogicalOperator> LogicalColumnDataGet::FormatDeserialize(FormatDeserializer &deserializer) {
261
- auto table_index = deserializer.ReadProperty<idx_t>("table_index");
262
- auto chunk_types = deserializer.ReadProperty<vector<LogicalType>>("chunk_types");
263
- auto collection = deserializer.ReadProperty<unique_ptr<ColumnDataCollection>>("collection");
261
+ auto table_index = deserializer.ReadProperty<idx_t>(200, "table_index");
262
+ auto chunk_types = deserializer.ReadProperty<vector<LogicalType>>(201, "chunk_types");
263
+ auto collection = deserializer.ReadProperty<unique_ptr<ColumnDataCollection>>(202, "collection");
264
264
  auto result = duckdb::unique_ptr<LogicalColumnDataGet>(new LogicalColumnDataGet(table_index, std::move(chunk_types), std::move(collection)));
265
265
  return std::move(result);
266
266
  }
267
267
 
268
268
  void LogicalComparisonJoin::FormatSerialize(FormatSerializer &serializer) const {
269
269
  LogicalOperator::FormatSerialize(serializer);
270
- serializer.WriteProperty("join_type", join_type);
271
- serializer.WriteProperty("mark_index", mark_index);
272
- serializer.WriteProperty("left_projection_map", left_projection_map);
273
- serializer.WriteProperty("right_projection_map", right_projection_map);
274
- serializer.WriteProperty("conditions", conditions);
275
- serializer.WriteProperty("mark_types", mark_types);
276
- serializer.WriteProperty("duplicate_eliminated_columns", duplicate_eliminated_columns);
270
+ serializer.WriteProperty(200, "join_type", join_type);
271
+ serializer.WriteProperty(201, "mark_index", mark_index);
272
+ serializer.WriteProperty(202, "left_projection_map", left_projection_map);
273
+ serializer.WriteProperty(203, "right_projection_map", right_projection_map);
274
+ serializer.WriteProperty(204, "conditions", conditions);
275
+ serializer.WriteProperty(205, "mark_types", mark_types);
276
+ serializer.WriteProperty(206, "duplicate_eliminated_columns", duplicate_eliminated_columns);
277
277
  }
278
278
 
279
279
  unique_ptr<LogicalOperator> LogicalComparisonJoin::FormatDeserialize(FormatDeserializer &deserializer) {
280
- auto join_type = deserializer.ReadProperty<JoinType>("join_type");
280
+ auto join_type = deserializer.ReadProperty<JoinType>(200, "join_type");
281
281
  auto result = duckdb::unique_ptr<LogicalComparisonJoin>(new LogicalComparisonJoin(join_type, deserializer.Get<LogicalOperatorType>()));
282
- deserializer.ReadProperty("mark_index", result->mark_index);
283
- deserializer.ReadProperty("left_projection_map", result->left_projection_map);
284
- deserializer.ReadProperty("right_projection_map", result->right_projection_map);
285
- deserializer.ReadProperty("conditions", result->conditions);
286
- deserializer.ReadProperty("mark_types", result->mark_types);
287
- deserializer.ReadProperty("duplicate_eliminated_columns", result->duplicate_eliminated_columns);
282
+ deserializer.ReadProperty(201, "mark_index", result->mark_index);
283
+ deserializer.ReadProperty(202, "left_projection_map", result->left_projection_map);
284
+ deserializer.ReadProperty(203, "right_projection_map", result->right_projection_map);
285
+ deserializer.ReadProperty(204, "conditions", result->conditions);
286
+ deserializer.ReadProperty(205, "mark_types", result->mark_types);
287
+ deserializer.ReadProperty(206, "duplicate_eliminated_columns", result->duplicate_eliminated_columns);
288
288
  return std::move(result);
289
289
  }
290
290
 
291
291
  void LogicalCreate::FormatSerialize(FormatSerializer &serializer) const {
292
292
  LogicalOperator::FormatSerialize(serializer);
293
- serializer.WriteProperty("info", *info);
293
+ serializer.WriteProperty(200, "info", *info);
294
294
  }
295
295
 
296
296
  unique_ptr<LogicalOperator> LogicalCreate::FormatDeserialize(FormatDeserializer &deserializer) {
297
- auto info = deserializer.ReadProperty<unique_ptr<CreateInfo>>("info");
297
+ auto info = deserializer.ReadProperty<unique_ptr<CreateInfo>>(200, "info");
298
298
  auto result = duckdb::unique_ptr<LogicalCreate>(new LogicalCreate(deserializer.Get<LogicalOperatorType>(), deserializer.Get<ClientContext &>(), std::move(info)));
299
299
  return std::move(result);
300
300
  }
301
301
 
302
302
  void LogicalCreateIndex::FormatSerialize(FormatSerializer &serializer) const {
303
303
  LogicalOperator::FormatSerialize(serializer);
304
- serializer.WriteProperty("info", *info);
305
- serializer.WriteProperty("unbound_expressions", unbound_expressions);
304
+ serializer.WriteProperty(200, "info", *info);
305
+ serializer.WriteProperty(201, "unbound_expressions", unbound_expressions);
306
306
  }
307
307
 
308
308
  unique_ptr<LogicalOperator> LogicalCreateIndex::FormatDeserialize(FormatDeserializer &deserializer) {
309
- auto info = deserializer.ReadProperty<unique_ptr<CreateInfo>>("info");
310
- auto unbound_expressions = deserializer.ReadProperty<vector<unique_ptr<Expression>>>("unbound_expressions");
309
+ auto info = deserializer.ReadProperty<unique_ptr<CreateInfo>>(200, "info");
310
+ auto unbound_expressions = deserializer.ReadProperty<vector<unique_ptr<Expression>>>(201, "unbound_expressions");
311
311
  auto result = duckdb::unique_ptr<LogicalCreateIndex>(new LogicalCreateIndex(deserializer.Get<ClientContext &>(), std::move(info), std::move(unbound_expressions)));
312
312
  return std::move(result);
313
313
  }
314
314
 
315
315
  void LogicalCreateTable::FormatSerialize(FormatSerializer &serializer) const {
316
316
  LogicalOperator::FormatSerialize(serializer);
317
- serializer.WriteProperty("catalog", schema.ParentCatalog().GetName());
318
- serializer.WriteProperty("schema", schema.name);
319
- serializer.WriteProperty("info", *info->base);
317
+ serializer.WriteProperty(200, "catalog", schema.ParentCatalog().GetName());
318
+ serializer.WriteProperty(201, "schema", schema.name);
319
+ serializer.WriteProperty(202, "info", *info->base);
320
320
  }
321
321
 
322
322
  unique_ptr<LogicalOperator> LogicalCreateTable::FormatDeserialize(FormatDeserializer &deserializer) {
323
- auto catalog = deserializer.ReadProperty<string>("catalog");
324
- auto schema = deserializer.ReadProperty<string>("schema");
325
- auto info = deserializer.ReadProperty<unique_ptr<CreateInfo>>("info");
323
+ auto catalog = deserializer.ReadProperty<string>(200, "catalog");
324
+ auto schema = deserializer.ReadProperty<string>(201, "schema");
325
+ auto info = deserializer.ReadProperty<unique_ptr<CreateInfo>>(202, "info");
326
326
  auto result = duckdb::unique_ptr<LogicalCreateTable>(new LogicalCreateTable(deserializer.Get<ClientContext &>(), catalog, schema, std::move(info)));
327
327
  return std::move(result);
328
328
  }
@@ -338,241 +338,241 @@ unique_ptr<LogicalOperator> LogicalCrossProduct::FormatDeserialize(FormatDeseria
338
338
 
339
339
  void LogicalDelete::FormatSerialize(FormatSerializer &serializer) const {
340
340
  LogicalOperator::FormatSerialize(serializer);
341
- serializer.WriteProperty("catalog", table.ParentCatalog().GetName());
342
- serializer.WriteProperty("schema", table.ParentSchema().name);
343
- serializer.WriteProperty("table", table.name);
344
- serializer.WriteProperty("table_index", table_index);
345
- serializer.WriteProperty("return_chunk", return_chunk);
346
- serializer.WriteProperty("expressions", expressions);
341
+ serializer.WriteProperty(200, "catalog", table.ParentCatalog().GetName());
342
+ serializer.WriteProperty(201, "schema", table.ParentSchema().name);
343
+ serializer.WriteProperty(202, "table", table.name);
344
+ serializer.WriteProperty(203, "table_index", table_index);
345
+ serializer.WriteProperty(204, "return_chunk", return_chunk);
346
+ serializer.WriteProperty(205, "expressions", expressions);
347
347
  }
348
348
 
349
349
  unique_ptr<LogicalOperator> LogicalDelete::FormatDeserialize(FormatDeserializer &deserializer) {
350
- auto catalog = deserializer.ReadProperty<string>("catalog");
351
- auto schema = deserializer.ReadProperty<string>("schema");
352
- auto table = deserializer.ReadProperty<string>("table");
350
+ auto catalog = deserializer.ReadProperty<string>(200, "catalog");
351
+ auto schema = deserializer.ReadProperty<string>(201, "schema");
352
+ auto table = deserializer.ReadProperty<string>(202, "table");
353
353
  auto result = duckdb::unique_ptr<LogicalDelete>(new LogicalDelete(deserializer.Get<ClientContext &>(), catalog, schema, table));
354
- deserializer.ReadProperty("table_index", result->table_index);
355
- deserializer.ReadProperty("return_chunk", result->return_chunk);
356
- deserializer.ReadProperty("expressions", result->expressions);
354
+ deserializer.ReadProperty(203, "table_index", result->table_index);
355
+ deserializer.ReadProperty(204, "return_chunk", result->return_chunk);
356
+ deserializer.ReadProperty(205, "expressions", result->expressions);
357
357
  return std::move(result);
358
358
  }
359
359
 
360
360
  void LogicalDelimGet::FormatSerialize(FormatSerializer &serializer) const {
361
361
  LogicalOperator::FormatSerialize(serializer);
362
- serializer.WriteProperty("table_index", table_index);
363
- serializer.WriteProperty("chunk_types", chunk_types);
362
+ serializer.WriteProperty(200, "table_index", table_index);
363
+ serializer.WriteProperty(201, "chunk_types", chunk_types);
364
364
  }
365
365
 
366
366
  unique_ptr<LogicalOperator> LogicalDelimGet::FormatDeserialize(FormatDeserializer &deserializer) {
367
- auto table_index = deserializer.ReadProperty<idx_t>("table_index");
368
- auto chunk_types = deserializer.ReadProperty<vector<LogicalType>>("chunk_types");
367
+ auto table_index = deserializer.ReadProperty<idx_t>(200, "table_index");
368
+ auto chunk_types = deserializer.ReadProperty<vector<LogicalType>>(201, "chunk_types");
369
369
  auto result = duckdb::unique_ptr<LogicalDelimGet>(new LogicalDelimGet(table_index, std::move(chunk_types)));
370
370
  return std::move(result);
371
371
  }
372
372
 
373
373
  void LogicalDistinct::FormatSerialize(FormatSerializer &serializer) const {
374
374
  LogicalOperator::FormatSerialize(serializer);
375
- serializer.WriteProperty("distinct_type", distinct_type);
376
- serializer.WriteProperty("distinct_targets", distinct_targets);
377
- serializer.WriteOptionalProperty("order_by", order_by);
375
+ serializer.WriteProperty(200, "distinct_type", distinct_type);
376
+ serializer.WriteProperty(201, "distinct_targets", distinct_targets);
377
+ serializer.WriteOptionalProperty(202, "order_by", order_by);
378
378
  }
379
379
 
380
380
  unique_ptr<LogicalOperator> LogicalDistinct::FormatDeserialize(FormatDeserializer &deserializer) {
381
- auto distinct_type = deserializer.ReadProperty<DistinctType>("distinct_type");
382
- auto distinct_targets = deserializer.ReadProperty<vector<unique_ptr<Expression>>>("distinct_targets");
381
+ auto distinct_type = deserializer.ReadProperty<DistinctType>(200, "distinct_type");
382
+ auto distinct_targets = deserializer.ReadProperty<vector<unique_ptr<Expression>>>(201, "distinct_targets");
383
383
  auto result = duckdb::unique_ptr<LogicalDistinct>(new LogicalDistinct(std::move(distinct_targets), distinct_type));
384
- deserializer.ReadOptionalProperty("order_by", result->order_by);
384
+ deserializer.ReadOptionalProperty(202, "order_by", result->order_by);
385
385
  return std::move(result);
386
386
  }
387
387
 
388
388
  void LogicalDummyScan::FormatSerialize(FormatSerializer &serializer) const {
389
389
  LogicalOperator::FormatSerialize(serializer);
390
- serializer.WriteProperty("table_index", table_index);
390
+ serializer.WriteProperty(200, "table_index", table_index);
391
391
  }
392
392
 
393
393
  unique_ptr<LogicalOperator> LogicalDummyScan::FormatDeserialize(FormatDeserializer &deserializer) {
394
- auto table_index = deserializer.ReadProperty<idx_t>("table_index");
394
+ auto table_index = deserializer.ReadProperty<idx_t>(200, "table_index");
395
395
  auto result = duckdb::unique_ptr<LogicalDummyScan>(new LogicalDummyScan(table_index));
396
396
  return std::move(result);
397
397
  }
398
398
 
399
399
  void LogicalEmptyResult::FormatSerialize(FormatSerializer &serializer) const {
400
400
  LogicalOperator::FormatSerialize(serializer);
401
- serializer.WriteProperty("return_types", return_types);
402
- serializer.WriteProperty("bindings", bindings);
401
+ serializer.WriteProperty(200, "return_types", return_types);
402
+ serializer.WriteProperty(201, "bindings", bindings);
403
403
  }
404
404
 
405
405
  unique_ptr<LogicalOperator> LogicalEmptyResult::FormatDeserialize(FormatDeserializer &deserializer) {
406
406
  auto result = duckdb::unique_ptr<LogicalEmptyResult>(new LogicalEmptyResult());
407
- deserializer.ReadProperty("return_types", result->return_types);
408
- deserializer.ReadProperty("bindings", result->bindings);
407
+ deserializer.ReadProperty(200, "return_types", result->return_types);
408
+ deserializer.ReadProperty(201, "bindings", result->bindings);
409
409
  return std::move(result);
410
410
  }
411
411
 
412
412
  void LogicalExplain::FormatSerialize(FormatSerializer &serializer) const {
413
413
  LogicalOperator::FormatSerialize(serializer);
414
- serializer.WriteProperty("explain_type", explain_type);
415
- serializer.WriteProperty("physical_plan", physical_plan);
416
- serializer.WriteProperty("logical_plan_unopt", logical_plan_unopt);
417
- serializer.WriteProperty("logical_plan_opt", logical_plan_opt);
414
+ serializer.WriteProperty(200, "explain_type", explain_type);
415
+ serializer.WriteProperty(201, "physical_plan", physical_plan);
416
+ serializer.WriteProperty(202, "logical_plan_unopt", logical_plan_unopt);
417
+ serializer.WriteProperty(203, "logical_plan_opt", logical_plan_opt);
418
418
  }
419
419
 
420
420
  unique_ptr<LogicalOperator> LogicalExplain::FormatDeserialize(FormatDeserializer &deserializer) {
421
- auto explain_type = deserializer.ReadProperty<ExplainType>("explain_type");
421
+ auto explain_type = deserializer.ReadProperty<ExplainType>(200, "explain_type");
422
422
  auto result = duckdb::unique_ptr<LogicalExplain>(new LogicalExplain(explain_type));
423
- deserializer.ReadProperty("physical_plan", result->physical_plan);
424
- deserializer.ReadProperty("logical_plan_unopt", result->logical_plan_unopt);
425
- deserializer.ReadProperty("logical_plan_opt", result->logical_plan_opt);
423
+ deserializer.ReadProperty(201, "physical_plan", result->physical_plan);
424
+ deserializer.ReadProperty(202, "logical_plan_unopt", result->logical_plan_unopt);
425
+ deserializer.ReadProperty(203, "logical_plan_opt", result->logical_plan_opt);
426
426
  return std::move(result);
427
427
  }
428
428
 
429
429
  void LogicalExpressionGet::FormatSerialize(FormatSerializer &serializer) const {
430
430
  LogicalOperator::FormatSerialize(serializer);
431
- serializer.WriteProperty("table_index", table_index);
432
- serializer.WriteProperty("expr_types", expr_types);
433
- serializer.WriteProperty("expressions", expressions);
431
+ serializer.WriteProperty(200, "table_index", table_index);
432
+ serializer.WriteProperty(201, "expr_types", expr_types);
433
+ serializer.WriteProperty(202, "expressions", expressions);
434
434
  }
435
435
 
436
436
  unique_ptr<LogicalOperator> LogicalExpressionGet::FormatDeserialize(FormatDeserializer &deserializer) {
437
- auto table_index = deserializer.ReadProperty<idx_t>("table_index");
438
- auto expr_types = deserializer.ReadProperty<vector<LogicalType>>("expr_types");
439
- auto expressions = deserializer.ReadProperty<vector<vector<unique_ptr<Expression>>>>("expressions");
437
+ auto table_index = deserializer.ReadProperty<idx_t>(200, "table_index");
438
+ auto expr_types = deserializer.ReadProperty<vector<LogicalType>>(201, "expr_types");
439
+ auto expressions = deserializer.ReadProperty<vector<vector<unique_ptr<Expression>>>>(202, "expressions");
440
440
  auto result = duckdb::unique_ptr<LogicalExpressionGet>(new LogicalExpressionGet(table_index, std::move(expr_types), std::move(expressions)));
441
441
  return std::move(result);
442
442
  }
443
443
 
444
444
  void LogicalFilter::FormatSerialize(FormatSerializer &serializer) const {
445
445
  LogicalOperator::FormatSerialize(serializer);
446
- serializer.WriteProperty("expressions", expressions);
447
- serializer.WriteProperty("projection_map", projection_map);
446
+ serializer.WriteProperty(200, "expressions", expressions);
447
+ serializer.WriteProperty(201, "projection_map", projection_map);
448
448
  }
449
449
 
450
450
  unique_ptr<LogicalOperator> LogicalFilter::FormatDeserialize(FormatDeserializer &deserializer) {
451
451
  auto result = duckdb::unique_ptr<LogicalFilter>(new LogicalFilter());
452
- deserializer.ReadProperty("expressions", result->expressions);
453
- deserializer.ReadProperty("projection_map", result->projection_map);
452
+ deserializer.ReadProperty(200, "expressions", result->expressions);
453
+ deserializer.ReadProperty(201, "projection_map", result->projection_map);
454
454
  return std::move(result);
455
455
  }
456
456
 
457
457
  void LogicalInsert::FormatSerialize(FormatSerializer &serializer) const {
458
458
  LogicalOperator::FormatSerialize(serializer);
459
- serializer.WriteProperty("catalog", table.ParentCatalog().GetName());
460
- serializer.WriteProperty("schema", table.ParentSchema().name);
461
- serializer.WriteProperty("table", table.name);
462
- serializer.WriteProperty("insert_values", insert_values);
463
- serializer.WriteProperty("column_index_map", column_index_map);
464
- serializer.WriteProperty("expected_types", expected_types);
465
- serializer.WriteProperty("table_index", table_index);
466
- serializer.WriteProperty("return_chunk", return_chunk);
467
- serializer.WriteProperty("bound_defaults", bound_defaults);
468
- serializer.WriteProperty("action_type", action_type);
469
- serializer.WriteProperty("expected_set_types", expected_set_types);
470
- serializer.WriteProperty("on_conflict_filter", on_conflict_filter);
471
- serializer.WriteOptionalProperty("on_conflict_condition", on_conflict_condition);
472
- serializer.WriteOptionalProperty("do_update_condition", do_update_condition);
473
- serializer.WriteProperty("set_columns", set_columns);
474
- serializer.WriteProperty("set_types", set_types);
475
- serializer.WriteProperty("excluded_table_index", excluded_table_index);
476
- serializer.WriteProperty("columns_to_fetch", columns_to_fetch);
477
- serializer.WriteProperty("source_columns", source_columns);
459
+ serializer.WriteProperty(200, "catalog", table.ParentCatalog().GetName());
460
+ serializer.WriteProperty(201, "schema", table.ParentSchema().name);
461
+ serializer.WriteProperty(202, "table", table.name);
462
+ serializer.WriteProperty(203, "insert_values", insert_values);
463
+ serializer.WriteProperty(204, "column_index_map", column_index_map);
464
+ serializer.WriteProperty(205, "expected_types", expected_types);
465
+ serializer.WriteProperty(206, "table_index", table_index);
466
+ serializer.WriteProperty(207, "return_chunk", return_chunk);
467
+ serializer.WriteProperty(208, "bound_defaults", bound_defaults);
468
+ serializer.WriteProperty(209, "action_type", action_type);
469
+ serializer.WriteProperty(210, "expected_set_types", expected_set_types);
470
+ serializer.WriteProperty(211, "on_conflict_filter", on_conflict_filter);
471
+ serializer.WriteOptionalProperty(212, "on_conflict_condition", on_conflict_condition);
472
+ serializer.WriteOptionalProperty(213, "do_update_condition", do_update_condition);
473
+ serializer.WriteProperty(214, "set_columns", set_columns);
474
+ serializer.WriteProperty(215, "set_types", set_types);
475
+ serializer.WriteProperty(216, "excluded_table_index", excluded_table_index);
476
+ serializer.WriteProperty(217, "columns_to_fetch", columns_to_fetch);
477
+ serializer.WriteProperty(218, "source_columns", source_columns);
478
478
  }
479
479
 
480
480
  unique_ptr<LogicalOperator> LogicalInsert::FormatDeserialize(FormatDeserializer &deserializer) {
481
- auto catalog = deserializer.ReadProperty<string>("catalog");
482
- auto schema = deserializer.ReadProperty<string>("schema");
483
- auto table = deserializer.ReadProperty<string>("table");
481
+ auto catalog = deserializer.ReadProperty<string>(200, "catalog");
482
+ auto schema = deserializer.ReadProperty<string>(201, "schema");
483
+ auto table = deserializer.ReadProperty<string>(202, "table");
484
484
  auto result = duckdb::unique_ptr<LogicalInsert>(new LogicalInsert(deserializer.Get<ClientContext &>(), catalog, schema, table));
485
- deserializer.ReadProperty("insert_values", result->insert_values);
486
- deserializer.ReadProperty("column_index_map", result->column_index_map);
487
- deserializer.ReadProperty("expected_types", result->expected_types);
488
- deserializer.ReadProperty("table_index", result->table_index);
489
- deserializer.ReadProperty("return_chunk", result->return_chunk);
490
- deserializer.ReadProperty("bound_defaults", result->bound_defaults);
491
- deserializer.ReadProperty("action_type", result->action_type);
492
- deserializer.ReadProperty("expected_set_types", result->expected_set_types);
493
- deserializer.ReadProperty("on_conflict_filter", result->on_conflict_filter);
494
- deserializer.ReadOptionalProperty("on_conflict_condition", result->on_conflict_condition);
495
- deserializer.ReadOptionalProperty("do_update_condition", result->do_update_condition);
496
- deserializer.ReadProperty("set_columns", result->set_columns);
497
- deserializer.ReadProperty("set_types", result->set_types);
498
- deserializer.ReadProperty("excluded_table_index", result->excluded_table_index);
499
- deserializer.ReadProperty("columns_to_fetch", result->columns_to_fetch);
500
- deserializer.ReadProperty("source_columns", result->source_columns);
485
+ deserializer.ReadProperty(203, "insert_values", result->insert_values);
486
+ deserializer.ReadProperty(204, "column_index_map", result->column_index_map);
487
+ deserializer.ReadProperty(205, "expected_types", result->expected_types);
488
+ deserializer.ReadProperty(206, "table_index", result->table_index);
489
+ deserializer.ReadProperty(207, "return_chunk", result->return_chunk);
490
+ deserializer.ReadProperty(208, "bound_defaults", result->bound_defaults);
491
+ deserializer.ReadProperty(209, "action_type", result->action_type);
492
+ deserializer.ReadProperty(210, "expected_set_types", result->expected_set_types);
493
+ deserializer.ReadProperty(211, "on_conflict_filter", result->on_conflict_filter);
494
+ deserializer.ReadOptionalProperty(212, "on_conflict_condition", result->on_conflict_condition);
495
+ deserializer.ReadOptionalProperty(213, "do_update_condition", result->do_update_condition);
496
+ deserializer.ReadProperty(214, "set_columns", result->set_columns);
497
+ deserializer.ReadProperty(215, "set_types", result->set_types);
498
+ deserializer.ReadProperty(216, "excluded_table_index", result->excluded_table_index);
499
+ deserializer.ReadProperty(217, "columns_to_fetch", result->columns_to_fetch);
500
+ deserializer.ReadProperty(218, "source_columns", result->source_columns);
501
501
  return std::move(result);
502
502
  }
503
503
 
504
504
  void LogicalLimit::FormatSerialize(FormatSerializer &serializer) const {
505
505
  LogicalOperator::FormatSerialize(serializer);
506
- serializer.WriteProperty("limit_val", limit_val);
507
- serializer.WriteProperty("offset_val", offset_val);
508
- serializer.WriteOptionalProperty("limit", limit);
509
- serializer.WriteOptionalProperty("offset", offset);
506
+ serializer.WriteProperty(200, "limit_val", limit_val);
507
+ serializer.WriteProperty(201, "offset_val", offset_val);
508
+ serializer.WriteOptionalProperty(202, "limit", limit);
509
+ serializer.WriteOptionalProperty(203, "offset", offset);
510
510
  }
511
511
 
512
512
  unique_ptr<LogicalOperator> LogicalLimit::FormatDeserialize(FormatDeserializer &deserializer) {
513
- auto limit_val = deserializer.ReadProperty<int64_t>("limit_val");
514
- auto offset_val = deserializer.ReadProperty<int64_t>("offset_val");
515
- auto limit = deserializer.ReadOptionalProperty<unique_ptr<Expression>>("limit");
516
- auto offset = deserializer.ReadOptionalProperty<unique_ptr<Expression>>("offset");
513
+ auto limit_val = deserializer.ReadProperty<int64_t>(200, "limit_val");
514
+ auto offset_val = deserializer.ReadProperty<int64_t>(201, "offset_val");
515
+ auto limit = deserializer.ReadOptionalProperty<unique_ptr<Expression>>(202, "limit");
516
+ auto offset = deserializer.ReadOptionalProperty<unique_ptr<Expression>>(203, "offset");
517
517
  auto result = duckdb::unique_ptr<LogicalLimit>(new LogicalLimit(limit_val, offset_val, std::move(limit), std::move(offset)));
518
518
  return std::move(result);
519
519
  }
520
520
 
521
521
  void LogicalLimitPercent::FormatSerialize(FormatSerializer &serializer) const {
522
522
  LogicalOperator::FormatSerialize(serializer);
523
- serializer.WriteProperty("limit_percent", limit_percent);
524
- serializer.WriteProperty("offset_val", offset_val);
525
- serializer.WriteOptionalProperty("limit", limit);
526
- serializer.WriteOptionalProperty("offset", offset);
523
+ serializer.WriteProperty(200, "limit_percent", limit_percent);
524
+ serializer.WriteProperty(201, "offset_val", offset_val);
525
+ serializer.WriteOptionalProperty(202, "limit", limit);
526
+ serializer.WriteOptionalProperty(203, "offset", offset);
527
527
  }
528
528
 
529
529
  unique_ptr<LogicalOperator> LogicalLimitPercent::FormatDeserialize(FormatDeserializer &deserializer) {
530
- auto limit_percent = deserializer.ReadProperty<double>("limit_percent");
531
- auto offset_val = deserializer.ReadProperty<int64_t>("offset_val");
532
- auto limit = deserializer.ReadOptionalProperty<unique_ptr<Expression>>("limit");
533
- auto offset = deserializer.ReadOptionalProperty<unique_ptr<Expression>>("offset");
530
+ auto limit_percent = deserializer.ReadProperty<double>(200, "limit_percent");
531
+ auto offset_val = deserializer.ReadProperty<int64_t>(201, "offset_val");
532
+ auto limit = deserializer.ReadOptionalProperty<unique_ptr<Expression>>(202, "limit");
533
+ auto offset = deserializer.ReadOptionalProperty<unique_ptr<Expression>>(203, "offset");
534
534
  auto result = duckdb::unique_ptr<LogicalLimitPercent>(new LogicalLimitPercent(limit_percent, offset_val, std::move(limit), std::move(offset)));
535
535
  return std::move(result);
536
536
  }
537
537
 
538
538
  void LogicalMaterializedCTE::FormatSerialize(FormatSerializer &serializer) const {
539
539
  LogicalOperator::FormatSerialize(serializer);
540
- serializer.WriteProperty("table_index", table_index);
541
- serializer.WriteProperty("column_count", column_count);
542
- serializer.WriteProperty("ctename", ctename);
540
+ serializer.WriteProperty(200, "table_index", table_index);
541
+ serializer.WriteProperty(201, "column_count", column_count);
542
+ serializer.WriteProperty(202, "ctename", ctename);
543
543
  }
544
544
 
545
545
  unique_ptr<LogicalOperator> LogicalMaterializedCTE::FormatDeserialize(FormatDeserializer &deserializer) {
546
546
  auto result = duckdb::unique_ptr<LogicalMaterializedCTE>(new LogicalMaterializedCTE());
547
- deserializer.ReadProperty("table_index", result->table_index);
548
- deserializer.ReadProperty("column_count", result->column_count);
549
- deserializer.ReadProperty("ctename", result->ctename);
547
+ deserializer.ReadProperty(200, "table_index", result->table_index);
548
+ deserializer.ReadProperty(201, "column_count", result->column_count);
549
+ deserializer.ReadProperty(202, "ctename", result->ctename);
550
550
  return std::move(result);
551
551
  }
552
552
 
553
553
  void LogicalOrder::FormatSerialize(FormatSerializer &serializer) const {
554
554
  LogicalOperator::FormatSerialize(serializer);
555
- serializer.WriteProperty("orders", orders);
556
- serializer.WriteProperty("projections", projections);
555
+ serializer.WriteProperty(200, "orders", orders);
556
+ serializer.WriteProperty(201, "projections", projections);
557
557
  }
558
558
 
559
559
  unique_ptr<LogicalOperator> LogicalOrder::FormatDeserialize(FormatDeserializer &deserializer) {
560
- auto orders = deserializer.ReadProperty<vector<BoundOrderByNode>>("orders");
560
+ auto orders = deserializer.ReadProperty<vector<BoundOrderByNode>>(200, "orders");
561
561
  auto result = duckdb::unique_ptr<LogicalOrder>(new LogicalOrder(std::move(orders)));
562
- deserializer.ReadProperty("projections", result->projections);
562
+ deserializer.ReadProperty(201, "projections", result->projections);
563
563
  return std::move(result);
564
564
  }
565
565
 
566
566
  void LogicalPivot::FormatSerialize(FormatSerializer &serializer) const {
567
567
  LogicalOperator::FormatSerialize(serializer);
568
- serializer.WriteProperty("pivot_index", pivot_index);
569
- serializer.WriteProperty("bound_pivot", bound_pivot);
568
+ serializer.WriteProperty(200, "pivot_index", pivot_index);
569
+ serializer.WriteProperty(201, "bound_pivot", bound_pivot);
570
570
  }
571
571
 
572
572
  unique_ptr<LogicalOperator> LogicalPivot::FormatDeserialize(FormatDeserializer &deserializer) {
573
573
  auto result = duckdb::unique_ptr<LogicalPivot>(new LogicalPivot());
574
- deserializer.ReadProperty("pivot_index", result->pivot_index);
575
- deserializer.ReadProperty("bound_pivot", result->bound_pivot);
574
+ deserializer.ReadProperty(200, "pivot_index", result->pivot_index);
575
+ deserializer.ReadProperty(201, "bound_pivot", result->bound_pivot);
576
576
  return std::move(result);
577
577
  }
578
578
 
@@ -587,175 +587,175 @@ unique_ptr<LogicalOperator> LogicalPositionalJoin::FormatDeserialize(FormatDeser
587
587
 
588
588
  void LogicalProjection::FormatSerialize(FormatSerializer &serializer) const {
589
589
  LogicalOperator::FormatSerialize(serializer);
590
- serializer.WriteProperty("table_index", table_index);
591
- serializer.WriteProperty("expressions", expressions);
590
+ serializer.WriteProperty(200, "table_index", table_index);
591
+ serializer.WriteProperty(201, "expressions", expressions);
592
592
  }
593
593
 
594
594
  unique_ptr<LogicalOperator> LogicalProjection::FormatDeserialize(FormatDeserializer &deserializer) {
595
- auto table_index = deserializer.ReadProperty<idx_t>("table_index");
596
- auto expressions = deserializer.ReadProperty<vector<unique_ptr<Expression>>>("expressions");
595
+ auto table_index = deserializer.ReadProperty<idx_t>(200, "table_index");
596
+ auto expressions = deserializer.ReadProperty<vector<unique_ptr<Expression>>>(201, "expressions");
597
597
  auto result = duckdb::unique_ptr<LogicalProjection>(new LogicalProjection(table_index, std::move(expressions)));
598
598
  return std::move(result);
599
599
  }
600
600
 
601
601
  void LogicalRecursiveCTE::FormatSerialize(FormatSerializer &serializer) const {
602
602
  LogicalOperator::FormatSerialize(serializer);
603
- serializer.WriteProperty("union_all", union_all);
604
- serializer.WriteProperty("ctename", ctename);
605
- serializer.WriteProperty("table_index", table_index);
606
- serializer.WriteProperty("column_count", column_count);
603
+ serializer.WriteProperty(200, "union_all", union_all);
604
+ serializer.WriteProperty(201, "ctename", ctename);
605
+ serializer.WriteProperty(202, "table_index", table_index);
606
+ serializer.WriteProperty(203, "column_count", column_count);
607
607
  }
608
608
 
609
609
  unique_ptr<LogicalOperator> LogicalRecursiveCTE::FormatDeserialize(FormatDeserializer &deserializer) {
610
610
  auto result = duckdb::unique_ptr<LogicalRecursiveCTE>(new LogicalRecursiveCTE());
611
- deserializer.ReadProperty("union_all", result->union_all);
612
- deserializer.ReadProperty("ctename", result->ctename);
613
- deserializer.ReadProperty("table_index", result->table_index);
614
- deserializer.ReadProperty("column_count", result->column_count);
611
+ deserializer.ReadProperty(200, "union_all", result->union_all);
612
+ deserializer.ReadProperty(201, "ctename", result->ctename);
613
+ deserializer.ReadProperty(202, "table_index", result->table_index);
614
+ deserializer.ReadProperty(203, "column_count", result->column_count);
615
615
  return std::move(result);
616
616
  }
617
617
 
618
618
  void LogicalReset::FormatSerialize(FormatSerializer &serializer) const {
619
619
  LogicalOperator::FormatSerialize(serializer);
620
- serializer.WriteProperty("name", name);
621
- serializer.WriteProperty("scope", scope);
620
+ serializer.WriteProperty(200, "name", name);
621
+ serializer.WriteProperty(201, "scope", scope);
622
622
  }
623
623
 
624
624
  unique_ptr<LogicalOperator> LogicalReset::FormatDeserialize(FormatDeserializer &deserializer) {
625
- auto name = deserializer.ReadProperty<string>("name");
626
- auto scope = deserializer.ReadProperty<SetScope>("scope");
625
+ auto name = deserializer.ReadProperty<string>(200, "name");
626
+ auto scope = deserializer.ReadProperty<SetScope>(201, "scope");
627
627
  auto result = duckdb::unique_ptr<LogicalReset>(new LogicalReset(std::move(name), scope));
628
628
  return std::move(result);
629
629
  }
630
630
 
631
631
  void LogicalSample::FormatSerialize(FormatSerializer &serializer) const {
632
632
  LogicalOperator::FormatSerialize(serializer);
633
- serializer.WriteProperty("sample_options", sample_options);
633
+ serializer.WriteProperty(200, "sample_options", sample_options);
634
634
  }
635
635
 
636
636
  unique_ptr<LogicalOperator> LogicalSample::FormatDeserialize(FormatDeserializer &deserializer) {
637
637
  auto result = duckdb::unique_ptr<LogicalSample>(new LogicalSample());
638
- deserializer.ReadProperty("sample_options", result->sample_options);
638
+ deserializer.ReadProperty(200, "sample_options", result->sample_options);
639
639
  return std::move(result);
640
640
  }
641
641
 
642
642
  void LogicalSet::FormatSerialize(FormatSerializer &serializer) const {
643
643
  LogicalOperator::FormatSerialize(serializer);
644
- serializer.WriteProperty("name", name);
645
- serializer.WriteProperty("value", value);
646
- serializer.WriteProperty("scope", scope);
644
+ serializer.WriteProperty(200, "name", name);
645
+ serializer.WriteProperty(201, "value", value);
646
+ serializer.WriteProperty(202, "scope", scope);
647
647
  }
648
648
 
649
649
  unique_ptr<LogicalOperator> LogicalSet::FormatDeserialize(FormatDeserializer &deserializer) {
650
- auto name = deserializer.ReadProperty<string>("name");
651
- auto value = deserializer.ReadProperty<Value>("value");
652
- auto scope = deserializer.ReadProperty<SetScope>("scope");
650
+ auto name = deserializer.ReadProperty<string>(200, "name");
651
+ auto value = deserializer.ReadProperty<Value>(201, "value");
652
+ auto scope = deserializer.ReadProperty<SetScope>(202, "scope");
653
653
  auto result = duckdb::unique_ptr<LogicalSet>(new LogicalSet(std::move(name), value, scope));
654
654
  return std::move(result);
655
655
  }
656
656
 
657
657
  void LogicalSetOperation::FormatSerialize(FormatSerializer &serializer) const {
658
658
  LogicalOperator::FormatSerialize(serializer);
659
- serializer.WriteProperty("table_index", table_index);
660
- serializer.WriteProperty("column_count", column_count);
659
+ serializer.WriteProperty(200, "table_index", table_index);
660
+ serializer.WriteProperty(201, "column_count", column_count);
661
661
  }
662
662
 
663
663
  unique_ptr<LogicalOperator> LogicalSetOperation::FormatDeserialize(FormatDeserializer &deserializer) {
664
- auto table_index = deserializer.ReadProperty<idx_t>("table_index");
665
- auto column_count = deserializer.ReadProperty<idx_t>("column_count");
664
+ auto table_index = deserializer.ReadProperty<idx_t>(200, "table_index");
665
+ auto column_count = deserializer.ReadProperty<idx_t>(201, "column_count");
666
666
  auto result = duckdb::unique_ptr<LogicalSetOperation>(new LogicalSetOperation(table_index, column_count, deserializer.Get<LogicalOperatorType>()));
667
667
  return std::move(result);
668
668
  }
669
669
 
670
670
  void LogicalShow::FormatSerialize(FormatSerializer &serializer) const {
671
671
  LogicalOperator::FormatSerialize(serializer);
672
- serializer.WriteProperty("types_select", types_select);
673
- serializer.WriteProperty("aliases", aliases);
672
+ serializer.WriteProperty(200, "types_select", types_select);
673
+ serializer.WriteProperty(201, "aliases", aliases);
674
674
  }
675
675
 
676
676
  unique_ptr<LogicalOperator> LogicalShow::FormatDeserialize(FormatDeserializer &deserializer) {
677
677
  auto result = duckdb::unique_ptr<LogicalShow>(new LogicalShow());
678
- deserializer.ReadProperty("types_select", result->types_select);
679
- deserializer.ReadProperty("aliases", result->aliases);
678
+ deserializer.ReadProperty(200, "types_select", result->types_select);
679
+ deserializer.ReadProperty(201, "aliases", result->aliases);
680
680
  return std::move(result);
681
681
  }
682
682
 
683
683
  void LogicalSimple::FormatSerialize(FormatSerializer &serializer) const {
684
684
  LogicalOperator::FormatSerialize(serializer);
685
- serializer.WriteProperty("info", *info);
685
+ serializer.WriteProperty(200, "info", *info);
686
686
  }
687
687
 
688
688
  unique_ptr<LogicalOperator> LogicalSimple::FormatDeserialize(FormatDeserializer &deserializer) {
689
- auto info = deserializer.ReadProperty<unique_ptr<ParseInfo>>("info");
689
+ auto info = deserializer.ReadProperty<unique_ptr<ParseInfo>>(200, "info");
690
690
  auto result = duckdb::unique_ptr<LogicalSimple>(new LogicalSimple(deserializer.Get<LogicalOperatorType>(), std::move(info)));
691
691
  return std::move(result);
692
692
  }
693
693
 
694
694
  void LogicalTopN::FormatSerialize(FormatSerializer &serializer) const {
695
695
  LogicalOperator::FormatSerialize(serializer);
696
- serializer.WriteProperty("orders", orders);
697
- serializer.WriteProperty("limit", limit);
698
- serializer.WriteProperty("offset", offset);
696
+ serializer.WriteProperty(200, "orders", orders);
697
+ serializer.WriteProperty(201, "limit", limit);
698
+ serializer.WriteProperty(202, "offset", offset);
699
699
  }
700
700
 
701
701
  unique_ptr<LogicalOperator> LogicalTopN::FormatDeserialize(FormatDeserializer &deserializer) {
702
- auto orders = deserializer.ReadProperty<vector<BoundOrderByNode>>("orders");
703
- auto limit = deserializer.ReadProperty<idx_t>("limit");
704
- auto offset = deserializer.ReadProperty<idx_t>("offset");
702
+ auto orders = deserializer.ReadProperty<vector<BoundOrderByNode>>(200, "orders");
703
+ auto limit = deserializer.ReadProperty<idx_t>(201, "limit");
704
+ auto offset = deserializer.ReadProperty<idx_t>(202, "offset");
705
705
  auto result = duckdb::unique_ptr<LogicalTopN>(new LogicalTopN(std::move(orders), limit, offset));
706
706
  return std::move(result);
707
707
  }
708
708
 
709
709
  void LogicalUnnest::FormatSerialize(FormatSerializer &serializer) const {
710
710
  LogicalOperator::FormatSerialize(serializer);
711
- serializer.WriteProperty("unnest_index", unnest_index);
712
- serializer.WriteProperty("expressions", expressions);
711
+ serializer.WriteProperty(200, "unnest_index", unnest_index);
712
+ serializer.WriteProperty(201, "expressions", expressions);
713
713
  }
714
714
 
715
715
  unique_ptr<LogicalOperator> LogicalUnnest::FormatDeserialize(FormatDeserializer &deserializer) {
716
- auto unnest_index = deserializer.ReadProperty<idx_t>("unnest_index");
716
+ auto unnest_index = deserializer.ReadProperty<idx_t>(200, "unnest_index");
717
717
  auto result = duckdb::unique_ptr<LogicalUnnest>(new LogicalUnnest(unnest_index));
718
- deserializer.ReadProperty("expressions", result->expressions);
718
+ deserializer.ReadProperty(201, "expressions", result->expressions);
719
719
  return std::move(result);
720
720
  }
721
721
 
722
722
  void LogicalUpdate::FormatSerialize(FormatSerializer &serializer) const {
723
723
  LogicalOperator::FormatSerialize(serializer);
724
- serializer.WriteProperty("catalog", table.ParentCatalog().GetName());
725
- serializer.WriteProperty("schema", table.ParentSchema().name);
726
- serializer.WriteProperty("table", table.name);
727
- serializer.WriteProperty("table_index", table_index);
728
- serializer.WriteProperty("return_chunk", return_chunk);
729
- serializer.WriteProperty("expressions", expressions);
730
- serializer.WriteProperty("columns", columns);
731
- serializer.WriteProperty("bound_defaults", bound_defaults);
732
- serializer.WriteProperty("update_is_del_and_insert", update_is_del_and_insert);
724
+ serializer.WriteProperty(200, "catalog", table.ParentCatalog().GetName());
725
+ serializer.WriteProperty(201, "schema", table.ParentSchema().name);
726
+ serializer.WriteProperty(202, "table", table.name);
727
+ serializer.WriteProperty(203, "table_index", table_index);
728
+ serializer.WriteProperty(204, "return_chunk", return_chunk);
729
+ serializer.WriteProperty(205, "expressions", expressions);
730
+ serializer.WriteProperty(206, "columns", columns);
731
+ serializer.WriteProperty(207, "bound_defaults", bound_defaults);
732
+ serializer.WriteProperty(208, "update_is_del_and_insert", update_is_del_and_insert);
733
733
  }
734
734
 
735
735
  unique_ptr<LogicalOperator> LogicalUpdate::FormatDeserialize(FormatDeserializer &deserializer) {
736
- auto catalog = deserializer.ReadProperty<string>("catalog");
737
- auto schema = deserializer.ReadProperty<string>("schema");
738
- auto table = deserializer.ReadProperty<string>("table");
736
+ auto catalog = deserializer.ReadProperty<string>(200, "catalog");
737
+ auto schema = deserializer.ReadProperty<string>(201, "schema");
738
+ auto table = deserializer.ReadProperty<string>(202, "table");
739
739
  auto result = duckdb::unique_ptr<LogicalUpdate>(new LogicalUpdate(deserializer.Get<ClientContext &>(), catalog, schema, table));
740
- deserializer.ReadProperty("table_index", result->table_index);
741
- deserializer.ReadProperty("return_chunk", result->return_chunk);
742
- deserializer.ReadProperty("expressions", result->expressions);
743
- deserializer.ReadProperty("columns", result->columns);
744
- deserializer.ReadProperty("bound_defaults", result->bound_defaults);
745
- deserializer.ReadProperty("update_is_del_and_insert", result->update_is_del_and_insert);
740
+ deserializer.ReadProperty(203, "table_index", result->table_index);
741
+ deserializer.ReadProperty(204, "return_chunk", result->return_chunk);
742
+ deserializer.ReadProperty(205, "expressions", result->expressions);
743
+ deserializer.ReadProperty(206, "columns", result->columns);
744
+ deserializer.ReadProperty(207, "bound_defaults", result->bound_defaults);
745
+ deserializer.ReadProperty(208, "update_is_del_and_insert", result->update_is_del_and_insert);
746
746
  return std::move(result);
747
747
  }
748
748
 
749
749
  void LogicalWindow::FormatSerialize(FormatSerializer &serializer) const {
750
750
  LogicalOperator::FormatSerialize(serializer);
751
- serializer.WriteProperty("window_index", window_index);
752
- serializer.WriteProperty("expressions", expressions);
751
+ serializer.WriteProperty(200, "window_index", window_index);
752
+ serializer.WriteProperty(201, "expressions", expressions);
753
753
  }
754
754
 
755
755
  unique_ptr<LogicalOperator> LogicalWindow::FormatDeserialize(FormatDeserializer &deserializer) {
756
- auto window_index = deserializer.ReadProperty<idx_t>("window_index");
756
+ auto window_index = deserializer.ReadProperty<idx_t>(200, "window_index");
757
757
  auto result = duckdb::unique_ptr<LogicalWindow>(new LogicalWindow(window_index));
758
- deserializer.ReadProperty("expressions", result->expressions);
758
+ deserializer.ReadProperty(201, "expressions", result->expressions);
759
759
  return std::move(result);
760
760
  }
761
761