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.
Files changed (213) hide show
  1. package/configure.py +7 -2
  2. package/package.json +1 -1
  3. package/src/duckdb/src/catalog/catalog.cpp +1 -1
  4. package/src/duckdb/src/catalog/catalog_entry/index_catalog_entry.cpp +17 -41
  5. package/src/duckdb/src/catalog/catalog_entry/macro_catalog_entry.cpp +2 -10
  6. package/src/duckdb/src/catalog/catalog_entry/schema_catalog_entry.cpp +4 -14
  7. package/src/duckdb/src/catalog/catalog_entry/sequence_catalog_entry.cpp +11 -28
  8. package/src/duckdb/src/catalog/catalog_entry/table_catalog_entry.cpp +11 -38
  9. package/src/duckdb/src/catalog/catalog_entry/view_catalog_entry.cpp +11 -27
  10. package/src/duckdb/src/catalog/catalog_entry.cpp +25 -1
  11. package/src/duckdb/src/common/adbc/adbc.cpp +18 -4
  12. package/src/duckdb/src/common/enum_util.cpp +159 -0
  13. package/src/duckdb/src/common/extra_type_info.cpp +1 -2
  14. package/src/duckdb/src/common/serializer/binary_deserializer.cpp +3 -0
  15. package/src/duckdb/src/common/serializer/binary_serializer.cpp +4 -4
  16. package/src/duckdb/src/common/types/column/column_data_collection.cpp +43 -0
  17. package/src/duckdb/src/common/types/vector.cpp +1 -1
  18. package/src/duckdb/src/common/types.cpp +0 -12
  19. package/src/duckdb/src/execution/physical_plan/plan_comparison_join.cpp +1 -1
  20. package/src/duckdb/src/function/table/version/pragma_version.cpp +2 -2
  21. package/src/duckdb/src/include/duckdb/catalog/catalog_entry/index_catalog_entry.hpp +1 -2
  22. package/src/duckdb/src/include/duckdb/catalog/catalog_entry/macro_catalog_entry.hpp +1 -4
  23. package/src/duckdb/src/include/duckdb/catalog/catalog_entry/schema_catalog_entry.hpp +2 -5
  24. package/src/duckdb/src/include/duckdb/catalog/catalog_entry/sequence_catalog_entry.hpp +1 -6
  25. package/src/duckdb/src/include/duckdb/catalog/catalog_entry/table_catalog_entry.hpp +2 -11
  26. package/src/duckdb/src/include/duckdb/catalog/catalog_entry/view_catalog_entry.hpp +2 -5
  27. package/src/duckdb/src/include/duckdb/catalog/catalog_entry.hpp +14 -0
  28. package/src/duckdb/src/include/duckdb/common/assert.hpp +1 -1
  29. package/src/duckdb/src/include/duckdb/common/constants.hpp +2 -0
  30. package/src/duckdb/src/include/duckdb/common/enum_util.hpp +32 -0
  31. package/src/duckdb/src/include/duckdb/common/enums/index_type.hpp +1 -1
  32. package/src/duckdb/src/include/duckdb/common/index_vector.hpp +12 -0
  33. package/src/duckdb/src/include/duckdb/common/serializer/binary_deserializer.hpp +28 -4
  34. package/src/duckdb/src/include/duckdb/common/serializer/binary_serializer.hpp +12 -5
  35. package/src/duckdb/src/include/duckdb/common/serializer/deserialization_data.hpp +110 -0
  36. package/src/duckdb/src/include/duckdb/common/serializer/format_deserializer.hpp +46 -1
  37. package/src/duckdb/src/include/duckdb/common/serializer/format_serializer.hpp +23 -21
  38. package/src/duckdb/src/include/duckdb/common/serializer/serialization_traits.hpp +12 -4
  39. package/src/duckdb/src/include/duckdb/common/types/column/column_data_collection.hpp +3 -0
  40. package/src/duckdb/src/include/duckdb/core_functions/scalar/math_functions.hpp +3 -3
  41. package/src/duckdb/src/include/duckdb/function/macro_function.hpp +3 -0
  42. package/src/duckdb/src/include/duckdb/function/scalar_macro_function.hpp +3 -0
  43. package/src/duckdb/src/include/duckdb/function/table_macro_function.hpp +3 -0
  44. package/src/duckdb/src/include/duckdb/parser/column_definition.hpp +6 -5
  45. package/src/duckdb/src/include/duckdb/parser/column_list.hpp +4 -0
  46. package/src/duckdb/src/include/duckdb/parser/constraint.hpp +5 -0
  47. package/src/duckdb/src/include/duckdb/parser/constraints/check_constraint.hpp +3 -0
  48. package/src/duckdb/src/include/duckdb/parser/constraints/foreign_key_constraint.hpp +6 -0
  49. package/src/duckdb/src/include/duckdb/parser/constraints/not_null_constraint.hpp +3 -0
  50. package/src/duckdb/src/include/duckdb/parser/constraints/unique_constraint.hpp +6 -0
  51. package/src/duckdb/src/include/duckdb/parser/expression/between_expression.hpp +1 -1
  52. package/src/duckdb/src/include/duckdb/parser/expression/case_expression.hpp +1 -1
  53. package/src/duckdb/src/include/duckdb/parser/expression/cast_expression.hpp +1 -1
  54. package/src/duckdb/src/include/duckdb/parser/expression/collate_expression.hpp +1 -1
  55. package/src/duckdb/src/include/duckdb/parser/expression/columnref_expression.hpp +1 -1
  56. package/src/duckdb/src/include/duckdb/parser/expression/comparison_expression.hpp +1 -1
  57. package/src/duckdb/src/include/duckdb/parser/expression/conjunction_expression.hpp +1 -1
  58. package/src/duckdb/src/include/duckdb/parser/expression/constant_expression.hpp +1 -1
  59. package/src/duckdb/src/include/duckdb/parser/expression/default_expression.hpp +1 -1
  60. package/src/duckdb/src/include/duckdb/parser/expression/function_expression.hpp +1 -1
  61. package/src/duckdb/src/include/duckdb/parser/expression/lambda_expression.hpp +1 -1
  62. package/src/duckdb/src/include/duckdb/parser/expression/operator_expression.hpp +1 -1
  63. package/src/duckdb/src/include/duckdb/parser/expression/parameter_expression.hpp +1 -1
  64. package/src/duckdb/src/include/duckdb/parser/expression/positional_reference_expression.hpp +1 -1
  65. package/src/duckdb/src/include/duckdb/parser/expression/star_expression.hpp +1 -1
  66. package/src/duckdb/src/include/duckdb/parser/expression/subquery_expression.hpp +1 -1
  67. package/src/duckdb/src/include/duckdb/parser/expression/window_expression.hpp +1 -1
  68. package/src/duckdb/src/include/duckdb/parser/parsed_data/alter_info.hpp +12 -1
  69. package/src/duckdb/src/include/duckdb/parser/parsed_data/alter_table_info.hpp +66 -2
  70. package/src/duckdb/src/include/duckdb/parser/parsed_data/attach_info.hpp +8 -1
  71. package/src/duckdb/src/include/duckdb/parser/parsed_data/copy_info.hpp +8 -1
  72. package/src/duckdb/src/include/duckdb/parser/parsed_data/create_index_info.hpp +4 -1
  73. package/src/duckdb/src/include/duckdb/parser/parsed_data/create_info.hpp +9 -2
  74. package/src/duckdb/src/include/duckdb/parser/parsed_data/create_macro_info.hpp +3 -0
  75. package/src/duckdb/src/include/duckdb/parser/parsed_data/create_schema_info.hpp +3 -0
  76. package/src/duckdb/src/include/duckdb/parser/parsed_data/create_sequence_info.hpp +3 -0
  77. package/src/duckdb/src/include/duckdb/parser/parsed_data/create_table_info.hpp +3 -0
  78. package/src/duckdb/src/include/duckdb/parser/parsed_data/create_type_info.hpp +3 -0
  79. package/src/duckdb/src/include/duckdb/parser/parsed_data/create_view_info.hpp +3 -0
  80. package/src/duckdb/src/include/duckdb/parser/parsed_data/detach_info.hpp +7 -0
  81. package/src/duckdb/src/include/duckdb/parser/parsed_data/drop_info.hpp +7 -0
  82. package/src/duckdb/src/include/duckdb/parser/parsed_data/exported_table_data.hpp +7 -0
  83. package/src/duckdb/src/include/duckdb/parser/parsed_data/load_info.hpp +13 -3
  84. package/src/duckdb/src/include/duckdb/parser/parsed_data/parse_info.hpp +22 -0
  85. package/src/duckdb/src/include/duckdb/parser/parsed_data/pragma_info.hpp +10 -0
  86. package/src/duckdb/src/include/duckdb/parser/parsed_data/show_select_info.hpp +7 -0
  87. package/src/duckdb/src/include/duckdb/parser/parsed_data/transaction_info.hpp +10 -0
  88. package/src/duckdb/src/include/duckdb/parser/parsed_data/vacuum_info.hpp +10 -0
  89. package/src/duckdb/src/include/duckdb/planner/bound_constraint.hpp +0 -8
  90. package/src/duckdb/src/include/duckdb/planner/bound_result_modifier.hpp +6 -0
  91. package/src/duckdb/src/include/duckdb/planner/column_binding.hpp +5 -0
  92. package/src/duckdb/src/include/duckdb/planner/expression/bound_between_expression.hpp +6 -0
  93. package/src/duckdb/src/include/duckdb/planner/expression/bound_case_expression.hpp +6 -0
  94. package/src/duckdb/src/include/duckdb/planner/expression/bound_cast_expression.hpp +6 -0
  95. package/src/duckdb/src/include/duckdb/planner/expression/bound_columnref_expression.hpp +3 -0
  96. package/src/duckdb/src/include/duckdb/planner/expression/bound_comparison_expression.hpp +3 -0
  97. package/src/duckdb/src/include/duckdb/planner/expression/bound_conjunction_expression.hpp +3 -0
  98. package/src/duckdb/src/include/duckdb/planner/expression/bound_constant_expression.hpp +3 -0
  99. package/src/duckdb/src/include/duckdb/planner/expression/bound_default_expression.hpp +3 -0
  100. package/src/duckdb/src/include/duckdb/planner/expression/bound_lambda_expression.hpp +3 -1
  101. package/src/duckdb/src/include/duckdb/planner/expression/bound_lambdaref_expression.hpp +3 -0
  102. package/src/duckdb/src/include/duckdb/planner/expression/bound_operator_expression.hpp +3 -0
  103. package/src/duckdb/src/include/duckdb/planner/expression/bound_parameter_data.hpp +5 -2
  104. package/src/duckdb/src/include/duckdb/planner/expression/bound_parameter_expression.hpp +7 -0
  105. package/src/duckdb/src/include/duckdb/planner/expression/bound_reference_expression.hpp +3 -0
  106. package/src/duckdb/src/include/duckdb/planner/expression/bound_unnest_expression.hpp +3 -0
  107. package/src/duckdb/src/include/duckdb/planner/expression/list.hpp +1 -0
  108. package/src/duckdb/src/include/duckdb/planner/expression.hpp +3 -0
  109. package/src/duckdb/src/include/duckdb/planner/joinside.hpp +3 -0
  110. package/src/duckdb/src/include/duckdb/planner/logical_operator.hpp +3 -0
  111. package/src/duckdb/src/include/duckdb/planner/operator/logical_aggregate.hpp +3 -0
  112. package/src/duckdb/src/include/duckdb/planner/operator/logical_any_join.hpp +3 -0
  113. package/src/duckdb/src/include/duckdb/planner/operator/logical_column_data_get.hpp +4 -0
  114. package/src/duckdb/src/include/duckdb/planner/operator/logical_comparison_join.hpp +9 -2
  115. package/src/duckdb/src/include/duckdb/planner/operator/logical_create.hpp +9 -6
  116. package/src/duckdb/src/include/duckdb/planner/operator/logical_create_index.hpp +2 -16
  117. package/src/duckdb/src/include/duckdb/planner/operator/logical_create_table.hpp +10 -6
  118. package/src/duckdb/src/include/duckdb/planner/operator/logical_cross_product.hpp +3 -0
  119. package/src/duckdb/src/include/duckdb/planner/operator/logical_cteref.hpp +2 -0
  120. package/src/duckdb/src/include/duckdb/planner/operator/logical_delete.hpp +7 -0
  121. package/src/duckdb/src/include/duckdb/planner/operator/logical_delim_get.hpp +3 -0
  122. package/src/duckdb/src/include/duckdb/planner/operator/logical_distinct.hpp +6 -10
  123. package/src/duckdb/src/include/duckdb/planner/operator/logical_dummy_scan.hpp +2 -0
  124. package/src/duckdb/src/include/duckdb/planner/operator/logical_empty_result.hpp +2 -0
  125. package/src/duckdb/src/include/duckdb/planner/operator/logical_explain.hpp +4 -0
  126. package/src/duckdb/src/include/duckdb/planner/operator/logical_expression_get.hpp +3 -0
  127. package/src/duckdb/src/include/duckdb/planner/operator/logical_filter.hpp +3 -0
  128. package/src/duckdb/src/include/duckdb/planner/operator/logical_insert.hpp +6 -0
  129. package/src/duckdb/src/include/duckdb/planner/operator/logical_limit.hpp +3 -0
  130. package/src/duckdb/src/include/duckdb/planner/operator/logical_limit_percent.hpp +3 -0
  131. package/src/duckdb/src/include/duckdb/planner/operator/logical_materialized_cte.hpp +5 -2
  132. package/src/duckdb/src/include/duckdb/planner/operator/logical_order.hpp +7 -35
  133. package/src/duckdb/src/include/duckdb/planner/operator/logical_pivot.hpp +6 -0
  134. package/src/duckdb/src/include/duckdb/planner/operator/logical_positional_join.hpp +3 -0
  135. package/src/duckdb/src/include/duckdb/planner/operator/logical_projection.hpp +3 -0
  136. package/src/duckdb/src/include/duckdb/planner/operator/logical_recursive_cte.hpp +5 -3
  137. package/src/duckdb/src/include/duckdb/planner/operator/logical_reset.hpp +4 -0
  138. package/src/duckdb/src/include/duckdb/planner/operator/logical_sample.hpp +6 -0
  139. package/src/duckdb/src/include/duckdb/planner/operator/logical_set.hpp +4 -0
  140. package/src/duckdb/src/include/duckdb/planner/operator/logical_set_operation.hpp +4 -0
  141. package/src/duckdb/src/include/duckdb/planner/operator/logical_show.hpp +3 -0
  142. package/src/duckdb/src/include/duckdb/planner/operator/logical_simple.hpp +3 -0
  143. package/src/duckdb/src/include/duckdb/planner/operator/logical_top_n.hpp +4 -0
  144. package/src/duckdb/src/include/duckdb/planner/operator/logical_unnest.hpp +2 -0
  145. package/src/duckdb/src/include/duckdb/planner/operator/logical_update.hpp +6 -0
  146. package/src/duckdb/src/include/duckdb/planner/operator/logical_window.hpp +3 -0
  147. package/src/duckdb/src/include/duckdb/planner/tableref/bound_pivotref.hpp +3 -0
  148. package/src/duckdb/src/optimizer/deliminator.cpp +5 -3
  149. package/src/duckdb/src/parser/column_definition.cpp +20 -32
  150. package/src/duckdb/src/parser/column_list.cpp +8 -0
  151. package/src/duckdb/src/parser/constraints/foreign_key_constraint.cpp +3 -0
  152. package/src/duckdb/src/parser/constraints/unique_constraint.cpp +3 -0
  153. package/src/duckdb/src/parser/expression/case_expression.cpp +0 -12
  154. package/src/duckdb/src/parser/parsed_data/alter_info.cpp +5 -2
  155. package/src/duckdb/src/parser/parsed_data/alter_table_info.cpp +38 -0
  156. package/src/duckdb/src/parser/parsed_data/create_index_info.cpp +3 -1
  157. package/src/duckdb/src/parser/parsed_data/create_sequence_info.cpp +2 -0
  158. package/src/duckdb/src/parser/parsed_data/detach_info.cpp +1 -1
  159. package/src/duckdb/src/parser/parsed_data/drop_info.cpp +1 -1
  160. package/src/duckdb/src/parser/parsed_data/sample_options.cpp +0 -18
  161. package/src/duckdb/src/parser/parsed_data/transaction_info.cpp +4 -1
  162. package/src/duckdb/src/parser/parsed_data/vacuum_info.cpp +1 -1
  163. package/src/duckdb/src/parser/query_node.cpp +0 -10
  164. package/src/duckdb/src/parser/result_modifier.cpp +0 -13
  165. package/src/duckdb/src/parser/statement/select_statement.cpp +0 -10
  166. package/src/duckdb/src/parser/tableref/pivotref.cpp +0 -16
  167. package/src/duckdb/src/parser/transform/statement/transform_create_index.cpp +5 -4
  168. package/src/duckdb/src/planner/binder/query_node/plan_subquery.cpp +1 -1
  169. package/src/duckdb/src/planner/binder/statement/bind_create.cpp +6 -1
  170. package/src/duckdb/src/planner/expression/bound_between_expression.cpp +4 -0
  171. package/src/duckdb/src/planner/expression/bound_cast_expression.cpp +13 -6
  172. package/src/duckdb/src/planner/expression/bound_parameter_expression.cpp +20 -12
  173. package/src/duckdb/src/planner/expression/bound_window_expression.cpp +1 -4
  174. package/src/duckdb/src/planner/logical_operator.cpp +13 -1
  175. package/src/duckdb/src/planner/operator/logical_comparison_join.cpp +16 -2
  176. package/src/duckdb/src/planner/operator/logical_create.cpp +14 -0
  177. package/src/duckdb/src/planner/operator/logical_create_index.cpp +20 -0
  178. package/src/duckdb/src/planner/operator/logical_create_table.cpp +16 -0
  179. package/src/duckdb/src/planner/operator/logical_delete.cpp +9 -2
  180. package/src/duckdb/src/planner/operator/logical_delim_join.cpp +2 -4
  181. package/src/duckdb/src/planner/operator/logical_distinct.cpp +13 -0
  182. package/src/duckdb/src/planner/operator/logical_explain.cpp +1 -1
  183. package/src/duckdb/src/planner/operator/logical_insert.cpp +8 -2
  184. package/src/duckdb/src/planner/operator/logical_materialized_cte.cpp +3 -2
  185. package/src/duckdb/src/planner/operator/logical_order.cpp +39 -0
  186. package/src/duckdb/src/planner/operator/logical_pivot.cpp +3 -0
  187. package/src/duckdb/src/planner/operator/logical_recursive_cte.cpp +5 -5
  188. package/src/duckdb/src/planner/operator/logical_sample.cpp +3 -0
  189. package/src/duckdb/src/planner/operator/logical_update.cpp +8 -2
  190. package/src/duckdb/src/planner/parsed_data/bound_create_table_info.cpp +4 -2
  191. package/src/duckdb/src/planner/planner.cpp +11 -0
  192. package/src/duckdb/src/storage/checkpoint_manager.cpp +23 -23
  193. package/src/duckdb/src/storage/serialization/serialize_constraint.cpp +98 -0
  194. package/src/duckdb/src/storage/serialization/serialize_create_info.cpp +188 -0
  195. package/src/duckdb/src/storage/serialization/serialize_expression.cpp +274 -0
  196. package/src/duckdb/src/storage/serialization/serialize_logical_operator.cpp +729 -0
  197. package/src/duckdb/src/storage/serialization/serialize_macro_function.cpp +62 -0
  198. package/src/duckdb/src/storage/serialization/serialize_nodes.cpp +242 -0
  199. package/src/duckdb/src/storage/serialization/serialize_parse_info.cpp +419 -0
  200. package/src/duckdb/src/storage/serialization/serialize_parsed_expression.cpp +40 -38
  201. package/src/duckdb/src/storage/serialization/serialize_query_node.cpp +36 -36
  202. package/src/duckdb/src/storage/serialization/serialize_result_modifier.cpp +25 -14
  203. package/src/duckdb/src/storage/serialization/serialize_statement.cpp +22 -0
  204. package/src/duckdb/src/storage/serialization/serialize_tableref.cpp +47 -47
  205. package/src/duckdb/src/storage/serialization/serialize_types.cpp +25 -25
  206. package/src/duckdb/src/storage/storage_info.cpp +3 -2
  207. package/src/duckdb/src/storage/wal_replay.cpp +20 -19
  208. package/src/duckdb/third_party/concurrentqueue/lightweightsemaphore.h +3 -76
  209. package/src/duckdb/third_party/libpg_query/pg_functions.cpp +13 -0
  210. package/src/duckdb/third_party/libpg_query/src_backend_parser_scansup.cpp +9 -0
  211. package/src/duckdb/ub_src_parser.cpp +0 -2
  212. package/src/duckdb/ub_src_storage_serialization.cpp +16 -0
  213. 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