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 ParsedExpression::FormatSerialize(FormatSerializer &serializer) const {
13
- serializer.WriteProperty("class", expression_class);
14
- serializer.WriteProperty("type", type);
15
- serializer.WriteProperty("alias", alias);
13
+ serializer.WriteProperty(100, "class", expression_class);
14
+ serializer.WriteProperty(101, "type", type);
15
+ serializer.WriteProperty(102, "alias", alias);
16
16
  }
17
17
 
18
18
  unique_ptr<ParsedExpression> ParsedExpression::FormatDeserialize(FormatDeserializer &deserializer) {
19
- auto expression_class = deserializer.ReadProperty<ExpressionClass>("class");
20
- auto type = deserializer.ReadProperty<ExpressionType>("type");
21
- auto alias = deserializer.ReadProperty<string>("alias");
19
+ auto expression_class = deserializer.ReadProperty<ExpressionClass>(100, "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<ParsedExpression> result;
24
24
  switch (expression_class) {
@@ -83,103 +83,103 @@ unique_ptr<ParsedExpression> ParsedExpression::FormatDeserialize(FormatDeseriali
83
83
 
84
84
  void BetweenExpression::FormatSerialize(FormatSerializer &serializer) const {
85
85
  ParsedExpression::FormatSerialize(serializer);
86
- serializer.WriteProperty("input", *input);
87
- serializer.WriteProperty("lower", *lower);
88
- serializer.WriteProperty("upper", *upper);
86
+ serializer.WriteProperty(200, "input", *input);
87
+ serializer.WriteProperty(201, "lower", *lower);
88
+ serializer.WriteProperty(202, "upper", *upper);
89
89
  }
90
90
 
91
91
  unique_ptr<ParsedExpression> BetweenExpression::FormatDeserialize(FormatDeserializer &deserializer) {
92
92
  auto result = duckdb::unique_ptr<BetweenExpression>(new BetweenExpression());
93
- deserializer.ReadProperty("input", result->input);
94
- deserializer.ReadProperty("lower", result->lower);
95
- deserializer.ReadProperty("upper", result->upper);
93
+ deserializer.ReadProperty(200, "input", result->input);
94
+ deserializer.ReadProperty(201, "lower", result->lower);
95
+ deserializer.ReadProperty(202, "upper", result->upper);
96
96
  return std::move(result);
97
97
  }
98
98
 
99
99
  void CaseExpression::FormatSerialize(FormatSerializer &serializer) const {
100
100
  ParsedExpression::FormatSerialize(serializer);
101
- serializer.WriteProperty("case_checks", case_checks);
102
- serializer.WriteProperty("else_expr", *else_expr);
101
+ serializer.WriteProperty(200, "case_checks", case_checks);
102
+ serializer.WriteProperty(201, "else_expr", *else_expr);
103
103
  }
104
104
 
105
105
  unique_ptr<ParsedExpression> CaseExpression::FormatDeserialize(FormatDeserializer &deserializer) {
106
106
  auto result = duckdb::unique_ptr<CaseExpression>(new CaseExpression());
107
- deserializer.ReadProperty("case_checks", result->case_checks);
108
- deserializer.ReadProperty("else_expr", result->else_expr);
107
+ deserializer.ReadProperty(200, "case_checks", result->case_checks);
108
+ deserializer.ReadProperty(201, "else_expr", result->else_expr);
109
109
  return std::move(result);
110
110
  }
111
111
 
112
112
  void CastExpression::FormatSerialize(FormatSerializer &serializer) const {
113
113
  ParsedExpression::FormatSerialize(serializer);
114
- serializer.WriteProperty("child", *child);
115
- serializer.WriteProperty("cast_type", cast_type);
116
- serializer.WriteProperty("try_cast", try_cast);
114
+ serializer.WriteProperty(200, "child", *child);
115
+ serializer.WriteProperty(201, "cast_type", cast_type);
116
+ serializer.WriteProperty(202, "try_cast", try_cast);
117
117
  }
118
118
 
119
119
  unique_ptr<ParsedExpression> CastExpression::FormatDeserialize(FormatDeserializer &deserializer) {
120
120
  auto result = duckdb::unique_ptr<CastExpression>(new CastExpression());
121
- deserializer.ReadProperty("child", result->child);
122
- deserializer.ReadProperty("cast_type", result->cast_type);
123
- deserializer.ReadProperty("try_cast", result->try_cast);
121
+ deserializer.ReadProperty(200, "child", result->child);
122
+ deserializer.ReadProperty(201, "cast_type", result->cast_type);
123
+ deserializer.ReadProperty(202, "try_cast", result->try_cast);
124
124
  return std::move(result);
125
125
  }
126
126
 
127
127
  void CollateExpression::FormatSerialize(FormatSerializer &serializer) const {
128
128
  ParsedExpression::FormatSerialize(serializer);
129
- serializer.WriteProperty("child", *child);
130
- serializer.WriteProperty("collation", collation);
129
+ serializer.WriteProperty(200, "child", *child);
130
+ serializer.WriteProperty(201, "collation", collation);
131
131
  }
132
132
 
133
133
  unique_ptr<ParsedExpression> CollateExpression::FormatDeserialize(FormatDeserializer &deserializer) {
134
134
  auto result = duckdb::unique_ptr<CollateExpression>(new CollateExpression());
135
- deserializer.ReadProperty("child", result->child);
136
- deserializer.ReadProperty("collation", result->collation);
135
+ deserializer.ReadProperty(200, "child", result->child);
136
+ deserializer.ReadProperty(201, "collation", result->collation);
137
137
  return std::move(result);
138
138
  }
139
139
 
140
140
  void ColumnRefExpression::FormatSerialize(FormatSerializer &serializer) const {
141
141
  ParsedExpression::FormatSerialize(serializer);
142
- serializer.WriteProperty("column_names", column_names);
142
+ serializer.WriteProperty(200, "column_names", column_names);
143
143
  }
144
144
 
145
145
  unique_ptr<ParsedExpression> ColumnRefExpression::FormatDeserialize(FormatDeserializer &deserializer) {
146
146
  auto result = duckdb::unique_ptr<ColumnRefExpression>(new ColumnRefExpression());
147
- deserializer.ReadProperty("column_names", result->column_names);
147
+ deserializer.ReadProperty(200, "column_names", result->column_names);
148
148
  return std::move(result);
149
149
  }
150
150
 
151
151
  void ComparisonExpression::FormatSerialize(FormatSerializer &serializer) const {
152
152
  ParsedExpression::FormatSerialize(serializer);
153
- serializer.WriteProperty("left", *left);
154
- serializer.WriteProperty("right", *right);
153
+ serializer.WriteProperty(200, "left", *left);
154
+ serializer.WriteProperty(201, "right", *right);
155
155
  }
156
156
 
157
157
  unique_ptr<ParsedExpression> ComparisonExpression::FormatDeserialize(FormatDeserializer &deserializer) {
158
158
  auto result = duckdb::unique_ptr<ComparisonExpression>(new ComparisonExpression(deserializer.Get<ExpressionType>()));
159
- deserializer.ReadProperty("left", result->left);
160
- deserializer.ReadProperty("right", result->right);
159
+ deserializer.ReadProperty(200, "left", result->left);
160
+ deserializer.ReadProperty(201, "right", result->right);
161
161
  return std::move(result);
162
162
  }
163
163
 
164
164
  void ConjunctionExpression::FormatSerialize(FormatSerializer &serializer) const {
165
165
  ParsedExpression::FormatSerialize(serializer);
166
- serializer.WriteProperty("children", children);
166
+ serializer.WriteProperty(200, "children", children);
167
167
  }
168
168
 
169
169
  unique_ptr<ParsedExpression> ConjunctionExpression::FormatDeserialize(FormatDeserializer &deserializer) {
170
170
  auto result = duckdb::unique_ptr<ConjunctionExpression>(new ConjunctionExpression(deserializer.Get<ExpressionType>()));
171
- deserializer.ReadProperty("children", result->children);
171
+ deserializer.ReadProperty(200, "children", result->children);
172
172
  return std::move(result);
173
173
  }
174
174
 
175
175
  void ConstantExpression::FormatSerialize(FormatSerializer &serializer) const {
176
176
  ParsedExpression::FormatSerialize(serializer);
177
- serializer.WriteProperty("value", value);
177
+ serializer.WriteProperty(200, "value", value);
178
178
  }
179
179
 
180
180
  unique_ptr<ParsedExpression> ConstantExpression::FormatDeserialize(FormatDeserializer &deserializer) {
181
181
  auto result = duckdb::unique_ptr<ConstantExpression>(new ConstantExpression());
182
- deserializer.ReadProperty("value", result->value);
182
+ deserializer.ReadProperty(200, "value", result->value);
183
183
  return std::move(result);
184
184
  }
185
185
 
@@ -194,148 +194,148 @@ unique_ptr<ParsedExpression> DefaultExpression::FormatDeserialize(FormatDeserial
194
194
 
195
195
  void FunctionExpression::FormatSerialize(FormatSerializer &serializer) const {
196
196
  ParsedExpression::FormatSerialize(serializer);
197
- serializer.WriteProperty("function_name", function_name);
198
- serializer.WriteProperty("schema", schema);
199
- serializer.WriteProperty("children", children);
200
- serializer.WriteOptionalProperty("filter", filter);
201
- serializer.WriteProperty("order_bys", (ResultModifier &)*order_bys);
202
- serializer.WriteProperty("distinct", distinct);
203
- serializer.WriteProperty("is_operator", is_operator);
204
- serializer.WriteProperty("export_state", export_state);
205
- serializer.WriteProperty("catalog", catalog);
197
+ serializer.WriteProperty(200, "function_name", function_name);
198
+ serializer.WriteProperty(201, "schema", schema);
199
+ serializer.WriteProperty(202, "children", children);
200
+ serializer.WriteOptionalProperty(203, "filter", filter);
201
+ serializer.WriteProperty(204, "order_bys", (ResultModifier &)*order_bys);
202
+ serializer.WriteProperty(205, "distinct", distinct);
203
+ serializer.WriteProperty(206, "is_operator", is_operator);
204
+ serializer.WriteProperty(207, "export_state", export_state);
205
+ serializer.WriteProperty(208, "catalog", catalog);
206
206
  }
207
207
 
208
208
  unique_ptr<ParsedExpression> FunctionExpression::FormatDeserialize(FormatDeserializer &deserializer) {
209
209
  auto result = duckdb::unique_ptr<FunctionExpression>(new FunctionExpression());
210
- deserializer.ReadProperty("function_name", result->function_name);
211
- deserializer.ReadProperty("schema", result->schema);
212
- deserializer.ReadProperty("children", result->children);
213
- deserializer.ReadOptionalProperty("filter", result->filter);
214
- auto order_bys = deserializer.ReadProperty<unique_ptr<ResultModifier>>("order_bys");
210
+ deserializer.ReadProperty(200, "function_name", result->function_name);
211
+ deserializer.ReadProperty(201, "schema", result->schema);
212
+ deserializer.ReadProperty(202, "children", result->children);
213
+ deserializer.ReadOptionalProperty(203, "filter", result->filter);
214
+ auto order_bys = deserializer.ReadProperty<unique_ptr<ResultModifier>>(204, "order_bys");
215
215
  result->order_bys = unique_ptr_cast<ResultModifier, OrderModifier>(std::move(order_bys));
216
- deserializer.ReadProperty("distinct", result->distinct);
217
- deserializer.ReadProperty("is_operator", result->is_operator);
218
- deserializer.ReadProperty("export_state", result->export_state);
219
- deserializer.ReadProperty("catalog", result->catalog);
216
+ deserializer.ReadProperty(205, "distinct", result->distinct);
217
+ deserializer.ReadProperty(206, "is_operator", result->is_operator);
218
+ deserializer.ReadProperty(207, "export_state", result->export_state);
219
+ deserializer.ReadProperty(208, "catalog", result->catalog);
220
220
  return std::move(result);
221
221
  }
222
222
 
223
223
  void LambdaExpression::FormatSerialize(FormatSerializer &serializer) const {
224
224
  ParsedExpression::FormatSerialize(serializer);
225
- serializer.WriteProperty("lhs", *lhs);
226
- serializer.WriteProperty("expr", *expr);
225
+ serializer.WriteProperty(200, "lhs", *lhs);
226
+ serializer.WriteProperty(201, "expr", *expr);
227
227
  }
228
228
 
229
229
  unique_ptr<ParsedExpression> LambdaExpression::FormatDeserialize(FormatDeserializer &deserializer) {
230
230
  auto result = duckdb::unique_ptr<LambdaExpression>(new LambdaExpression());
231
- deserializer.ReadProperty("lhs", result->lhs);
232
- deserializer.ReadProperty("expr", result->expr);
231
+ deserializer.ReadProperty(200, "lhs", result->lhs);
232
+ deserializer.ReadProperty(201, "expr", result->expr);
233
233
  return std::move(result);
234
234
  }
235
235
 
236
236
  void OperatorExpression::FormatSerialize(FormatSerializer &serializer) const {
237
237
  ParsedExpression::FormatSerialize(serializer);
238
- serializer.WriteProperty("children", children);
238
+ serializer.WriteProperty(200, "children", children);
239
239
  }
240
240
 
241
241
  unique_ptr<ParsedExpression> OperatorExpression::FormatDeserialize(FormatDeserializer &deserializer) {
242
242
  auto result = duckdb::unique_ptr<OperatorExpression>(new OperatorExpression(deserializer.Get<ExpressionType>()));
243
- deserializer.ReadProperty("children", result->children);
243
+ deserializer.ReadProperty(200, "children", result->children);
244
244
  return std::move(result);
245
245
  }
246
246
 
247
247
  void ParameterExpression::FormatSerialize(FormatSerializer &serializer) const {
248
248
  ParsedExpression::FormatSerialize(serializer);
249
- serializer.WriteProperty("identifier", identifier);
249
+ serializer.WriteProperty(200, "identifier", identifier);
250
250
  }
251
251
 
252
252
  unique_ptr<ParsedExpression> ParameterExpression::FormatDeserialize(FormatDeserializer &deserializer) {
253
253
  auto result = duckdb::unique_ptr<ParameterExpression>(new ParameterExpression());
254
- deserializer.ReadProperty("identifier", result->identifier);
254
+ deserializer.ReadProperty(200, "identifier", result->identifier);
255
255
  return std::move(result);
256
256
  }
257
257
 
258
258
  void PositionalReferenceExpression::FormatSerialize(FormatSerializer &serializer) const {
259
259
  ParsedExpression::FormatSerialize(serializer);
260
- serializer.WriteProperty("index", index);
260
+ serializer.WriteProperty(200, "index", index);
261
261
  }
262
262
 
263
263
  unique_ptr<ParsedExpression> PositionalReferenceExpression::FormatDeserialize(FormatDeserializer &deserializer) {
264
264
  auto result = duckdb::unique_ptr<PositionalReferenceExpression>(new PositionalReferenceExpression());
265
- deserializer.ReadProperty("index", result->index);
265
+ deserializer.ReadProperty(200, "index", result->index);
266
266
  return std::move(result);
267
267
  }
268
268
 
269
269
  void StarExpression::FormatSerialize(FormatSerializer &serializer) const {
270
270
  ParsedExpression::FormatSerialize(serializer);
271
- serializer.WriteProperty("relation_name", relation_name);
272
- serializer.WriteProperty("exclude_list", exclude_list);
273
- serializer.WriteProperty("replace_list", replace_list);
274
- serializer.WriteProperty("columns", columns);
275
- serializer.WriteOptionalProperty("expr", expr);
271
+ serializer.WriteProperty(200, "relation_name", relation_name);
272
+ serializer.WriteProperty(201, "exclude_list", exclude_list);
273
+ serializer.WriteProperty(202, "replace_list", replace_list);
274
+ serializer.WriteProperty(203, "columns", columns);
275
+ serializer.WriteOptionalProperty(204, "expr", expr);
276
276
  }
277
277
 
278
278
  unique_ptr<ParsedExpression> StarExpression::FormatDeserialize(FormatDeserializer &deserializer) {
279
279
  auto result = duckdb::unique_ptr<StarExpression>(new StarExpression());
280
- deserializer.ReadProperty("relation_name", result->relation_name);
281
- deserializer.ReadProperty("exclude_list", result->exclude_list);
282
- deserializer.ReadProperty("replace_list", result->replace_list);
283
- deserializer.ReadProperty("columns", result->columns);
284
- deserializer.ReadOptionalProperty("expr", result->expr);
280
+ deserializer.ReadProperty(200, "relation_name", result->relation_name);
281
+ deserializer.ReadProperty(201, "exclude_list", result->exclude_list);
282
+ deserializer.ReadProperty(202, "replace_list", result->replace_list);
283
+ deserializer.ReadProperty(203, "columns", result->columns);
284
+ deserializer.ReadOptionalProperty(204, "expr", result->expr);
285
285
  return std::move(result);
286
286
  }
287
287
 
288
288
  void SubqueryExpression::FormatSerialize(FormatSerializer &serializer) const {
289
289
  ParsedExpression::FormatSerialize(serializer);
290
- serializer.WriteProperty("subquery_type", subquery_type);
291
- serializer.WriteProperty("subquery", subquery);
292
- serializer.WriteOptionalProperty("child", child);
293
- serializer.WriteProperty("comparison_type", comparison_type);
290
+ serializer.WriteProperty(200, "subquery_type", subquery_type);
291
+ serializer.WriteProperty(201, "subquery", subquery);
292
+ serializer.WriteOptionalProperty(202, "child", child);
293
+ serializer.WriteProperty(203, "comparison_type", comparison_type);
294
294
  }
295
295
 
296
296
  unique_ptr<ParsedExpression> SubqueryExpression::FormatDeserialize(FormatDeserializer &deserializer) {
297
297
  auto result = duckdb::unique_ptr<SubqueryExpression>(new SubqueryExpression());
298
- deserializer.ReadProperty("subquery_type", result->subquery_type);
299
- deserializer.ReadProperty("subquery", result->subquery);
300
- deserializer.ReadOptionalProperty("child", result->child);
301
- deserializer.ReadProperty("comparison_type", result->comparison_type);
298
+ deserializer.ReadProperty(200, "subquery_type", result->subquery_type);
299
+ deserializer.ReadProperty(201, "subquery", result->subquery);
300
+ deserializer.ReadOptionalProperty(202, "child", result->child);
301
+ deserializer.ReadProperty(203, "comparison_type", result->comparison_type);
302
302
  return std::move(result);
303
303
  }
304
304
 
305
305
  void WindowExpression::FormatSerialize(FormatSerializer &serializer) const {
306
306
  ParsedExpression::FormatSerialize(serializer);
307
- serializer.WriteProperty("function_name", function_name);
308
- serializer.WriteProperty("schema", schema);
309
- serializer.WriteProperty("catalog", catalog);
310
- serializer.WriteProperty("children", children);
311
- serializer.WriteProperty("partitions", partitions);
312
- serializer.WriteProperty("orders", orders);
313
- serializer.WriteProperty("start", start);
314
- serializer.WriteProperty("end", end);
315
- serializer.WriteOptionalProperty("start_expr", start_expr);
316
- serializer.WriteOptionalProperty("end_expr", end_expr);
317
- serializer.WriteOptionalProperty("offset_expr", offset_expr);
318
- serializer.WriteOptionalProperty("default_expr", default_expr);
319
- serializer.WriteProperty("ignore_nulls", ignore_nulls);
320
- serializer.WriteOptionalProperty("filter_expr", filter_expr);
307
+ serializer.WriteProperty(200, "function_name", function_name);
308
+ serializer.WriteProperty(201, "schema", schema);
309
+ serializer.WriteProperty(202, "catalog", catalog);
310
+ serializer.WriteProperty(203, "children", children);
311
+ serializer.WriteProperty(204, "partitions", partitions);
312
+ serializer.WriteProperty(205, "orders", orders);
313
+ serializer.WriteProperty(206, "start", start);
314
+ serializer.WriteProperty(207, "end", end);
315
+ serializer.WriteOptionalProperty(208, "start_expr", start_expr);
316
+ serializer.WriteOptionalProperty(209, "end_expr", end_expr);
317
+ serializer.WriteOptionalProperty(210, "offset_expr", offset_expr);
318
+ serializer.WriteOptionalProperty(211, "default_expr", default_expr);
319
+ serializer.WriteProperty(212, "ignore_nulls", ignore_nulls);
320
+ serializer.WriteOptionalProperty(213, "filter_expr", filter_expr);
321
321
  }
322
322
 
323
323
  unique_ptr<ParsedExpression> WindowExpression::FormatDeserialize(FormatDeserializer &deserializer) {
324
324
  auto result = duckdb::unique_ptr<WindowExpression>(new WindowExpression(deserializer.Get<ExpressionType>()));
325
- deserializer.ReadProperty("function_name", result->function_name);
326
- deserializer.ReadProperty("schema", result->schema);
327
- deserializer.ReadProperty("catalog", result->catalog);
328
- deserializer.ReadProperty("children", result->children);
329
- deserializer.ReadProperty("partitions", result->partitions);
330
- deserializer.ReadProperty("orders", result->orders);
331
- deserializer.ReadProperty("start", result->start);
332
- deserializer.ReadProperty("end", result->end);
333
- deserializer.ReadOptionalProperty("start_expr", result->start_expr);
334
- deserializer.ReadOptionalProperty("end_expr", result->end_expr);
335
- deserializer.ReadOptionalProperty("offset_expr", result->offset_expr);
336
- deserializer.ReadOptionalProperty("default_expr", result->default_expr);
337
- deserializer.ReadProperty("ignore_nulls", result->ignore_nulls);
338
- deserializer.ReadOptionalProperty("filter_expr", result->filter_expr);
325
+ deserializer.ReadProperty(200, "function_name", result->function_name);
326
+ deserializer.ReadProperty(201, "schema", result->schema);
327
+ deserializer.ReadProperty(202, "catalog", result->catalog);
328
+ deserializer.ReadProperty(203, "children", result->children);
329
+ deserializer.ReadProperty(204, "partitions", result->partitions);
330
+ deserializer.ReadProperty(205, "orders", result->orders);
331
+ deserializer.ReadProperty(206, "start", result->start);
332
+ deserializer.ReadProperty(207, "end", result->end);
333
+ deserializer.ReadOptionalProperty(208, "start_expr", result->start_expr);
334
+ deserializer.ReadOptionalProperty(209, "end_expr", result->end_expr);
335
+ deserializer.ReadOptionalProperty(210, "offset_expr", result->offset_expr);
336
+ deserializer.ReadOptionalProperty(211, "default_expr", result->default_expr);
337
+ deserializer.ReadProperty(212, "ignore_nulls", result->ignore_nulls);
338
+ deserializer.ReadOptionalProperty(213, "filter_expr", result->filter_expr);
339
339
  return std::move(result);
340
340
  }
341
341
 
@@ -10,15 +10,15 @@
10
10
  namespace duckdb {
11
11
 
12
12
  void QueryNode::FormatSerialize(FormatSerializer &serializer) const {
13
- serializer.WriteProperty("type", type);
14
- serializer.WriteProperty("modifiers", modifiers);
15
- serializer.WriteProperty("cte_map", cte_map);
13
+ serializer.WriteProperty(100, "type", type);
14
+ serializer.WriteProperty(101, "modifiers", modifiers);
15
+ serializer.WriteProperty(102, "cte_map", cte_map);
16
16
  }
17
17
 
18
18
  unique_ptr<QueryNode> QueryNode::FormatDeserialize(FormatDeserializer &deserializer) {
19
- auto type = deserializer.ReadProperty<QueryNodeType>("type");
20
- auto modifiers = deserializer.ReadProperty<vector<unique_ptr<ResultModifier>>>("modifiers");
21
- auto cte_map = deserializer.ReadProperty<CommonTableExpressionMap>("cte_map");
19
+ auto type = deserializer.ReadProperty<QueryNodeType>(100, "type");
20
+ auto modifiers = deserializer.ReadProperty<vector<unique_ptr<ResultModifier>>>(101, "modifiers");
21
+ auto cte_map = deserializer.ReadProperty<CommonTableExpressionMap>(102, "cte_map");
22
22
  unique_ptr<QueryNode> result;
23
23
  switch (type) {
24
24
  case QueryNodeType::CTE_NODE:
@@ -43,79 +43,79 @@ unique_ptr<QueryNode> QueryNode::FormatDeserialize(FormatDeserializer &deseriali
43
43
 
44
44
  void CTENode::FormatSerialize(FormatSerializer &serializer) const {
45
45
  QueryNode::FormatSerialize(serializer);
46
- serializer.WriteProperty("cte_name", ctename);
47
- serializer.WriteProperty("query", *query);
48
- serializer.WriteProperty("child", *child);
49
- serializer.WriteProperty("aliases", aliases);
46
+ serializer.WriteProperty(200, "cte_name", ctename);
47
+ serializer.WriteProperty(201, "query", *query);
48
+ serializer.WriteProperty(202, "child", *child);
49
+ serializer.WriteProperty(203, "aliases", aliases);
50
50
  }
51
51
 
52
52
  unique_ptr<QueryNode> CTENode::FormatDeserialize(FormatDeserializer &deserializer) {
53
53
  auto result = duckdb::unique_ptr<CTENode>(new CTENode());
54
- deserializer.ReadProperty("cte_name", result->ctename);
55
- deserializer.ReadProperty("query", result->query);
56
- deserializer.ReadProperty("child", result->child);
57
- deserializer.ReadProperty("aliases", result->aliases);
54
+ deserializer.ReadProperty(200, "cte_name", result->ctename);
55
+ deserializer.ReadProperty(201, "query", result->query);
56
+ deserializer.ReadProperty(202, "child", result->child);
57
+ deserializer.ReadProperty(203, "aliases", result->aliases);
58
58
  return std::move(result);
59
59
  }
60
60
 
61
61
  void RecursiveCTENode::FormatSerialize(FormatSerializer &serializer) const {
62
62
  QueryNode::FormatSerialize(serializer);
63
- serializer.WriteProperty("cte_name", ctename);
64
- serializer.WriteProperty("union_all", union_all);
65
- serializer.WriteProperty("left", *left);
66
- serializer.WriteProperty("right", *right);
67
- serializer.WriteProperty("aliases", aliases);
63
+ serializer.WriteProperty(200, "cte_name", ctename);
64
+ serializer.WriteProperty(201, "union_all", union_all);
65
+ serializer.WriteProperty(202, "left", *left);
66
+ serializer.WriteProperty(203, "right", *right);
67
+ serializer.WriteProperty(204, "aliases", aliases);
68
68
  }
69
69
 
70
70
  unique_ptr<QueryNode> RecursiveCTENode::FormatDeserialize(FormatDeserializer &deserializer) {
71
71
  auto result = duckdb::unique_ptr<RecursiveCTENode>(new RecursiveCTENode());
72
- deserializer.ReadProperty("cte_name", result->ctename);
73
- deserializer.ReadProperty("union_all", result->union_all);
74
- deserializer.ReadProperty("left", result->left);
75
- deserializer.ReadProperty("right", result->right);
76
- deserializer.ReadProperty("aliases", result->aliases);
72
+ deserializer.ReadProperty(200, "cte_name", result->ctename);
73
+ deserializer.ReadProperty(201, "union_all", result->union_all);
74
+ deserializer.ReadProperty(202, "left", result->left);
75
+ deserializer.ReadProperty(203, "right", result->right);
76
+ deserializer.ReadProperty(204, "aliases", result->aliases);
77
77
  return std::move(result);
78
78
  }
79
79
 
80
80
  void SelectNode::FormatSerialize(FormatSerializer &serializer) const {
81
81
  QueryNode::FormatSerialize(serializer);
82
- serializer.WriteProperty("select_list", select_list);
83
- serializer.WriteOptionalProperty("from_table", from_table);
84
- serializer.WriteOptionalProperty("where_clause", where_clause);
85
- serializer.WriteProperty("group_expressions", groups.group_expressions);
86
- serializer.WriteProperty("group_sets", groups.grouping_sets);
87
- serializer.WriteProperty("aggregate_handling", aggregate_handling);
88
- serializer.WriteOptionalProperty("having", having);
89
- serializer.WriteOptionalProperty("sample", sample);
90
- serializer.WriteOptionalProperty("qualify", qualify);
82
+ serializer.WriteProperty(200, "select_list", select_list);
83
+ serializer.WriteOptionalProperty(201, "from_table", from_table);
84
+ serializer.WriteOptionalProperty(202, "where_clause", where_clause);
85
+ serializer.WriteProperty(203, "group_expressions", groups.group_expressions);
86
+ serializer.WriteProperty(204, "group_sets", groups.grouping_sets);
87
+ serializer.WriteProperty(205, "aggregate_handling", aggregate_handling);
88
+ serializer.WriteOptionalProperty(206, "having", having);
89
+ serializer.WriteOptionalProperty(207, "sample", sample);
90
+ serializer.WriteOptionalProperty(208, "qualify", qualify);
91
91
  }
92
92
 
93
93
  unique_ptr<QueryNode> SelectNode::FormatDeserialize(FormatDeserializer &deserializer) {
94
94
  auto result = duckdb::unique_ptr<SelectNode>(new SelectNode());
95
- deserializer.ReadProperty("select_list", result->select_list);
96
- deserializer.ReadOptionalProperty("from_table", result->from_table);
97
- deserializer.ReadOptionalProperty("where_clause", result->where_clause);
98
- deserializer.ReadProperty("group_expressions", result->groups.group_expressions);
99
- deserializer.ReadProperty("group_sets", result->groups.grouping_sets);
100
- deserializer.ReadProperty("aggregate_handling", result->aggregate_handling);
101
- deserializer.ReadOptionalProperty("having", result->having);
102
- deserializer.ReadOptionalProperty("sample", result->sample);
103
- deserializer.ReadOptionalProperty("qualify", result->qualify);
95
+ deserializer.ReadProperty(200, "select_list", result->select_list);
96
+ deserializer.ReadOptionalProperty(201, "from_table", result->from_table);
97
+ deserializer.ReadOptionalProperty(202, "where_clause", result->where_clause);
98
+ deserializer.ReadProperty(203, "group_expressions", result->groups.group_expressions);
99
+ deserializer.ReadProperty(204, "group_sets", result->groups.grouping_sets);
100
+ deserializer.ReadProperty(205, "aggregate_handling", result->aggregate_handling);
101
+ deserializer.ReadOptionalProperty(206, "having", result->having);
102
+ deserializer.ReadOptionalProperty(207, "sample", result->sample);
103
+ deserializer.ReadOptionalProperty(208, "qualify", result->qualify);
104
104
  return std::move(result);
105
105
  }
106
106
 
107
107
  void SetOperationNode::FormatSerialize(FormatSerializer &serializer) const {
108
108
  QueryNode::FormatSerialize(serializer);
109
- serializer.WriteProperty("setop_type", setop_type);
110
- serializer.WriteProperty("left", *left);
111
- serializer.WriteProperty("right", *right);
109
+ serializer.WriteProperty(200, "setop_type", setop_type);
110
+ serializer.WriteProperty(201, "left", *left);
111
+ serializer.WriteProperty(202, "right", *right);
112
112
  }
113
113
 
114
114
  unique_ptr<QueryNode> SetOperationNode::FormatDeserialize(FormatDeserializer &deserializer) {
115
115
  auto result = duckdb::unique_ptr<SetOperationNode>(new SetOperationNode());
116
- deserializer.ReadProperty("setop_type", result->setop_type);
117
- deserializer.ReadProperty("left", result->left);
118
- deserializer.ReadProperty("right", result->right);
116
+ deserializer.ReadProperty(200, "setop_type", result->setop_type);
117
+ deserializer.ReadProperty(201, "left", result->left);
118
+ deserializer.ReadProperty(202, "right", result->right);
119
119
  return std::move(result);
120
120
  }
121
121
 
@@ -11,11 +11,11 @@
11
11
  namespace duckdb {
12
12
 
13
13
  void ResultModifier::FormatSerialize(FormatSerializer &serializer) const {
14
- serializer.WriteProperty("type", type);
14
+ serializer.WriteProperty(100, "type", type);
15
15
  }
16
16
 
17
17
  unique_ptr<ResultModifier> ResultModifier::FormatDeserialize(FormatDeserializer &deserializer) {
18
- auto type = deserializer.ReadProperty<ResultModifierType>("type");
18
+ auto type = deserializer.ReadProperty<ResultModifierType>(100, "type");
19
19
  unique_ptr<ResultModifier> result;
20
20
  switch (type) {
21
21
  case ResultModifierType::DISTINCT_MODIFIER:
@@ -37,60 +37,60 @@ unique_ptr<ResultModifier> ResultModifier::FormatDeserialize(FormatDeserializer
37
37
  }
38
38
 
39
39
  void BoundOrderModifier::FormatSerialize(FormatSerializer &serializer) const {
40
- serializer.WriteProperty("orders", orders);
40
+ serializer.WriteProperty(100, "orders", orders);
41
41
  }
42
42
 
43
43
  unique_ptr<BoundOrderModifier> BoundOrderModifier::FormatDeserialize(FormatDeserializer &deserializer) {
44
44
  auto result = duckdb::unique_ptr<BoundOrderModifier>(new BoundOrderModifier());
45
- deserializer.ReadProperty("orders", result->orders);
45
+ deserializer.ReadProperty(100, "orders", result->orders);
46
46
  return result;
47
47
  }
48
48
 
49
49
  void DistinctModifier::FormatSerialize(FormatSerializer &serializer) const {
50
50
  ResultModifier::FormatSerialize(serializer);
51
- serializer.WriteProperty("distinct_on_targets", distinct_on_targets);
51
+ serializer.WriteProperty(200, "distinct_on_targets", distinct_on_targets);
52
52
  }
53
53
 
54
54
  unique_ptr<ResultModifier> DistinctModifier::FormatDeserialize(FormatDeserializer &deserializer) {
55
55
  auto result = duckdb::unique_ptr<DistinctModifier>(new DistinctModifier());
56
- deserializer.ReadProperty("distinct_on_targets", result->distinct_on_targets);
56
+ deserializer.ReadProperty(200, "distinct_on_targets", result->distinct_on_targets);
57
57
  return std::move(result);
58
58
  }
59
59
 
60
60
  void LimitModifier::FormatSerialize(FormatSerializer &serializer) const {
61
61
  ResultModifier::FormatSerialize(serializer);
62
- serializer.WriteOptionalProperty("limit", limit);
63
- serializer.WriteOptionalProperty("offset", offset);
62
+ serializer.WriteOptionalProperty(200, "limit", limit);
63
+ serializer.WriteOptionalProperty(201, "offset", offset);
64
64
  }
65
65
 
66
66
  unique_ptr<ResultModifier> LimitModifier::FormatDeserialize(FormatDeserializer &deserializer) {
67
67
  auto result = duckdb::unique_ptr<LimitModifier>(new LimitModifier());
68
- deserializer.ReadOptionalProperty("limit", result->limit);
69
- deserializer.ReadOptionalProperty("offset", result->offset);
68
+ deserializer.ReadOptionalProperty(200, "limit", result->limit);
69
+ deserializer.ReadOptionalProperty(201, "offset", result->offset);
70
70
  return std::move(result);
71
71
  }
72
72
 
73
73
  void LimitPercentModifier::FormatSerialize(FormatSerializer &serializer) const {
74
74
  ResultModifier::FormatSerialize(serializer);
75
- serializer.WriteOptionalProperty("limit", limit);
76
- serializer.WriteOptionalProperty("offset", offset);
75
+ serializer.WriteOptionalProperty(200, "limit", limit);
76
+ serializer.WriteOptionalProperty(201, "offset", offset);
77
77
  }
78
78
 
79
79
  unique_ptr<ResultModifier> LimitPercentModifier::FormatDeserialize(FormatDeserializer &deserializer) {
80
80
  auto result = duckdb::unique_ptr<LimitPercentModifier>(new LimitPercentModifier());
81
- deserializer.ReadOptionalProperty("limit", result->limit);
82
- deserializer.ReadOptionalProperty("offset", result->offset);
81
+ deserializer.ReadOptionalProperty(200, "limit", result->limit);
82
+ deserializer.ReadOptionalProperty(201, "offset", result->offset);
83
83
  return std::move(result);
84
84
  }
85
85
 
86
86
  void OrderModifier::FormatSerialize(FormatSerializer &serializer) const {
87
87
  ResultModifier::FormatSerialize(serializer);
88
- serializer.WriteProperty("orders", orders);
88
+ serializer.WriteProperty(200, "orders", orders);
89
89
  }
90
90
 
91
91
  unique_ptr<ResultModifier> OrderModifier::FormatDeserialize(FormatDeserializer &deserializer) {
92
92
  auto result = duckdb::unique_ptr<OrderModifier>(new OrderModifier());
93
- deserializer.ReadProperty("orders", result->orders);
93
+ deserializer.ReadProperty(200, "orders", result->orders);
94
94
  return std::move(result);
95
95
  }
96
96
 
@@ -10,12 +10,12 @@
10
10
  namespace duckdb {
11
11
 
12
12
  void SelectStatement::FormatSerialize(FormatSerializer &serializer) const {
13
- serializer.WriteProperty("node", *node);
13
+ serializer.WriteProperty(100, "node", *node);
14
14
  }
15
15
 
16
16
  unique_ptr<SelectStatement> SelectStatement::FormatDeserialize(FormatDeserializer &deserializer) {
17
17
  auto result = duckdb::unique_ptr<SelectStatement>(new SelectStatement());
18
- deserializer.ReadProperty("node", result->node);
18
+ deserializer.ReadProperty(100, "node", result->node);
19
19
  return result;
20
20
  }
21
21