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.
- package/package.json +1 -1
- package/src/duckdb/extension/icu/icu-makedate.cpp +12 -6
- package/src/duckdb/extension/json/include/json_deserializer.hpp +1 -1
- package/src/duckdb/extension/json/include/json_serializer.hpp +1 -1
- package/src/duckdb/extension/json/json_deserializer.cpp +10 -10
- package/src/duckdb/extension/json/json_scan.cpp +2 -2
- package/src/duckdb/extension/json/json_serializer.cpp +11 -10
- package/src/duckdb/extension/json/serialize_json.cpp +44 -44
- package/src/duckdb/extension/parquet/parquet_extension.cpp +11 -10
- package/src/duckdb/extension/parquet/serialize_parquet.cpp +6 -6
- package/src/duckdb/src/common/adbc/adbc.cpp +52 -21
- package/src/duckdb/src/common/adbc/driver_manager.cpp +12 -2
- package/src/duckdb/src/common/enum_util.cpp +5 -0
- package/src/duckdb/src/common/extra_type_info.cpp +2 -2
- package/src/duckdb/src/common/serializer/binary_deserializer.cpp +5 -3
- package/src/duckdb/src/common/serializer/binary_serializer.cpp +10 -5
- package/src/duckdb/src/common/types/column/column_data_collection.cpp +4 -4
- package/src/duckdb/src/common/types/row/row_data_collection_scanner.cpp +35 -5
- package/src/duckdb/src/common/types/value.cpp +33 -33
- package/src/duckdb/src/common/types/vector.cpp +20 -20
- package/src/duckdb/src/core_functions/aggregate/holistic/approximate_quantile.cpp +2 -2
- package/src/duckdb/src/core_functions/aggregate/holistic/quantile.cpp +6 -6
- package/src/duckdb/src/core_functions/aggregate/holistic/reservoir_quantile.cpp +4 -4
- package/src/duckdb/src/core_functions/scalar/list/list_lambdas.cpp +4 -4
- package/src/duckdb/src/execution/operator/aggregate/physical_window.cpp +283 -91
- package/src/duckdb/src/execution/operator/filter/physical_filter.cpp +1 -1
- package/src/duckdb/src/execution/operator/join/physical_comparison_join.cpp +1 -2
- package/src/duckdb/src/execution/operator/scan/physical_table_scan.cpp +1 -1
- package/src/duckdb/src/execution/physical_plan_generator.cpp +1 -6
- package/src/duckdb/src/execution/window_executor.cpp +10 -1
- package/src/duckdb/src/function/table/read_csv.cpp +4 -4
- package/src/duckdb/src/function/table/table_scan.cpp +14 -14
- package/src/duckdb/src/function/table/version/pragma_version.cpp +5 -2
- package/src/duckdb/src/include/duckdb/common/adbc/adbc.hpp +2 -0
- package/src/duckdb/src/include/duckdb/common/enums/pending_execution_result.hpp +1 -1
- package/src/duckdb/src/include/duckdb/common/index_vector.hpp +2 -2
- package/src/duckdb/src/include/duckdb/common/serializer/binary_deserializer.hpp +7 -3
- package/src/duckdb/src/include/duckdb/common/serializer/binary_serializer.hpp +2 -1
- package/src/duckdb/src/include/duckdb/common/serializer/format_deserializer.hpp +18 -17
- package/src/duckdb/src/include/duckdb/common/serializer/format_serializer.hpp +10 -9
- package/src/duckdb/src/include/duckdb/common/serializer/serialization_traits.hpp +4 -0
- package/src/duckdb/src/include/duckdb/common/types/row/row_data_collection_scanner.hpp +5 -1
- package/src/duckdb/src/include/duckdb/execution/physical_operator.hpp +0 -2
- package/src/duckdb/src/include/duckdb/function/function_serialization.hpp +10 -10
- package/src/duckdb/src/include/duckdb/main/pending_query_result.hpp +5 -0
- package/src/duckdb/src/include/duckdb/main/relation/aggregate_relation.hpp +4 -1
- package/src/duckdb/src/include/duckdb/optimizer/join_order/cardinality_estimator.hpp +37 -63
- package/src/duckdb/src/include/duckdb/optimizer/join_order/cost_model.hpp +37 -0
- package/src/duckdb/src/include/duckdb/optimizer/join_order/join_node.hpp +14 -29
- package/src/duckdb/src/include/duckdb/optimizer/join_order/join_order_optimizer.hpp +7 -21
- package/src/duckdb/src/include/duckdb/optimizer/join_order/join_relation.hpp +0 -11
- package/src/duckdb/src/include/duckdb/optimizer/join_order/plan_enumerator.hpp +89 -0
- package/src/duckdb/src/include/duckdb/optimizer/join_order/query_graph.hpp +17 -31
- package/src/duckdb/src/include/duckdb/optimizer/join_order/query_graph_manager.hpp +113 -0
- package/src/duckdb/src/include/duckdb/optimizer/join_order/relation_manager.hpp +73 -0
- package/src/duckdb/src/include/duckdb/optimizer/join_order/relation_statistics_helper.hpp +73 -0
- package/src/duckdb/src/include/duckdb/parallel/task_scheduler.hpp +4 -1
- package/src/duckdb/src/include/duckdb/parser/group_by_node.hpp +11 -0
- package/src/duckdb/src/include/duckdb/parser/parser.hpp +4 -0
- package/src/duckdb/src/include/duckdb/planner/logical_operator.hpp +0 -2
- package/src/duckdb/src/include/duckdb.h +11 -1
- package/src/duckdb/src/main/capi/pending-c.cpp +17 -0
- package/src/duckdb/src/main/pending_query_result.cpp +9 -1
- package/src/duckdb/src/main/relation/aggregate_relation.cpp +20 -10
- package/src/duckdb/src/main/relation.cpp +4 -4
- package/src/duckdb/src/optimizer/join_order/cardinality_estimator.cpp +79 -325
- package/src/duckdb/src/optimizer/join_order/cost_model.cpp +19 -0
- package/src/duckdb/src/optimizer/join_order/join_node.cpp +5 -37
- package/src/duckdb/src/optimizer/join_order/join_order_optimizer.cpp +48 -1078
- package/src/duckdb/src/optimizer/join_order/plan_enumerator.cpp +552 -0
- package/src/duckdb/src/optimizer/join_order/query_graph.cpp +32 -29
- package/src/duckdb/src/optimizer/join_order/query_graph_manager.cpp +409 -0
- package/src/duckdb/src/optimizer/join_order/relation_manager.cpp +356 -0
- package/src/duckdb/src/optimizer/join_order/relation_statistics_helper.cpp +351 -0
- package/src/duckdb/src/parallel/executor.cpp +6 -0
- package/src/duckdb/src/parallel/task_scheduler.cpp +7 -0
- package/src/duckdb/src/parser/parser.cpp +18 -3
- package/src/duckdb/src/parser/tableref/pivotref.cpp +6 -6
- package/src/duckdb/src/planner/binder/statement/bind_execute.cpp +1 -1
- package/src/duckdb/src/planner/expression/bound_aggregate_expression.cpp +10 -10
- package/src/duckdb/src/planner/expression/bound_function_expression.cpp +6 -6
- package/src/duckdb/src/planner/expression/bound_window_expression.cpp +24 -24
- package/src/duckdb/src/planner/operator/logical_extension_operator.cpp +2 -2
- package/src/duckdb/src/planner/operator/logical_get.cpp +26 -22
- package/src/duckdb/src/storage/serialization/serialize_constraint.cpp +26 -26
- package/src/duckdb/src/storage/serialization/serialize_create_info.cpp +66 -66
- package/src/duckdb/src/storage/serialization/serialize_expression.cpp +78 -78
- package/src/duckdb/src/storage/serialization/serialize_logical_operator.cpp +250 -250
- package/src/duckdb/src/storage/serialization/serialize_macro_function.cpp +10 -10
- package/src/duckdb/src/storage/serialization/serialize_nodes.cpp +206 -206
- package/src/duckdb/src/storage/serialization/serialize_parse_info.cpp +116 -116
- package/src/duckdb/src/storage/serialization/serialize_parsed_expression.cpp +110 -110
- package/src/duckdb/src/storage/serialization/serialize_query_node.cpp +48 -48
- package/src/duckdb/src/storage/serialization/serialize_result_modifier.cpp +16 -16
- package/src/duckdb/src/storage/serialization/serialize_statement.cpp +2 -2
- package/src/duckdb/src/storage/serialization/serialize_table_filter.cpp +10 -10
- package/src/duckdb/src/storage/serialization/serialize_tableref.cpp +54 -54
- package/src/duckdb/src/storage/serialization/serialize_types.cpp +22 -22
- package/src/duckdb/src/storage/table/update_segment.cpp +1 -1
- 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
|
|