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
@@ -12,13 +12,13 @@
|
|
12
12
|
namespace duckdb {
|
13
13
|
|
14
14
|
void LogicalOperator::FormatSerialize(FormatSerializer &serializer) const {
|
15
|
-
serializer.WriteProperty("type", type);
|
16
|
-
serializer.WriteProperty("children", children);
|
15
|
+
serializer.WriteProperty(100, "type", type);
|
16
|
+
serializer.WriteProperty(101, "children", children);
|
17
17
|
}
|
18
18
|
|
19
19
|
unique_ptr<LogicalOperator> LogicalOperator::FormatDeserialize(FormatDeserializer &deserializer) {
|
20
|
-
auto type = deserializer.ReadProperty<LogicalOperatorType>("type");
|
21
|
-
auto children = deserializer.ReadProperty<vector<unique_ptr<LogicalOperator>>>("children");
|
20
|
+
auto type = deserializer.ReadProperty<LogicalOperatorType>(100, "type");
|
21
|
+
auto children = deserializer.ReadProperty<vector<unique_ptr<LogicalOperator>>>(101, "children");
|
22
22
|
deserializer.Set<LogicalOperatorType>(type);
|
23
23
|
unique_ptr<LogicalOperator> result;
|
24
24
|
switch (type) {
|
@@ -191,138 +191,138 @@ unique_ptr<LogicalOperator> LogicalOperator::FormatDeserialize(FormatDeserialize
|
|
191
191
|
|
192
192
|
void LogicalAggregate::FormatSerialize(FormatSerializer &serializer) const {
|
193
193
|
LogicalOperator::FormatSerialize(serializer);
|
194
|
-
serializer.WriteProperty("expressions", expressions);
|
195
|
-
serializer.WriteProperty("group_index", group_index);
|
196
|
-
serializer.WriteProperty("aggregate_index", aggregate_index);
|
197
|
-
serializer.WriteProperty("groupings_index", groupings_index);
|
198
|
-
serializer.WriteProperty("groups", groups);
|
199
|
-
serializer.WriteProperty("grouping_sets", grouping_sets);
|
200
|
-
serializer.WriteProperty("grouping_functions", grouping_functions);
|
194
|
+
serializer.WriteProperty(200, "expressions", expressions);
|
195
|
+
serializer.WriteProperty(201, "group_index", group_index);
|
196
|
+
serializer.WriteProperty(202, "aggregate_index", aggregate_index);
|
197
|
+
serializer.WriteProperty(203, "groupings_index", groupings_index);
|
198
|
+
serializer.WriteProperty(204, "groups", groups);
|
199
|
+
serializer.WriteProperty(205, "grouping_sets", grouping_sets);
|
200
|
+
serializer.WriteProperty(206, "grouping_functions", grouping_functions);
|
201
201
|
}
|
202
202
|
|
203
203
|
unique_ptr<LogicalOperator> LogicalAggregate::FormatDeserialize(FormatDeserializer &deserializer) {
|
204
|
-
auto expressions = deserializer.ReadProperty<vector<unique_ptr<Expression>>>("expressions");
|
205
|
-
auto group_index = deserializer.ReadProperty<idx_t>("group_index");
|
206
|
-
auto aggregate_index = deserializer.ReadProperty<idx_t>("aggregate_index");
|
204
|
+
auto expressions = deserializer.ReadProperty<vector<unique_ptr<Expression>>>(200, "expressions");
|
205
|
+
auto group_index = deserializer.ReadProperty<idx_t>(201, "group_index");
|
206
|
+
auto aggregate_index = deserializer.ReadProperty<idx_t>(202, "aggregate_index");
|
207
207
|
auto result = duckdb::unique_ptr<LogicalAggregate>(new LogicalAggregate(group_index, aggregate_index, std::move(expressions)));
|
208
|
-
deserializer.ReadProperty("groupings_index", result->groupings_index);
|
209
|
-
deserializer.ReadProperty("groups", result->groups);
|
210
|
-
deserializer.ReadProperty("grouping_sets", result->grouping_sets);
|
211
|
-
deserializer.ReadProperty("grouping_functions", result->grouping_functions);
|
208
|
+
deserializer.ReadProperty(203, "groupings_index", result->groupings_index);
|
209
|
+
deserializer.ReadProperty(204, "groups", result->groups);
|
210
|
+
deserializer.ReadProperty(205, "grouping_sets", result->grouping_sets);
|
211
|
+
deserializer.ReadProperty(206, "grouping_functions", result->grouping_functions);
|
212
212
|
return std::move(result);
|
213
213
|
}
|
214
214
|
|
215
215
|
void LogicalAnyJoin::FormatSerialize(FormatSerializer &serializer) const {
|
216
216
|
LogicalOperator::FormatSerialize(serializer);
|
217
|
-
serializer.WriteProperty("join_type", join_type);
|
218
|
-
serializer.WriteProperty("mark_index", mark_index);
|
219
|
-
serializer.WriteProperty("left_projection_map", left_projection_map);
|
220
|
-
serializer.WriteProperty("right_projection_map", right_projection_map);
|
221
|
-
serializer.WriteProperty("condition", *condition);
|
217
|
+
serializer.WriteProperty(200, "join_type", join_type);
|
218
|
+
serializer.WriteProperty(201, "mark_index", mark_index);
|
219
|
+
serializer.WriteProperty(202, "left_projection_map", left_projection_map);
|
220
|
+
serializer.WriteProperty(203, "right_projection_map", right_projection_map);
|
221
|
+
serializer.WriteProperty(204, "condition", *condition);
|
222
222
|
}
|
223
223
|
|
224
224
|
unique_ptr<LogicalOperator> LogicalAnyJoin::FormatDeserialize(FormatDeserializer &deserializer) {
|
225
|
-
auto join_type = deserializer.ReadProperty<JoinType>("join_type");
|
225
|
+
auto join_type = deserializer.ReadProperty<JoinType>(200, "join_type");
|
226
226
|
auto result = duckdb::unique_ptr<LogicalAnyJoin>(new LogicalAnyJoin(join_type));
|
227
|
-
deserializer.ReadProperty("mark_index", result->mark_index);
|
228
|
-
deserializer.ReadProperty("left_projection_map", result->left_projection_map);
|
229
|
-
deserializer.ReadProperty("right_projection_map", result->right_projection_map);
|
230
|
-
deserializer.ReadProperty("condition", result->condition);
|
227
|
+
deserializer.ReadProperty(201, "mark_index", result->mark_index);
|
228
|
+
deserializer.ReadProperty(202, "left_projection_map", result->left_projection_map);
|
229
|
+
deserializer.ReadProperty(203, "right_projection_map", result->right_projection_map);
|
230
|
+
deserializer.ReadProperty(204, "condition", result->condition);
|
231
231
|
return std::move(result);
|
232
232
|
}
|
233
233
|
|
234
234
|
void LogicalCTERef::FormatSerialize(FormatSerializer &serializer) const {
|
235
235
|
LogicalOperator::FormatSerialize(serializer);
|
236
|
-
serializer.WriteProperty("table_index", table_index);
|
237
|
-
serializer.WriteProperty("cte_index", cte_index);
|
238
|
-
serializer.WriteProperty("chunk_types", chunk_types);
|
239
|
-
serializer.WriteProperty("bound_columns", bound_columns);
|
240
|
-
serializer.WriteProperty("materialized_cte", materialized_cte);
|
236
|
+
serializer.WriteProperty(200, "table_index", table_index);
|
237
|
+
serializer.WriteProperty(201, "cte_index", cte_index);
|
238
|
+
serializer.WriteProperty(202, "chunk_types", chunk_types);
|
239
|
+
serializer.WriteProperty(203, "bound_columns", bound_columns);
|
240
|
+
serializer.WriteProperty(204, "materialized_cte", materialized_cte);
|
241
241
|
}
|
242
242
|
|
243
243
|
unique_ptr<LogicalOperator> LogicalCTERef::FormatDeserialize(FormatDeserializer &deserializer) {
|
244
|
-
auto table_index = deserializer.ReadProperty<idx_t>("table_index");
|
245
|
-
auto cte_index = deserializer.ReadProperty<idx_t>("cte_index");
|
246
|
-
auto chunk_types = deserializer.ReadProperty<vector<LogicalType>>("chunk_types");
|
247
|
-
auto bound_columns = deserializer.ReadProperty<vector<string>>("bound_columns");
|
248
|
-
auto materialized_cte = deserializer.ReadProperty<CTEMaterialize>("materialized_cte");
|
244
|
+
auto table_index = deserializer.ReadProperty<idx_t>(200, "table_index");
|
245
|
+
auto cte_index = deserializer.ReadProperty<idx_t>(201, "cte_index");
|
246
|
+
auto chunk_types = deserializer.ReadProperty<vector<LogicalType>>(202, "chunk_types");
|
247
|
+
auto bound_columns = deserializer.ReadProperty<vector<string>>(203, "bound_columns");
|
248
|
+
auto materialized_cte = deserializer.ReadProperty<CTEMaterialize>(204, "materialized_cte");
|
249
249
|
auto result = duckdb::unique_ptr<LogicalCTERef>(new LogicalCTERef(table_index, cte_index, std::move(chunk_types), std::move(bound_columns), materialized_cte));
|
250
250
|
return std::move(result);
|
251
251
|
}
|
252
252
|
|
253
253
|
void LogicalColumnDataGet::FormatSerialize(FormatSerializer &serializer) const {
|
254
254
|
LogicalOperator::FormatSerialize(serializer);
|
255
|
-
serializer.WriteProperty("table_index", table_index);
|
256
|
-
serializer.WriteProperty("chunk_types", chunk_types);
|
257
|
-
serializer.WriteProperty("collection", *collection);
|
255
|
+
serializer.WriteProperty(200, "table_index", table_index);
|
256
|
+
serializer.WriteProperty(201, "chunk_types", chunk_types);
|
257
|
+
serializer.WriteProperty(202, "collection", *collection);
|
258
258
|
}
|
259
259
|
|
260
260
|
unique_ptr<LogicalOperator> LogicalColumnDataGet::FormatDeserialize(FormatDeserializer &deserializer) {
|
261
|
-
auto table_index = deserializer.ReadProperty<idx_t>("table_index");
|
262
|
-
auto chunk_types = deserializer.ReadProperty<vector<LogicalType>>("chunk_types");
|
263
|
-
auto collection = deserializer.ReadProperty<unique_ptr<ColumnDataCollection>>("collection");
|
261
|
+
auto table_index = deserializer.ReadProperty<idx_t>(200, "table_index");
|
262
|
+
auto chunk_types = deserializer.ReadProperty<vector<LogicalType>>(201, "chunk_types");
|
263
|
+
auto collection = deserializer.ReadProperty<unique_ptr<ColumnDataCollection>>(202, "collection");
|
264
264
|
auto result = duckdb::unique_ptr<LogicalColumnDataGet>(new LogicalColumnDataGet(table_index, std::move(chunk_types), std::move(collection)));
|
265
265
|
return std::move(result);
|
266
266
|
}
|
267
267
|
|
268
268
|
void LogicalComparisonJoin::FormatSerialize(FormatSerializer &serializer) const {
|
269
269
|
LogicalOperator::FormatSerialize(serializer);
|
270
|
-
serializer.WriteProperty("join_type", join_type);
|
271
|
-
serializer.WriteProperty("mark_index", mark_index);
|
272
|
-
serializer.WriteProperty("left_projection_map", left_projection_map);
|
273
|
-
serializer.WriteProperty("right_projection_map", right_projection_map);
|
274
|
-
serializer.WriteProperty("conditions", conditions);
|
275
|
-
serializer.WriteProperty("mark_types", mark_types);
|
276
|
-
serializer.WriteProperty("duplicate_eliminated_columns", duplicate_eliminated_columns);
|
270
|
+
serializer.WriteProperty(200, "join_type", join_type);
|
271
|
+
serializer.WriteProperty(201, "mark_index", mark_index);
|
272
|
+
serializer.WriteProperty(202, "left_projection_map", left_projection_map);
|
273
|
+
serializer.WriteProperty(203, "right_projection_map", right_projection_map);
|
274
|
+
serializer.WriteProperty(204, "conditions", conditions);
|
275
|
+
serializer.WriteProperty(205, "mark_types", mark_types);
|
276
|
+
serializer.WriteProperty(206, "duplicate_eliminated_columns", duplicate_eliminated_columns);
|
277
277
|
}
|
278
278
|
|
279
279
|
unique_ptr<LogicalOperator> LogicalComparisonJoin::FormatDeserialize(FormatDeserializer &deserializer) {
|
280
|
-
auto join_type = deserializer.ReadProperty<JoinType>("join_type");
|
280
|
+
auto join_type = deserializer.ReadProperty<JoinType>(200, "join_type");
|
281
281
|
auto result = duckdb::unique_ptr<LogicalComparisonJoin>(new LogicalComparisonJoin(join_type, deserializer.Get<LogicalOperatorType>()));
|
282
|
-
deserializer.ReadProperty("mark_index", result->mark_index);
|
283
|
-
deserializer.ReadProperty("left_projection_map", result->left_projection_map);
|
284
|
-
deserializer.ReadProperty("right_projection_map", result->right_projection_map);
|
285
|
-
deserializer.ReadProperty("conditions", result->conditions);
|
286
|
-
deserializer.ReadProperty("mark_types", result->mark_types);
|
287
|
-
deserializer.ReadProperty("duplicate_eliminated_columns", result->duplicate_eliminated_columns);
|
282
|
+
deserializer.ReadProperty(201, "mark_index", result->mark_index);
|
283
|
+
deserializer.ReadProperty(202, "left_projection_map", result->left_projection_map);
|
284
|
+
deserializer.ReadProperty(203, "right_projection_map", result->right_projection_map);
|
285
|
+
deserializer.ReadProperty(204, "conditions", result->conditions);
|
286
|
+
deserializer.ReadProperty(205, "mark_types", result->mark_types);
|
287
|
+
deserializer.ReadProperty(206, "duplicate_eliminated_columns", result->duplicate_eliminated_columns);
|
288
288
|
return std::move(result);
|
289
289
|
}
|
290
290
|
|
291
291
|
void LogicalCreate::FormatSerialize(FormatSerializer &serializer) const {
|
292
292
|
LogicalOperator::FormatSerialize(serializer);
|
293
|
-
serializer.WriteProperty("info", *info);
|
293
|
+
serializer.WriteProperty(200, "info", *info);
|
294
294
|
}
|
295
295
|
|
296
296
|
unique_ptr<LogicalOperator> LogicalCreate::FormatDeserialize(FormatDeserializer &deserializer) {
|
297
|
-
auto info = deserializer.ReadProperty<unique_ptr<CreateInfo>>("info");
|
297
|
+
auto info = deserializer.ReadProperty<unique_ptr<CreateInfo>>(200, "info");
|
298
298
|
auto result = duckdb::unique_ptr<LogicalCreate>(new LogicalCreate(deserializer.Get<LogicalOperatorType>(), deserializer.Get<ClientContext &>(), std::move(info)));
|
299
299
|
return std::move(result);
|
300
300
|
}
|
301
301
|
|
302
302
|
void LogicalCreateIndex::FormatSerialize(FormatSerializer &serializer) const {
|
303
303
|
LogicalOperator::FormatSerialize(serializer);
|
304
|
-
serializer.WriteProperty("info", *info);
|
305
|
-
serializer.WriteProperty("unbound_expressions", unbound_expressions);
|
304
|
+
serializer.WriteProperty(200, "info", *info);
|
305
|
+
serializer.WriteProperty(201, "unbound_expressions", unbound_expressions);
|
306
306
|
}
|
307
307
|
|
308
308
|
unique_ptr<LogicalOperator> LogicalCreateIndex::FormatDeserialize(FormatDeserializer &deserializer) {
|
309
|
-
auto info = deserializer.ReadProperty<unique_ptr<CreateInfo>>("info");
|
310
|
-
auto unbound_expressions = deserializer.ReadProperty<vector<unique_ptr<Expression>>>("unbound_expressions");
|
309
|
+
auto info = deserializer.ReadProperty<unique_ptr<CreateInfo>>(200, "info");
|
310
|
+
auto unbound_expressions = deserializer.ReadProperty<vector<unique_ptr<Expression>>>(201, "unbound_expressions");
|
311
311
|
auto result = duckdb::unique_ptr<LogicalCreateIndex>(new LogicalCreateIndex(deserializer.Get<ClientContext &>(), std::move(info), std::move(unbound_expressions)));
|
312
312
|
return std::move(result);
|
313
313
|
}
|
314
314
|
|
315
315
|
void LogicalCreateTable::FormatSerialize(FormatSerializer &serializer) const {
|
316
316
|
LogicalOperator::FormatSerialize(serializer);
|
317
|
-
serializer.WriteProperty("catalog", schema.ParentCatalog().GetName());
|
318
|
-
serializer.WriteProperty("schema", schema.name);
|
319
|
-
serializer.WriteProperty("info", *info->base);
|
317
|
+
serializer.WriteProperty(200, "catalog", schema.ParentCatalog().GetName());
|
318
|
+
serializer.WriteProperty(201, "schema", schema.name);
|
319
|
+
serializer.WriteProperty(202, "info", *info->base);
|
320
320
|
}
|
321
321
|
|
322
322
|
unique_ptr<LogicalOperator> LogicalCreateTable::FormatDeserialize(FormatDeserializer &deserializer) {
|
323
|
-
auto catalog = deserializer.ReadProperty<string>("catalog");
|
324
|
-
auto schema = deserializer.ReadProperty<string>("schema");
|
325
|
-
auto info = deserializer.ReadProperty<unique_ptr<CreateInfo>>("info");
|
323
|
+
auto catalog = deserializer.ReadProperty<string>(200, "catalog");
|
324
|
+
auto schema = deserializer.ReadProperty<string>(201, "schema");
|
325
|
+
auto info = deserializer.ReadProperty<unique_ptr<CreateInfo>>(202, "info");
|
326
326
|
auto result = duckdb::unique_ptr<LogicalCreateTable>(new LogicalCreateTable(deserializer.Get<ClientContext &>(), catalog, schema, std::move(info)));
|
327
327
|
return std::move(result);
|
328
328
|
}
|
@@ -338,241 +338,241 @@ unique_ptr<LogicalOperator> LogicalCrossProduct::FormatDeserialize(FormatDeseria
|
|
338
338
|
|
339
339
|
void LogicalDelete::FormatSerialize(FormatSerializer &serializer) const {
|
340
340
|
LogicalOperator::FormatSerialize(serializer);
|
341
|
-
serializer.WriteProperty("catalog", table.ParentCatalog().GetName());
|
342
|
-
serializer.WriteProperty("schema", table.ParentSchema().name);
|
343
|
-
serializer.WriteProperty("table", table.name);
|
344
|
-
serializer.WriteProperty("table_index", table_index);
|
345
|
-
serializer.WriteProperty("return_chunk", return_chunk);
|
346
|
-
serializer.WriteProperty("expressions", expressions);
|
341
|
+
serializer.WriteProperty(200, "catalog", table.ParentCatalog().GetName());
|
342
|
+
serializer.WriteProperty(201, "schema", table.ParentSchema().name);
|
343
|
+
serializer.WriteProperty(202, "table", table.name);
|
344
|
+
serializer.WriteProperty(203, "table_index", table_index);
|
345
|
+
serializer.WriteProperty(204, "return_chunk", return_chunk);
|
346
|
+
serializer.WriteProperty(205, "expressions", expressions);
|
347
347
|
}
|
348
348
|
|
349
349
|
unique_ptr<LogicalOperator> LogicalDelete::FormatDeserialize(FormatDeserializer &deserializer) {
|
350
|
-
auto catalog = deserializer.ReadProperty<string>("catalog");
|
351
|
-
auto schema = deserializer.ReadProperty<string>("schema");
|
352
|
-
auto table = deserializer.ReadProperty<string>("table");
|
350
|
+
auto catalog = deserializer.ReadProperty<string>(200, "catalog");
|
351
|
+
auto schema = deserializer.ReadProperty<string>(201, "schema");
|
352
|
+
auto table = deserializer.ReadProperty<string>(202, "table");
|
353
353
|
auto result = duckdb::unique_ptr<LogicalDelete>(new LogicalDelete(deserializer.Get<ClientContext &>(), catalog, schema, table));
|
354
|
-
deserializer.ReadProperty("table_index", result->table_index);
|
355
|
-
deserializer.ReadProperty("return_chunk", result->return_chunk);
|
356
|
-
deserializer.ReadProperty("expressions", result->expressions);
|
354
|
+
deserializer.ReadProperty(203, "table_index", result->table_index);
|
355
|
+
deserializer.ReadProperty(204, "return_chunk", result->return_chunk);
|
356
|
+
deserializer.ReadProperty(205, "expressions", result->expressions);
|
357
357
|
return std::move(result);
|
358
358
|
}
|
359
359
|
|
360
360
|
void LogicalDelimGet::FormatSerialize(FormatSerializer &serializer) const {
|
361
361
|
LogicalOperator::FormatSerialize(serializer);
|
362
|
-
serializer.WriteProperty("table_index", table_index);
|
363
|
-
serializer.WriteProperty("chunk_types", chunk_types);
|
362
|
+
serializer.WriteProperty(200, "table_index", table_index);
|
363
|
+
serializer.WriteProperty(201, "chunk_types", chunk_types);
|
364
364
|
}
|
365
365
|
|
366
366
|
unique_ptr<LogicalOperator> LogicalDelimGet::FormatDeserialize(FormatDeserializer &deserializer) {
|
367
|
-
auto table_index = deserializer.ReadProperty<idx_t>("table_index");
|
368
|
-
auto chunk_types = deserializer.ReadProperty<vector<LogicalType>>("chunk_types");
|
367
|
+
auto table_index = deserializer.ReadProperty<idx_t>(200, "table_index");
|
368
|
+
auto chunk_types = deserializer.ReadProperty<vector<LogicalType>>(201, "chunk_types");
|
369
369
|
auto result = duckdb::unique_ptr<LogicalDelimGet>(new LogicalDelimGet(table_index, std::move(chunk_types)));
|
370
370
|
return std::move(result);
|
371
371
|
}
|
372
372
|
|
373
373
|
void LogicalDistinct::FormatSerialize(FormatSerializer &serializer) const {
|
374
374
|
LogicalOperator::FormatSerialize(serializer);
|
375
|
-
serializer.WriteProperty("distinct_type", distinct_type);
|
376
|
-
serializer.WriteProperty("distinct_targets", distinct_targets);
|
377
|
-
serializer.WriteOptionalProperty("order_by", order_by);
|
375
|
+
serializer.WriteProperty(200, "distinct_type", distinct_type);
|
376
|
+
serializer.WriteProperty(201, "distinct_targets", distinct_targets);
|
377
|
+
serializer.WriteOptionalProperty(202, "order_by", order_by);
|
378
378
|
}
|
379
379
|
|
380
380
|
unique_ptr<LogicalOperator> LogicalDistinct::FormatDeserialize(FormatDeserializer &deserializer) {
|
381
|
-
auto distinct_type = deserializer.ReadProperty<DistinctType>("distinct_type");
|
382
|
-
auto distinct_targets = deserializer.ReadProperty<vector<unique_ptr<Expression>>>("distinct_targets");
|
381
|
+
auto distinct_type = deserializer.ReadProperty<DistinctType>(200, "distinct_type");
|
382
|
+
auto distinct_targets = deserializer.ReadProperty<vector<unique_ptr<Expression>>>(201, "distinct_targets");
|
383
383
|
auto result = duckdb::unique_ptr<LogicalDistinct>(new LogicalDistinct(std::move(distinct_targets), distinct_type));
|
384
|
-
deserializer.ReadOptionalProperty("order_by", result->order_by);
|
384
|
+
deserializer.ReadOptionalProperty(202, "order_by", result->order_by);
|
385
385
|
return std::move(result);
|
386
386
|
}
|
387
387
|
|
388
388
|
void LogicalDummyScan::FormatSerialize(FormatSerializer &serializer) const {
|
389
389
|
LogicalOperator::FormatSerialize(serializer);
|
390
|
-
serializer.WriteProperty("table_index", table_index);
|
390
|
+
serializer.WriteProperty(200, "table_index", table_index);
|
391
391
|
}
|
392
392
|
|
393
393
|
unique_ptr<LogicalOperator> LogicalDummyScan::FormatDeserialize(FormatDeserializer &deserializer) {
|
394
|
-
auto table_index = deserializer.ReadProperty<idx_t>("table_index");
|
394
|
+
auto table_index = deserializer.ReadProperty<idx_t>(200, "table_index");
|
395
395
|
auto result = duckdb::unique_ptr<LogicalDummyScan>(new LogicalDummyScan(table_index));
|
396
396
|
return std::move(result);
|
397
397
|
}
|
398
398
|
|
399
399
|
void LogicalEmptyResult::FormatSerialize(FormatSerializer &serializer) const {
|
400
400
|
LogicalOperator::FormatSerialize(serializer);
|
401
|
-
serializer.WriteProperty("return_types", return_types);
|
402
|
-
serializer.WriteProperty("bindings", bindings);
|
401
|
+
serializer.WriteProperty(200, "return_types", return_types);
|
402
|
+
serializer.WriteProperty(201, "bindings", bindings);
|
403
403
|
}
|
404
404
|
|
405
405
|
unique_ptr<LogicalOperator> LogicalEmptyResult::FormatDeserialize(FormatDeserializer &deserializer) {
|
406
406
|
auto result = duckdb::unique_ptr<LogicalEmptyResult>(new LogicalEmptyResult());
|
407
|
-
deserializer.ReadProperty("return_types", result->return_types);
|
408
|
-
deserializer.ReadProperty("bindings", result->bindings);
|
407
|
+
deserializer.ReadProperty(200, "return_types", result->return_types);
|
408
|
+
deserializer.ReadProperty(201, "bindings", result->bindings);
|
409
409
|
return std::move(result);
|
410
410
|
}
|
411
411
|
|
412
412
|
void LogicalExplain::FormatSerialize(FormatSerializer &serializer) const {
|
413
413
|
LogicalOperator::FormatSerialize(serializer);
|
414
|
-
serializer.WriteProperty("explain_type", explain_type);
|
415
|
-
serializer.WriteProperty("physical_plan", physical_plan);
|
416
|
-
serializer.WriteProperty("logical_plan_unopt", logical_plan_unopt);
|
417
|
-
serializer.WriteProperty("logical_plan_opt", logical_plan_opt);
|
414
|
+
serializer.WriteProperty(200, "explain_type", explain_type);
|
415
|
+
serializer.WriteProperty(201, "physical_plan", physical_plan);
|
416
|
+
serializer.WriteProperty(202, "logical_plan_unopt", logical_plan_unopt);
|
417
|
+
serializer.WriteProperty(203, "logical_plan_opt", logical_plan_opt);
|
418
418
|
}
|
419
419
|
|
420
420
|
unique_ptr<LogicalOperator> LogicalExplain::FormatDeserialize(FormatDeserializer &deserializer) {
|
421
|
-
auto explain_type = deserializer.ReadProperty<ExplainType>("explain_type");
|
421
|
+
auto explain_type = deserializer.ReadProperty<ExplainType>(200, "explain_type");
|
422
422
|
auto result = duckdb::unique_ptr<LogicalExplain>(new LogicalExplain(explain_type));
|
423
|
-
deserializer.ReadProperty("physical_plan", result->physical_plan);
|
424
|
-
deserializer.ReadProperty("logical_plan_unopt", result->logical_plan_unopt);
|
425
|
-
deserializer.ReadProperty("logical_plan_opt", result->logical_plan_opt);
|
423
|
+
deserializer.ReadProperty(201, "physical_plan", result->physical_plan);
|
424
|
+
deserializer.ReadProperty(202, "logical_plan_unopt", result->logical_plan_unopt);
|
425
|
+
deserializer.ReadProperty(203, "logical_plan_opt", result->logical_plan_opt);
|
426
426
|
return std::move(result);
|
427
427
|
}
|
428
428
|
|
429
429
|
void LogicalExpressionGet::FormatSerialize(FormatSerializer &serializer) const {
|
430
430
|
LogicalOperator::FormatSerialize(serializer);
|
431
|
-
serializer.WriteProperty("table_index", table_index);
|
432
|
-
serializer.WriteProperty("expr_types", expr_types);
|
433
|
-
serializer.WriteProperty("expressions", expressions);
|
431
|
+
serializer.WriteProperty(200, "table_index", table_index);
|
432
|
+
serializer.WriteProperty(201, "expr_types", expr_types);
|
433
|
+
serializer.WriteProperty(202, "expressions", expressions);
|
434
434
|
}
|
435
435
|
|
436
436
|
unique_ptr<LogicalOperator> LogicalExpressionGet::FormatDeserialize(FormatDeserializer &deserializer) {
|
437
|
-
auto table_index = deserializer.ReadProperty<idx_t>("table_index");
|
438
|
-
auto expr_types = deserializer.ReadProperty<vector<LogicalType>>("expr_types");
|
439
|
-
auto expressions = deserializer.ReadProperty<vector<vector<unique_ptr<Expression>>>>("expressions");
|
437
|
+
auto table_index = deserializer.ReadProperty<idx_t>(200, "table_index");
|
438
|
+
auto expr_types = deserializer.ReadProperty<vector<LogicalType>>(201, "expr_types");
|
439
|
+
auto expressions = deserializer.ReadProperty<vector<vector<unique_ptr<Expression>>>>(202, "expressions");
|
440
440
|
auto result = duckdb::unique_ptr<LogicalExpressionGet>(new LogicalExpressionGet(table_index, std::move(expr_types), std::move(expressions)));
|
441
441
|
return std::move(result);
|
442
442
|
}
|
443
443
|
|
444
444
|
void LogicalFilter::FormatSerialize(FormatSerializer &serializer) const {
|
445
445
|
LogicalOperator::FormatSerialize(serializer);
|
446
|
-
serializer.WriteProperty("expressions", expressions);
|
447
|
-
serializer.WriteProperty("projection_map", projection_map);
|
446
|
+
serializer.WriteProperty(200, "expressions", expressions);
|
447
|
+
serializer.WriteProperty(201, "projection_map", projection_map);
|
448
448
|
}
|
449
449
|
|
450
450
|
unique_ptr<LogicalOperator> LogicalFilter::FormatDeserialize(FormatDeserializer &deserializer) {
|
451
451
|
auto result = duckdb::unique_ptr<LogicalFilter>(new LogicalFilter());
|
452
|
-
deserializer.ReadProperty("expressions", result->expressions);
|
453
|
-
deserializer.ReadProperty("projection_map", result->projection_map);
|
452
|
+
deserializer.ReadProperty(200, "expressions", result->expressions);
|
453
|
+
deserializer.ReadProperty(201, "projection_map", result->projection_map);
|
454
454
|
return std::move(result);
|
455
455
|
}
|
456
456
|
|
457
457
|
void LogicalInsert::FormatSerialize(FormatSerializer &serializer) const {
|
458
458
|
LogicalOperator::FormatSerialize(serializer);
|
459
|
-
serializer.WriteProperty("catalog", table.ParentCatalog().GetName());
|
460
|
-
serializer.WriteProperty("schema", table.ParentSchema().name);
|
461
|
-
serializer.WriteProperty("table", table.name);
|
462
|
-
serializer.WriteProperty("insert_values", insert_values);
|
463
|
-
serializer.WriteProperty("column_index_map", column_index_map);
|
464
|
-
serializer.WriteProperty("expected_types", expected_types);
|
465
|
-
serializer.WriteProperty("table_index", table_index);
|
466
|
-
serializer.WriteProperty("return_chunk", return_chunk);
|
467
|
-
serializer.WriteProperty("bound_defaults", bound_defaults);
|
468
|
-
serializer.WriteProperty("action_type", action_type);
|
469
|
-
serializer.WriteProperty("expected_set_types", expected_set_types);
|
470
|
-
serializer.WriteProperty("on_conflict_filter", on_conflict_filter);
|
471
|
-
serializer.WriteOptionalProperty("on_conflict_condition", on_conflict_condition);
|
472
|
-
serializer.WriteOptionalProperty("do_update_condition", do_update_condition);
|
473
|
-
serializer.WriteProperty("set_columns", set_columns);
|
474
|
-
serializer.WriteProperty("set_types", set_types);
|
475
|
-
serializer.WriteProperty("excluded_table_index", excluded_table_index);
|
476
|
-
serializer.WriteProperty("columns_to_fetch", columns_to_fetch);
|
477
|
-
serializer.WriteProperty("source_columns", source_columns);
|
459
|
+
serializer.WriteProperty(200, "catalog", table.ParentCatalog().GetName());
|
460
|
+
serializer.WriteProperty(201, "schema", table.ParentSchema().name);
|
461
|
+
serializer.WriteProperty(202, "table", table.name);
|
462
|
+
serializer.WriteProperty(203, "insert_values", insert_values);
|
463
|
+
serializer.WriteProperty(204, "column_index_map", column_index_map);
|
464
|
+
serializer.WriteProperty(205, "expected_types", expected_types);
|
465
|
+
serializer.WriteProperty(206, "table_index", table_index);
|
466
|
+
serializer.WriteProperty(207, "return_chunk", return_chunk);
|
467
|
+
serializer.WriteProperty(208, "bound_defaults", bound_defaults);
|
468
|
+
serializer.WriteProperty(209, "action_type", action_type);
|
469
|
+
serializer.WriteProperty(210, "expected_set_types", expected_set_types);
|
470
|
+
serializer.WriteProperty(211, "on_conflict_filter", on_conflict_filter);
|
471
|
+
serializer.WriteOptionalProperty(212, "on_conflict_condition", on_conflict_condition);
|
472
|
+
serializer.WriteOptionalProperty(213, "do_update_condition", do_update_condition);
|
473
|
+
serializer.WriteProperty(214, "set_columns", set_columns);
|
474
|
+
serializer.WriteProperty(215, "set_types", set_types);
|
475
|
+
serializer.WriteProperty(216, "excluded_table_index", excluded_table_index);
|
476
|
+
serializer.WriteProperty(217, "columns_to_fetch", columns_to_fetch);
|
477
|
+
serializer.WriteProperty(218, "source_columns", source_columns);
|
478
478
|
}
|
479
479
|
|
480
480
|
unique_ptr<LogicalOperator> LogicalInsert::FormatDeserialize(FormatDeserializer &deserializer) {
|
481
|
-
auto catalog = deserializer.ReadProperty<string>("catalog");
|
482
|
-
auto schema = deserializer.ReadProperty<string>("schema");
|
483
|
-
auto table = deserializer.ReadProperty<string>("table");
|
481
|
+
auto catalog = deserializer.ReadProperty<string>(200, "catalog");
|
482
|
+
auto schema = deserializer.ReadProperty<string>(201, "schema");
|
483
|
+
auto table = deserializer.ReadProperty<string>(202, "table");
|
484
484
|
auto result = duckdb::unique_ptr<LogicalInsert>(new LogicalInsert(deserializer.Get<ClientContext &>(), catalog, schema, table));
|
485
|
-
deserializer.ReadProperty("insert_values", result->insert_values);
|
486
|
-
deserializer.ReadProperty("column_index_map", result->column_index_map);
|
487
|
-
deserializer.ReadProperty("expected_types", result->expected_types);
|
488
|
-
deserializer.ReadProperty("table_index", result->table_index);
|
489
|
-
deserializer.ReadProperty("return_chunk", result->return_chunk);
|
490
|
-
deserializer.ReadProperty("bound_defaults", result->bound_defaults);
|
491
|
-
deserializer.ReadProperty("action_type", result->action_type);
|
492
|
-
deserializer.ReadProperty("expected_set_types", result->expected_set_types);
|
493
|
-
deserializer.ReadProperty("on_conflict_filter", result->on_conflict_filter);
|
494
|
-
deserializer.ReadOptionalProperty("on_conflict_condition", result->on_conflict_condition);
|
495
|
-
deserializer.ReadOptionalProperty("do_update_condition", result->do_update_condition);
|
496
|
-
deserializer.ReadProperty("set_columns", result->set_columns);
|
497
|
-
deserializer.ReadProperty("set_types", result->set_types);
|
498
|
-
deserializer.ReadProperty("excluded_table_index", result->excluded_table_index);
|
499
|
-
deserializer.ReadProperty("columns_to_fetch", result->columns_to_fetch);
|
500
|
-
deserializer.ReadProperty("source_columns", result->source_columns);
|
485
|
+
deserializer.ReadProperty(203, "insert_values", result->insert_values);
|
486
|
+
deserializer.ReadProperty(204, "column_index_map", result->column_index_map);
|
487
|
+
deserializer.ReadProperty(205, "expected_types", result->expected_types);
|
488
|
+
deserializer.ReadProperty(206, "table_index", result->table_index);
|
489
|
+
deserializer.ReadProperty(207, "return_chunk", result->return_chunk);
|
490
|
+
deserializer.ReadProperty(208, "bound_defaults", result->bound_defaults);
|
491
|
+
deserializer.ReadProperty(209, "action_type", result->action_type);
|
492
|
+
deserializer.ReadProperty(210, "expected_set_types", result->expected_set_types);
|
493
|
+
deserializer.ReadProperty(211, "on_conflict_filter", result->on_conflict_filter);
|
494
|
+
deserializer.ReadOptionalProperty(212, "on_conflict_condition", result->on_conflict_condition);
|
495
|
+
deserializer.ReadOptionalProperty(213, "do_update_condition", result->do_update_condition);
|
496
|
+
deserializer.ReadProperty(214, "set_columns", result->set_columns);
|
497
|
+
deserializer.ReadProperty(215, "set_types", result->set_types);
|
498
|
+
deserializer.ReadProperty(216, "excluded_table_index", result->excluded_table_index);
|
499
|
+
deserializer.ReadProperty(217, "columns_to_fetch", result->columns_to_fetch);
|
500
|
+
deserializer.ReadProperty(218, "source_columns", result->source_columns);
|
501
501
|
return std::move(result);
|
502
502
|
}
|
503
503
|
|
504
504
|
void LogicalLimit::FormatSerialize(FormatSerializer &serializer) const {
|
505
505
|
LogicalOperator::FormatSerialize(serializer);
|
506
|
-
serializer.WriteProperty("limit_val", limit_val);
|
507
|
-
serializer.WriteProperty("offset_val", offset_val);
|
508
|
-
serializer.WriteOptionalProperty("limit", limit);
|
509
|
-
serializer.WriteOptionalProperty("offset", offset);
|
506
|
+
serializer.WriteProperty(200, "limit_val", limit_val);
|
507
|
+
serializer.WriteProperty(201, "offset_val", offset_val);
|
508
|
+
serializer.WriteOptionalProperty(202, "limit", limit);
|
509
|
+
serializer.WriteOptionalProperty(203, "offset", offset);
|
510
510
|
}
|
511
511
|
|
512
512
|
unique_ptr<LogicalOperator> LogicalLimit::FormatDeserialize(FormatDeserializer &deserializer) {
|
513
|
-
auto limit_val = deserializer.ReadProperty<int64_t>("limit_val");
|
514
|
-
auto offset_val = deserializer.ReadProperty<int64_t>("offset_val");
|
515
|
-
auto limit = deserializer.ReadOptionalProperty<unique_ptr<Expression>>("limit");
|
516
|
-
auto offset = deserializer.ReadOptionalProperty<unique_ptr<Expression>>("offset");
|
513
|
+
auto limit_val = deserializer.ReadProperty<int64_t>(200, "limit_val");
|
514
|
+
auto offset_val = deserializer.ReadProperty<int64_t>(201, "offset_val");
|
515
|
+
auto limit = deserializer.ReadOptionalProperty<unique_ptr<Expression>>(202, "limit");
|
516
|
+
auto offset = deserializer.ReadOptionalProperty<unique_ptr<Expression>>(203, "offset");
|
517
517
|
auto result = duckdb::unique_ptr<LogicalLimit>(new LogicalLimit(limit_val, offset_val, std::move(limit), std::move(offset)));
|
518
518
|
return std::move(result);
|
519
519
|
}
|
520
520
|
|
521
521
|
void LogicalLimitPercent::FormatSerialize(FormatSerializer &serializer) const {
|
522
522
|
LogicalOperator::FormatSerialize(serializer);
|
523
|
-
serializer.WriteProperty("limit_percent", limit_percent);
|
524
|
-
serializer.WriteProperty("offset_val", offset_val);
|
525
|
-
serializer.WriteOptionalProperty("limit", limit);
|
526
|
-
serializer.WriteOptionalProperty("offset", offset);
|
523
|
+
serializer.WriteProperty(200, "limit_percent", limit_percent);
|
524
|
+
serializer.WriteProperty(201, "offset_val", offset_val);
|
525
|
+
serializer.WriteOptionalProperty(202, "limit", limit);
|
526
|
+
serializer.WriteOptionalProperty(203, "offset", offset);
|
527
527
|
}
|
528
528
|
|
529
529
|
unique_ptr<LogicalOperator> LogicalLimitPercent::FormatDeserialize(FormatDeserializer &deserializer) {
|
530
|
-
auto limit_percent = deserializer.ReadProperty<double>("limit_percent");
|
531
|
-
auto offset_val = deserializer.ReadProperty<int64_t>("offset_val");
|
532
|
-
auto limit = deserializer.ReadOptionalProperty<unique_ptr<Expression>>("limit");
|
533
|
-
auto offset = deserializer.ReadOptionalProperty<unique_ptr<Expression>>("offset");
|
530
|
+
auto limit_percent = deserializer.ReadProperty<double>(200, "limit_percent");
|
531
|
+
auto offset_val = deserializer.ReadProperty<int64_t>(201, "offset_val");
|
532
|
+
auto limit = deserializer.ReadOptionalProperty<unique_ptr<Expression>>(202, "limit");
|
533
|
+
auto offset = deserializer.ReadOptionalProperty<unique_ptr<Expression>>(203, "offset");
|
534
534
|
auto result = duckdb::unique_ptr<LogicalLimitPercent>(new LogicalLimitPercent(limit_percent, offset_val, std::move(limit), std::move(offset)));
|
535
535
|
return std::move(result);
|
536
536
|
}
|
537
537
|
|
538
538
|
void LogicalMaterializedCTE::FormatSerialize(FormatSerializer &serializer) const {
|
539
539
|
LogicalOperator::FormatSerialize(serializer);
|
540
|
-
serializer.WriteProperty("table_index", table_index);
|
541
|
-
serializer.WriteProperty("column_count", column_count);
|
542
|
-
serializer.WriteProperty("ctename", ctename);
|
540
|
+
serializer.WriteProperty(200, "table_index", table_index);
|
541
|
+
serializer.WriteProperty(201, "column_count", column_count);
|
542
|
+
serializer.WriteProperty(202, "ctename", ctename);
|
543
543
|
}
|
544
544
|
|
545
545
|
unique_ptr<LogicalOperator> LogicalMaterializedCTE::FormatDeserialize(FormatDeserializer &deserializer) {
|
546
546
|
auto result = duckdb::unique_ptr<LogicalMaterializedCTE>(new LogicalMaterializedCTE());
|
547
|
-
deserializer.ReadProperty("table_index", result->table_index);
|
548
|
-
deserializer.ReadProperty("column_count", result->column_count);
|
549
|
-
deserializer.ReadProperty("ctename", result->ctename);
|
547
|
+
deserializer.ReadProperty(200, "table_index", result->table_index);
|
548
|
+
deserializer.ReadProperty(201, "column_count", result->column_count);
|
549
|
+
deserializer.ReadProperty(202, "ctename", result->ctename);
|
550
550
|
return std::move(result);
|
551
551
|
}
|
552
552
|
|
553
553
|
void LogicalOrder::FormatSerialize(FormatSerializer &serializer) const {
|
554
554
|
LogicalOperator::FormatSerialize(serializer);
|
555
|
-
serializer.WriteProperty("orders", orders);
|
556
|
-
serializer.WriteProperty("projections", projections);
|
555
|
+
serializer.WriteProperty(200, "orders", orders);
|
556
|
+
serializer.WriteProperty(201, "projections", projections);
|
557
557
|
}
|
558
558
|
|
559
559
|
unique_ptr<LogicalOperator> LogicalOrder::FormatDeserialize(FormatDeserializer &deserializer) {
|
560
|
-
auto orders = deserializer.ReadProperty<vector<BoundOrderByNode>>("orders");
|
560
|
+
auto orders = deserializer.ReadProperty<vector<BoundOrderByNode>>(200, "orders");
|
561
561
|
auto result = duckdb::unique_ptr<LogicalOrder>(new LogicalOrder(std::move(orders)));
|
562
|
-
deserializer.ReadProperty("projections", result->projections);
|
562
|
+
deserializer.ReadProperty(201, "projections", result->projections);
|
563
563
|
return std::move(result);
|
564
564
|
}
|
565
565
|
|
566
566
|
void LogicalPivot::FormatSerialize(FormatSerializer &serializer) const {
|
567
567
|
LogicalOperator::FormatSerialize(serializer);
|
568
|
-
serializer.WriteProperty("pivot_index", pivot_index);
|
569
|
-
serializer.WriteProperty("bound_pivot", bound_pivot);
|
568
|
+
serializer.WriteProperty(200, "pivot_index", pivot_index);
|
569
|
+
serializer.WriteProperty(201, "bound_pivot", bound_pivot);
|
570
570
|
}
|
571
571
|
|
572
572
|
unique_ptr<LogicalOperator> LogicalPivot::FormatDeserialize(FormatDeserializer &deserializer) {
|
573
573
|
auto result = duckdb::unique_ptr<LogicalPivot>(new LogicalPivot());
|
574
|
-
deserializer.ReadProperty("pivot_index", result->pivot_index);
|
575
|
-
deserializer.ReadProperty("bound_pivot", result->bound_pivot);
|
574
|
+
deserializer.ReadProperty(200, "pivot_index", result->pivot_index);
|
575
|
+
deserializer.ReadProperty(201, "bound_pivot", result->bound_pivot);
|
576
576
|
return std::move(result);
|
577
577
|
}
|
578
578
|
|
@@ -587,175 +587,175 @@ unique_ptr<LogicalOperator> LogicalPositionalJoin::FormatDeserialize(FormatDeser
|
|
587
587
|
|
588
588
|
void LogicalProjection::FormatSerialize(FormatSerializer &serializer) const {
|
589
589
|
LogicalOperator::FormatSerialize(serializer);
|
590
|
-
serializer.WriteProperty("table_index", table_index);
|
591
|
-
serializer.WriteProperty("expressions", expressions);
|
590
|
+
serializer.WriteProperty(200, "table_index", table_index);
|
591
|
+
serializer.WriteProperty(201, "expressions", expressions);
|
592
592
|
}
|
593
593
|
|
594
594
|
unique_ptr<LogicalOperator> LogicalProjection::FormatDeserialize(FormatDeserializer &deserializer) {
|
595
|
-
auto table_index = deserializer.ReadProperty<idx_t>("table_index");
|
596
|
-
auto expressions = deserializer.ReadProperty<vector<unique_ptr<Expression>>>("expressions");
|
595
|
+
auto table_index = deserializer.ReadProperty<idx_t>(200, "table_index");
|
596
|
+
auto expressions = deserializer.ReadProperty<vector<unique_ptr<Expression>>>(201, "expressions");
|
597
597
|
auto result = duckdb::unique_ptr<LogicalProjection>(new LogicalProjection(table_index, std::move(expressions)));
|
598
598
|
return std::move(result);
|
599
599
|
}
|
600
600
|
|
601
601
|
void LogicalRecursiveCTE::FormatSerialize(FormatSerializer &serializer) const {
|
602
602
|
LogicalOperator::FormatSerialize(serializer);
|
603
|
-
serializer.WriteProperty("union_all", union_all);
|
604
|
-
serializer.WriteProperty("ctename", ctename);
|
605
|
-
serializer.WriteProperty("table_index", table_index);
|
606
|
-
serializer.WriteProperty("column_count", column_count);
|
603
|
+
serializer.WriteProperty(200, "union_all", union_all);
|
604
|
+
serializer.WriteProperty(201, "ctename", ctename);
|
605
|
+
serializer.WriteProperty(202, "table_index", table_index);
|
606
|
+
serializer.WriteProperty(203, "column_count", column_count);
|
607
607
|
}
|
608
608
|
|
609
609
|
unique_ptr<LogicalOperator> LogicalRecursiveCTE::FormatDeserialize(FormatDeserializer &deserializer) {
|
610
610
|
auto result = duckdb::unique_ptr<LogicalRecursiveCTE>(new LogicalRecursiveCTE());
|
611
|
-
deserializer.ReadProperty("union_all", result->union_all);
|
612
|
-
deserializer.ReadProperty("ctename", result->ctename);
|
613
|
-
deserializer.ReadProperty("table_index", result->table_index);
|
614
|
-
deserializer.ReadProperty("column_count", result->column_count);
|
611
|
+
deserializer.ReadProperty(200, "union_all", result->union_all);
|
612
|
+
deserializer.ReadProperty(201, "ctename", result->ctename);
|
613
|
+
deserializer.ReadProperty(202, "table_index", result->table_index);
|
614
|
+
deserializer.ReadProperty(203, "column_count", result->column_count);
|
615
615
|
return std::move(result);
|
616
616
|
}
|
617
617
|
|
618
618
|
void LogicalReset::FormatSerialize(FormatSerializer &serializer) const {
|
619
619
|
LogicalOperator::FormatSerialize(serializer);
|
620
|
-
serializer.WriteProperty("name", name);
|
621
|
-
serializer.WriteProperty("scope", scope);
|
620
|
+
serializer.WriteProperty(200, "name", name);
|
621
|
+
serializer.WriteProperty(201, "scope", scope);
|
622
622
|
}
|
623
623
|
|
624
624
|
unique_ptr<LogicalOperator> LogicalReset::FormatDeserialize(FormatDeserializer &deserializer) {
|
625
|
-
auto name = deserializer.ReadProperty<string>("name");
|
626
|
-
auto scope = deserializer.ReadProperty<SetScope>("scope");
|
625
|
+
auto name = deserializer.ReadProperty<string>(200, "name");
|
626
|
+
auto scope = deserializer.ReadProperty<SetScope>(201, "scope");
|
627
627
|
auto result = duckdb::unique_ptr<LogicalReset>(new LogicalReset(std::move(name), scope));
|
628
628
|
return std::move(result);
|
629
629
|
}
|
630
630
|
|
631
631
|
void LogicalSample::FormatSerialize(FormatSerializer &serializer) const {
|
632
632
|
LogicalOperator::FormatSerialize(serializer);
|
633
|
-
serializer.WriteProperty("sample_options", sample_options);
|
633
|
+
serializer.WriteProperty(200, "sample_options", sample_options);
|
634
634
|
}
|
635
635
|
|
636
636
|
unique_ptr<LogicalOperator> LogicalSample::FormatDeserialize(FormatDeserializer &deserializer) {
|
637
637
|
auto result = duckdb::unique_ptr<LogicalSample>(new LogicalSample());
|
638
|
-
deserializer.ReadProperty("sample_options", result->sample_options);
|
638
|
+
deserializer.ReadProperty(200, "sample_options", result->sample_options);
|
639
639
|
return std::move(result);
|
640
640
|
}
|
641
641
|
|
642
642
|
void LogicalSet::FormatSerialize(FormatSerializer &serializer) const {
|
643
643
|
LogicalOperator::FormatSerialize(serializer);
|
644
|
-
serializer.WriteProperty("name", name);
|
645
|
-
serializer.WriteProperty("value", value);
|
646
|
-
serializer.WriteProperty("scope", scope);
|
644
|
+
serializer.WriteProperty(200, "name", name);
|
645
|
+
serializer.WriteProperty(201, "value", value);
|
646
|
+
serializer.WriteProperty(202, "scope", scope);
|
647
647
|
}
|
648
648
|
|
649
649
|
unique_ptr<LogicalOperator> LogicalSet::FormatDeserialize(FormatDeserializer &deserializer) {
|
650
|
-
auto name = deserializer.ReadProperty<string>("name");
|
651
|
-
auto value = deserializer.ReadProperty<Value>("value");
|
652
|
-
auto scope = deserializer.ReadProperty<SetScope>("scope");
|
650
|
+
auto name = deserializer.ReadProperty<string>(200, "name");
|
651
|
+
auto value = deserializer.ReadProperty<Value>(201, "value");
|
652
|
+
auto scope = deserializer.ReadProperty<SetScope>(202, "scope");
|
653
653
|
auto result = duckdb::unique_ptr<LogicalSet>(new LogicalSet(std::move(name), value, scope));
|
654
654
|
return std::move(result);
|
655
655
|
}
|
656
656
|
|
657
657
|
void LogicalSetOperation::FormatSerialize(FormatSerializer &serializer) const {
|
658
658
|
LogicalOperator::FormatSerialize(serializer);
|
659
|
-
serializer.WriteProperty("table_index", table_index);
|
660
|
-
serializer.WriteProperty("column_count", column_count);
|
659
|
+
serializer.WriteProperty(200, "table_index", table_index);
|
660
|
+
serializer.WriteProperty(201, "column_count", column_count);
|
661
661
|
}
|
662
662
|
|
663
663
|
unique_ptr<LogicalOperator> LogicalSetOperation::FormatDeserialize(FormatDeserializer &deserializer) {
|
664
|
-
auto table_index = deserializer.ReadProperty<idx_t>("table_index");
|
665
|
-
auto column_count = deserializer.ReadProperty<idx_t>("column_count");
|
664
|
+
auto table_index = deserializer.ReadProperty<idx_t>(200, "table_index");
|
665
|
+
auto column_count = deserializer.ReadProperty<idx_t>(201, "column_count");
|
666
666
|
auto result = duckdb::unique_ptr<LogicalSetOperation>(new LogicalSetOperation(table_index, column_count, deserializer.Get<LogicalOperatorType>()));
|
667
667
|
return std::move(result);
|
668
668
|
}
|
669
669
|
|
670
670
|
void LogicalShow::FormatSerialize(FormatSerializer &serializer) const {
|
671
671
|
LogicalOperator::FormatSerialize(serializer);
|
672
|
-
serializer.WriteProperty("types_select", types_select);
|
673
|
-
serializer.WriteProperty("aliases", aliases);
|
672
|
+
serializer.WriteProperty(200, "types_select", types_select);
|
673
|
+
serializer.WriteProperty(201, "aliases", aliases);
|
674
674
|
}
|
675
675
|
|
676
676
|
unique_ptr<LogicalOperator> LogicalShow::FormatDeserialize(FormatDeserializer &deserializer) {
|
677
677
|
auto result = duckdb::unique_ptr<LogicalShow>(new LogicalShow());
|
678
|
-
deserializer.ReadProperty("types_select", result->types_select);
|
679
|
-
deserializer.ReadProperty("aliases", result->aliases);
|
678
|
+
deserializer.ReadProperty(200, "types_select", result->types_select);
|
679
|
+
deserializer.ReadProperty(201, "aliases", result->aliases);
|
680
680
|
return std::move(result);
|
681
681
|
}
|
682
682
|
|
683
683
|
void LogicalSimple::FormatSerialize(FormatSerializer &serializer) const {
|
684
684
|
LogicalOperator::FormatSerialize(serializer);
|
685
|
-
serializer.WriteProperty("info", *info);
|
685
|
+
serializer.WriteProperty(200, "info", *info);
|
686
686
|
}
|
687
687
|
|
688
688
|
unique_ptr<LogicalOperator> LogicalSimple::FormatDeserialize(FormatDeserializer &deserializer) {
|
689
|
-
auto info = deserializer.ReadProperty<unique_ptr<ParseInfo>>("info");
|
689
|
+
auto info = deserializer.ReadProperty<unique_ptr<ParseInfo>>(200, "info");
|
690
690
|
auto result = duckdb::unique_ptr<LogicalSimple>(new LogicalSimple(deserializer.Get<LogicalOperatorType>(), std::move(info)));
|
691
691
|
return std::move(result);
|
692
692
|
}
|
693
693
|
|
694
694
|
void LogicalTopN::FormatSerialize(FormatSerializer &serializer) const {
|
695
695
|
LogicalOperator::FormatSerialize(serializer);
|
696
|
-
serializer.WriteProperty("orders", orders);
|
697
|
-
serializer.WriteProperty("limit", limit);
|
698
|
-
serializer.WriteProperty("offset", offset);
|
696
|
+
serializer.WriteProperty(200, "orders", orders);
|
697
|
+
serializer.WriteProperty(201, "limit", limit);
|
698
|
+
serializer.WriteProperty(202, "offset", offset);
|
699
699
|
}
|
700
700
|
|
701
701
|
unique_ptr<LogicalOperator> LogicalTopN::FormatDeserialize(FormatDeserializer &deserializer) {
|
702
|
-
auto orders = deserializer.ReadProperty<vector<BoundOrderByNode>>("orders");
|
703
|
-
auto limit = deserializer.ReadProperty<idx_t>("limit");
|
704
|
-
auto offset = deserializer.ReadProperty<idx_t>("offset");
|
702
|
+
auto orders = deserializer.ReadProperty<vector<BoundOrderByNode>>(200, "orders");
|
703
|
+
auto limit = deserializer.ReadProperty<idx_t>(201, "limit");
|
704
|
+
auto offset = deserializer.ReadProperty<idx_t>(202, "offset");
|
705
705
|
auto result = duckdb::unique_ptr<LogicalTopN>(new LogicalTopN(std::move(orders), limit, offset));
|
706
706
|
return std::move(result);
|
707
707
|
}
|
708
708
|
|
709
709
|
void LogicalUnnest::FormatSerialize(FormatSerializer &serializer) const {
|
710
710
|
LogicalOperator::FormatSerialize(serializer);
|
711
|
-
serializer.WriteProperty("unnest_index", unnest_index);
|
712
|
-
serializer.WriteProperty("expressions", expressions);
|
711
|
+
serializer.WriteProperty(200, "unnest_index", unnest_index);
|
712
|
+
serializer.WriteProperty(201, "expressions", expressions);
|
713
713
|
}
|
714
714
|
|
715
715
|
unique_ptr<LogicalOperator> LogicalUnnest::FormatDeserialize(FormatDeserializer &deserializer) {
|
716
|
-
auto unnest_index = deserializer.ReadProperty<idx_t>("unnest_index");
|
716
|
+
auto unnest_index = deserializer.ReadProperty<idx_t>(200, "unnest_index");
|
717
717
|
auto result = duckdb::unique_ptr<LogicalUnnest>(new LogicalUnnest(unnest_index));
|
718
|
-
deserializer.ReadProperty("expressions", result->expressions);
|
718
|
+
deserializer.ReadProperty(201, "expressions", result->expressions);
|
719
719
|
return std::move(result);
|
720
720
|
}
|
721
721
|
|
722
722
|
void LogicalUpdate::FormatSerialize(FormatSerializer &serializer) const {
|
723
723
|
LogicalOperator::FormatSerialize(serializer);
|
724
|
-
serializer.WriteProperty("catalog", table.ParentCatalog().GetName());
|
725
|
-
serializer.WriteProperty("schema", table.ParentSchema().name);
|
726
|
-
serializer.WriteProperty("table", table.name);
|
727
|
-
serializer.WriteProperty("table_index", table_index);
|
728
|
-
serializer.WriteProperty("return_chunk", return_chunk);
|
729
|
-
serializer.WriteProperty("expressions", expressions);
|
730
|
-
serializer.WriteProperty("columns", columns);
|
731
|
-
serializer.WriteProperty("bound_defaults", bound_defaults);
|
732
|
-
serializer.WriteProperty("update_is_del_and_insert", update_is_del_and_insert);
|
724
|
+
serializer.WriteProperty(200, "catalog", table.ParentCatalog().GetName());
|
725
|
+
serializer.WriteProperty(201, "schema", table.ParentSchema().name);
|
726
|
+
serializer.WriteProperty(202, "table", table.name);
|
727
|
+
serializer.WriteProperty(203, "table_index", table_index);
|
728
|
+
serializer.WriteProperty(204, "return_chunk", return_chunk);
|
729
|
+
serializer.WriteProperty(205, "expressions", expressions);
|
730
|
+
serializer.WriteProperty(206, "columns", columns);
|
731
|
+
serializer.WriteProperty(207, "bound_defaults", bound_defaults);
|
732
|
+
serializer.WriteProperty(208, "update_is_del_and_insert", update_is_del_and_insert);
|
733
733
|
}
|
734
734
|
|
735
735
|
unique_ptr<LogicalOperator> LogicalUpdate::FormatDeserialize(FormatDeserializer &deserializer) {
|
736
|
-
auto catalog = deserializer.ReadProperty<string>("catalog");
|
737
|
-
auto schema = deserializer.ReadProperty<string>("schema");
|
738
|
-
auto table = deserializer.ReadProperty<string>("table");
|
736
|
+
auto catalog = deserializer.ReadProperty<string>(200, "catalog");
|
737
|
+
auto schema = deserializer.ReadProperty<string>(201, "schema");
|
738
|
+
auto table = deserializer.ReadProperty<string>(202, "table");
|
739
739
|
auto result = duckdb::unique_ptr<LogicalUpdate>(new LogicalUpdate(deserializer.Get<ClientContext &>(), catalog, schema, table));
|
740
|
-
deserializer.ReadProperty("table_index", result->table_index);
|
741
|
-
deserializer.ReadProperty("return_chunk", result->return_chunk);
|
742
|
-
deserializer.ReadProperty("expressions", result->expressions);
|
743
|
-
deserializer.ReadProperty("columns", result->columns);
|
744
|
-
deserializer.ReadProperty("bound_defaults", result->bound_defaults);
|
745
|
-
deserializer.ReadProperty("update_is_del_and_insert", result->update_is_del_and_insert);
|
740
|
+
deserializer.ReadProperty(203, "table_index", result->table_index);
|
741
|
+
deserializer.ReadProperty(204, "return_chunk", result->return_chunk);
|
742
|
+
deserializer.ReadProperty(205, "expressions", result->expressions);
|
743
|
+
deserializer.ReadProperty(206, "columns", result->columns);
|
744
|
+
deserializer.ReadProperty(207, "bound_defaults", result->bound_defaults);
|
745
|
+
deserializer.ReadProperty(208, "update_is_del_and_insert", result->update_is_del_and_insert);
|
746
746
|
return std::move(result);
|
747
747
|
}
|
748
748
|
|
749
749
|
void LogicalWindow::FormatSerialize(FormatSerializer &serializer) const {
|
750
750
|
LogicalOperator::FormatSerialize(serializer);
|
751
|
-
serializer.WriteProperty("window_index", window_index);
|
752
|
-
serializer.WriteProperty("expressions", expressions);
|
751
|
+
serializer.WriteProperty(200, "window_index", window_index);
|
752
|
+
serializer.WriteProperty(201, "expressions", expressions);
|
753
753
|
}
|
754
754
|
|
755
755
|
unique_ptr<LogicalOperator> LogicalWindow::FormatDeserialize(FormatDeserializer &deserializer) {
|
756
|
-
auto window_index = deserializer.ReadProperty<idx_t>("window_index");
|
756
|
+
auto window_index = deserializer.ReadProperty<idx_t>(200, "window_index");
|
757
757
|
auto result = duckdb::unique_ptr<LogicalWindow>(new LogicalWindow(window_index));
|
758
|
-
deserializer.ReadProperty("expressions", result->expressions);
|
758
|
+
deserializer.ReadProperty(201, "expressions", result->expressions);
|
759
759
|
return std::move(result);
|
760
760
|
}
|
761
761
|
|