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
@@ -109,6 +109,10 @@ void LogicalGet::ResolveTypes() {
109
109
  }
110
110
 
111
111
  idx_t LogicalGet::EstimateCardinality(ClientContext &context) {
112
+ // join order optimizer does better cardinality estimation.
113
+ if (has_estimated_cardinality) {
114
+ return estimated_cardinality;
115
+ }
112
116
  if (function.cardinality) {
113
117
  auto node_stats = function.cardinality(context, bind_data.get());
114
118
  if (node_stats && node_stats->has_estimated_cardinality) {
@@ -206,32 +210,32 @@ unique_ptr<LogicalOperator> LogicalGet::Deserialize(LogicalDeserializationState
206
210
 
207
211
  void LogicalGet::FormatSerialize(FormatSerializer &serializer) const {
208
212
  LogicalOperator::FormatSerialize(serializer);
209
- serializer.WriteProperty("table_index", table_index);
210
- serializer.WriteProperty("returned_types", returned_types);
211
- serializer.WriteProperty("names", names);
212
- serializer.WriteProperty("column_ids", column_ids);
213
- serializer.WriteProperty("projection_ids", projection_ids);
214
- serializer.WriteProperty("table_filters", table_filters);
213
+ serializer.WriteProperty(200, "table_index", table_index);
214
+ serializer.WriteProperty(201, "returned_types", returned_types);
215
+ serializer.WriteProperty(202, "names", names);
216
+ serializer.WriteProperty(203, "column_ids", column_ids);
217
+ serializer.WriteProperty(204, "projection_ids", projection_ids);
218
+ serializer.WriteProperty(205, "table_filters", table_filters);
215
219
  FunctionSerializer::FormatSerialize(serializer, function, bind_data.get());
216
220
  if (!function.format_serialize) {
217
221
  D_ASSERT(!function.format_deserialize);
218
222
  // no serialize method: serialize input values and named_parameters for rebinding purposes
219
- serializer.WriteProperty("parameters", parameters);
220
- serializer.WriteProperty("named_parameters", named_parameters);
221
- serializer.WriteProperty("input_table_types", input_table_types);
222
- serializer.WriteProperty("input_table_names", input_table_names);
223
+ serializer.WriteProperty(206, "parameters", parameters);
224
+ serializer.WriteProperty(207, "named_parameters", named_parameters);
225
+ serializer.WriteProperty(208, "input_table_types", input_table_types);
226
+ serializer.WriteProperty(209, "input_table_names", input_table_names);
223
227
  }
224
- serializer.WriteProperty("projected_input", projected_input);
228
+ serializer.WriteProperty(210, "projected_input", projected_input);
225
229
  }
226
230
 
227
231
  unique_ptr<LogicalOperator> LogicalGet::FormatDeserialize(FormatDeserializer &deserializer) {
228
232
  auto result = unique_ptr<LogicalGet>(new LogicalGet());
229
- deserializer.ReadProperty("table_index", result->table_index);
230
- deserializer.ReadProperty("returned_types", result->returned_types);
231
- deserializer.ReadProperty("names", result->names);
232
- deserializer.ReadProperty("column_ids", result->column_ids);
233
- deserializer.ReadProperty("projection_ids", result->projection_ids);
234
- deserializer.ReadProperty("table_filters", result->table_filters);
233
+ deserializer.ReadProperty(200, "table_index", result->table_index);
234
+ deserializer.ReadProperty(201, "returned_types", result->returned_types);
235
+ deserializer.ReadProperty(202, "names", result->names);
236
+ deserializer.ReadProperty(203, "column_ids", result->column_ids);
237
+ deserializer.ReadProperty(204, "projection_ids", result->projection_ids);
238
+ deserializer.ReadProperty(205, "table_filters", result->table_filters);
235
239
  auto entry = FunctionSerializer::FormatDeserializeBase<TableFunction, TableFunctionCatalogEntry>(
236
240
  deserializer, CatalogType::TABLE_FUNCTION_ENTRY);
237
241
  auto &function = entry.first;
@@ -239,10 +243,10 @@ unique_ptr<LogicalOperator> LogicalGet::FormatDeserialize(FormatDeserializer &de
239
243
 
240
244
  unique_ptr<FunctionData> bind_data;
241
245
  if (!has_serialize) {
242
- deserializer.ReadProperty("parameters", result->parameters);
243
- deserializer.ReadProperty("named_parameters", result->named_parameters);
244
- deserializer.ReadProperty("input_table_types", result->input_table_types);
245
- deserializer.ReadProperty("input_table_names", result->input_table_names);
246
+ deserializer.ReadProperty(206, "parameters", result->parameters);
247
+ deserializer.ReadProperty(207, "named_parameters", result->named_parameters);
248
+ deserializer.ReadProperty(208, "input_table_types", result->input_table_types);
249
+ deserializer.ReadProperty(209, "input_table_names", result->input_table_names);
246
250
  TableFunctionBindInput input(result->parameters, result->named_parameters, result->input_table_types,
247
251
  result->input_table_names, function.function_info.get());
248
252
 
@@ -264,7 +268,7 @@ unique_ptr<LogicalOperator> LogicalGet::FormatDeserialize(FormatDeserializer &de
264
268
  } else {
265
269
  bind_data = FunctionSerializer::FunctionDeserialize(deserializer, function);
266
270
  }
267
- deserializer.ReadProperty("projected_input", result->projected_input);
271
+ deserializer.ReadProperty(210, "projected_input", result->projected_input);
268
272
  return std::move(result);
269
273
  }
270
274
 
@@ -10,11 +10,11 @@
10
10
  namespace duckdb {
11
11
 
12
12
  void Constraint::FormatSerialize(FormatSerializer &serializer) const {
13
- serializer.WriteProperty("type", type);
13
+ serializer.WriteProperty(100, "type", type);
14
14
  }
15
15
 
16
16
  unique_ptr<Constraint> Constraint::FormatDeserialize(FormatDeserializer &deserializer) {
17
- auto type = deserializer.ReadProperty<ConstraintType>("type");
17
+ auto type = deserializer.ReadProperty<ConstraintType>(100, "type");
18
18
  unique_ptr<Constraint> result;
19
19
  switch (type) {
20
20
  case ConstraintType::CHECK:
@@ -37,61 +37,61 @@ unique_ptr<Constraint> Constraint::FormatDeserialize(FormatDeserializer &deseria
37
37
 
38
38
  void CheckConstraint::FormatSerialize(FormatSerializer &serializer) const {
39
39
  Constraint::FormatSerialize(serializer);
40
- serializer.WriteProperty("expression", *expression);
40
+ serializer.WriteProperty(200, "expression", *expression);
41
41
  }
42
42
 
43
43
  unique_ptr<Constraint> CheckConstraint::FormatDeserialize(FormatDeserializer &deserializer) {
44
- auto expression = deserializer.ReadProperty<unique_ptr<ParsedExpression>>("expression");
44
+ auto expression = deserializer.ReadProperty<unique_ptr<ParsedExpression>>(200, "expression");
45
45
  auto result = duckdb::unique_ptr<CheckConstraint>(new CheckConstraint(std::move(expression)));
46
46
  return std::move(result);
47
47
  }
48
48
 
49
49
  void ForeignKeyConstraint::FormatSerialize(FormatSerializer &serializer) const {
50
50
  Constraint::FormatSerialize(serializer);
51
- serializer.WriteProperty("pk_columns", pk_columns);
52
- serializer.WriteProperty("fk_columns", fk_columns);
53
- serializer.WriteProperty("fk_type", info.type);
54
- serializer.WriteProperty("schema", info.schema);
55
- serializer.WriteProperty("table", info.table);
56
- serializer.WriteProperty("pk_keys", info.pk_keys);
57
- serializer.WriteProperty("fk_keys", info.fk_keys);
51
+ serializer.WriteProperty(200, "pk_columns", pk_columns);
52
+ serializer.WriteProperty(201, "fk_columns", fk_columns);
53
+ serializer.WriteProperty(202, "fk_type", info.type);
54
+ serializer.WriteProperty(203, "schema", info.schema);
55
+ serializer.WriteProperty(204, "table", info.table);
56
+ serializer.WriteProperty(205, "pk_keys", info.pk_keys);
57
+ serializer.WriteProperty(206, "fk_keys", info.fk_keys);
58
58
  }
59
59
 
60
60
  unique_ptr<Constraint> ForeignKeyConstraint::FormatDeserialize(FormatDeserializer &deserializer) {
61
61
  auto result = duckdb::unique_ptr<ForeignKeyConstraint>(new ForeignKeyConstraint());
62
- deserializer.ReadProperty("pk_columns", result->pk_columns);
63
- deserializer.ReadProperty("fk_columns", result->fk_columns);
64
- deserializer.ReadProperty("fk_type", result->info.type);
65
- deserializer.ReadProperty("schema", result->info.schema);
66
- deserializer.ReadProperty("table", result->info.table);
67
- deserializer.ReadProperty("pk_keys", result->info.pk_keys);
68
- deserializer.ReadProperty("fk_keys", result->info.fk_keys);
62
+ deserializer.ReadProperty(200, "pk_columns", result->pk_columns);
63
+ deserializer.ReadProperty(201, "fk_columns", result->fk_columns);
64
+ deserializer.ReadProperty(202, "fk_type", result->info.type);
65
+ deserializer.ReadProperty(203, "schema", result->info.schema);
66
+ deserializer.ReadProperty(204, "table", result->info.table);
67
+ deserializer.ReadProperty(205, "pk_keys", result->info.pk_keys);
68
+ deserializer.ReadProperty(206, "fk_keys", result->info.fk_keys);
69
69
  return std::move(result);
70
70
  }
71
71
 
72
72
  void NotNullConstraint::FormatSerialize(FormatSerializer &serializer) const {
73
73
  Constraint::FormatSerialize(serializer);
74
- serializer.WriteProperty("index", index);
74
+ serializer.WriteProperty(200, "index", index);
75
75
  }
76
76
 
77
77
  unique_ptr<Constraint> NotNullConstraint::FormatDeserialize(FormatDeserializer &deserializer) {
78
- auto index = deserializer.ReadProperty<LogicalIndex>("index");
78
+ auto index = deserializer.ReadProperty<LogicalIndex>(200, "index");
79
79
  auto result = duckdb::unique_ptr<NotNullConstraint>(new NotNullConstraint(index));
80
80
  return std::move(result);
81
81
  }
82
82
 
83
83
  void UniqueConstraint::FormatSerialize(FormatSerializer &serializer) const {
84
84
  Constraint::FormatSerialize(serializer);
85
- serializer.WriteProperty("is_primary_key", is_primary_key);
86
- serializer.WriteProperty("index", index);
87
- serializer.WriteProperty("columns", columns);
85
+ serializer.WriteProperty(200, "is_primary_key", is_primary_key);
86
+ serializer.WriteProperty(201, "index", index);
87
+ serializer.WriteProperty(202, "columns", columns);
88
88
  }
89
89
 
90
90
  unique_ptr<Constraint> UniqueConstraint::FormatDeserialize(FormatDeserializer &deserializer) {
91
91
  auto result = duckdb::unique_ptr<UniqueConstraint>(new UniqueConstraint());
92
- deserializer.ReadProperty("is_primary_key", result->is_primary_key);
93
- deserializer.ReadProperty("index", result->index);
94
- deserializer.ReadProperty("columns", result->columns);
92
+ deserializer.ReadProperty(200, "is_primary_key", result->is_primary_key);
93
+ deserializer.ReadProperty(201, "index", result->index);
94
+ deserializer.ReadProperty(202, "columns", result->columns);
95
95
  return std::move(result);
96
96
  }
97
97
 
@@ -17,23 +17,23 @@
17
17
  namespace duckdb {
18
18
 
19
19
  void CreateInfo::FormatSerialize(FormatSerializer &serializer) const {
20
- serializer.WriteProperty("type", type);
21
- serializer.WriteProperty("catalog", catalog);
22
- serializer.WriteProperty("schema", schema);
23
- serializer.WriteProperty("temporary", temporary);
24
- serializer.WriteProperty("internal", internal);
25
- serializer.WriteProperty("on_conflict", on_conflict);
26
- serializer.WriteProperty("sql", sql);
20
+ serializer.WriteProperty(100, "type", type);
21
+ serializer.WriteProperty(101, "catalog", catalog);
22
+ serializer.WriteProperty(102, "schema", schema);
23
+ serializer.WriteProperty(103, "temporary", temporary);
24
+ serializer.WriteProperty(104, "internal", internal);
25
+ serializer.WriteProperty(105, "on_conflict", on_conflict);
26
+ serializer.WriteProperty(106, "sql", sql);
27
27
  }
28
28
 
29
29
  unique_ptr<CreateInfo> CreateInfo::FormatDeserialize(FormatDeserializer &deserializer) {
30
- auto type = deserializer.ReadProperty<CatalogType>("type");
31
- auto catalog = deserializer.ReadProperty<string>("catalog");
32
- auto schema = deserializer.ReadProperty<string>("schema");
33
- auto temporary = deserializer.ReadProperty<bool>("temporary");
34
- auto internal = deserializer.ReadProperty<bool>("internal");
35
- auto on_conflict = deserializer.ReadProperty<OnCreateConflict>("on_conflict");
36
- auto sql = deserializer.ReadProperty<string>("sql");
30
+ auto type = deserializer.ReadProperty<CatalogType>(100, "type");
31
+ auto catalog = deserializer.ReadProperty<string>(101, "catalog");
32
+ auto schema = deserializer.ReadProperty<string>(102, "schema");
33
+ auto temporary = deserializer.ReadProperty<bool>(103, "temporary");
34
+ auto internal = deserializer.ReadProperty<bool>(104, "internal");
35
+ auto on_conflict = deserializer.ReadProperty<OnCreateConflict>(105, "on_conflict");
36
+ auto sql = deserializer.ReadProperty<string>(106, "sql");
37
37
  unique_ptr<CreateInfo> result;
38
38
  switch (type) {
39
39
  case CatalogType::INDEX_ENTRY:
@@ -74,37 +74,37 @@ unique_ptr<CreateInfo> CreateInfo::FormatDeserialize(FormatDeserializer &deseria
74
74
 
75
75
  void CreateIndexInfo::FormatSerialize(FormatSerializer &serializer) const {
76
76
  CreateInfo::FormatSerialize(serializer);
77
- serializer.WriteProperty("name", index_name);
78
- serializer.WriteProperty("table", table);
79
- serializer.WriteProperty("index_type", index_type);
80
- serializer.WriteProperty("constraint_type", constraint_type);
81
- serializer.WriteProperty("parsed_expressions", parsed_expressions);
82
- serializer.WriteProperty("names", names);
83
- serializer.WriteProperty("column_ids", column_ids);
77
+ serializer.WriteProperty(200, "name", index_name);
78
+ serializer.WriteProperty(201, "table", table);
79
+ serializer.WriteProperty(202, "index_type", index_type);
80
+ serializer.WriteProperty(203, "constraint_type", constraint_type);
81
+ serializer.WriteProperty(204, "parsed_expressions", parsed_expressions);
82
+ serializer.WriteProperty(205, "names", names);
83
+ serializer.WriteProperty(206, "column_ids", column_ids);
84
84
  }
85
85
 
86
86
  unique_ptr<CreateInfo> CreateIndexInfo::FormatDeserialize(FormatDeserializer &deserializer) {
87
87
  auto result = duckdb::unique_ptr<CreateIndexInfo>(new CreateIndexInfo());
88
- deserializer.ReadProperty("name", result->index_name);
89
- deserializer.ReadProperty("table", result->table);
90
- deserializer.ReadProperty("index_type", result->index_type);
91
- deserializer.ReadProperty("constraint_type", result->constraint_type);
92
- deserializer.ReadProperty("parsed_expressions", result->parsed_expressions);
93
- deserializer.ReadProperty("names", result->names);
94
- deserializer.ReadProperty("column_ids", result->column_ids);
88
+ deserializer.ReadProperty(200, "name", result->index_name);
89
+ deserializer.ReadProperty(201, "table", result->table);
90
+ deserializer.ReadProperty(202, "index_type", result->index_type);
91
+ deserializer.ReadProperty(203, "constraint_type", result->constraint_type);
92
+ deserializer.ReadProperty(204, "parsed_expressions", result->parsed_expressions);
93
+ deserializer.ReadProperty(205, "names", result->names);
94
+ deserializer.ReadProperty(206, "column_ids", result->column_ids);
95
95
  return std::move(result);
96
96
  }
97
97
 
98
98
  void CreateMacroInfo::FormatSerialize(FormatSerializer &serializer) const {
99
99
  CreateInfo::FormatSerialize(serializer);
100
- serializer.WriteProperty("name", name);
101
- serializer.WriteProperty("function", *function);
100
+ serializer.WriteProperty(200, "name", name);
101
+ serializer.WriteProperty(201, "function", *function);
102
102
  }
103
103
 
104
104
  unique_ptr<CreateInfo> CreateMacroInfo::FormatDeserialize(FormatDeserializer &deserializer) {
105
105
  auto result = duckdb::unique_ptr<CreateMacroInfo>(new CreateMacroInfo());
106
- deserializer.ReadProperty("name", result->name);
107
- deserializer.ReadProperty("function", result->function);
106
+ deserializer.ReadProperty(200, "name", result->name);
107
+ deserializer.ReadProperty(201, "function", result->function);
108
108
  return std::move(result);
109
109
  }
110
110
 
@@ -119,71 +119,71 @@ unique_ptr<CreateInfo> CreateSchemaInfo::FormatDeserialize(FormatDeserializer &d
119
119
 
120
120
  void CreateSequenceInfo::FormatSerialize(FormatSerializer &serializer) const {
121
121
  CreateInfo::FormatSerialize(serializer);
122
- serializer.WriteProperty("name", name);
123
- serializer.WriteProperty("usage_count", usage_count);
124
- serializer.WriteProperty("increment", increment);
125
- serializer.WriteProperty("min_value", min_value);
126
- serializer.WriteProperty("max_value", max_value);
127
- serializer.WriteProperty("start_value", start_value);
128
- serializer.WriteProperty("cycle", cycle);
122
+ serializer.WriteProperty(200, "name", name);
123
+ serializer.WriteProperty(201, "usage_count", usage_count);
124
+ serializer.WriteProperty(202, "increment", increment);
125
+ serializer.WriteProperty(203, "min_value", min_value);
126
+ serializer.WriteProperty(204, "max_value", max_value);
127
+ serializer.WriteProperty(205, "start_value", start_value);
128
+ serializer.WriteProperty(206, "cycle", cycle);
129
129
  }
130
130
 
131
131
  unique_ptr<CreateInfo> CreateSequenceInfo::FormatDeserialize(FormatDeserializer &deserializer) {
132
132
  auto result = duckdb::unique_ptr<CreateSequenceInfo>(new CreateSequenceInfo());
133
- deserializer.ReadProperty("name", result->name);
134
- deserializer.ReadProperty("usage_count", result->usage_count);
135
- deserializer.ReadProperty("increment", result->increment);
136
- deserializer.ReadProperty("min_value", result->min_value);
137
- deserializer.ReadProperty("max_value", result->max_value);
138
- deserializer.ReadProperty("start_value", result->start_value);
139
- deserializer.ReadProperty("cycle", result->cycle);
133
+ deserializer.ReadProperty(200, "name", result->name);
134
+ deserializer.ReadProperty(201, "usage_count", result->usage_count);
135
+ deserializer.ReadProperty(202, "increment", result->increment);
136
+ deserializer.ReadProperty(203, "min_value", result->min_value);
137
+ deserializer.ReadProperty(204, "max_value", result->max_value);
138
+ deserializer.ReadProperty(205, "start_value", result->start_value);
139
+ deserializer.ReadProperty(206, "cycle", result->cycle);
140
140
  return std::move(result);
141
141
  }
142
142
 
143
143
  void CreateTableInfo::FormatSerialize(FormatSerializer &serializer) const {
144
144
  CreateInfo::FormatSerialize(serializer);
145
- serializer.WriteProperty("table", table);
146
- serializer.WriteProperty("columns", columns);
147
- serializer.WriteProperty("constraints", constraints);
148
- serializer.WriteOptionalProperty("query", query);
145
+ serializer.WriteProperty(200, "table", table);
146
+ serializer.WriteProperty(201, "columns", columns);
147
+ serializer.WriteProperty(202, "constraints", constraints);
148
+ serializer.WriteOptionalProperty(203, "query", query);
149
149
  }
150
150
 
151
151
  unique_ptr<CreateInfo> CreateTableInfo::FormatDeserialize(FormatDeserializer &deserializer) {
152
152
  auto result = duckdb::unique_ptr<CreateTableInfo>(new CreateTableInfo());
153
- deserializer.ReadProperty("table", result->table);
154
- deserializer.ReadProperty("columns", result->columns);
155
- deserializer.ReadProperty("constraints", result->constraints);
156
- deserializer.ReadOptionalProperty("query", result->query);
153
+ deserializer.ReadProperty(200, "table", result->table);
154
+ deserializer.ReadProperty(201, "columns", result->columns);
155
+ deserializer.ReadProperty(202, "constraints", result->constraints);
156
+ deserializer.ReadOptionalProperty(203, "query", result->query);
157
157
  return std::move(result);
158
158
  }
159
159
 
160
160
  void CreateTypeInfo::FormatSerialize(FormatSerializer &serializer) const {
161
161
  CreateInfo::FormatSerialize(serializer);
162
- serializer.WriteProperty("name", name);
163
- serializer.WriteProperty("logical_type", type);
162
+ serializer.WriteProperty(200, "name", name);
163
+ serializer.WriteProperty(201, "logical_type", type);
164
164
  }
165
165
 
166
166
  unique_ptr<CreateInfo> CreateTypeInfo::FormatDeserialize(FormatDeserializer &deserializer) {
167
167
  auto result = duckdb::unique_ptr<CreateTypeInfo>(new CreateTypeInfo());
168
- deserializer.ReadProperty("name", result->name);
169
- deserializer.ReadProperty("logical_type", result->type);
168
+ deserializer.ReadProperty(200, "name", result->name);
169
+ deserializer.ReadProperty(201, "logical_type", result->type);
170
170
  return std::move(result);
171
171
  }
172
172
 
173
173
  void CreateViewInfo::FormatSerialize(FormatSerializer &serializer) const {
174
174
  CreateInfo::FormatSerialize(serializer);
175
- serializer.WriteProperty("view_name", view_name);
176
- serializer.WriteProperty("aliases", aliases);
177
- serializer.WriteProperty("types", types);
178
- serializer.WriteOptionalProperty("query", query);
175
+ serializer.WriteProperty(200, "view_name", view_name);
176
+ serializer.WriteProperty(201, "aliases", aliases);
177
+ serializer.WriteProperty(202, "types", types);
178
+ serializer.WriteOptionalProperty(203, "query", query);
179
179
  }
180
180
 
181
181
  unique_ptr<CreateInfo> CreateViewInfo::FormatDeserialize(FormatDeserializer &deserializer) {
182
182
  auto result = duckdb::unique_ptr<CreateViewInfo>(new CreateViewInfo());
183
- deserializer.ReadProperty("view_name", result->view_name);
184
- deserializer.ReadProperty("aliases", result->aliases);
185
- deserializer.ReadProperty("types", result->types);
186
- deserializer.ReadOptionalProperty("query", result->query);
183
+ deserializer.ReadProperty(200, "view_name", result->view_name);
184
+ deserializer.ReadProperty(201, "aliases", result->aliases);
185
+ deserializer.ReadProperty(202, "types", result->types);
186
+ deserializer.ReadOptionalProperty(203, "query", result->query);
187
187
  return std::move(result);
188
188
  }
189
189