duckdb 0.8.2-dev1968.0 → 0.8.2-dev2044.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/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/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/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/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/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/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,419 @@
|
|
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/parser/parsed_data/parse_info.hpp"
|
9
|
+
#include "duckdb/parser/parsed_data/alter_info.hpp"
|
10
|
+
#include "duckdb/parser/parsed_data/alter_table_info.hpp"
|
11
|
+
#include "duckdb/parser/parsed_data/attach_info.hpp"
|
12
|
+
#include "duckdb/parser/parsed_data/copy_info.hpp"
|
13
|
+
#include "duckdb/parser/parsed_data/detach_info.hpp"
|
14
|
+
#include "duckdb/parser/parsed_data/drop_info.hpp"
|
15
|
+
#include "duckdb/parser/parsed_data/load_info.hpp"
|
16
|
+
#include "duckdb/parser/parsed_data/pragma_info.hpp"
|
17
|
+
#include "duckdb/parser/parsed_data/transaction_info.hpp"
|
18
|
+
#include "duckdb/parser/parsed_data/vacuum_info.hpp"
|
19
|
+
|
20
|
+
namespace duckdb {
|
21
|
+
|
22
|
+
void ParseInfo::FormatSerialize(FormatSerializer &serializer) const {
|
23
|
+
serializer.WriteProperty("info_type", info_type);
|
24
|
+
}
|
25
|
+
|
26
|
+
unique_ptr<ParseInfo> ParseInfo::FormatDeserialize(FormatDeserializer &deserializer) {
|
27
|
+
auto info_type = deserializer.ReadProperty<ParseInfoType>("info_type");
|
28
|
+
unique_ptr<ParseInfo> result;
|
29
|
+
switch (info_type) {
|
30
|
+
case ParseInfoType::ALTER_INFO:
|
31
|
+
result = AlterInfo::FormatDeserialize(deserializer);
|
32
|
+
break;
|
33
|
+
case ParseInfoType::ATTACH_INFO:
|
34
|
+
result = AttachInfo::FormatDeserialize(deserializer);
|
35
|
+
break;
|
36
|
+
case ParseInfoType::COPY_INFO:
|
37
|
+
result = CopyInfo::FormatDeserialize(deserializer);
|
38
|
+
break;
|
39
|
+
case ParseInfoType::DETACH_INFO:
|
40
|
+
result = DetachInfo::FormatDeserialize(deserializer);
|
41
|
+
break;
|
42
|
+
case ParseInfoType::DROP_INFO:
|
43
|
+
result = DropInfo::FormatDeserialize(deserializer);
|
44
|
+
break;
|
45
|
+
case ParseInfoType::LOAD_INFO:
|
46
|
+
result = LoadInfo::FormatDeserialize(deserializer);
|
47
|
+
break;
|
48
|
+
case ParseInfoType::PRAGMA_INFO:
|
49
|
+
result = PragmaInfo::FormatDeserialize(deserializer);
|
50
|
+
break;
|
51
|
+
case ParseInfoType::TRANSACTION_INFO:
|
52
|
+
result = TransactionInfo::FormatDeserialize(deserializer);
|
53
|
+
break;
|
54
|
+
case ParseInfoType::VACUUM_INFO:
|
55
|
+
result = VacuumInfo::FormatDeserialize(deserializer);
|
56
|
+
break;
|
57
|
+
default:
|
58
|
+
throw SerializationException("Unsupported type for deserialization of ParseInfo!");
|
59
|
+
}
|
60
|
+
return result;
|
61
|
+
}
|
62
|
+
|
63
|
+
void AlterInfo::FormatSerialize(FormatSerializer &serializer) const {
|
64
|
+
ParseInfo::FormatSerialize(serializer);
|
65
|
+
serializer.WriteProperty("type", type);
|
66
|
+
serializer.WriteProperty("catalog", catalog);
|
67
|
+
serializer.WriteProperty("schema", schema);
|
68
|
+
serializer.WriteProperty("name", name);
|
69
|
+
serializer.WriteProperty("if_not_found", if_not_found);
|
70
|
+
serializer.WriteProperty("allow_internal", allow_internal);
|
71
|
+
}
|
72
|
+
|
73
|
+
unique_ptr<ParseInfo> AlterInfo::FormatDeserialize(FormatDeserializer &deserializer) {
|
74
|
+
auto type = deserializer.ReadProperty<AlterType>("type");
|
75
|
+
auto catalog = deserializer.ReadProperty<string>("catalog");
|
76
|
+
auto schema = deserializer.ReadProperty<string>("schema");
|
77
|
+
auto name = deserializer.ReadProperty<string>("name");
|
78
|
+
auto if_not_found = deserializer.ReadProperty<OnEntryNotFound>("if_not_found");
|
79
|
+
auto allow_internal = deserializer.ReadProperty<bool>("allow_internal");
|
80
|
+
unique_ptr<AlterInfo> result;
|
81
|
+
switch (type) {
|
82
|
+
case AlterType::ALTER_TABLE:
|
83
|
+
result = AlterTableInfo::FormatDeserialize(deserializer);
|
84
|
+
break;
|
85
|
+
case AlterType::ALTER_VIEW:
|
86
|
+
result = AlterViewInfo::FormatDeserialize(deserializer);
|
87
|
+
break;
|
88
|
+
default:
|
89
|
+
throw SerializationException("Unsupported type for deserialization of AlterInfo!");
|
90
|
+
}
|
91
|
+
result->catalog = std::move(catalog);
|
92
|
+
result->schema = std::move(schema);
|
93
|
+
result->name = std::move(name);
|
94
|
+
result->if_not_found = if_not_found;
|
95
|
+
result->allow_internal = allow_internal;
|
96
|
+
return std::move(result);
|
97
|
+
}
|
98
|
+
|
99
|
+
void AlterTableInfo::FormatSerialize(FormatSerializer &serializer) const {
|
100
|
+
AlterInfo::FormatSerialize(serializer);
|
101
|
+
serializer.WriteProperty("alter_table_type", alter_table_type);
|
102
|
+
}
|
103
|
+
|
104
|
+
unique_ptr<AlterInfo> AlterTableInfo::FormatDeserialize(FormatDeserializer &deserializer) {
|
105
|
+
auto alter_table_type = deserializer.ReadProperty<AlterTableType>("alter_table_type");
|
106
|
+
unique_ptr<AlterTableInfo> result;
|
107
|
+
switch (alter_table_type) {
|
108
|
+
case AlterTableType::ADD_COLUMN:
|
109
|
+
result = AddColumnInfo::FormatDeserialize(deserializer);
|
110
|
+
break;
|
111
|
+
case AlterTableType::ALTER_COLUMN_TYPE:
|
112
|
+
result = ChangeColumnTypeInfo::FormatDeserialize(deserializer);
|
113
|
+
break;
|
114
|
+
case AlterTableType::DROP_NOT_NULL:
|
115
|
+
result = DropNotNullInfo::FormatDeserialize(deserializer);
|
116
|
+
break;
|
117
|
+
case AlterTableType::FOREIGN_KEY_CONSTRAINT:
|
118
|
+
result = AlterForeignKeyInfo::FormatDeserialize(deserializer);
|
119
|
+
break;
|
120
|
+
case AlterTableType::REMOVE_COLUMN:
|
121
|
+
result = RemoveColumnInfo::FormatDeserialize(deserializer);
|
122
|
+
break;
|
123
|
+
case AlterTableType::RENAME_COLUMN:
|
124
|
+
result = RenameColumnInfo::FormatDeserialize(deserializer);
|
125
|
+
break;
|
126
|
+
case AlterTableType::RENAME_TABLE:
|
127
|
+
result = RenameTableInfo::FormatDeserialize(deserializer);
|
128
|
+
break;
|
129
|
+
case AlterTableType::SET_DEFAULT:
|
130
|
+
result = SetDefaultInfo::FormatDeserialize(deserializer);
|
131
|
+
break;
|
132
|
+
case AlterTableType::SET_NOT_NULL:
|
133
|
+
result = SetNotNullInfo::FormatDeserialize(deserializer);
|
134
|
+
break;
|
135
|
+
default:
|
136
|
+
throw SerializationException("Unsupported type for deserialization of AlterTableInfo!");
|
137
|
+
}
|
138
|
+
return std::move(result);
|
139
|
+
}
|
140
|
+
|
141
|
+
void AlterViewInfo::FormatSerialize(FormatSerializer &serializer) const {
|
142
|
+
AlterInfo::FormatSerialize(serializer);
|
143
|
+
serializer.WriteProperty("alter_view_type", alter_view_type);
|
144
|
+
}
|
145
|
+
|
146
|
+
unique_ptr<AlterInfo> AlterViewInfo::FormatDeserialize(FormatDeserializer &deserializer) {
|
147
|
+
auto alter_view_type = deserializer.ReadProperty<AlterViewType>("alter_view_type");
|
148
|
+
unique_ptr<AlterViewInfo> result;
|
149
|
+
switch (alter_view_type) {
|
150
|
+
case AlterViewType::RENAME_VIEW:
|
151
|
+
result = RenameViewInfo::FormatDeserialize(deserializer);
|
152
|
+
break;
|
153
|
+
default:
|
154
|
+
throw SerializationException("Unsupported type for deserialization of AlterViewInfo!");
|
155
|
+
}
|
156
|
+
return std::move(result);
|
157
|
+
}
|
158
|
+
|
159
|
+
void AddColumnInfo::FormatSerialize(FormatSerializer &serializer) const {
|
160
|
+
AlterTableInfo::FormatSerialize(serializer);
|
161
|
+
serializer.WriteProperty("new_column", new_column);
|
162
|
+
serializer.WriteProperty("if_column_not_exists", if_column_not_exists);
|
163
|
+
}
|
164
|
+
|
165
|
+
unique_ptr<AlterTableInfo> AddColumnInfo::FormatDeserialize(FormatDeserializer &deserializer) {
|
166
|
+
auto new_column = deserializer.ReadProperty<ColumnDefinition>("new_column");
|
167
|
+
auto result = duckdb::unique_ptr<AddColumnInfo>(new AddColumnInfo(std::move(new_column)));
|
168
|
+
deserializer.ReadProperty("if_column_not_exists", result->if_column_not_exists);
|
169
|
+
return std::move(result);
|
170
|
+
}
|
171
|
+
|
172
|
+
void AlterForeignKeyInfo::FormatSerialize(FormatSerializer &serializer) const {
|
173
|
+
AlterTableInfo::FormatSerialize(serializer);
|
174
|
+
serializer.WriteProperty("fk_table", fk_table);
|
175
|
+
serializer.WriteProperty("pk_columns", pk_columns);
|
176
|
+
serializer.WriteProperty("fk_columns", fk_columns);
|
177
|
+
serializer.WriteProperty("pk_keys", pk_keys);
|
178
|
+
serializer.WriteProperty("fk_keys", fk_keys);
|
179
|
+
serializer.WriteProperty("type", type);
|
180
|
+
}
|
181
|
+
|
182
|
+
unique_ptr<AlterTableInfo> AlterForeignKeyInfo::FormatDeserialize(FormatDeserializer &deserializer) {
|
183
|
+
auto result = duckdb::unique_ptr<AlterForeignKeyInfo>(new AlterForeignKeyInfo());
|
184
|
+
deserializer.ReadProperty("fk_table", result->fk_table);
|
185
|
+
deserializer.ReadProperty("pk_columns", result->pk_columns);
|
186
|
+
deserializer.ReadProperty("fk_columns", result->fk_columns);
|
187
|
+
deserializer.ReadProperty("pk_keys", result->pk_keys);
|
188
|
+
deserializer.ReadProperty("fk_keys", result->fk_keys);
|
189
|
+
deserializer.ReadProperty("type", result->type);
|
190
|
+
return std::move(result);
|
191
|
+
}
|
192
|
+
|
193
|
+
void AttachInfo::FormatSerialize(FormatSerializer &serializer) const {
|
194
|
+
ParseInfo::FormatSerialize(serializer);
|
195
|
+
serializer.WriteProperty("name", name);
|
196
|
+
serializer.WriteProperty("path", path);
|
197
|
+
serializer.WriteProperty("options", options);
|
198
|
+
}
|
199
|
+
|
200
|
+
unique_ptr<ParseInfo> AttachInfo::FormatDeserialize(FormatDeserializer &deserializer) {
|
201
|
+
auto result = duckdb::unique_ptr<AttachInfo>(new AttachInfo());
|
202
|
+
deserializer.ReadProperty("name", result->name);
|
203
|
+
deserializer.ReadProperty("path", result->path);
|
204
|
+
deserializer.ReadProperty("options", result->options);
|
205
|
+
return std::move(result);
|
206
|
+
}
|
207
|
+
|
208
|
+
void ChangeColumnTypeInfo::FormatSerialize(FormatSerializer &serializer) const {
|
209
|
+
AlterTableInfo::FormatSerialize(serializer);
|
210
|
+
serializer.WriteProperty("column_name", column_name);
|
211
|
+
serializer.WriteProperty("target_type", target_type);
|
212
|
+
serializer.WriteProperty("expression", *expression);
|
213
|
+
}
|
214
|
+
|
215
|
+
unique_ptr<AlterTableInfo> ChangeColumnTypeInfo::FormatDeserialize(FormatDeserializer &deserializer) {
|
216
|
+
auto result = duckdb::unique_ptr<ChangeColumnTypeInfo>(new ChangeColumnTypeInfo());
|
217
|
+
deserializer.ReadProperty("column_name", result->column_name);
|
218
|
+
deserializer.ReadProperty("target_type", result->target_type);
|
219
|
+
deserializer.ReadProperty("expression", result->expression);
|
220
|
+
return std::move(result);
|
221
|
+
}
|
222
|
+
|
223
|
+
void CopyInfo::FormatSerialize(FormatSerializer &serializer) const {
|
224
|
+
ParseInfo::FormatSerialize(serializer);
|
225
|
+
serializer.WriteProperty("catalog", catalog);
|
226
|
+
serializer.WriteProperty("schema", schema);
|
227
|
+
serializer.WriteProperty("table", table);
|
228
|
+
serializer.WriteProperty("select_list", select_list);
|
229
|
+
serializer.WriteProperty("is_from", is_from);
|
230
|
+
serializer.WriteProperty("format", format);
|
231
|
+
serializer.WriteProperty("file_path", file_path);
|
232
|
+
serializer.WriteProperty("options", options);
|
233
|
+
}
|
234
|
+
|
235
|
+
unique_ptr<ParseInfo> CopyInfo::FormatDeserialize(FormatDeserializer &deserializer) {
|
236
|
+
auto result = duckdb::unique_ptr<CopyInfo>(new CopyInfo());
|
237
|
+
deserializer.ReadProperty("catalog", result->catalog);
|
238
|
+
deserializer.ReadProperty("schema", result->schema);
|
239
|
+
deserializer.ReadProperty("table", result->table);
|
240
|
+
deserializer.ReadProperty("select_list", result->select_list);
|
241
|
+
deserializer.ReadProperty("is_from", result->is_from);
|
242
|
+
deserializer.ReadProperty("format", result->format);
|
243
|
+
deserializer.ReadProperty("file_path", result->file_path);
|
244
|
+
deserializer.ReadProperty("options", result->options);
|
245
|
+
return std::move(result);
|
246
|
+
}
|
247
|
+
|
248
|
+
void DetachInfo::FormatSerialize(FormatSerializer &serializer) const {
|
249
|
+
ParseInfo::FormatSerialize(serializer);
|
250
|
+
serializer.WriteProperty("name", name);
|
251
|
+
serializer.WriteProperty("if_not_found", if_not_found);
|
252
|
+
}
|
253
|
+
|
254
|
+
unique_ptr<ParseInfo> DetachInfo::FormatDeserialize(FormatDeserializer &deserializer) {
|
255
|
+
auto result = duckdb::unique_ptr<DetachInfo>(new DetachInfo());
|
256
|
+
deserializer.ReadProperty("name", result->name);
|
257
|
+
deserializer.ReadProperty("if_not_found", result->if_not_found);
|
258
|
+
return std::move(result);
|
259
|
+
}
|
260
|
+
|
261
|
+
void DropInfo::FormatSerialize(FormatSerializer &serializer) const {
|
262
|
+
ParseInfo::FormatSerialize(serializer);
|
263
|
+
serializer.WriteProperty("type", type);
|
264
|
+
serializer.WriteProperty("catalog", catalog);
|
265
|
+
serializer.WriteProperty("schema", schema);
|
266
|
+
serializer.WriteProperty("name", name);
|
267
|
+
serializer.WriteProperty("if_not_found", if_not_found);
|
268
|
+
serializer.WriteProperty("cascade", cascade);
|
269
|
+
serializer.WriteProperty("allow_drop_internal", allow_drop_internal);
|
270
|
+
}
|
271
|
+
|
272
|
+
unique_ptr<ParseInfo> DropInfo::FormatDeserialize(FormatDeserializer &deserializer) {
|
273
|
+
auto result = duckdb::unique_ptr<DropInfo>(new DropInfo());
|
274
|
+
deserializer.ReadProperty("type", result->type);
|
275
|
+
deserializer.ReadProperty("catalog", result->catalog);
|
276
|
+
deserializer.ReadProperty("schema", result->schema);
|
277
|
+
deserializer.ReadProperty("name", result->name);
|
278
|
+
deserializer.ReadProperty("if_not_found", result->if_not_found);
|
279
|
+
deserializer.ReadProperty("cascade", result->cascade);
|
280
|
+
deserializer.ReadProperty("allow_drop_internal", result->allow_drop_internal);
|
281
|
+
return std::move(result);
|
282
|
+
}
|
283
|
+
|
284
|
+
void DropNotNullInfo::FormatSerialize(FormatSerializer &serializer) const {
|
285
|
+
AlterTableInfo::FormatSerialize(serializer);
|
286
|
+
serializer.WriteProperty("column_name", column_name);
|
287
|
+
}
|
288
|
+
|
289
|
+
unique_ptr<AlterTableInfo> DropNotNullInfo::FormatDeserialize(FormatDeserializer &deserializer) {
|
290
|
+
auto result = duckdb::unique_ptr<DropNotNullInfo>(new DropNotNullInfo());
|
291
|
+
deserializer.ReadProperty("column_name", result->column_name);
|
292
|
+
return std::move(result);
|
293
|
+
}
|
294
|
+
|
295
|
+
void LoadInfo::FormatSerialize(FormatSerializer &serializer) const {
|
296
|
+
ParseInfo::FormatSerialize(serializer);
|
297
|
+
serializer.WriteProperty("filename", filename);
|
298
|
+
serializer.WriteProperty("load_type", load_type);
|
299
|
+
}
|
300
|
+
|
301
|
+
unique_ptr<ParseInfo> LoadInfo::FormatDeserialize(FormatDeserializer &deserializer) {
|
302
|
+
auto result = duckdb::unique_ptr<LoadInfo>(new LoadInfo());
|
303
|
+
deserializer.ReadProperty("filename", result->filename);
|
304
|
+
deserializer.ReadProperty("load_type", result->load_type);
|
305
|
+
return std::move(result);
|
306
|
+
}
|
307
|
+
|
308
|
+
void PragmaInfo::FormatSerialize(FormatSerializer &serializer) const {
|
309
|
+
ParseInfo::FormatSerialize(serializer);
|
310
|
+
serializer.WriteProperty("name", name);
|
311
|
+
serializer.WriteProperty("parameters", parameters);
|
312
|
+
serializer.WriteProperty("named_parameters", named_parameters);
|
313
|
+
}
|
314
|
+
|
315
|
+
unique_ptr<ParseInfo> PragmaInfo::FormatDeserialize(FormatDeserializer &deserializer) {
|
316
|
+
auto result = duckdb::unique_ptr<PragmaInfo>(new PragmaInfo());
|
317
|
+
deserializer.ReadProperty("name", result->name);
|
318
|
+
deserializer.ReadProperty("parameters", result->parameters);
|
319
|
+
deserializer.ReadProperty("named_parameters", result->named_parameters);
|
320
|
+
return std::move(result);
|
321
|
+
}
|
322
|
+
|
323
|
+
void RemoveColumnInfo::FormatSerialize(FormatSerializer &serializer) const {
|
324
|
+
AlterTableInfo::FormatSerialize(serializer);
|
325
|
+
serializer.WriteProperty("removed_column", removed_column);
|
326
|
+
serializer.WriteProperty("if_column_exists", if_column_exists);
|
327
|
+
serializer.WriteProperty("cascade", cascade);
|
328
|
+
}
|
329
|
+
|
330
|
+
unique_ptr<AlterTableInfo> RemoveColumnInfo::FormatDeserialize(FormatDeserializer &deserializer) {
|
331
|
+
auto result = duckdb::unique_ptr<RemoveColumnInfo>(new RemoveColumnInfo());
|
332
|
+
deserializer.ReadProperty("removed_column", result->removed_column);
|
333
|
+
deserializer.ReadProperty("if_column_exists", result->if_column_exists);
|
334
|
+
deserializer.ReadProperty("cascade", result->cascade);
|
335
|
+
return std::move(result);
|
336
|
+
}
|
337
|
+
|
338
|
+
void RenameColumnInfo::FormatSerialize(FormatSerializer &serializer) const {
|
339
|
+
AlterTableInfo::FormatSerialize(serializer);
|
340
|
+
serializer.WriteProperty("old_name", old_name);
|
341
|
+
serializer.WriteProperty("new_name", new_name);
|
342
|
+
}
|
343
|
+
|
344
|
+
unique_ptr<AlterTableInfo> RenameColumnInfo::FormatDeserialize(FormatDeserializer &deserializer) {
|
345
|
+
auto result = duckdb::unique_ptr<RenameColumnInfo>(new RenameColumnInfo());
|
346
|
+
deserializer.ReadProperty("old_name", result->old_name);
|
347
|
+
deserializer.ReadProperty("new_name", result->new_name);
|
348
|
+
return std::move(result);
|
349
|
+
}
|
350
|
+
|
351
|
+
void RenameTableInfo::FormatSerialize(FormatSerializer &serializer) const {
|
352
|
+
AlterTableInfo::FormatSerialize(serializer);
|
353
|
+
serializer.WriteProperty("new_table_name", new_table_name);
|
354
|
+
}
|
355
|
+
|
356
|
+
unique_ptr<AlterTableInfo> RenameTableInfo::FormatDeserialize(FormatDeserializer &deserializer) {
|
357
|
+
auto result = duckdb::unique_ptr<RenameTableInfo>(new RenameTableInfo());
|
358
|
+
deserializer.ReadProperty("new_table_name", result->new_table_name);
|
359
|
+
return std::move(result);
|
360
|
+
}
|
361
|
+
|
362
|
+
void RenameViewInfo::FormatSerialize(FormatSerializer &serializer) const {
|
363
|
+
AlterViewInfo::FormatSerialize(serializer);
|
364
|
+
serializer.WriteProperty("new_view_name", new_view_name);
|
365
|
+
}
|
366
|
+
|
367
|
+
unique_ptr<AlterViewInfo> RenameViewInfo::FormatDeserialize(FormatDeserializer &deserializer) {
|
368
|
+
auto result = duckdb::unique_ptr<RenameViewInfo>(new RenameViewInfo());
|
369
|
+
deserializer.ReadProperty("new_view_name", result->new_view_name);
|
370
|
+
return std::move(result);
|
371
|
+
}
|
372
|
+
|
373
|
+
void SetDefaultInfo::FormatSerialize(FormatSerializer &serializer) const {
|
374
|
+
AlterTableInfo::FormatSerialize(serializer);
|
375
|
+
serializer.WriteProperty("column_name", column_name);
|
376
|
+
serializer.WriteOptionalProperty("expression", expression);
|
377
|
+
}
|
378
|
+
|
379
|
+
unique_ptr<AlterTableInfo> SetDefaultInfo::FormatDeserialize(FormatDeserializer &deserializer) {
|
380
|
+
auto result = duckdb::unique_ptr<SetDefaultInfo>(new SetDefaultInfo());
|
381
|
+
deserializer.ReadProperty("column_name", result->column_name);
|
382
|
+
deserializer.ReadOptionalProperty("expression", result->expression);
|
383
|
+
return std::move(result);
|
384
|
+
}
|
385
|
+
|
386
|
+
void SetNotNullInfo::FormatSerialize(FormatSerializer &serializer) const {
|
387
|
+
AlterTableInfo::FormatSerialize(serializer);
|
388
|
+
serializer.WriteProperty("column_name", column_name);
|
389
|
+
}
|
390
|
+
|
391
|
+
unique_ptr<AlterTableInfo> SetNotNullInfo::FormatDeserialize(FormatDeserializer &deserializer) {
|
392
|
+
auto result = duckdb::unique_ptr<SetNotNullInfo>(new SetNotNullInfo());
|
393
|
+
deserializer.ReadProperty("column_name", result->column_name);
|
394
|
+
return std::move(result);
|
395
|
+
}
|
396
|
+
|
397
|
+
void TransactionInfo::FormatSerialize(FormatSerializer &serializer) const {
|
398
|
+
ParseInfo::FormatSerialize(serializer);
|
399
|
+
serializer.WriteProperty("type", type);
|
400
|
+
}
|
401
|
+
|
402
|
+
unique_ptr<ParseInfo> TransactionInfo::FormatDeserialize(FormatDeserializer &deserializer) {
|
403
|
+
auto result = duckdb::unique_ptr<TransactionInfo>(new TransactionInfo());
|
404
|
+
deserializer.ReadProperty("type", result->type);
|
405
|
+
return std::move(result);
|
406
|
+
}
|
407
|
+
|
408
|
+
void VacuumInfo::FormatSerialize(FormatSerializer &serializer) const {
|
409
|
+
ParseInfo::FormatSerialize(serializer);
|
410
|
+
serializer.WriteProperty("options", options);
|
411
|
+
}
|
412
|
+
|
413
|
+
unique_ptr<ParseInfo> VacuumInfo::FormatDeserialize(FormatDeserializer &deserializer) {
|
414
|
+
auto options = deserializer.ReadProperty<VacuumOptions>("options");
|
415
|
+
auto result = duckdb::unique_ptr<VacuumInfo>(new VacuumInfo(options));
|
416
|
+
return std::move(result);
|
417
|
+
}
|
418
|
+
|
419
|
+
} // namespace duckdb
|
@@ -19,62 +19,64 @@ unique_ptr<ParsedExpression> ParsedExpression::FormatDeserialize(FormatDeseriali
|
|
19
19
|
auto expression_class = deserializer.ReadProperty<ExpressionClass>("class");
|
20
20
|
auto type = deserializer.ReadProperty<ExpressionType>("type");
|
21
21
|
auto alias = deserializer.ReadProperty<string>("alias");
|
22
|
+
deserializer.Set<ExpressionType>(type);
|
22
23
|
unique_ptr<ParsedExpression> result;
|
23
24
|
switch (expression_class) {
|
24
25
|
case ExpressionClass::BETWEEN:
|
25
|
-
result = BetweenExpression::FormatDeserialize(
|
26
|
+
result = BetweenExpression::FormatDeserialize(deserializer);
|
26
27
|
break;
|
27
28
|
case ExpressionClass::CASE:
|
28
|
-
result = CaseExpression::FormatDeserialize(
|
29
|
+
result = CaseExpression::FormatDeserialize(deserializer);
|
29
30
|
break;
|
30
31
|
case ExpressionClass::CAST:
|
31
|
-
result = CastExpression::FormatDeserialize(
|
32
|
+
result = CastExpression::FormatDeserialize(deserializer);
|
32
33
|
break;
|
33
34
|
case ExpressionClass::COLLATE:
|
34
|
-
result = CollateExpression::FormatDeserialize(
|
35
|
+
result = CollateExpression::FormatDeserialize(deserializer);
|
35
36
|
break;
|
36
37
|
case ExpressionClass::COLUMN_REF:
|
37
|
-
result = ColumnRefExpression::FormatDeserialize(
|
38
|
+
result = ColumnRefExpression::FormatDeserialize(deserializer);
|
38
39
|
break;
|
39
40
|
case ExpressionClass::COMPARISON:
|
40
|
-
result = ComparisonExpression::FormatDeserialize(
|
41
|
+
result = ComparisonExpression::FormatDeserialize(deserializer);
|
41
42
|
break;
|
42
43
|
case ExpressionClass::CONJUNCTION:
|
43
|
-
result = ConjunctionExpression::FormatDeserialize(
|
44
|
+
result = ConjunctionExpression::FormatDeserialize(deserializer);
|
44
45
|
break;
|
45
46
|
case ExpressionClass::CONSTANT:
|
46
|
-
result = ConstantExpression::FormatDeserialize(
|
47
|
+
result = ConstantExpression::FormatDeserialize(deserializer);
|
47
48
|
break;
|
48
49
|
case ExpressionClass::DEFAULT:
|
49
|
-
result = DefaultExpression::FormatDeserialize(
|
50
|
+
result = DefaultExpression::FormatDeserialize(deserializer);
|
50
51
|
break;
|
51
52
|
case ExpressionClass::FUNCTION:
|
52
|
-
result = FunctionExpression::FormatDeserialize(
|
53
|
+
result = FunctionExpression::FormatDeserialize(deserializer);
|
53
54
|
break;
|
54
55
|
case ExpressionClass::LAMBDA:
|
55
|
-
result = LambdaExpression::FormatDeserialize(
|
56
|
+
result = LambdaExpression::FormatDeserialize(deserializer);
|
56
57
|
break;
|
57
58
|
case ExpressionClass::OPERATOR:
|
58
|
-
result = OperatorExpression::FormatDeserialize(
|
59
|
+
result = OperatorExpression::FormatDeserialize(deserializer);
|
59
60
|
break;
|
60
61
|
case ExpressionClass::PARAMETER:
|
61
|
-
result = ParameterExpression::FormatDeserialize(
|
62
|
+
result = ParameterExpression::FormatDeserialize(deserializer);
|
62
63
|
break;
|
63
64
|
case ExpressionClass::POSITIONAL_REFERENCE:
|
64
|
-
result = PositionalReferenceExpression::FormatDeserialize(
|
65
|
+
result = PositionalReferenceExpression::FormatDeserialize(deserializer);
|
65
66
|
break;
|
66
67
|
case ExpressionClass::STAR:
|
67
|
-
result = StarExpression::FormatDeserialize(
|
68
|
+
result = StarExpression::FormatDeserialize(deserializer);
|
68
69
|
break;
|
69
70
|
case ExpressionClass::SUBQUERY:
|
70
|
-
result = SubqueryExpression::FormatDeserialize(
|
71
|
+
result = SubqueryExpression::FormatDeserialize(deserializer);
|
71
72
|
break;
|
72
73
|
case ExpressionClass::WINDOW:
|
73
|
-
result = WindowExpression::FormatDeserialize(
|
74
|
+
result = WindowExpression::FormatDeserialize(deserializer);
|
74
75
|
break;
|
75
76
|
default:
|
76
77
|
throw SerializationException("Unsupported type for deserialization of ParsedExpression!");
|
77
78
|
}
|
79
|
+
deserializer.Unset<ExpressionType>();
|
78
80
|
result->alias = std::move(alias);
|
79
81
|
return result;
|
80
82
|
}
|
@@ -86,7 +88,7 @@ void BetweenExpression::FormatSerialize(FormatSerializer &serializer) const {
|
|
86
88
|
serializer.WriteProperty("upper", *upper);
|
87
89
|
}
|
88
90
|
|
89
|
-
unique_ptr<ParsedExpression> BetweenExpression::FormatDeserialize(
|
91
|
+
unique_ptr<ParsedExpression> BetweenExpression::FormatDeserialize(FormatDeserializer &deserializer) {
|
90
92
|
auto result = duckdb::unique_ptr<BetweenExpression>(new BetweenExpression());
|
91
93
|
deserializer.ReadProperty("input", result->input);
|
92
94
|
deserializer.ReadProperty("lower", result->lower);
|
@@ -100,7 +102,7 @@ void CaseExpression::FormatSerialize(FormatSerializer &serializer) const {
|
|
100
102
|
serializer.WriteProperty("else_expr", *else_expr);
|
101
103
|
}
|
102
104
|
|
103
|
-
unique_ptr<ParsedExpression> CaseExpression::FormatDeserialize(
|
105
|
+
unique_ptr<ParsedExpression> CaseExpression::FormatDeserialize(FormatDeserializer &deserializer) {
|
104
106
|
auto result = duckdb::unique_ptr<CaseExpression>(new CaseExpression());
|
105
107
|
deserializer.ReadProperty("case_checks", result->case_checks);
|
106
108
|
deserializer.ReadProperty("else_expr", result->else_expr);
|
@@ -114,7 +116,7 @@ void CastExpression::FormatSerialize(FormatSerializer &serializer) const {
|
|
114
116
|
serializer.WriteProperty("try_cast", try_cast);
|
115
117
|
}
|
116
118
|
|
117
|
-
unique_ptr<ParsedExpression> CastExpression::FormatDeserialize(
|
119
|
+
unique_ptr<ParsedExpression> CastExpression::FormatDeserialize(FormatDeserializer &deserializer) {
|
118
120
|
auto result = duckdb::unique_ptr<CastExpression>(new CastExpression());
|
119
121
|
deserializer.ReadProperty("child", result->child);
|
120
122
|
deserializer.ReadProperty("cast_type", result->cast_type);
|
@@ -128,7 +130,7 @@ void CollateExpression::FormatSerialize(FormatSerializer &serializer) const {
|
|
128
130
|
serializer.WriteProperty("collation", collation);
|
129
131
|
}
|
130
132
|
|
131
|
-
unique_ptr<ParsedExpression> CollateExpression::FormatDeserialize(
|
133
|
+
unique_ptr<ParsedExpression> CollateExpression::FormatDeserialize(FormatDeserializer &deserializer) {
|
132
134
|
auto result = duckdb::unique_ptr<CollateExpression>(new CollateExpression());
|
133
135
|
deserializer.ReadProperty("child", result->child);
|
134
136
|
deserializer.ReadProperty("collation", result->collation);
|
@@ -140,7 +142,7 @@ void ColumnRefExpression::FormatSerialize(FormatSerializer &serializer) const {
|
|
140
142
|
serializer.WriteProperty("column_names", column_names);
|
141
143
|
}
|
142
144
|
|
143
|
-
unique_ptr<ParsedExpression> ColumnRefExpression::FormatDeserialize(
|
145
|
+
unique_ptr<ParsedExpression> ColumnRefExpression::FormatDeserialize(FormatDeserializer &deserializer) {
|
144
146
|
auto result = duckdb::unique_ptr<ColumnRefExpression>(new ColumnRefExpression());
|
145
147
|
deserializer.ReadProperty("column_names", result->column_names);
|
146
148
|
return std::move(result);
|
@@ -152,8 +154,8 @@ void ComparisonExpression::FormatSerialize(FormatSerializer &serializer) const {
|
|
152
154
|
serializer.WriteProperty("right", *right);
|
153
155
|
}
|
154
156
|
|
155
|
-
unique_ptr<ParsedExpression> ComparisonExpression::FormatDeserialize(
|
156
|
-
auto result = duckdb::unique_ptr<ComparisonExpression>(new ComparisonExpression(
|
157
|
+
unique_ptr<ParsedExpression> ComparisonExpression::FormatDeserialize(FormatDeserializer &deserializer) {
|
158
|
+
auto result = duckdb::unique_ptr<ComparisonExpression>(new ComparisonExpression(deserializer.Get<ExpressionType>()));
|
157
159
|
deserializer.ReadProperty("left", result->left);
|
158
160
|
deserializer.ReadProperty("right", result->right);
|
159
161
|
return std::move(result);
|
@@ -164,8 +166,8 @@ void ConjunctionExpression::FormatSerialize(FormatSerializer &serializer) const
|
|
164
166
|
serializer.WriteProperty("children", children);
|
165
167
|
}
|
166
168
|
|
167
|
-
unique_ptr<ParsedExpression> ConjunctionExpression::FormatDeserialize(
|
168
|
-
auto result = duckdb::unique_ptr<ConjunctionExpression>(new ConjunctionExpression(
|
169
|
+
unique_ptr<ParsedExpression> ConjunctionExpression::FormatDeserialize(FormatDeserializer &deserializer) {
|
170
|
+
auto result = duckdb::unique_ptr<ConjunctionExpression>(new ConjunctionExpression(deserializer.Get<ExpressionType>()));
|
169
171
|
deserializer.ReadProperty("children", result->children);
|
170
172
|
return std::move(result);
|
171
173
|
}
|
@@ -175,7 +177,7 @@ void ConstantExpression::FormatSerialize(FormatSerializer &serializer) const {
|
|
175
177
|
serializer.WriteProperty("value", value);
|
176
178
|
}
|
177
179
|
|
178
|
-
unique_ptr<ParsedExpression> ConstantExpression::FormatDeserialize(
|
180
|
+
unique_ptr<ParsedExpression> ConstantExpression::FormatDeserialize(FormatDeserializer &deserializer) {
|
179
181
|
auto result = duckdb::unique_ptr<ConstantExpression>(new ConstantExpression());
|
180
182
|
deserializer.ReadProperty("value", result->value);
|
181
183
|
return std::move(result);
|
@@ -185,7 +187,7 @@ void DefaultExpression::FormatSerialize(FormatSerializer &serializer) const {
|
|
185
187
|
ParsedExpression::FormatSerialize(serializer);
|
186
188
|
}
|
187
189
|
|
188
|
-
unique_ptr<ParsedExpression> DefaultExpression::FormatDeserialize(
|
190
|
+
unique_ptr<ParsedExpression> DefaultExpression::FormatDeserialize(FormatDeserializer &deserializer) {
|
189
191
|
auto result = duckdb::unique_ptr<DefaultExpression>(new DefaultExpression());
|
190
192
|
return std::move(result);
|
191
193
|
}
|
@@ -203,7 +205,7 @@ void FunctionExpression::FormatSerialize(FormatSerializer &serializer) const {
|
|
203
205
|
serializer.WriteProperty("catalog", catalog);
|
204
206
|
}
|
205
207
|
|
206
|
-
unique_ptr<ParsedExpression> FunctionExpression::FormatDeserialize(
|
208
|
+
unique_ptr<ParsedExpression> FunctionExpression::FormatDeserialize(FormatDeserializer &deserializer) {
|
207
209
|
auto result = duckdb::unique_ptr<FunctionExpression>(new FunctionExpression());
|
208
210
|
deserializer.ReadProperty("function_name", result->function_name);
|
209
211
|
deserializer.ReadProperty("schema", result->schema);
|
@@ -224,7 +226,7 @@ void LambdaExpression::FormatSerialize(FormatSerializer &serializer) const {
|
|
224
226
|
serializer.WriteProperty("expr", *expr);
|
225
227
|
}
|
226
228
|
|
227
|
-
unique_ptr<ParsedExpression> LambdaExpression::FormatDeserialize(
|
229
|
+
unique_ptr<ParsedExpression> LambdaExpression::FormatDeserialize(FormatDeserializer &deserializer) {
|
228
230
|
auto result = duckdb::unique_ptr<LambdaExpression>(new LambdaExpression());
|
229
231
|
deserializer.ReadProperty("lhs", result->lhs);
|
230
232
|
deserializer.ReadProperty("expr", result->expr);
|
@@ -236,8 +238,8 @@ void OperatorExpression::FormatSerialize(FormatSerializer &serializer) const {
|
|
236
238
|
serializer.WriteProperty("children", children);
|
237
239
|
}
|
238
240
|
|
239
|
-
unique_ptr<ParsedExpression> OperatorExpression::FormatDeserialize(
|
240
|
-
auto result = duckdb::unique_ptr<OperatorExpression>(new OperatorExpression(
|
241
|
+
unique_ptr<ParsedExpression> OperatorExpression::FormatDeserialize(FormatDeserializer &deserializer) {
|
242
|
+
auto result = duckdb::unique_ptr<OperatorExpression>(new OperatorExpression(deserializer.Get<ExpressionType>()));
|
241
243
|
deserializer.ReadProperty("children", result->children);
|
242
244
|
return std::move(result);
|
243
245
|
}
|
@@ -247,7 +249,7 @@ void ParameterExpression::FormatSerialize(FormatSerializer &serializer) const {
|
|
247
249
|
serializer.WriteProperty("parameter_nr", parameter_nr);
|
248
250
|
}
|
249
251
|
|
250
|
-
unique_ptr<ParsedExpression> ParameterExpression::FormatDeserialize(
|
252
|
+
unique_ptr<ParsedExpression> ParameterExpression::FormatDeserialize(FormatDeserializer &deserializer) {
|
251
253
|
auto result = duckdb::unique_ptr<ParameterExpression>(new ParameterExpression());
|
252
254
|
deserializer.ReadProperty("parameter_nr", result->parameter_nr);
|
253
255
|
return std::move(result);
|
@@ -258,7 +260,7 @@ void PositionalReferenceExpression::FormatSerialize(FormatSerializer &serializer
|
|
258
260
|
serializer.WriteProperty("index", index);
|
259
261
|
}
|
260
262
|
|
261
|
-
unique_ptr<ParsedExpression> PositionalReferenceExpression::FormatDeserialize(
|
263
|
+
unique_ptr<ParsedExpression> PositionalReferenceExpression::FormatDeserialize(FormatDeserializer &deserializer) {
|
262
264
|
auto result = duckdb::unique_ptr<PositionalReferenceExpression>(new PositionalReferenceExpression());
|
263
265
|
deserializer.ReadProperty("index", result->index);
|
264
266
|
return std::move(result);
|
@@ -273,7 +275,7 @@ void StarExpression::FormatSerialize(FormatSerializer &serializer) const {
|
|
273
275
|
serializer.WriteOptionalProperty("expr", expr);
|
274
276
|
}
|
275
277
|
|
276
|
-
unique_ptr<ParsedExpression> StarExpression::FormatDeserialize(
|
278
|
+
unique_ptr<ParsedExpression> StarExpression::FormatDeserialize(FormatDeserializer &deserializer) {
|
277
279
|
auto result = duckdb::unique_ptr<StarExpression>(new StarExpression());
|
278
280
|
deserializer.ReadProperty("relation_name", result->relation_name);
|
279
281
|
deserializer.ReadProperty("exclude_list", result->exclude_list);
|
@@ -291,7 +293,7 @@ void SubqueryExpression::FormatSerialize(FormatSerializer &serializer) const {
|
|
291
293
|
serializer.WriteProperty("comparison_type", comparison_type);
|
292
294
|
}
|
293
295
|
|
294
|
-
unique_ptr<ParsedExpression> SubqueryExpression::FormatDeserialize(
|
296
|
+
unique_ptr<ParsedExpression> SubqueryExpression::FormatDeserialize(FormatDeserializer &deserializer) {
|
295
297
|
auto result = duckdb::unique_ptr<SubqueryExpression>(new SubqueryExpression());
|
296
298
|
deserializer.ReadProperty("subquery_type", result->subquery_type);
|
297
299
|
deserializer.ReadProperty("subquery", result->subquery);
|
@@ -318,8 +320,8 @@ void WindowExpression::FormatSerialize(FormatSerializer &serializer) const {
|
|
318
320
|
serializer.WriteOptionalProperty("filter_expr", filter_expr);
|
319
321
|
}
|
320
322
|
|
321
|
-
unique_ptr<ParsedExpression> WindowExpression::FormatDeserialize(
|
322
|
-
auto result = duckdb::unique_ptr<WindowExpression>(new WindowExpression(
|
323
|
+
unique_ptr<ParsedExpression> WindowExpression::FormatDeserialize(FormatDeserializer &deserializer) {
|
324
|
+
auto result = duckdb::unique_ptr<WindowExpression>(new WindowExpression(deserializer.Get<ExpressionType>()));
|
323
325
|
deserializer.ReadProperty("function_name", result->function_name);
|
324
326
|
deserializer.ReadProperty("schema", result->schema);
|
325
327
|
deserializer.ReadProperty("catalog", result->catalog);
|