duckdb 0.8.2-dev1968.0 → 0.8.2-dev2068.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/configure.py +7 -2
- package/package.json +1 -1
- package/src/duckdb/src/catalog/catalog.cpp +1 -1
- package/src/duckdb/src/catalog/catalog_entry/index_catalog_entry.cpp +17 -41
- package/src/duckdb/src/catalog/catalog_entry/macro_catalog_entry.cpp +2 -10
- package/src/duckdb/src/catalog/catalog_entry/schema_catalog_entry.cpp +4 -14
- package/src/duckdb/src/catalog/catalog_entry/sequence_catalog_entry.cpp +11 -28
- package/src/duckdb/src/catalog/catalog_entry/table_catalog_entry.cpp +11 -38
- package/src/duckdb/src/catalog/catalog_entry/view_catalog_entry.cpp +11 -27
- package/src/duckdb/src/catalog/catalog_entry.cpp +25 -1
- package/src/duckdb/src/common/adbc/adbc.cpp +18 -4
- package/src/duckdb/src/common/enum_util.cpp +159 -0
- package/src/duckdb/src/common/extra_type_info.cpp +1 -2
- package/src/duckdb/src/common/serializer/binary_deserializer.cpp +3 -0
- package/src/duckdb/src/common/serializer/binary_serializer.cpp +4 -4
- package/src/duckdb/src/common/types/column/column_data_collection.cpp +43 -0
- package/src/duckdb/src/common/types/vector.cpp +1 -1
- package/src/duckdb/src/common/types.cpp +0 -12
- package/src/duckdb/src/execution/physical_plan/plan_comparison_join.cpp +1 -1
- package/src/duckdb/src/function/table/version/pragma_version.cpp +2 -2
- package/src/duckdb/src/include/duckdb/catalog/catalog_entry/index_catalog_entry.hpp +1 -2
- package/src/duckdb/src/include/duckdb/catalog/catalog_entry/macro_catalog_entry.hpp +1 -4
- package/src/duckdb/src/include/duckdb/catalog/catalog_entry/schema_catalog_entry.hpp +2 -5
- package/src/duckdb/src/include/duckdb/catalog/catalog_entry/sequence_catalog_entry.hpp +1 -6
- package/src/duckdb/src/include/duckdb/catalog/catalog_entry/table_catalog_entry.hpp +2 -11
- package/src/duckdb/src/include/duckdb/catalog/catalog_entry/view_catalog_entry.hpp +2 -5
- package/src/duckdb/src/include/duckdb/catalog/catalog_entry.hpp +14 -0
- package/src/duckdb/src/include/duckdb/common/assert.hpp +1 -1
- package/src/duckdb/src/include/duckdb/common/constants.hpp +2 -0
- package/src/duckdb/src/include/duckdb/common/enum_util.hpp +32 -0
- package/src/duckdb/src/include/duckdb/common/enums/index_type.hpp +1 -1
- package/src/duckdb/src/include/duckdb/common/index_vector.hpp +12 -0
- package/src/duckdb/src/include/duckdb/common/serializer/binary_deserializer.hpp +28 -4
- package/src/duckdb/src/include/duckdb/common/serializer/binary_serializer.hpp +12 -5
- package/src/duckdb/src/include/duckdb/common/serializer/deserialization_data.hpp +110 -0
- package/src/duckdb/src/include/duckdb/common/serializer/format_deserializer.hpp +46 -1
- package/src/duckdb/src/include/duckdb/common/serializer/format_serializer.hpp +23 -21
- package/src/duckdb/src/include/duckdb/common/serializer/serialization_traits.hpp +12 -4
- package/src/duckdb/src/include/duckdb/common/types/column/column_data_collection.hpp +3 -0
- package/src/duckdb/src/include/duckdb/core_functions/scalar/math_functions.hpp +3 -3
- package/src/duckdb/src/include/duckdb/function/macro_function.hpp +3 -0
- package/src/duckdb/src/include/duckdb/function/scalar_macro_function.hpp +3 -0
- package/src/duckdb/src/include/duckdb/function/table_macro_function.hpp +3 -0
- package/src/duckdb/src/include/duckdb/parser/column_definition.hpp +6 -5
- package/src/duckdb/src/include/duckdb/parser/column_list.hpp +4 -0
- package/src/duckdb/src/include/duckdb/parser/constraint.hpp +5 -0
- package/src/duckdb/src/include/duckdb/parser/constraints/check_constraint.hpp +3 -0
- package/src/duckdb/src/include/duckdb/parser/constraints/foreign_key_constraint.hpp +6 -0
- package/src/duckdb/src/include/duckdb/parser/constraints/not_null_constraint.hpp +3 -0
- package/src/duckdb/src/include/duckdb/parser/constraints/unique_constraint.hpp +6 -0
- package/src/duckdb/src/include/duckdb/parser/expression/between_expression.hpp +1 -1
- package/src/duckdb/src/include/duckdb/parser/expression/case_expression.hpp +1 -1
- package/src/duckdb/src/include/duckdb/parser/expression/cast_expression.hpp +1 -1
- package/src/duckdb/src/include/duckdb/parser/expression/collate_expression.hpp +1 -1
- package/src/duckdb/src/include/duckdb/parser/expression/columnref_expression.hpp +1 -1
- package/src/duckdb/src/include/duckdb/parser/expression/comparison_expression.hpp +1 -1
- package/src/duckdb/src/include/duckdb/parser/expression/conjunction_expression.hpp +1 -1
- package/src/duckdb/src/include/duckdb/parser/expression/constant_expression.hpp +1 -1
- package/src/duckdb/src/include/duckdb/parser/expression/default_expression.hpp +1 -1
- package/src/duckdb/src/include/duckdb/parser/expression/function_expression.hpp +1 -1
- package/src/duckdb/src/include/duckdb/parser/expression/lambda_expression.hpp +1 -1
- package/src/duckdb/src/include/duckdb/parser/expression/operator_expression.hpp +1 -1
- package/src/duckdb/src/include/duckdb/parser/expression/parameter_expression.hpp +1 -1
- package/src/duckdb/src/include/duckdb/parser/expression/positional_reference_expression.hpp +1 -1
- package/src/duckdb/src/include/duckdb/parser/expression/star_expression.hpp +1 -1
- package/src/duckdb/src/include/duckdb/parser/expression/subquery_expression.hpp +1 -1
- package/src/duckdb/src/include/duckdb/parser/expression/window_expression.hpp +1 -1
- package/src/duckdb/src/include/duckdb/parser/parsed_data/alter_info.hpp +12 -1
- package/src/duckdb/src/include/duckdb/parser/parsed_data/alter_table_info.hpp +66 -2
- package/src/duckdb/src/include/duckdb/parser/parsed_data/attach_info.hpp +8 -1
- package/src/duckdb/src/include/duckdb/parser/parsed_data/copy_info.hpp +8 -1
- package/src/duckdb/src/include/duckdb/parser/parsed_data/create_index_info.hpp +4 -1
- package/src/duckdb/src/include/duckdb/parser/parsed_data/create_info.hpp +9 -2
- package/src/duckdb/src/include/duckdb/parser/parsed_data/create_macro_info.hpp +3 -0
- package/src/duckdb/src/include/duckdb/parser/parsed_data/create_schema_info.hpp +3 -0
- package/src/duckdb/src/include/duckdb/parser/parsed_data/create_sequence_info.hpp +3 -0
- package/src/duckdb/src/include/duckdb/parser/parsed_data/create_table_info.hpp +3 -0
- package/src/duckdb/src/include/duckdb/parser/parsed_data/create_type_info.hpp +3 -0
- package/src/duckdb/src/include/duckdb/parser/parsed_data/create_view_info.hpp +3 -0
- package/src/duckdb/src/include/duckdb/parser/parsed_data/detach_info.hpp +7 -0
- package/src/duckdb/src/include/duckdb/parser/parsed_data/drop_info.hpp +7 -0
- package/src/duckdb/src/include/duckdb/parser/parsed_data/exported_table_data.hpp +7 -0
- package/src/duckdb/src/include/duckdb/parser/parsed_data/load_info.hpp +13 -3
- package/src/duckdb/src/include/duckdb/parser/parsed_data/parse_info.hpp +22 -0
- package/src/duckdb/src/include/duckdb/parser/parsed_data/pragma_info.hpp +10 -0
- package/src/duckdb/src/include/duckdb/parser/parsed_data/show_select_info.hpp +7 -0
- package/src/duckdb/src/include/duckdb/parser/parsed_data/transaction_info.hpp +10 -0
- package/src/duckdb/src/include/duckdb/parser/parsed_data/vacuum_info.hpp +10 -0
- package/src/duckdb/src/include/duckdb/planner/bound_constraint.hpp +0 -8
- package/src/duckdb/src/include/duckdb/planner/bound_result_modifier.hpp +6 -0
- package/src/duckdb/src/include/duckdb/planner/column_binding.hpp +5 -0
- package/src/duckdb/src/include/duckdb/planner/expression/bound_between_expression.hpp +6 -0
- package/src/duckdb/src/include/duckdb/planner/expression/bound_case_expression.hpp +6 -0
- package/src/duckdb/src/include/duckdb/planner/expression/bound_cast_expression.hpp +6 -0
- package/src/duckdb/src/include/duckdb/planner/expression/bound_columnref_expression.hpp +3 -0
- package/src/duckdb/src/include/duckdb/planner/expression/bound_comparison_expression.hpp +3 -0
- package/src/duckdb/src/include/duckdb/planner/expression/bound_conjunction_expression.hpp +3 -0
- package/src/duckdb/src/include/duckdb/planner/expression/bound_constant_expression.hpp +3 -0
- package/src/duckdb/src/include/duckdb/planner/expression/bound_default_expression.hpp +3 -0
- package/src/duckdb/src/include/duckdb/planner/expression/bound_lambda_expression.hpp +3 -1
- package/src/duckdb/src/include/duckdb/planner/expression/bound_lambdaref_expression.hpp +3 -0
- package/src/duckdb/src/include/duckdb/planner/expression/bound_operator_expression.hpp +3 -0
- package/src/duckdb/src/include/duckdb/planner/expression/bound_parameter_data.hpp +5 -2
- package/src/duckdb/src/include/duckdb/planner/expression/bound_parameter_expression.hpp +7 -0
- package/src/duckdb/src/include/duckdb/planner/expression/bound_reference_expression.hpp +3 -0
- package/src/duckdb/src/include/duckdb/planner/expression/bound_unnest_expression.hpp +3 -0
- package/src/duckdb/src/include/duckdb/planner/expression/list.hpp +1 -0
- package/src/duckdb/src/include/duckdb/planner/expression.hpp +3 -0
- package/src/duckdb/src/include/duckdb/planner/joinside.hpp +3 -0
- package/src/duckdb/src/include/duckdb/planner/logical_operator.hpp +3 -0
- package/src/duckdb/src/include/duckdb/planner/operator/logical_aggregate.hpp +3 -0
- package/src/duckdb/src/include/duckdb/planner/operator/logical_any_join.hpp +3 -0
- package/src/duckdb/src/include/duckdb/planner/operator/logical_column_data_get.hpp +4 -0
- package/src/duckdb/src/include/duckdb/planner/operator/logical_comparison_join.hpp +9 -2
- package/src/duckdb/src/include/duckdb/planner/operator/logical_create.hpp +9 -6
- package/src/duckdb/src/include/duckdb/planner/operator/logical_create_index.hpp +2 -16
- package/src/duckdb/src/include/duckdb/planner/operator/logical_create_table.hpp +10 -6
- package/src/duckdb/src/include/duckdb/planner/operator/logical_cross_product.hpp +3 -0
- package/src/duckdb/src/include/duckdb/planner/operator/logical_cteref.hpp +2 -0
- package/src/duckdb/src/include/duckdb/planner/operator/logical_delete.hpp +7 -0
- package/src/duckdb/src/include/duckdb/planner/operator/logical_delim_get.hpp +3 -0
- package/src/duckdb/src/include/duckdb/planner/operator/logical_distinct.hpp +6 -10
- package/src/duckdb/src/include/duckdb/planner/operator/logical_dummy_scan.hpp +2 -0
- package/src/duckdb/src/include/duckdb/planner/operator/logical_empty_result.hpp +2 -0
- package/src/duckdb/src/include/duckdb/planner/operator/logical_explain.hpp +4 -0
- package/src/duckdb/src/include/duckdb/planner/operator/logical_expression_get.hpp +3 -0
- package/src/duckdb/src/include/duckdb/planner/operator/logical_filter.hpp +3 -0
- package/src/duckdb/src/include/duckdb/planner/operator/logical_insert.hpp +6 -0
- package/src/duckdb/src/include/duckdb/planner/operator/logical_limit.hpp +3 -0
- package/src/duckdb/src/include/duckdb/planner/operator/logical_limit_percent.hpp +3 -0
- package/src/duckdb/src/include/duckdb/planner/operator/logical_materialized_cte.hpp +5 -2
- package/src/duckdb/src/include/duckdb/planner/operator/logical_order.hpp +7 -35
- package/src/duckdb/src/include/duckdb/planner/operator/logical_pivot.hpp +6 -0
- package/src/duckdb/src/include/duckdb/planner/operator/logical_positional_join.hpp +3 -0
- package/src/duckdb/src/include/duckdb/planner/operator/logical_projection.hpp +3 -0
- package/src/duckdb/src/include/duckdb/planner/operator/logical_recursive_cte.hpp +5 -3
- package/src/duckdb/src/include/duckdb/planner/operator/logical_reset.hpp +4 -0
- package/src/duckdb/src/include/duckdb/planner/operator/logical_sample.hpp +6 -0
- package/src/duckdb/src/include/duckdb/planner/operator/logical_set.hpp +4 -0
- package/src/duckdb/src/include/duckdb/planner/operator/logical_set_operation.hpp +4 -0
- package/src/duckdb/src/include/duckdb/planner/operator/logical_show.hpp +3 -0
- package/src/duckdb/src/include/duckdb/planner/operator/logical_simple.hpp +3 -0
- package/src/duckdb/src/include/duckdb/planner/operator/logical_top_n.hpp +4 -0
- package/src/duckdb/src/include/duckdb/planner/operator/logical_unnest.hpp +2 -0
- package/src/duckdb/src/include/duckdb/planner/operator/logical_update.hpp +6 -0
- package/src/duckdb/src/include/duckdb/planner/operator/logical_window.hpp +3 -0
- package/src/duckdb/src/include/duckdb/planner/tableref/bound_pivotref.hpp +3 -0
- package/src/duckdb/src/optimizer/deliminator.cpp +5 -3
- package/src/duckdb/src/parser/column_definition.cpp +20 -32
- package/src/duckdb/src/parser/column_list.cpp +8 -0
- package/src/duckdb/src/parser/constraints/foreign_key_constraint.cpp +3 -0
- package/src/duckdb/src/parser/constraints/unique_constraint.cpp +3 -0
- package/src/duckdb/src/parser/expression/case_expression.cpp +0 -12
- package/src/duckdb/src/parser/parsed_data/alter_info.cpp +5 -2
- package/src/duckdb/src/parser/parsed_data/alter_table_info.cpp +38 -0
- package/src/duckdb/src/parser/parsed_data/create_index_info.cpp +3 -1
- package/src/duckdb/src/parser/parsed_data/create_sequence_info.cpp +2 -0
- package/src/duckdb/src/parser/parsed_data/detach_info.cpp +1 -1
- package/src/duckdb/src/parser/parsed_data/drop_info.cpp +1 -1
- package/src/duckdb/src/parser/parsed_data/sample_options.cpp +0 -18
- package/src/duckdb/src/parser/parsed_data/transaction_info.cpp +4 -1
- package/src/duckdb/src/parser/parsed_data/vacuum_info.cpp +1 -1
- package/src/duckdb/src/parser/query_node.cpp +0 -10
- package/src/duckdb/src/parser/result_modifier.cpp +0 -13
- package/src/duckdb/src/parser/statement/select_statement.cpp +0 -10
- package/src/duckdb/src/parser/tableref/pivotref.cpp +0 -16
- package/src/duckdb/src/parser/transform/statement/transform_create_index.cpp +5 -4
- package/src/duckdb/src/planner/binder/query_node/plan_subquery.cpp +1 -1
- package/src/duckdb/src/planner/binder/statement/bind_create.cpp +6 -1
- package/src/duckdb/src/planner/expression/bound_between_expression.cpp +4 -0
- package/src/duckdb/src/planner/expression/bound_cast_expression.cpp +13 -6
- package/src/duckdb/src/planner/expression/bound_parameter_expression.cpp +20 -12
- package/src/duckdb/src/planner/expression/bound_window_expression.cpp +1 -4
- package/src/duckdb/src/planner/logical_operator.cpp +13 -1
- package/src/duckdb/src/planner/operator/logical_comparison_join.cpp +16 -2
- package/src/duckdb/src/planner/operator/logical_create.cpp +14 -0
- package/src/duckdb/src/planner/operator/logical_create_index.cpp +20 -0
- package/src/duckdb/src/planner/operator/logical_create_table.cpp +16 -0
- package/src/duckdb/src/planner/operator/logical_delete.cpp +9 -2
- package/src/duckdb/src/planner/operator/logical_delim_join.cpp +2 -4
- package/src/duckdb/src/planner/operator/logical_distinct.cpp +13 -0
- package/src/duckdb/src/planner/operator/logical_explain.cpp +1 -1
- package/src/duckdb/src/planner/operator/logical_insert.cpp +8 -2
- package/src/duckdb/src/planner/operator/logical_materialized_cte.cpp +3 -2
- package/src/duckdb/src/planner/operator/logical_order.cpp +39 -0
- package/src/duckdb/src/planner/operator/logical_pivot.cpp +3 -0
- package/src/duckdb/src/planner/operator/logical_recursive_cte.cpp +5 -5
- package/src/duckdb/src/planner/operator/logical_sample.cpp +3 -0
- package/src/duckdb/src/planner/operator/logical_update.cpp +8 -2
- package/src/duckdb/src/planner/parsed_data/bound_create_table_info.cpp +4 -2
- package/src/duckdb/src/planner/planner.cpp +11 -0
- package/src/duckdb/src/storage/checkpoint_manager.cpp +23 -23
- package/src/duckdb/src/storage/serialization/serialize_constraint.cpp +98 -0
- package/src/duckdb/src/storage/serialization/serialize_create_info.cpp +188 -0
- package/src/duckdb/src/storage/serialization/serialize_expression.cpp +274 -0
- package/src/duckdb/src/storage/serialization/serialize_logical_operator.cpp +729 -0
- package/src/duckdb/src/storage/serialization/serialize_macro_function.cpp +62 -0
- package/src/duckdb/src/storage/serialization/serialize_nodes.cpp +242 -0
- package/src/duckdb/src/storage/serialization/serialize_parse_info.cpp +419 -0
- package/src/duckdb/src/storage/serialization/serialize_parsed_expression.cpp +40 -38
- package/src/duckdb/src/storage/serialization/serialize_query_node.cpp +36 -36
- package/src/duckdb/src/storage/serialization/serialize_result_modifier.cpp +25 -14
- package/src/duckdb/src/storage/serialization/serialize_statement.cpp +22 -0
- package/src/duckdb/src/storage/serialization/serialize_tableref.cpp +47 -47
- package/src/duckdb/src/storage/serialization/serialize_types.cpp +25 -25
- package/src/duckdb/src/storage/storage_info.cpp +3 -2
- package/src/duckdb/src/storage/wal_replay.cpp +20 -19
- package/src/duckdb/third_party/concurrentqueue/lightweightsemaphore.h +3 -76
- package/src/duckdb/third_party/libpg_query/pg_functions.cpp +13 -0
- package/src/duckdb/third_party/libpg_query/src_backend_parser_scansup.cpp +9 -0
- package/src/duckdb/ub_src_parser.cpp +0 -2
- package/src/duckdb/ub_src_storage_serialization.cpp +16 -0
- package/src/duckdb/src/parser/common_table_expression_info.cpp +0 -21
@@ -0,0 +1,729 @@
|
|
1
|
+
//===----------------------------------------------------------------------===//
|
2
|
+
// This file is automatically generated by scripts/generate_serialization.py
|
3
|
+
// Do not edit this file manually, your changes will be overwritten
|
4
|
+
//===----------------------------------------------------------------------===//
|
5
|
+
|
6
|
+
#include "duckdb/common/serializer/format_serializer.hpp"
|
7
|
+
#include "duckdb/common/serializer/format_deserializer.hpp"
|
8
|
+
#include "duckdb/planner/operator/list.hpp"
|
9
|
+
#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
|
10
|
+
#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
|
11
|
+
|
12
|
+
namespace duckdb {
|
13
|
+
|
14
|
+
void LogicalOperator::FormatSerialize(FormatSerializer &serializer) const {
|
15
|
+
serializer.WriteProperty("type", type);
|
16
|
+
serializer.WriteProperty("children", children);
|
17
|
+
}
|
18
|
+
|
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");
|
22
|
+
deserializer.Set<LogicalOperatorType>(type);
|
23
|
+
unique_ptr<LogicalOperator> result;
|
24
|
+
switch (type) {
|
25
|
+
case LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY:
|
26
|
+
result = LogicalAggregate::FormatDeserialize(deserializer);
|
27
|
+
break;
|
28
|
+
case LogicalOperatorType::LOGICAL_ALTER:
|
29
|
+
result = LogicalSimple::FormatDeserialize(deserializer);
|
30
|
+
break;
|
31
|
+
case LogicalOperatorType::LOGICAL_ANY_JOIN:
|
32
|
+
result = LogicalAnyJoin::FormatDeserialize(deserializer);
|
33
|
+
break;
|
34
|
+
case LogicalOperatorType::LOGICAL_ATTACH:
|
35
|
+
result = LogicalSimple::FormatDeserialize(deserializer);
|
36
|
+
break;
|
37
|
+
case LogicalOperatorType::LOGICAL_CHUNK_GET:
|
38
|
+
result = LogicalColumnDataGet::FormatDeserialize(deserializer);
|
39
|
+
break;
|
40
|
+
case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
|
41
|
+
result = LogicalComparisonJoin::FormatDeserialize(deserializer);
|
42
|
+
break;
|
43
|
+
case LogicalOperatorType::LOGICAL_CREATE_MACRO:
|
44
|
+
result = LogicalCreate::FormatDeserialize(deserializer);
|
45
|
+
break;
|
46
|
+
case LogicalOperatorType::LOGICAL_CREATE_SCHEMA:
|
47
|
+
result = LogicalCreate::FormatDeserialize(deserializer);
|
48
|
+
break;
|
49
|
+
case LogicalOperatorType::LOGICAL_CREATE_SEQUENCE:
|
50
|
+
result = LogicalCreate::FormatDeserialize(deserializer);
|
51
|
+
break;
|
52
|
+
case LogicalOperatorType::LOGICAL_CREATE_TABLE:
|
53
|
+
result = LogicalCreateTable::FormatDeserialize(deserializer);
|
54
|
+
break;
|
55
|
+
case LogicalOperatorType::LOGICAL_CREATE_TYPE:
|
56
|
+
result = LogicalCreate::FormatDeserialize(deserializer);
|
57
|
+
break;
|
58
|
+
case LogicalOperatorType::LOGICAL_CREATE_VIEW:
|
59
|
+
result = LogicalCreate::FormatDeserialize(deserializer);
|
60
|
+
break;
|
61
|
+
case LogicalOperatorType::LOGICAL_CROSS_PRODUCT:
|
62
|
+
result = LogicalCrossProduct::FormatDeserialize(deserializer);
|
63
|
+
break;
|
64
|
+
case LogicalOperatorType::LOGICAL_CTE_REF:
|
65
|
+
result = LogicalCTERef::FormatDeserialize(deserializer);
|
66
|
+
break;
|
67
|
+
case LogicalOperatorType::LOGICAL_DELETE:
|
68
|
+
result = LogicalDelete::FormatDeserialize(deserializer);
|
69
|
+
break;
|
70
|
+
case LogicalOperatorType::LOGICAL_DELIM_GET:
|
71
|
+
result = LogicalDelimGet::FormatDeserialize(deserializer);
|
72
|
+
break;
|
73
|
+
case LogicalOperatorType::LOGICAL_DETACH:
|
74
|
+
result = LogicalSimple::FormatDeserialize(deserializer);
|
75
|
+
break;
|
76
|
+
case LogicalOperatorType::LOGICAL_DISTINCT:
|
77
|
+
result = LogicalDistinct::FormatDeserialize(deserializer);
|
78
|
+
break;
|
79
|
+
case LogicalOperatorType::LOGICAL_DROP:
|
80
|
+
result = LogicalSimple::FormatDeserialize(deserializer);
|
81
|
+
break;
|
82
|
+
case LogicalOperatorType::LOGICAL_DUMMY_SCAN:
|
83
|
+
result = LogicalDummyScan::FormatDeserialize(deserializer);
|
84
|
+
break;
|
85
|
+
case LogicalOperatorType::LOGICAL_EMPTY_RESULT:
|
86
|
+
result = LogicalEmptyResult::FormatDeserialize(deserializer);
|
87
|
+
break;
|
88
|
+
case LogicalOperatorType::LOGICAL_EXCEPT:
|
89
|
+
result = LogicalSetOperation::FormatDeserialize(deserializer);
|
90
|
+
break;
|
91
|
+
case LogicalOperatorType::LOGICAL_EXPLAIN:
|
92
|
+
result = LogicalExplain::FormatDeserialize(deserializer);
|
93
|
+
break;
|
94
|
+
case LogicalOperatorType::LOGICAL_EXPRESSION_GET:
|
95
|
+
result = LogicalExpressionGet::FormatDeserialize(deserializer);
|
96
|
+
break;
|
97
|
+
case LogicalOperatorType::LOGICAL_FILTER:
|
98
|
+
result = LogicalFilter::FormatDeserialize(deserializer);
|
99
|
+
break;
|
100
|
+
case LogicalOperatorType::LOGICAL_INSERT:
|
101
|
+
result = LogicalInsert::FormatDeserialize(deserializer);
|
102
|
+
break;
|
103
|
+
case LogicalOperatorType::LOGICAL_INTERSECT:
|
104
|
+
result = LogicalSetOperation::FormatDeserialize(deserializer);
|
105
|
+
break;
|
106
|
+
case LogicalOperatorType::LOGICAL_LIMIT:
|
107
|
+
result = LogicalLimit::FormatDeserialize(deserializer);
|
108
|
+
break;
|
109
|
+
case LogicalOperatorType::LOGICAL_LIMIT_PERCENT:
|
110
|
+
result = LogicalLimitPercent::FormatDeserialize(deserializer);
|
111
|
+
break;
|
112
|
+
case LogicalOperatorType::LOGICAL_LOAD:
|
113
|
+
result = LogicalSimple::FormatDeserialize(deserializer);
|
114
|
+
break;
|
115
|
+
case LogicalOperatorType::LOGICAL_MATERIALIZED_CTE:
|
116
|
+
result = LogicalMaterializedCTE::FormatDeserialize(deserializer);
|
117
|
+
break;
|
118
|
+
case LogicalOperatorType::LOGICAL_ORDER_BY:
|
119
|
+
result = LogicalOrder::FormatDeserialize(deserializer);
|
120
|
+
break;
|
121
|
+
case LogicalOperatorType::LOGICAL_PIVOT:
|
122
|
+
result = LogicalPivot::FormatDeserialize(deserializer);
|
123
|
+
break;
|
124
|
+
case LogicalOperatorType::LOGICAL_POSITIONAL_JOIN:
|
125
|
+
result = LogicalPositionalJoin::FormatDeserialize(deserializer);
|
126
|
+
break;
|
127
|
+
case LogicalOperatorType::LOGICAL_PROJECTION:
|
128
|
+
result = LogicalProjection::FormatDeserialize(deserializer);
|
129
|
+
break;
|
130
|
+
case LogicalOperatorType::LOGICAL_RECURSIVE_CTE:
|
131
|
+
result = LogicalRecursiveCTE::FormatDeserialize(deserializer);
|
132
|
+
break;
|
133
|
+
case LogicalOperatorType::LOGICAL_RESET:
|
134
|
+
result = LogicalReset::FormatDeserialize(deserializer);
|
135
|
+
break;
|
136
|
+
case LogicalOperatorType::LOGICAL_SAMPLE:
|
137
|
+
result = LogicalSample::FormatDeserialize(deserializer);
|
138
|
+
break;
|
139
|
+
case LogicalOperatorType::LOGICAL_SET:
|
140
|
+
result = LogicalSet::FormatDeserialize(deserializer);
|
141
|
+
break;
|
142
|
+
case LogicalOperatorType::LOGICAL_SHOW:
|
143
|
+
result = LogicalShow::FormatDeserialize(deserializer);
|
144
|
+
break;
|
145
|
+
case LogicalOperatorType::LOGICAL_TOP_N:
|
146
|
+
result = LogicalTopN::FormatDeserialize(deserializer);
|
147
|
+
break;
|
148
|
+
case LogicalOperatorType::LOGICAL_TRANSACTION:
|
149
|
+
result = LogicalSimple::FormatDeserialize(deserializer);
|
150
|
+
break;
|
151
|
+
case LogicalOperatorType::LOGICAL_UNION:
|
152
|
+
result = LogicalSetOperation::FormatDeserialize(deserializer);
|
153
|
+
break;
|
154
|
+
case LogicalOperatorType::LOGICAL_UNNEST:
|
155
|
+
result = LogicalUnnest::FormatDeserialize(deserializer);
|
156
|
+
break;
|
157
|
+
case LogicalOperatorType::LOGICAL_UPDATE:
|
158
|
+
result = LogicalUpdate::FormatDeserialize(deserializer);
|
159
|
+
break;
|
160
|
+
case LogicalOperatorType::LOGICAL_VACUUM:
|
161
|
+
result = LogicalSimple::FormatDeserialize(deserializer);
|
162
|
+
break;
|
163
|
+
case LogicalOperatorType::LOGICAL_WINDOW:
|
164
|
+
result = LogicalWindow::FormatDeserialize(deserializer);
|
165
|
+
break;
|
166
|
+
default:
|
167
|
+
throw SerializationException("Unsupported type for deserialization of LogicalOperator!");
|
168
|
+
}
|
169
|
+
deserializer.Unset<LogicalOperatorType>();
|
170
|
+
result->children = std::move(children);
|
171
|
+
return result;
|
172
|
+
}
|
173
|
+
|
174
|
+
void LogicalAggregate::FormatSerialize(FormatSerializer &serializer) const {
|
175
|
+
LogicalOperator::FormatSerialize(serializer);
|
176
|
+
serializer.WriteProperty("expressions", expressions);
|
177
|
+
serializer.WriteProperty("group_index", group_index);
|
178
|
+
serializer.WriteProperty("aggregate_index", aggregate_index);
|
179
|
+
serializer.WriteProperty("groupings_index", groupings_index);
|
180
|
+
serializer.WriteProperty("groups", groups);
|
181
|
+
serializer.WriteProperty("grouping_sets", grouping_sets);
|
182
|
+
serializer.WriteProperty("grouping_functions", grouping_functions);
|
183
|
+
}
|
184
|
+
|
185
|
+
unique_ptr<LogicalOperator> LogicalAggregate::FormatDeserialize(FormatDeserializer &deserializer) {
|
186
|
+
auto expressions = deserializer.ReadProperty<vector<unique_ptr<Expression>>>("expressions");
|
187
|
+
auto group_index = deserializer.ReadProperty<idx_t>("group_index");
|
188
|
+
auto aggregate_index = deserializer.ReadProperty<idx_t>("aggregate_index");
|
189
|
+
auto result = duckdb::unique_ptr<LogicalAggregate>(new LogicalAggregate(group_index, aggregate_index, std::move(expressions)));
|
190
|
+
deserializer.ReadProperty("groupings_index", result->groupings_index);
|
191
|
+
deserializer.ReadProperty("groups", result->groups);
|
192
|
+
deserializer.ReadProperty("grouping_sets", result->grouping_sets);
|
193
|
+
deserializer.ReadProperty("grouping_functions", result->grouping_functions);
|
194
|
+
return std::move(result);
|
195
|
+
}
|
196
|
+
|
197
|
+
void LogicalAnyJoin::FormatSerialize(FormatSerializer &serializer) const {
|
198
|
+
LogicalOperator::FormatSerialize(serializer);
|
199
|
+
serializer.WriteProperty("join_type", join_type);
|
200
|
+
serializer.WriteProperty("mark_index", mark_index);
|
201
|
+
serializer.WriteProperty("left_projection_map", left_projection_map);
|
202
|
+
serializer.WriteProperty("right_projection_map", right_projection_map);
|
203
|
+
serializer.WriteProperty("condition", *condition);
|
204
|
+
}
|
205
|
+
|
206
|
+
unique_ptr<LogicalOperator> LogicalAnyJoin::FormatDeserialize(FormatDeserializer &deserializer) {
|
207
|
+
auto join_type = deserializer.ReadProperty<JoinType>("join_type");
|
208
|
+
auto result = duckdb::unique_ptr<LogicalAnyJoin>(new LogicalAnyJoin(join_type));
|
209
|
+
deserializer.ReadProperty("mark_index", result->mark_index);
|
210
|
+
deserializer.ReadProperty("left_projection_map", result->left_projection_map);
|
211
|
+
deserializer.ReadProperty("right_projection_map", result->right_projection_map);
|
212
|
+
deserializer.ReadProperty("condition", result->condition);
|
213
|
+
return std::move(result);
|
214
|
+
}
|
215
|
+
|
216
|
+
void LogicalCTERef::FormatSerialize(FormatSerializer &serializer) const {
|
217
|
+
LogicalOperator::FormatSerialize(serializer);
|
218
|
+
serializer.WriteProperty("table_index", table_index);
|
219
|
+
serializer.WriteProperty("cte_index", cte_index);
|
220
|
+
serializer.WriteProperty("chunk_types", chunk_types);
|
221
|
+
serializer.WriteProperty("bound_columns", bound_columns);
|
222
|
+
serializer.WriteProperty("materialized_cte", materialized_cte);
|
223
|
+
}
|
224
|
+
|
225
|
+
unique_ptr<LogicalOperator> LogicalCTERef::FormatDeserialize(FormatDeserializer &deserializer) {
|
226
|
+
auto table_index = deserializer.ReadProperty<idx_t>("table_index");
|
227
|
+
auto cte_index = deserializer.ReadProperty<idx_t>("cte_index");
|
228
|
+
auto chunk_types = deserializer.ReadProperty<vector<LogicalType>>("chunk_types");
|
229
|
+
auto bound_columns = deserializer.ReadProperty<vector<string>>("bound_columns");
|
230
|
+
auto materialized_cte = deserializer.ReadProperty<CTEMaterialize>("materialized_cte");
|
231
|
+
auto result = duckdb::unique_ptr<LogicalCTERef>(new LogicalCTERef(table_index, cte_index, std::move(chunk_types), std::move(bound_columns), materialized_cte));
|
232
|
+
return std::move(result);
|
233
|
+
}
|
234
|
+
|
235
|
+
void LogicalColumnDataGet::FormatSerialize(FormatSerializer &serializer) const {
|
236
|
+
LogicalOperator::FormatSerialize(serializer);
|
237
|
+
serializer.WriteProperty("table_index", table_index);
|
238
|
+
serializer.WriteProperty("chunk_types", chunk_types);
|
239
|
+
serializer.WriteProperty("collection", *collection);
|
240
|
+
}
|
241
|
+
|
242
|
+
unique_ptr<LogicalOperator> LogicalColumnDataGet::FormatDeserialize(FormatDeserializer &deserializer) {
|
243
|
+
auto table_index = deserializer.ReadProperty<idx_t>("table_index");
|
244
|
+
auto chunk_types = deserializer.ReadProperty<vector<LogicalType>>("chunk_types");
|
245
|
+
auto collection = deserializer.ReadProperty<unique_ptr<ColumnDataCollection>>("collection");
|
246
|
+
auto result = duckdb::unique_ptr<LogicalColumnDataGet>(new LogicalColumnDataGet(table_index, std::move(chunk_types), std::move(collection)));
|
247
|
+
return std::move(result);
|
248
|
+
}
|
249
|
+
|
250
|
+
void LogicalComparisonJoin::FormatSerialize(FormatSerializer &serializer) const {
|
251
|
+
LogicalOperator::FormatSerialize(serializer);
|
252
|
+
serializer.WriteProperty("join_type", join_type);
|
253
|
+
serializer.WriteProperty("mark_index", mark_index);
|
254
|
+
serializer.WriteProperty("left_projection_map", left_projection_map);
|
255
|
+
serializer.WriteProperty("right_projection_map", right_projection_map);
|
256
|
+
serializer.WriteProperty("conditions", conditions);
|
257
|
+
serializer.WriteProperty("mark_types", mark_types);
|
258
|
+
}
|
259
|
+
|
260
|
+
unique_ptr<LogicalOperator> LogicalComparisonJoin::FormatDeserialize(FormatDeserializer &deserializer) {
|
261
|
+
auto join_type = deserializer.ReadProperty<JoinType>("join_type");
|
262
|
+
auto result = duckdb::unique_ptr<LogicalComparisonJoin>(new LogicalComparisonJoin(join_type, deserializer.Get<LogicalOperatorType>()));
|
263
|
+
deserializer.ReadProperty("mark_index", result->mark_index);
|
264
|
+
deserializer.ReadProperty("left_projection_map", result->left_projection_map);
|
265
|
+
deserializer.ReadProperty("right_projection_map", result->right_projection_map);
|
266
|
+
deserializer.ReadProperty("conditions", result->conditions);
|
267
|
+
deserializer.ReadProperty("mark_types", result->mark_types);
|
268
|
+
return std::move(result);
|
269
|
+
}
|
270
|
+
|
271
|
+
void LogicalCreate::FormatSerialize(FormatSerializer &serializer) const {
|
272
|
+
LogicalOperator::FormatSerialize(serializer);
|
273
|
+
serializer.WriteProperty("info", *info);
|
274
|
+
}
|
275
|
+
|
276
|
+
unique_ptr<LogicalOperator> LogicalCreate::FormatDeserialize(FormatDeserializer &deserializer) {
|
277
|
+
auto info = deserializer.ReadProperty<unique_ptr<CreateInfo>>("info");
|
278
|
+
auto result = duckdb::unique_ptr<LogicalCreate>(new LogicalCreate(deserializer.Get<LogicalOperatorType>(), deserializer.Get<ClientContext &>(), std::move(info)));
|
279
|
+
return std::move(result);
|
280
|
+
}
|
281
|
+
|
282
|
+
void LogicalCreateTable::FormatSerialize(FormatSerializer &serializer) const {
|
283
|
+
LogicalOperator::FormatSerialize(serializer);
|
284
|
+
serializer.WriteProperty("catalog", schema.ParentCatalog().GetName());
|
285
|
+
serializer.WriteProperty("schema", schema.name);
|
286
|
+
serializer.WriteProperty("info", *info->base);
|
287
|
+
}
|
288
|
+
|
289
|
+
unique_ptr<LogicalOperator> LogicalCreateTable::FormatDeserialize(FormatDeserializer &deserializer) {
|
290
|
+
auto catalog = deserializer.ReadProperty<string>("catalog");
|
291
|
+
auto schema = deserializer.ReadProperty<string>("schema");
|
292
|
+
auto info = deserializer.ReadProperty<unique_ptr<CreateInfo>>("info");
|
293
|
+
auto result = duckdb::unique_ptr<LogicalCreateTable>(new LogicalCreateTable(deserializer.Get<ClientContext &>(), catalog, schema, std::move(info)));
|
294
|
+
return std::move(result);
|
295
|
+
}
|
296
|
+
|
297
|
+
void LogicalCrossProduct::FormatSerialize(FormatSerializer &serializer) const {
|
298
|
+
LogicalOperator::FormatSerialize(serializer);
|
299
|
+
}
|
300
|
+
|
301
|
+
unique_ptr<LogicalOperator> LogicalCrossProduct::FormatDeserialize(FormatDeserializer &deserializer) {
|
302
|
+
auto result = duckdb::unique_ptr<LogicalCrossProduct>(new LogicalCrossProduct());
|
303
|
+
return std::move(result);
|
304
|
+
}
|
305
|
+
|
306
|
+
void LogicalDelete::FormatSerialize(FormatSerializer &serializer) const {
|
307
|
+
LogicalOperator::FormatSerialize(serializer);
|
308
|
+
serializer.WriteProperty("catalog", table.ParentCatalog().GetName());
|
309
|
+
serializer.WriteProperty("schema", table.ParentSchema().name);
|
310
|
+
serializer.WriteProperty("table", table.name);
|
311
|
+
serializer.WriteProperty("table_index", table_index);
|
312
|
+
serializer.WriteProperty("return_chunk", return_chunk);
|
313
|
+
serializer.WriteProperty("expressions", expressions);
|
314
|
+
}
|
315
|
+
|
316
|
+
unique_ptr<LogicalOperator> LogicalDelete::FormatDeserialize(FormatDeserializer &deserializer) {
|
317
|
+
auto catalog = deserializer.ReadProperty<string>("catalog");
|
318
|
+
auto schema = deserializer.ReadProperty<string>("schema");
|
319
|
+
auto table = deserializer.ReadProperty<string>("table");
|
320
|
+
auto result = duckdb::unique_ptr<LogicalDelete>(new LogicalDelete(deserializer.Get<ClientContext &>(), catalog, schema, table));
|
321
|
+
deserializer.ReadProperty("table_index", result->table_index);
|
322
|
+
deserializer.ReadProperty("return_chunk", result->return_chunk);
|
323
|
+
deserializer.ReadProperty("expressions", result->expressions);
|
324
|
+
return std::move(result);
|
325
|
+
}
|
326
|
+
|
327
|
+
void LogicalDelimGet::FormatSerialize(FormatSerializer &serializer) const {
|
328
|
+
LogicalOperator::FormatSerialize(serializer);
|
329
|
+
serializer.WriteProperty("table_index", table_index);
|
330
|
+
serializer.WriteProperty("chunk_types", chunk_types);
|
331
|
+
}
|
332
|
+
|
333
|
+
unique_ptr<LogicalOperator> LogicalDelimGet::FormatDeserialize(FormatDeserializer &deserializer) {
|
334
|
+
auto table_index = deserializer.ReadProperty<idx_t>("table_index");
|
335
|
+
auto chunk_types = deserializer.ReadProperty<vector<LogicalType>>("chunk_types");
|
336
|
+
auto result = duckdb::unique_ptr<LogicalDelimGet>(new LogicalDelimGet(table_index, std::move(chunk_types)));
|
337
|
+
return std::move(result);
|
338
|
+
}
|
339
|
+
|
340
|
+
void LogicalDistinct::FormatSerialize(FormatSerializer &serializer) const {
|
341
|
+
LogicalOperator::FormatSerialize(serializer);
|
342
|
+
serializer.WriteProperty("distinct_type", distinct_type);
|
343
|
+
serializer.WriteProperty("distinct_targets", distinct_targets);
|
344
|
+
serializer.WriteOptionalProperty("order_by", order_by);
|
345
|
+
}
|
346
|
+
|
347
|
+
unique_ptr<LogicalOperator> LogicalDistinct::FormatDeserialize(FormatDeserializer &deserializer) {
|
348
|
+
auto distinct_type = deserializer.ReadProperty<DistinctType>("distinct_type");
|
349
|
+
auto distinct_targets = deserializer.ReadProperty<vector<unique_ptr<Expression>>>("distinct_targets");
|
350
|
+
auto result = duckdb::unique_ptr<LogicalDistinct>(new LogicalDistinct(std::move(distinct_targets), distinct_type));
|
351
|
+
deserializer.ReadOptionalProperty("order_by", result->order_by);
|
352
|
+
return std::move(result);
|
353
|
+
}
|
354
|
+
|
355
|
+
void LogicalDummyScan::FormatSerialize(FormatSerializer &serializer) const {
|
356
|
+
LogicalOperator::FormatSerialize(serializer);
|
357
|
+
serializer.WriteProperty("table_index", table_index);
|
358
|
+
}
|
359
|
+
|
360
|
+
unique_ptr<LogicalOperator> LogicalDummyScan::FormatDeserialize(FormatDeserializer &deserializer) {
|
361
|
+
auto table_index = deserializer.ReadProperty<idx_t>("table_index");
|
362
|
+
auto result = duckdb::unique_ptr<LogicalDummyScan>(new LogicalDummyScan(table_index));
|
363
|
+
return std::move(result);
|
364
|
+
}
|
365
|
+
|
366
|
+
void LogicalEmptyResult::FormatSerialize(FormatSerializer &serializer) const {
|
367
|
+
LogicalOperator::FormatSerialize(serializer);
|
368
|
+
serializer.WriteProperty("return_types", return_types);
|
369
|
+
serializer.WriteProperty("bindings", bindings);
|
370
|
+
}
|
371
|
+
|
372
|
+
unique_ptr<LogicalOperator> LogicalEmptyResult::FormatDeserialize(FormatDeserializer &deserializer) {
|
373
|
+
auto result = duckdb::unique_ptr<LogicalEmptyResult>(new LogicalEmptyResult());
|
374
|
+
deserializer.ReadProperty("return_types", result->return_types);
|
375
|
+
deserializer.ReadProperty("bindings", result->bindings);
|
376
|
+
return std::move(result);
|
377
|
+
}
|
378
|
+
|
379
|
+
void LogicalExplain::FormatSerialize(FormatSerializer &serializer) const {
|
380
|
+
LogicalOperator::FormatSerialize(serializer);
|
381
|
+
serializer.WriteProperty("explain_type", explain_type);
|
382
|
+
serializer.WriteProperty("physical_plan", physical_plan);
|
383
|
+
serializer.WriteProperty("logical_plan_unopt", logical_plan_unopt);
|
384
|
+
serializer.WriteProperty("logical_plan_opt", logical_plan_opt);
|
385
|
+
}
|
386
|
+
|
387
|
+
unique_ptr<LogicalOperator> LogicalExplain::FormatDeserialize(FormatDeserializer &deserializer) {
|
388
|
+
auto explain_type = deserializer.ReadProperty<ExplainType>("explain_type");
|
389
|
+
auto result = duckdb::unique_ptr<LogicalExplain>(new LogicalExplain(explain_type));
|
390
|
+
deserializer.ReadProperty("physical_plan", result->physical_plan);
|
391
|
+
deserializer.ReadProperty("logical_plan_unopt", result->logical_plan_unopt);
|
392
|
+
deserializer.ReadProperty("logical_plan_opt", result->logical_plan_opt);
|
393
|
+
return std::move(result);
|
394
|
+
}
|
395
|
+
|
396
|
+
void LogicalExpressionGet::FormatSerialize(FormatSerializer &serializer) const {
|
397
|
+
LogicalOperator::FormatSerialize(serializer);
|
398
|
+
serializer.WriteProperty("table_index", table_index);
|
399
|
+
serializer.WriteProperty("expr_types", expr_types);
|
400
|
+
serializer.WriteProperty("expressions", expressions);
|
401
|
+
}
|
402
|
+
|
403
|
+
unique_ptr<LogicalOperator> LogicalExpressionGet::FormatDeserialize(FormatDeserializer &deserializer) {
|
404
|
+
auto table_index = deserializer.ReadProperty<idx_t>("table_index");
|
405
|
+
auto expr_types = deserializer.ReadProperty<vector<LogicalType>>("expr_types");
|
406
|
+
auto expressions = deserializer.ReadProperty<vector<vector<unique_ptr<Expression>>>>("expressions");
|
407
|
+
auto result = duckdb::unique_ptr<LogicalExpressionGet>(new LogicalExpressionGet(table_index, std::move(expr_types), std::move(expressions)));
|
408
|
+
return std::move(result);
|
409
|
+
}
|
410
|
+
|
411
|
+
void LogicalFilter::FormatSerialize(FormatSerializer &serializer) const {
|
412
|
+
LogicalOperator::FormatSerialize(serializer);
|
413
|
+
serializer.WriteProperty("expressions", expressions);
|
414
|
+
serializer.WriteProperty("projection_map", projection_map);
|
415
|
+
}
|
416
|
+
|
417
|
+
unique_ptr<LogicalOperator> LogicalFilter::FormatDeserialize(FormatDeserializer &deserializer) {
|
418
|
+
auto result = duckdb::unique_ptr<LogicalFilter>(new LogicalFilter());
|
419
|
+
deserializer.ReadProperty("expressions", result->expressions);
|
420
|
+
deserializer.ReadProperty("projection_map", result->projection_map);
|
421
|
+
return std::move(result);
|
422
|
+
}
|
423
|
+
|
424
|
+
void LogicalInsert::FormatSerialize(FormatSerializer &serializer) const {
|
425
|
+
LogicalOperator::FormatSerialize(serializer);
|
426
|
+
serializer.WriteProperty("catalog", table.ParentCatalog().GetName());
|
427
|
+
serializer.WriteProperty("schema", table.ParentSchema().name);
|
428
|
+
serializer.WriteProperty("table", table.name);
|
429
|
+
serializer.WriteProperty("insert_values", insert_values);
|
430
|
+
serializer.WriteProperty("column_index_map", column_index_map);
|
431
|
+
serializer.WriteProperty("expected_types", expected_types);
|
432
|
+
serializer.WriteProperty("table_index", table_index);
|
433
|
+
serializer.WriteProperty("return_chunk", return_chunk);
|
434
|
+
serializer.WriteProperty("bound_defaults", bound_defaults);
|
435
|
+
serializer.WriteProperty("action_type", action_type);
|
436
|
+
serializer.WriteProperty("expected_set_types", expected_set_types);
|
437
|
+
serializer.WriteProperty("on_conflict_filter", on_conflict_filter);
|
438
|
+
serializer.WriteOptionalProperty("on_conflict_condition", on_conflict_condition);
|
439
|
+
serializer.WriteOptionalProperty("do_update_condition", do_update_condition);
|
440
|
+
serializer.WriteProperty("set_columns", set_columns);
|
441
|
+
serializer.WriteProperty("set_types", set_types);
|
442
|
+
serializer.WriteProperty("excluded_table_index", excluded_table_index);
|
443
|
+
serializer.WriteProperty("columns_to_fetch", columns_to_fetch);
|
444
|
+
serializer.WriteProperty("source_columns", source_columns);
|
445
|
+
}
|
446
|
+
|
447
|
+
unique_ptr<LogicalOperator> LogicalInsert::FormatDeserialize(FormatDeserializer &deserializer) {
|
448
|
+
auto catalog = deserializer.ReadProperty<string>("catalog");
|
449
|
+
auto schema = deserializer.ReadProperty<string>("schema");
|
450
|
+
auto table = deserializer.ReadProperty<string>("table");
|
451
|
+
auto result = duckdb::unique_ptr<LogicalInsert>(new LogicalInsert(deserializer.Get<ClientContext &>(), catalog, schema, table));
|
452
|
+
deserializer.ReadProperty("insert_values", result->insert_values);
|
453
|
+
deserializer.ReadProperty("column_index_map", result->column_index_map);
|
454
|
+
deserializer.ReadProperty("expected_types", result->expected_types);
|
455
|
+
deserializer.ReadProperty("table_index", result->table_index);
|
456
|
+
deserializer.ReadProperty("return_chunk", result->return_chunk);
|
457
|
+
deserializer.ReadProperty("bound_defaults", result->bound_defaults);
|
458
|
+
deserializer.ReadProperty("action_type", result->action_type);
|
459
|
+
deserializer.ReadProperty("expected_set_types", result->expected_set_types);
|
460
|
+
deserializer.ReadProperty("on_conflict_filter", result->on_conflict_filter);
|
461
|
+
deserializer.ReadOptionalProperty("on_conflict_condition", result->on_conflict_condition);
|
462
|
+
deserializer.ReadOptionalProperty("do_update_condition", result->do_update_condition);
|
463
|
+
deserializer.ReadProperty("set_columns", result->set_columns);
|
464
|
+
deserializer.ReadProperty("set_types", result->set_types);
|
465
|
+
deserializer.ReadProperty("excluded_table_index", result->excluded_table_index);
|
466
|
+
deserializer.ReadProperty("columns_to_fetch", result->columns_to_fetch);
|
467
|
+
deserializer.ReadProperty("source_columns", result->source_columns);
|
468
|
+
return std::move(result);
|
469
|
+
}
|
470
|
+
|
471
|
+
void LogicalLimit::FormatSerialize(FormatSerializer &serializer) const {
|
472
|
+
LogicalOperator::FormatSerialize(serializer);
|
473
|
+
serializer.WriteProperty("limit_val", limit_val);
|
474
|
+
serializer.WriteProperty("offset_val", offset_val);
|
475
|
+
serializer.WriteOptionalProperty("limit", limit);
|
476
|
+
serializer.WriteOptionalProperty("offset", offset);
|
477
|
+
}
|
478
|
+
|
479
|
+
unique_ptr<LogicalOperator> LogicalLimit::FormatDeserialize(FormatDeserializer &deserializer) {
|
480
|
+
auto limit_val = deserializer.ReadProperty<int64_t>("limit_val");
|
481
|
+
auto offset_val = deserializer.ReadProperty<int64_t>("offset_val");
|
482
|
+
auto limit = deserializer.ReadOptionalProperty<unique_ptr<Expression>>("limit");
|
483
|
+
auto offset = deserializer.ReadOptionalProperty<unique_ptr<Expression>>("offset");
|
484
|
+
auto result = duckdb::unique_ptr<LogicalLimit>(new LogicalLimit(limit_val, offset_val, std::move(limit), std::move(offset)));
|
485
|
+
return std::move(result);
|
486
|
+
}
|
487
|
+
|
488
|
+
void LogicalLimitPercent::FormatSerialize(FormatSerializer &serializer) const {
|
489
|
+
LogicalOperator::FormatSerialize(serializer);
|
490
|
+
serializer.WriteProperty("limit_percent", limit_percent);
|
491
|
+
serializer.WriteProperty("offset_val", offset_val);
|
492
|
+
serializer.WriteOptionalProperty("limit", limit);
|
493
|
+
serializer.WriteOptionalProperty("offset", offset);
|
494
|
+
}
|
495
|
+
|
496
|
+
unique_ptr<LogicalOperator> LogicalLimitPercent::FormatDeserialize(FormatDeserializer &deserializer) {
|
497
|
+
auto limit_percent = deserializer.ReadProperty<double>("limit_percent");
|
498
|
+
auto offset_val = deserializer.ReadProperty<int64_t>("offset_val");
|
499
|
+
auto limit = deserializer.ReadOptionalProperty<unique_ptr<Expression>>("limit");
|
500
|
+
auto offset = deserializer.ReadOptionalProperty<unique_ptr<Expression>>("offset");
|
501
|
+
auto result = duckdb::unique_ptr<LogicalLimitPercent>(new LogicalLimitPercent(limit_percent, offset_val, std::move(limit), std::move(offset)));
|
502
|
+
return std::move(result);
|
503
|
+
}
|
504
|
+
|
505
|
+
void LogicalMaterializedCTE::FormatSerialize(FormatSerializer &serializer) const {
|
506
|
+
LogicalOperator::FormatSerialize(serializer);
|
507
|
+
serializer.WriteProperty("table_index", table_index);
|
508
|
+
serializer.WriteProperty("column_count", column_count);
|
509
|
+
serializer.WriteProperty("ctename", ctename);
|
510
|
+
}
|
511
|
+
|
512
|
+
unique_ptr<LogicalOperator> LogicalMaterializedCTE::FormatDeserialize(FormatDeserializer &deserializer) {
|
513
|
+
auto result = duckdb::unique_ptr<LogicalMaterializedCTE>(new LogicalMaterializedCTE());
|
514
|
+
deserializer.ReadProperty("table_index", result->table_index);
|
515
|
+
deserializer.ReadProperty("column_count", result->column_count);
|
516
|
+
deserializer.ReadProperty("ctename", result->ctename);
|
517
|
+
return std::move(result);
|
518
|
+
}
|
519
|
+
|
520
|
+
void LogicalOrder::FormatSerialize(FormatSerializer &serializer) const {
|
521
|
+
LogicalOperator::FormatSerialize(serializer);
|
522
|
+
serializer.WriteProperty("orders", orders);
|
523
|
+
serializer.WriteProperty("projections", projections);
|
524
|
+
}
|
525
|
+
|
526
|
+
unique_ptr<LogicalOperator> LogicalOrder::FormatDeserialize(FormatDeserializer &deserializer) {
|
527
|
+
auto orders = deserializer.ReadProperty<vector<BoundOrderByNode>>("orders");
|
528
|
+
auto result = duckdb::unique_ptr<LogicalOrder>(new LogicalOrder(std::move(orders)));
|
529
|
+
deserializer.ReadProperty("projections", result->projections);
|
530
|
+
return std::move(result);
|
531
|
+
}
|
532
|
+
|
533
|
+
void LogicalPivot::FormatSerialize(FormatSerializer &serializer) const {
|
534
|
+
LogicalOperator::FormatSerialize(serializer);
|
535
|
+
serializer.WriteProperty("pivot_index", pivot_index);
|
536
|
+
serializer.WriteProperty("bound_pivot", bound_pivot);
|
537
|
+
}
|
538
|
+
|
539
|
+
unique_ptr<LogicalOperator> LogicalPivot::FormatDeserialize(FormatDeserializer &deserializer) {
|
540
|
+
auto result = duckdb::unique_ptr<LogicalPivot>(new LogicalPivot());
|
541
|
+
deserializer.ReadProperty("pivot_index", result->pivot_index);
|
542
|
+
deserializer.ReadProperty("bound_pivot", result->bound_pivot);
|
543
|
+
return std::move(result);
|
544
|
+
}
|
545
|
+
|
546
|
+
void LogicalPositionalJoin::FormatSerialize(FormatSerializer &serializer) const {
|
547
|
+
LogicalOperator::FormatSerialize(serializer);
|
548
|
+
}
|
549
|
+
|
550
|
+
unique_ptr<LogicalOperator> LogicalPositionalJoin::FormatDeserialize(FormatDeserializer &deserializer) {
|
551
|
+
auto result = duckdb::unique_ptr<LogicalPositionalJoin>(new LogicalPositionalJoin());
|
552
|
+
return std::move(result);
|
553
|
+
}
|
554
|
+
|
555
|
+
void LogicalProjection::FormatSerialize(FormatSerializer &serializer) const {
|
556
|
+
LogicalOperator::FormatSerialize(serializer);
|
557
|
+
serializer.WriteProperty("table_index", table_index);
|
558
|
+
serializer.WriteProperty("expressions", expressions);
|
559
|
+
}
|
560
|
+
|
561
|
+
unique_ptr<LogicalOperator> LogicalProjection::FormatDeserialize(FormatDeserializer &deserializer) {
|
562
|
+
auto table_index = deserializer.ReadProperty<idx_t>("table_index");
|
563
|
+
auto expressions = deserializer.ReadProperty<vector<unique_ptr<Expression>>>("expressions");
|
564
|
+
auto result = duckdb::unique_ptr<LogicalProjection>(new LogicalProjection(table_index, std::move(expressions)));
|
565
|
+
return std::move(result);
|
566
|
+
}
|
567
|
+
|
568
|
+
void LogicalRecursiveCTE::FormatSerialize(FormatSerializer &serializer) const {
|
569
|
+
LogicalOperator::FormatSerialize(serializer);
|
570
|
+
serializer.WriteProperty("union_all", union_all);
|
571
|
+
serializer.WriteProperty("ctename", ctename);
|
572
|
+
serializer.WriteProperty("table_index", table_index);
|
573
|
+
serializer.WriteProperty("column_count", column_count);
|
574
|
+
}
|
575
|
+
|
576
|
+
unique_ptr<LogicalOperator> LogicalRecursiveCTE::FormatDeserialize(FormatDeserializer &deserializer) {
|
577
|
+
auto result = duckdb::unique_ptr<LogicalRecursiveCTE>(new LogicalRecursiveCTE());
|
578
|
+
deserializer.ReadProperty("union_all", result->union_all);
|
579
|
+
deserializer.ReadProperty("ctename", result->ctename);
|
580
|
+
deserializer.ReadProperty("table_index", result->table_index);
|
581
|
+
deserializer.ReadProperty("column_count", result->column_count);
|
582
|
+
return std::move(result);
|
583
|
+
}
|
584
|
+
|
585
|
+
void LogicalReset::FormatSerialize(FormatSerializer &serializer) const {
|
586
|
+
LogicalOperator::FormatSerialize(serializer);
|
587
|
+
serializer.WriteProperty("name", name);
|
588
|
+
serializer.WriteProperty("scope", scope);
|
589
|
+
}
|
590
|
+
|
591
|
+
unique_ptr<LogicalOperator> LogicalReset::FormatDeserialize(FormatDeserializer &deserializer) {
|
592
|
+
auto name = deserializer.ReadProperty<string>("name");
|
593
|
+
auto scope = deserializer.ReadProperty<SetScope>("scope");
|
594
|
+
auto result = duckdb::unique_ptr<LogicalReset>(new LogicalReset(std::move(name), scope));
|
595
|
+
return std::move(result);
|
596
|
+
}
|
597
|
+
|
598
|
+
void LogicalSample::FormatSerialize(FormatSerializer &serializer) const {
|
599
|
+
LogicalOperator::FormatSerialize(serializer);
|
600
|
+
serializer.WriteProperty("sample_options", sample_options);
|
601
|
+
}
|
602
|
+
|
603
|
+
unique_ptr<LogicalOperator> LogicalSample::FormatDeserialize(FormatDeserializer &deserializer) {
|
604
|
+
auto result = duckdb::unique_ptr<LogicalSample>(new LogicalSample());
|
605
|
+
deserializer.ReadProperty("sample_options", result->sample_options);
|
606
|
+
return std::move(result);
|
607
|
+
}
|
608
|
+
|
609
|
+
void LogicalSet::FormatSerialize(FormatSerializer &serializer) const {
|
610
|
+
LogicalOperator::FormatSerialize(serializer);
|
611
|
+
serializer.WriteProperty("name", name);
|
612
|
+
serializer.WriteProperty("value", value);
|
613
|
+
serializer.WriteProperty("scope", scope);
|
614
|
+
}
|
615
|
+
|
616
|
+
unique_ptr<LogicalOperator> LogicalSet::FormatDeserialize(FormatDeserializer &deserializer) {
|
617
|
+
auto name = deserializer.ReadProperty<string>("name");
|
618
|
+
auto value = deserializer.ReadProperty<Value>("value");
|
619
|
+
auto scope = deserializer.ReadProperty<SetScope>("scope");
|
620
|
+
auto result = duckdb::unique_ptr<LogicalSet>(new LogicalSet(std::move(name), value, scope));
|
621
|
+
return std::move(result);
|
622
|
+
}
|
623
|
+
|
624
|
+
void LogicalSetOperation::FormatSerialize(FormatSerializer &serializer) const {
|
625
|
+
LogicalOperator::FormatSerialize(serializer);
|
626
|
+
serializer.WriteProperty("table_index", table_index);
|
627
|
+
serializer.WriteProperty("column_count", column_count);
|
628
|
+
}
|
629
|
+
|
630
|
+
unique_ptr<LogicalOperator> LogicalSetOperation::FormatDeserialize(FormatDeserializer &deserializer) {
|
631
|
+
auto table_index = deserializer.ReadProperty<idx_t>("table_index");
|
632
|
+
auto column_count = deserializer.ReadProperty<idx_t>("column_count");
|
633
|
+
auto result = duckdb::unique_ptr<LogicalSetOperation>(new LogicalSetOperation(table_index, column_count, deserializer.Get<LogicalOperatorType>()));
|
634
|
+
return std::move(result);
|
635
|
+
}
|
636
|
+
|
637
|
+
void LogicalShow::FormatSerialize(FormatSerializer &serializer) const {
|
638
|
+
LogicalOperator::FormatSerialize(serializer);
|
639
|
+
serializer.WriteProperty("types_select", types_select);
|
640
|
+
serializer.WriteProperty("aliases", aliases);
|
641
|
+
}
|
642
|
+
|
643
|
+
unique_ptr<LogicalOperator> LogicalShow::FormatDeserialize(FormatDeserializer &deserializer) {
|
644
|
+
auto result = duckdb::unique_ptr<LogicalShow>(new LogicalShow());
|
645
|
+
deserializer.ReadProperty("types_select", result->types_select);
|
646
|
+
deserializer.ReadProperty("aliases", result->aliases);
|
647
|
+
return std::move(result);
|
648
|
+
}
|
649
|
+
|
650
|
+
void LogicalSimple::FormatSerialize(FormatSerializer &serializer) const {
|
651
|
+
LogicalOperator::FormatSerialize(serializer);
|
652
|
+
serializer.WriteProperty("info", *info);
|
653
|
+
}
|
654
|
+
|
655
|
+
unique_ptr<LogicalOperator> LogicalSimple::FormatDeserialize(FormatDeserializer &deserializer) {
|
656
|
+
auto info = deserializer.ReadProperty<unique_ptr<ParseInfo>>("info");
|
657
|
+
auto result = duckdb::unique_ptr<LogicalSimple>(new LogicalSimple(deserializer.Get<LogicalOperatorType>(), std::move(info)));
|
658
|
+
return std::move(result);
|
659
|
+
}
|
660
|
+
|
661
|
+
void LogicalTopN::FormatSerialize(FormatSerializer &serializer) const {
|
662
|
+
LogicalOperator::FormatSerialize(serializer);
|
663
|
+
serializer.WriteProperty("orders", orders);
|
664
|
+
serializer.WriteProperty("limit", limit);
|
665
|
+
serializer.WriteProperty("offset", offset);
|
666
|
+
}
|
667
|
+
|
668
|
+
unique_ptr<LogicalOperator> LogicalTopN::FormatDeserialize(FormatDeserializer &deserializer) {
|
669
|
+
auto orders = deserializer.ReadProperty<vector<BoundOrderByNode>>("orders");
|
670
|
+
auto limit = deserializer.ReadProperty<idx_t>("limit");
|
671
|
+
auto offset = deserializer.ReadProperty<idx_t>("offset");
|
672
|
+
auto result = duckdb::unique_ptr<LogicalTopN>(new LogicalTopN(std::move(orders), limit, offset));
|
673
|
+
return std::move(result);
|
674
|
+
}
|
675
|
+
|
676
|
+
void LogicalUnnest::FormatSerialize(FormatSerializer &serializer) const {
|
677
|
+
LogicalOperator::FormatSerialize(serializer);
|
678
|
+
serializer.WriteProperty("unnest_index", unnest_index);
|
679
|
+
serializer.WriteProperty("expressions", expressions);
|
680
|
+
}
|
681
|
+
|
682
|
+
unique_ptr<LogicalOperator> LogicalUnnest::FormatDeserialize(FormatDeserializer &deserializer) {
|
683
|
+
auto unnest_index = deserializer.ReadProperty<idx_t>("unnest_index");
|
684
|
+
auto result = duckdb::unique_ptr<LogicalUnnest>(new LogicalUnnest(unnest_index));
|
685
|
+
deserializer.ReadProperty("expressions", result->expressions);
|
686
|
+
return std::move(result);
|
687
|
+
}
|
688
|
+
|
689
|
+
void LogicalUpdate::FormatSerialize(FormatSerializer &serializer) const {
|
690
|
+
LogicalOperator::FormatSerialize(serializer);
|
691
|
+
serializer.WriteProperty("catalog", table.ParentCatalog().GetName());
|
692
|
+
serializer.WriteProperty("schema", table.ParentSchema().name);
|
693
|
+
serializer.WriteProperty("table", table.name);
|
694
|
+
serializer.WriteProperty("table_index", table_index);
|
695
|
+
serializer.WriteProperty("return_chunk", return_chunk);
|
696
|
+
serializer.WriteProperty("expressions", expressions);
|
697
|
+
serializer.WriteProperty("columns", columns);
|
698
|
+
serializer.WriteProperty("bound_defaults", bound_defaults);
|
699
|
+
serializer.WriteProperty("update_is_del_and_insert", update_is_del_and_insert);
|
700
|
+
}
|
701
|
+
|
702
|
+
unique_ptr<LogicalOperator> LogicalUpdate::FormatDeserialize(FormatDeserializer &deserializer) {
|
703
|
+
auto catalog = deserializer.ReadProperty<string>("catalog");
|
704
|
+
auto schema = deserializer.ReadProperty<string>("schema");
|
705
|
+
auto table = deserializer.ReadProperty<string>("table");
|
706
|
+
auto result = duckdb::unique_ptr<LogicalUpdate>(new LogicalUpdate(deserializer.Get<ClientContext &>(), catalog, schema, table));
|
707
|
+
deserializer.ReadProperty("table_index", result->table_index);
|
708
|
+
deserializer.ReadProperty("return_chunk", result->return_chunk);
|
709
|
+
deserializer.ReadProperty("expressions", result->expressions);
|
710
|
+
deserializer.ReadProperty("columns", result->columns);
|
711
|
+
deserializer.ReadProperty("bound_defaults", result->bound_defaults);
|
712
|
+
deserializer.ReadProperty("update_is_del_and_insert", result->update_is_del_and_insert);
|
713
|
+
return std::move(result);
|
714
|
+
}
|
715
|
+
|
716
|
+
void LogicalWindow::FormatSerialize(FormatSerializer &serializer) const {
|
717
|
+
LogicalOperator::FormatSerialize(serializer);
|
718
|
+
serializer.WriteProperty("window_index", window_index);
|
719
|
+
serializer.WriteProperty("expressions", expressions);
|
720
|
+
}
|
721
|
+
|
722
|
+
unique_ptr<LogicalOperator> LogicalWindow::FormatDeserialize(FormatDeserializer &deserializer) {
|
723
|
+
auto window_index = deserializer.ReadProperty<idx_t>("window_index");
|
724
|
+
auto result = duckdb::unique_ptr<LogicalWindow>(new LogicalWindow(window_index));
|
725
|
+
deserializer.ReadProperty("expressions", result->expressions);
|
726
|
+
return std::move(result);
|
727
|
+
}
|
728
|
+
|
729
|
+
} // namespace duckdb
|