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
@@ -10,15 +10,15 @@
10
10
  namespace duckdb {
11
11
 
12
12
  void Expression::FormatSerialize(FormatSerializer &serializer) const {
13
- serializer.WriteProperty("expression_class", expression_class);
14
- serializer.WriteProperty("type", type);
15
- serializer.WriteProperty("alias", alias);
13
+ serializer.WriteProperty(100, "expression_class", expression_class);
14
+ serializer.WriteProperty(101, "type", type);
15
+ serializer.WriteProperty(102, "alias", alias);
16
16
  }
17
17
 
18
18
  unique_ptr<Expression> Expression::FormatDeserialize(FormatDeserializer &deserializer) {
19
- auto expression_class = deserializer.ReadProperty<ExpressionClass>("expression_class");
20
- auto type = deserializer.ReadProperty<ExpressionType>("type");
21
- auto alias = deserializer.ReadProperty<string>("alias");
19
+ auto expression_class = deserializer.ReadProperty<ExpressionClass>(100, "expression_class");
20
+ auto type = deserializer.ReadProperty<ExpressionType>(101, "type");
21
+ auto alias = deserializer.ReadProperty<string>(102, "alias");
22
22
  deserializer.Set<ExpressionType>(type);
23
23
  unique_ptr<Expression> result;
24
24
  switch (expression_class) {
@@ -83,127 +83,127 @@ unique_ptr<Expression> Expression::FormatDeserialize(FormatDeserializer &deseria
83
83
 
84
84
  void BoundBetweenExpression::FormatSerialize(FormatSerializer &serializer) const {
85
85
  Expression::FormatSerialize(serializer);
86
- serializer.WriteProperty("input", *input);
87
- serializer.WriteProperty("lower", *lower);
88
- serializer.WriteProperty("upper", *upper);
89
- serializer.WriteProperty("lower_inclusive", lower_inclusive);
90
- serializer.WriteProperty("upper_inclusive", upper_inclusive);
86
+ serializer.WriteProperty(200, "input", *input);
87
+ serializer.WriteProperty(201, "lower", *lower);
88
+ serializer.WriteProperty(202, "upper", *upper);
89
+ serializer.WriteProperty(203, "lower_inclusive", lower_inclusive);
90
+ serializer.WriteProperty(204, "upper_inclusive", upper_inclusive);
91
91
  }
92
92
 
93
93
  unique_ptr<Expression> BoundBetweenExpression::FormatDeserialize(FormatDeserializer &deserializer) {
94
94
  auto result = duckdb::unique_ptr<BoundBetweenExpression>(new BoundBetweenExpression());
95
- deserializer.ReadProperty("input", result->input);
96
- deserializer.ReadProperty("lower", result->lower);
97
- deserializer.ReadProperty("upper", result->upper);
98
- deserializer.ReadProperty("lower_inclusive", result->lower_inclusive);
99
- deserializer.ReadProperty("upper_inclusive", result->upper_inclusive);
95
+ deserializer.ReadProperty(200, "input", result->input);
96
+ deserializer.ReadProperty(201, "lower", result->lower);
97
+ deserializer.ReadProperty(202, "upper", result->upper);
98
+ deserializer.ReadProperty(203, "lower_inclusive", result->lower_inclusive);
99
+ deserializer.ReadProperty(204, "upper_inclusive", result->upper_inclusive);
100
100
  return std::move(result);
101
101
  }
102
102
 
103
103
  void BoundCaseExpression::FormatSerialize(FormatSerializer &serializer) const {
104
104
  Expression::FormatSerialize(serializer);
105
- serializer.WriteProperty("return_type", return_type);
106
- serializer.WriteProperty("case_checks", case_checks);
107
- serializer.WriteProperty("else_expr", *else_expr);
105
+ serializer.WriteProperty(200, "return_type", return_type);
106
+ serializer.WriteProperty(201, "case_checks", case_checks);
107
+ serializer.WriteProperty(202, "else_expr", *else_expr);
108
108
  }
109
109
 
110
110
  unique_ptr<Expression> BoundCaseExpression::FormatDeserialize(FormatDeserializer &deserializer) {
111
- auto return_type = deserializer.ReadProperty<LogicalType>("return_type");
111
+ auto return_type = deserializer.ReadProperty<LogicalType>(200, "return_type");
112
112
  auto result = duckdb::unique_ptr<BoundCaseExpression>(new BoundCaseExpression(std::move(return_type)));
113
- deserializer.ReadProperty("case_checks", result->case_checks);
114
- deserializer.ReadProperty("else_expr", result->else_expr);
113
+ deserializer.ReadProperty(201, "case_checks", result->case_checks);
114
+ deserializer.ReadProperty(202, "else_expr", result->else_expr);
115
115
  return std::move(result);
116
116
  }
117
117
 
118
118
  void BoundCastExpression::FormatSerialize(FormatSerializer &serializer) const {
119
119
  Expression::FormatSerialize(serializer);
120
- serializer.WriteProperty("child", *child);
121
- serializer.WriteProperty("return_type", return_type);
122
- serializer.WriteProperty("try_cast", try_cast);
120
+ serializer.WriteProperty(200, "child", *child);
121
+ serializer.WriteProperty(201, "return_type", return_type);
122
+ serializer.WriteProperty(202, "try_cast", try_cast);
123
123
  }
124
124
 
125
125
  unique_ptr<Expression> BoundCastExpression::FormatDeserialize(FormatDeserializer &deserializer) {
126
- auto child = deserializer.ReadProperty<unique_ptr<Expression>>("child");
127
- auto return_type = deserializer.ReadProperty<LogicalType>("return_type");
126
+ auto child = deserializer.ReadProperty<unique_ptr<Expression>>(200, "child");
127
+ auto return_type = deserializer.ReadProperty<LogicalType>(201, "return_type");
128
128
  auto result = duckdb::unique_ptr<BoundCastExpression>(new BoundCastExpression(deserializer.Get<ClientContext &>(), std::move(child), std::move(return_type)));
129
- deserializer.ReadProperty("try_cast", result->try_cast);
129
+ deserializer.ReadProperty(202, "try_cast", result->try_cast);
130
130
  return std::move(result);
131
131
  }
132
132
 
133
133
  void BoundColumnRefExpression::FormatSerialize(FormatSerializer &serializer) const {
134
134
  Expression::FormatSerialize(serializer);
135
- serializer.WriteProperty("return_type", return_type);
136
- serializer.WriteProperty("binding", binding);
137
- serializer.WriteProperty("depth", depth);
135
+ serializer.WriteProperty(200, "return_type", return_type);
136
+ serializer.WriteProperty(201, "binding", binding);
137
+ serializer.WriteProperty(202, "depth", depth);
138
138
  }
139
139
 
140
140
  unique_ptr<Expression> BoundColumnRefExpression::FormatDeserialize(FormatDeserializer &deserializer) {
141
- auto return_type = deserializer.ReadProperty<LogicalType>("return_type");
142
- auto binding = deserializer.ReadProperty<ColumnBinding>("binding");
143
- auto depth = deserializer.ReadProperty<idx_t>("depth");
141
+ auto return_type = deserializer.ReadProperty<LogicalType>(200, "return_type");
142
+ auto binding = deserializer.ReadProperty<ColumnBinding>(201, "binding");
143
+ auto depth = deserializer.ReadProperty<idx_t>(202, "depth");
144
144
  auto result = duckdb::unique_ptr<BoundColumnRefExpression>(new BoundColumnRefExpression(std::move(return_type), binding, depth));
145
145
  return std::move(result);
146
146
  }
147
147
 
148
148
  void BoundComparisonExpression::FormatSerialize(FormatSerializer &serializer) const {
149
149
  Expression::FormatSerialize(serializer);
150
- serializer.WriteProperty("left", *left);
151
- serializer.WriteProperty("right", *right);
150
+ serializer.WriteProperty(200, "left", *left);
151
+ serializer.WriteProperty(201, "right", *right);
152
152
  }
153
153
 
154
154
  unique_ptr<Expression> BoundComparisonExpression::FormatDeserialize(FormatDeserializer &deserializer) {
155
- auto left = deserializer.ReadProperty<unique_ptr<Expression>>("left");
156
- auto right = deserializer.ReadProperty<unique_ptr<Expression>>("right");
155
+ auto left = deserializer.ReadProperty<unique_ptr<Expression>>(200, "left");
156
+ auto right = deserializer.ReadProperty<unique_ptr<Expression>>(201, "right");
157
157
  auto result = duckdb::unique_ptr<BoundComparisonExpression>(new BoundComparisonExpression(deserializer.Get<ExpressionType>(), std::move(left), std::move(right)));
158
158
  return std::move(result);
159
159
  }
160
160
 
161
161
  void BoundConjunctionExpression::FormatSerialize(FormatSerializer &serializer) const {
162
162
  Expression::FormatSerialize(serializer);
163
- serializer.WriteProperty("children", children);
163
+ serializer.WriteProperty(200, "children", children);
164
164
  }
165
165
 
166
166
  unique_ptr<Expression> BoundConjunctionExpression::FormatDeserialize(FormatDeserializer &deserializer) {
167
167
  auto result = duckdb::unique_ptr<BoundConjunctionExpression>(new BoundConjunctionExpression(deserializer.Get<ExpressionType>()));
168
- deserializer.ReadProperty("children", result->children);
168
+ deserializer.ReadProperty(200, "children", result->children);
169
169
  return std::move(result);
170
170
  }
171
171
 
172
172
  void BoundConstantExpression::FormatSerialize(FormatSerializer &serializer) const {
173
173
  Expression::FormatSerialize(serializer);
174
- serializer.WriteProperty("value", value);
174
+ serializer.WriteProperty(200, "value", value);
175
175
  }
176
176
 
177
177
  unique_ptr<Expression> BoundConstantExpression::FormatDeserialize(FormatDeserializer &deserializer) {
178
- auto value = deserializer.ReadProperty<Value>("value");
178
+ auto value = deserializer.ReadProperty<Value>(200, "value");
179
179
  auto result = duckdb::unique_ptr<BoundConstantExpression>(new BoundConstantExpression(value));
180
180
  return std::move(result);
181
181
  }
182
182
 
183
183
  void BoundDefaultExpression::FormatSerialize(FormatSerializer &serializer) const {
184
184
  Expression::FormatSerialize(serializer);
185
- serializer.WriteProperty("return_type", return_type);
185
+ serializer.WriteProperty(200, "return_type", return_type);
186
186
  }
187
187
 
188
188
  unique_ptr<Expression> BoundDefaultExpression::FormatDeserialize(FormatDeserializer &deserializer) {
189
- auto return_type = deserializer.ReadProperty<LogicalType>("return_type");
189
+ auto return_type = deserializer.ReadProperty<LogicalType>(200, "return_type");
190
190
  auto result = duckdb::unique_ptr<BoundDefaultExpression>(new BoundDefaultExpression(std::move(return_type)));
191
191
  return std::move(result);
192
192
  }
193
193
 
194
194
  void BoundLambdaExpression::FormatSerialize(FormatSerializer &serializer) const {
195
195
  Expression::FormatSerialize(serializer);
196
- serializer.WriteProperty("return_type", return_type);
197
- serializer.WriteProperty("lambda_expr", *lambda_expr);
198
- serializer.WriteProperty("captures", captures);
199
- serializer.WriteProperty("parameter_count", parameter_count);
196
+ serializer.WriteProperty(200, "return_type", return_type);
197
+ serializer.WriteProperty(201, "lambda_expr", *lambda_expr);
198
+ serializer.WriteProperty(202, "captures", captures);
199
+ serializer.WriteProperty(203, "parameter_count", parameter_count);
200
200
  }
201
201
 
202
202
  unique_ptr<Expression> BoundLambdaExpression::FormatDeserialize(FormatDeserializer &deserializer) {
203
- auto return_type = deserializer.ReadProperty<LogicalType>("return_type");
204
- auto lambda_expr = deserializer.ReadProperty<unique_ptr<Expression>>("lambda_expr");
205
- auto captures = deserializer.ReadProperty<vector<unique_ptr<Expression>>>("captures");
206
- auto parameter_count = deserializer.ReadProperty<idx_t>("parameter_count");
203
+ auto return_type = deserializer.ReadProperty<LogicalType>(200, "return_type");
204
+ auto lambda_expr = deserializer.ReadProperty<unique_ptr<Expression>>(201, "lambda_expr");
205
+ auto captures = deserializer.ReadProperty<vector<unique_ptr<Expression>>>(202, "captures");
206
+ auto parameter_count = deserializer.ReadProperty<idx_t>(203, "parameter_count");
207
207
  auto result = duckdb::unique_ptr<BoundLambdaExpression>(new BoundLambdaExpression(deserializer.Get<ExpressionType>(), std::move(return_type), std::move(lambda_expr), parameter_count));
208
208
  result->captures = std::move(captures);
209
209
  return std::move(result);
@@ -211,72 +211,72 @@ unique_ptr<Expression> BoundLambdaExpression::FormatDeserialize(FormatDeserializ
211
211
 
212
212
  void BoundLambdaRefExpression::FormatSerialize(FormatSerializer &serializer) const {
213
213
  Expression::FormatSerialize(serializer);
214
- serializer.WriteProperty("return_type", return_type);
215
- serializer.WriteProperty("binding", binding);
216
- serializer.WriteProperty("lambda_index", lambda_index);
217
- serializer.WriteProperty("depth", depth);
214
+ serializer.WriteProperty(200, "return_type", return_type);
215
+ serializer.WriteProperty(201, "binding", binding);
216
+ serializer.WriteProperty(202, "lambda_index", lambda_index);
217
+ serializer.WriteProperty(203, "depth", depth);
218
218
  }
219
219
 
220
220
  unique_ptr<Expression> BoundLambdaRefExpression::FormatDeserialize(FormatDeserializer &deserializer) {
221
- auto return_type = deserializer.ReadProperty<LogicalType>("return_type");
222
- auto binding = deserializer.ReadProperty<ColumnBinding>("binding");
223
- auto lambda_index = deserializer.ReadProperty<idx_t>("lambda_index");
224
- auto depth = deserializer.ReadProperty<idx_t>("depth");
221
+ auto return_type = deserializer.ReadProperty<LogicalType>(200, "return_type");
222
+ auto binding = deserializer.ReadProperty<ColumnBinding>(201, "binding");
223
+ auto lambda_index = deserializer.ReadProperty<idx_t>(202, "lambda_index");
224
+ auto depth = deserializer.ReadProperty<idx_t>(203, "depth");
225
225
  auto result = duckdb::unique_ptr<BoundLambdaRefExpression>(new BoundLambdaRefExpression(std::move(return_type), binding, lambda_index, depth));
226
226
  return std::move(result);
227
227
  }
228
228
 
229
229
  void BoundOperatorExpression::FormatSerialize(FormatSerializer &serializer) const {
230
230
  Expression::FormatSerialize(serializer);
231
- serializer.WriteProperty("return_type", return_type);
232
- serializer.WriteProperty("children", children);
231
+ serializer.WriteProperty(200, "return_type", return_type);
232
+ serializer.WriteProperty(201, "children", children);
233
233
  }
234
234
 
235
235
  unique_ptr<Expression> BoundOperatorExpression::FormatDeserialize(FormatDeserializer &deserializer) {
236
- auto return_type = deserializer.ReadProperty<LogicalType>("return_type");
236
+ auto return_type = deserializer.ReadProperty<LogicalType>(200, "return_type");
237
237
  auto result = duckdb::unique_ptr<BoundOperatorExpression>(new BoundOperatorExpression(deserializer.Get<ExpressionType>(), std::move(return_type)));
238
- deserializer.ReadProperty("children", result->children);
238
+ deserializer.ReadProperty(201, "children", result->children);
239
239
  return std::move(result);
240
240
  }
241
241
 
242
242
  void BoundParameterExpression::FormatSerialize(FormatSerializer &serializer) const {
243
243
  Expression::FormatSerialize(serializer);
244
- serializer.WriteProperty("identifier", identifier);
245
- serializer.WriteProperty("return_type", return_type);
246
- serializer.WriteProperty("parameter_data", *parameter_data);
244
+ serializer.WriteProperty(200, "identifier", identifier);
245
+ serializer.WriteProperty(201, "return_type", return_type);
246
+ serializer.WriteProperty(202, "parameter_data", *parameter_data);
247
247
  }
248
248
 
249
249
  unique_ptr<Expression> BoundParameterExpression::FormatDeserialize(FormatDeserializer &deserializer) {
250
- auto identifier = deserializer.ReadProperty<string>("identifier");
251
- auto return_type = deserializer.ReadProperty<LogicalType>("return_type");
252
- auto parameter_data = deserializer.ReadProperty<shared_ptr<BoundParameterData>>("parameter_data");
250
+ auto identifier = deserializer.ReadProperty<string>(200, "identifier");
251
+ auto return_type = deserializer.ReadProperty<LogicalType>(201, "return_type");
252
+ auto parameter_data = deserializer.ReadProperty<shared_ptr<BoundParameterData>>(202, "parameter_data");
253
253
  auto result = duckdb::unique_ptr<BoundParameterExpression>(new BoundParameterExpression(deserializer.Get<bound_parameter_map_t &>(), std::move(identifier), std::move(return_type), std::move(parameter_data)));
254
254
  return std::move(result);
255
255
  }
256
256
 
257
257
  void BoundReferenceExpression::FormatSerialize(FormatSerializer &serializer) const {
258
258
  Expression::FormatSerialize(serializer);
259
- serializer.WriteProperty("return_type", return_type);
260
- serializer.WriteProperty("index", index);
259
+ serializer.WriteProperty(200, "return_type", return_type);
260
+ serializer.WriteProperty(201, "index", index);
261
261
  }
262
262
 
263
263
  unique_ptr<Expression> BoundReferenceExpression::FormatDeserialize(FormatDeserializer &deserializer) {
264
- auto return_type = deserializer.ReadProperty<LogicalType>("return_type");
265
- auto index = deserializer.ReadProperty<idx_t>("index");
264
+ auto return_type = deserializer.ReadProperty<LogicalType>(200, "return_type");
265
+ auto index = deserializer.ReadProperty<idx_t>(201, "index");
266
266
  auto result = duckdb::unique_ptr<BoundReferenceExpression>(new BoundReferenceExpression(std::move(return_type), index));
267
267
  return std::move(result);
268
268
  }
269
269
 
270
270
  void BoundUnnestExpression::FormatSerialize(FormatSerializer &serializer) const {
271
271
  Expression::FormatSerialize(serializer);
272
- serializer.WriteProperty("return_type", return_type);
273
- serializer.WriteProperty("child", *child);
272
+ serializer.WriteProperty(200, "return_type", return_type);
273
+ serializer.WriteProperty(201, "child", *child);
274
274
  }
275
275
 
276
276
  unique_ptr<Expression> BoundUnnestExpression::FormatDeserialize(FormatDeserializer &deserializer) {
277
- auto return_type = deserializer.ReadProperty<LogicalType>("return_type");
277
+ auto return_type = deserializer.ReadProperty<LogicalType>(200, "return_type");
278
278
  auto result = duckdb::unique_ptr<BoundUnnestExpression>(new BoundUnnestExpression(std::move(return_type)));
279
- deserializer.ReadProperty("child", result->child);
279
+ deserializer.ReadProperty(201, "child", result->child);
280
280
  return std::move(result);
281
281
  }
282
282