duckdb 0.8.2-dev1435.0 → 0.8.2-dev1493.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 (74) hide show
  1. package/binding.gyp +1 -0
  2. package/package.json +1 -1
  3. package/src/duckdb/src/catalog/catalog_search_path.cpp +5 -4
  4. package/src/duckdb/src/common/radix_partitioning.cpp +1 -1
  5. package/src/duckdb/src/function/table/version/pragma_version.cpp +2 -2
  6. package/src/duckdb/src/include/duckdb/core_functions/aggregate/algebraic_functions.hpp +3 -1
  7. package/src/duckdb/src/include/duckdb/core_functions/aggregate/distributive_functions.hpp +3 -1
  8. package/src/duckdb/src/include/duckdb/core_functions/aggregate/holistic_functions.hpp +3 -1
  9. package/src/duckdb/src/include/duckdb/core_functions/aggregate/nested_functions.hpp +3 -1
  10. package/src/duckdb/src/include/duckdb/core_functions/aggregate/regression_functions.hpp +3 -1
  11. package/src/duckdb/src/include/duckdb/core_functions/scalar/bit_functions.hpp +3 -1
  12. package/src/duckdb/src/include/duckdb/core_functions/scalar/blob_functions.hpp +3 -1
  13. package/src/duckdb/src/include/duckdb/core_functions/scalar/date_functions.hpp +3 -1
  14. package/src/duckdb/src/include/duckdb/core_functions/scalar/enum_functions.hpp +3 -1
  15. package/src/duckdb/src/include/duckdb/core_functions/scalar/generic_functions.hpp +3 -1
  16. package/src/duckdb/src/include/duckdb/core_functions/scalar/list_functions.hpp +3 -1
  17. package/src/duckdb/src/include/duckdb/core_functions/scalar/map_functions.hpp +3 -1
  18. package/src/duckdb/src/include/duckdb/core_functions/scalar/math_functions.hpp +3 -1
  19. package/src/duckdb/src/include/duckdb/core_functions/scalar/operators_functions.hpp +3 -1
  20. package/src/duckdb/src/include/duckdb/core_functions/scalar/random_functions.hpp +3 -1
  21. package/src/duckdb/src/include/duckdb/core_functions/scalar/string_functions.hpp +3 -1
  22. package/src/duckdb/src/include/duckdb/core_functions/scalar/struct_functions.hpp +3 -1
  23. package/src/duckdb/src/include/duckdb/core_functions/scalar/union_functions.hpp +3 -1
  24. package/src/duckdb/src/include/duckdb/parser/expression/between_expression.hpp +3 -0
  25. package/src/duckdb/src/include/duckdb/parser/expression/cast_expression.hpp +3 -0
  26. package/src/duckdb/src/include/duckdb/parser/expression/collate_expression.hpp +3 -0
  27. package/src/duckdb/src/include/duckdb/parser/expression/columnref_expression.hpp +3 -0
  28. package/src/duckdb/src/include/duckdb/parser/expression/comparison_expression.hpp +3 -0
  29. package/src/duckdb/src/include/duckdb/parser/expression/constant_expression.hpp +3 -0
  30. package/src/duckdb/src/include/duckdb/parser/expression/default_expression.hpp +1 -0
  31. package/src/duckdb/src/include/duckdb/parser/expression/function_expression.hpp +3 -0
  32. package/src/duckdb/src/include/duckdb/parser/expression/lambda_expression.hpp +3 -0
  33. package/src/duckdb/src/include/duckdb/parser/expression/positional_reference_expression.hpp +3 -0
  34. package/src/duckdb/src/include/duckdb/parser/expression/window_expression.hpp +3 -0
  35. package/src/duckdb/src/include/duckdb/parser/tableref/emptytableref.hpp +1 -0
  36. package/src/duckdb/src/include/duckdb/parser/tableref/joinref.hpp +1 -1
  37. package/src/duckdb/src/include/duckdb/parser/tableref/subqueryref.hpp +3 -0
  38. package/src/duckdb/src/parser/expression/between_expression.cpp +3 -15
  39. package/src/duckdb/src/parser/expression/case_expression.cpp +0 -13
  40. package/src/duckdb/src/parser/expression/cast_expression.cpp +3 -14
  41. package/src/duckdb/src/parser/expression/collate_expression.cpp +3 -13
  42. package/src/duckdb/src/parser/expression/columnref_expression.cpp +3 -12
  43. package/src/duckdb/src/parser/expression/comparison_expression.cpp +3 -13
  44. package/src/duckdb/src/parser/expression/conjunction_expression.cpp +0 -12
  45. package/src/duckdb/src/parser/expression/constant_expression.cpp +3 -11
  46. package/src/duckdb/src/parser/expression/default_expression.cpp +0 -4
  47. package/src/duckdb/src/parser/expression/function_expression.cpp +3 -32
  48. package/src/duckdb/src/parser/expression/lambda_expression.cpp +3 -13
  49. package/src/duckdb/src/parser/expression/operator_expression.cpp +0 -12
  50. package/src/duckdb/src/parser/expression/parameter_expression.cpp +0 -12
  51. package/src/duckdb/src/parser/expression/positional_reference_expression.cpp +4 -11
  52. package/src/duckdb/src/parser/expression/star_expression.cpp +0 -19
  53. package/src/duckdb/src/parser/expression/subquery_expression.cpp +0 -18
  54. package/src/duckdb/src/parser/expression/window_expression.cpp +3 -39
  55. package/src/duckdb/src/parser/parsed_expression.cpp +0 -70
  56. package/src/duckdb/src/parser/query_node/cte_node.cpp +0 -17
  57. package/src/duckdb/src/parser/query_node/recursive_cte_node.cpp +0 -19
  58. package/src/duckdb/src/parser/query_node/select_node.cpp +0 -29
  59. package/src/duckdb/src/parser/query_node/set_operation_node.cpp +0 -15
  60. package/src/duckdb/src/parser/query_node.cpp +0 -39
  61. package/src/duckdb/src/parser/result_modifier.cpp +0 -74
  62. package/src/duckdb/src/parser/tableref/basetableref.cpp +0 -19
  63. package/src/duckdb/src/parser/tableref/emptytableref.cpp +0 -4
  64. package/src/duckdb/src/parser/tableref/expressionlistref.cpp +0 -15
  65. package/src/duckdb/src/parser/tableref/joinref.cpp +0 -23
  66. package/src/duckdb/src/parser/tableref/pivotref.cpp +0 -23
  67. package/src/duckdb/src/parser/tableref/subqueryref.cpp +3 -13
  68. package/src/duckdb/src/parser/tableref/table_function.cpp +0 -15
  69. package/src/duckdb/src/parser/tableref.cpp +0 -44
  70. package/src/duckdb/src/storage/serialization/serialize_parsed_expression.cpp +340 -0
  71. package/src/duckdb/src/storage/serialization/serialize_query_node.cpp +122 -0
  72. package/src/duckdb/src/storage/serialization/serialize_result_modifier.cpp +86 -0
  73. package/src/duckdb/src/storage/serialization/serialize_tableref.cpp +166 -0
  74. package/src/duckdb/ub_src_storage_serialization.cpp +8 -0
@@ -91,29 +91,6 @@ void JoinRef::Serialize(FieldWriter &writer) const {
91
91
  writer.WriteList<string>(using_columns);
92
92
  }
93
93
 
94
- void JoinRef::FormatSerialize(FormatSerializer &serializer) const {
95
- TableRef::FormatSerialize(serializer);
96
- serializer.WriteProperty("left", *left);
97
- serializer.WriteProperty("right", *right);
98
- serializer.WriteOptionalProperty("condition", condition);
99
- serializer.WriteProperty("join_type", type);
100
- serializer.WriteProperty("ref_type", ref_type);
101
- serializer.WriteProperty("using_columns", using_columns);
102
- }
103
-
104
- unique_ptr<TableRef> JoinRef::FormatDeserialize(FormatDeserializer &source) {
105
- auto result = make_uniq<JoinRef>(JoinRefType::REGULAR);
106
-
107
- source.ReadProperty("left", result->left);
108
- source.ReadProperty("right", result->right);
109
- source.ReadOptionalProperty("condition", result->condition);
110
- source.ReadProperty("join_type", result->type);
111
- source.ReadProperty("ref_type", result->ref_type);
112
- source.ReadProperty("using_columns", result->using_columns);
113
-
114
- return std::move(result);
115
- }
116
-
117
94
  unique_ptr<TableRef> JoinRef::Deserialize(FieldReader &reader) {
118
95
  auto result = make_uniq<JoinRef>(JoinRefType::REGULAR);
119
96
  result->left = reader.ReadRequiredSerializable<TableRef>();
@@ -330,17 +330,6 @@ void PivotRef::Serialize(FieldWriter &writer) const {
330
330
  writer.WriteField<bool>(include_nulls);
331
331
  }
332
332
 
333
- void PivotRef::FormatSerialize(FormatSerializer &serializer) const {
334
- TableRef::FormatSerialize(serializer);
335
- serializer.WriteProperty("source", source);
336
- serializer.WriteProperty("aggregates", aggregates);
337
- serializer.WriteProperty("unpivot_names", unpivot_names);
338
- serializer.WriteProperty("pivots", pivots);
339
- serializer.WriteProperty("groups", groups);
340
- serializer.WriteProperty("column_name_alias", column_name_alias);
341
- serializer.WriteProperty("include_nulls", include_nulls);
342
- }
343
-
344
333
  unique_ptr<TableRef> PivotRef::Deserialize(FieldReader &reader) {
345
334
  auto result = make_uniq<PivotRef>();
346
335
  result->source = reader.ReadRequiredSerializable<TableRef>();
@@ -353,16 +342,4 @@ unique_ptr<TableRef> PivotRef::Deserialize(FieldReader &reader) {
353
342
  return std::move(result);
354
343
  }
355
344
 
356
- unique_ptr<TableRef> PivotRef::FormatDeserialize(FormatDeserializer &source) {
357
- auto result = make_uniq<PivotRef>();
358
- source.ReadProperty("source", result->source);
359
- source.ReadProperty("aggregates", result->aggregates);
360
- source.ReadProperty("unpivot_names", result->unpivot_names);
361
- source.ReadProperty("pivots", result->pivots);
362
- source.ReadProperty("groups", result->groups);
363
- source.ReadProperty("column_name_alias", result->column_name_alias);
364
- source.ReadProperty("include_nulls", result->include_nulls);
365
- return std::move(result);
366
- }
367
-
368
345
  } // namespace duckdb
@@ -12,6 +12,9 @@ string SubqueryRef::ToString() const {
12
12
  return BaseToString(result, column_name_alias);
13
13
  }
14
14
 
15
+ SubqueryRef::SubqueryRef() : TableRef(TableReferenceType::SUBQUERY) {
16
+ }
17
+
15
18
  SubqueryRef::SubqueryRef(unique_ptr<SelectStatement> subquery_p, string alias_p)
16
19
  : TableRef(TableReferenceType::SUBQUERY), subquery(std::move(subquery_p)) {
17
20
  this->alias = std::move(alias_p);
@@ -37,19 +40,6 @@ void SubqueryRef::Serialize(FieldWriter &writer) const {
37
40
  writer.WriteList<string>(column_name_alias);
38
41
  }
39
42
 
40
- void SubqueryRef::FormatSerialize(FormatSerializer &serializer) const {
41
- TableRef::FormatSerialize(serializer);
42
- serializer.WriteProperty("subquery", subquery);
43
- serializer.WriteProperty("column_name_alias", column_name_alias);
44
- }
45
-
46
- unique_ptr<TableRef> SubqueryRef::FormatDeserialize(FormatDeserializer &deserializer) {
47
- auto subquery = deserializer.ReadProperty<unique_ptr<SelectStatement>>("subquery");
48
- auto result = make_uniq<SubqueryRef>(std::move(subquery));
49
- deserializer.ReadProperty("column_name_alias", result->column_name_alias);
50
- return std::move(result);
51
- }
52
-
53
43
  unique_ptr<TableRef> SubqueryRef::Deserialize(FieldReader &reader) {
54
44
  auto subquery = reader.ReadRequiredSerializable<SelectStatement>();
55
45
  auto result = make_uniq<SubqueryRef>(std::move(subquery));
@@ -27,21 +27,6 @@ void TableFunctionRef::Serialize(FieldWriter &writer) const {
27
27
  writer.WriteList<string>(column_name_alias);
28
28
  }
29
29
 
30
- void TableFunctionRef::FormatSerialize(FormatSerializer &serializer) const {
31
- TableRef::FormatSerialize(serializer);
32
- serializer.WriteProperty("function", function);
33
- serializer.WriteProperty("alias", alias);
34
- serializer.WriteProperty("column_name_alias", column_name_alias);
35
- }
36
-
37
- unique_ptr<TableRef> TableFunctionRef::FormatDeserialize(FormatDeserializer &deserializer) {
38
- auto result = make_uniq<TableFunctionRef>();
39
- deserializer.ReadProperty("function", result->function);
40
- deserializer.ReadProperty("alias", result->alias);
41
- deserializer.ReadProperty("column_name_alias", result->column_name_alias);
42
- return std::move(result);
43
- }
44
-
45
30
  unique_ptr<TableRef> TableFunctionRef::Deserialize(FieldReader &reader) {
46
31
  auto result = make_uniq<TableFunctionRef>();
47
32
  result->function = reader.ReadRequiredSerializable<ParsedExpression>();
@@ -53,50 +53,6 @@ void TableRef::Serialize(Serializer &serializer) const {
53
53
  writer.Finalize();
54
54
  }
55
55
 
56
- void TableRef::FormatSerialize(FormatSerializer &serializer) const {
57
- serializer.WriteProperty("type", type);
58
- serializer.WriteProperty("alias", alias);
59
- serializer.WriteOptionalProperty("sample", sample);
60
- }
61
-
62
- unique_ptr<TableRef> TableRef::FormatDeserialize(FormatDeserializer &deserializer) {
63
- auto type = deserializer.ReadProperty<TableReferenceType>("type");
64
- auto alias = deserializer.ReadProperty<string>("alias");
65
- auto sample = deserializer.ReadOptionalProperty<unique_ptr<SampleOptions>>("sample");
66
-
67
- unique_ptr<TableRef> result;
68
-
69
- switch (type) {
70
- case TableReferenceType::BASE_TABLE:
71
- result = BaseTableRef::FormatDeserialize(deserializer);
72
- break;
73
- case TableReferenceType::JOIN:
74
- result = JoinRef::FormatDeserialize(deserializer);
75
- break;
76
- case TableReferenceType::SUBQUERY:
77
- result = SubqueryRef::FormatDeserialize(deserializer);
78
- break;
79
- case TableReferenceType::TABLE_FUNCTION:
80
- result = TableFunctionRef::FormatDeserialize(deserializer);
81
- break;
82
- case TableReferenceType::EMPTY:
83
- result = EmptyTableRef::FormatDeserialize(deserializer);
84
- break;
85
- case TableReferenceType::EXPRESSION_LIST:
86
- result = ExpressionListRef::FormatDeserialize(deserializer);
87
- break;
88
- case TableReferenceType::PIVOT:
89
- result = PivotRef::FormatDeserialize(deserializer);
90
- break;
91
- case TableReferenceType::CTE:
92
- case TableReferenceType::INVALID:
93
- throw InternalException("Unsupported type for TableRef::FormatDeserialize");
94
- }
95
- result->alias = alias;
96
- result->sample = std::move(sample);
97
- return result;
98
- }
99
-
100
56
  unique_ptr<TableRef> TableRef::Deserialize(Deserializer &source) {
101
57
  FieldReader reader(source);
102
58
 
@@ -0,0 +1,340 @@
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/expression/list.hpp"
9
+
10
+ namespace duckdb {
11
+
12
+ void ParsedExpression::FormatSerialize(FormatSerializer &serializer) const {
13
+ serializer.WriteProperty("class", expression_class);
14
+ serializer.WriteProperty("type", type);
15
+ serializer.WriteProperty("alias", alias);
16
+ }
17
+
18
+ unique_ptr<ParsedExpression> ParsedExpression::FormatDeserialize(FormatDeserializer &deserializer) {
19
+ auto expression_class = deserializer.ReadProperty<ExpressionClass>("class");
20
+ auto type = deserializer.ReadProperty<ExpressionType>("type");
21
+ auto alias = deserializer.ReadProperty<string>("alias");
22
+ unique_ptr<ParsedExpression> result;
23
+ switch (expression_class) {
24
+ case ExpressionClass::BETWEEN:
25
+ result = BetweenExpression::FormatDeserialize(type, deserializer);
26
+ break;
27
+ case ExpressionClass::CASE:
28
+ result = CaseExpression::FormatDeserialize(type, deserializer);
29
+ break;
30
+ case ExpressionClass::CAST:
31
+ result = CastExpression::FormatDeserialize(type, deserializer);
32
+ break;
33
+ case ExpressionClass::COLLATE:
34
+ result = CollateExpression::FormatDeserialize(type, deserializer);
35
+ break;
36
+ case ExpressionClass::COLUMN_REF:
37
+ result = ColumnRefExpression::FormatDeserialize(type, deserializer);
38
+ break;
39
+ case ExpressionClass::COMPARISON:
40
+ result = ComparisonExpression::FormatDeserialize(type, deserializer);
41
+ break;
42
+ case ExpressionClass::CONJUNCTION:
43
+ result = ConjunctionExpression::FormatDeserialize(type, deserializer);
44
+ break;
45
+ case ExpressionClass::CONSTANT:
46
+ result = ConstantExpression::FormatDeserialize(type, deserializer);
47
+ break;
48
+ case ExpressionClass::DEFAULT:
49
+ result = DefaultExpression::FormatDeserialize(type, deserializer);
50
+ break;
51
+ case ExpressionClass::FUNCTION:
52
+ result = FunctionExpression::FormatDeserialize(type, deserializer);
53
+ break;
54
+ case ExpressionClass::LAMBDA:
55
+ result = LambdaExpression::FormatDeserialize(type, deserializer);
56
+ break;
57
+ case ExpressionClass::OPERATOR:
58
+ result = OperatorExpression::FormatDeserialize(type, deserializer);
59
+ break;
60
+ case ExpressionClass::PARAMETER:
61
+ result = ParameterExpression::FormatDeserialize(type, deserializer);
62
+ break;
63
+ case ExpressionClass::POSITIONAL_REFERENCE:
64
+ result = PositionalReferenceExpression::FormatDeserialize(type, deserializer);
65
+ break;
66
+ case ExpressionClass::STAR:
67
+ result = StarExpression::FormatDeserialize(type, deserializer);
68
+ break;
69
+ case ExpressionClass::SUBQUERY:
70
+ result = SubqueryExpression::FormatDeserialize(type, deserializer);
71
+ break;
72
+ case ExpressionClass::WINDOW:
73
+ result = WindowExpression::FormatDeserialize(type, deserializer);
74
+ break;
75
+ default:
76
+ throw SerializationException("Unsupported type for deserialization of ParsedExpression!");
77
+ }
78
+ result->alias = std::move(alias);
79
+ return result;
80
+ }
81
+
82
+ void BetweenExpression::FormatSerialize(FormatSerializer &serializer) const {
83
+ ParsedExpression::FormatSerialize(serializer);
84
+ serializer.WriteProperty("input", *input);
85
+ serializer.WriteProperty("lower", *lower);
86
+ serializer.WriteProperty("upper", *upper);
87
+ }
88
+
89
+ unique_ptr<ParsedExpression> BetweenExpression::FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer) {
90
+ auto result = duckdb::unique_ptr<BetweenExpression>(new BetweenExpression());
91
+ deserializer.ReadProperty("input", result->input);
92
+ deserializer.ReadProperty("lower", result->lower);
93
+ deserializer.ReadProperty("upper", result->upper);
94
+ return std::move(result);
95
+ }
96
+
97
+ void CaseExpression::FormatSerialize(FormatSerializer &serializer) const {
98
+ ParsedExpression::FormatSerialize(serializer);
99
+ serializer.WriteProperty("case_checks", case_checks);
100
+ serializer.WriteProperty("else_expr", *else_expr);
101
+ }
102
+
103
+ unique_ptr<ParsedExpression> CaseExpression::FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer) {
104
+ auto result = duckdb::unique_ptr<CaseExpression>(new CaseExpression());
105
+ deserializer.ReadProperty("case_checks", result->case_checks);
106
+ deserializer.ReadProperty("else_expr", result->else_expr);
107
+ return std::move(result);
108
+ }
109
+
110
+ void CastExpression::FormatSerialize(FormatSerializer &serializer) const {
111
+ ParsedExpression::FormatSerialize(serializer);
112
+ serializer.WriteProperty("child", *child);
113
+ serializer.WriteProperty("cast_type", cast_type);
114
+ serializer.WriteProperty("try_cast", try_cast);
115
+ }
116
+
117
+ unique_ptr<ParsedExpression> CastExpression::FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer) {
118
+ auto result = duckdb::unique_ptr<CastExpression>(new CastExpression());
119
+ deserializer.ReadProperty("child", result->child);
120
+ deserializer.ReadProperty("cast_type", result->cast_type);
121
+ deserializer.ReadProperty("try_cast", result->try_cast);
122
+ return std::move(result);
123
+ }
124
+
125
+ void CollateExpression::FormatSerialize(FormatSerializer &serializer) const {
126
+ ParsedExpression::FormatSerialize(serializer);
127
+ serializer.WriteProperty("child", *child);
128
+ serializer.WriteProperty("collation", collation);
129
+ }
130
+
131
+ unique_ptr<ParsedExpression> CollateExpression::FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer) {
132
+ auto result = duckdb::unique_ptr<CollateExpression>(new CollateExpression());
133
+ deserializer.ReadProperty("child", result->child);
134
+ deserializer.ReadProperty("collation", result->collation);
135
+ return std::move(result);
136
+ }
137
+
138
+ void ColumnRefExpression::FormatSerialize(FormatSerializer &serializer) const {
139
+ ParsedExpression::FormatSerialize(serializer);
140
+ serializer.WriteProperty("column_names", column_names);
141
+ }
142
+
143
+ unique_ptr<ParsedExpression> ColumnRefExpression::FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer) {
144
+ auto result = duckdb::unique_ptr<ColumnRefExpression>(new ColumnRefExpression());
145
+ deserializer.ReadProperty("column_names", result->column_names);
146
+ return std::move(result);
147
+ }
148
+
149
+ void ComparisonExpression::FormatSerialize(FormatSerializer &serializer) const {
150
+ ParsedExpression::FormatSerialize(serializer);
151
+ serializer.WriteProperty("left", *left);
152
+ serializer.WriteProperty("right", *right);
153
+ }
154
+
155
+ unique_ptr<ParsedExpression> ComparisonExpression::FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer) {
156
+ auto result = duckdb::unique_ptr<ComparisonExpression>(new ComparisonExpression(type));
157
+ deserializer.ReadProperty("left", result->left);
158
+ deserializer.ReadProperty("right", result->right);
159
+ return std::move(result);
160
+ }
161
+
162
+ void ConjunctionExpression::FormatSerialize(FormatSerializer &serializer) const {
163
+ ParsedExpression::FormatSerialize(serializer);
164
+ serializer.WriteProperty("children", children);
165
+ }
166
+
167
+ unique_ptr<ParsedExpression> ConjunctionExpression::FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer) {
168
+ auto result = duckdb::unique_ptr<ConjunctionExpression>(new ConjunctionExpression(type));
169
+ deserializer.ReadProperty("children", result->children);
170
+ return std::move(result);
171
+ }
172
+
173
+ void ConstantExpression::FormatSerialize(FormatSerializer &serializer) const {
174
+ ParsedExpression::FormatSerialize(serializer);
175
+ serializer.WriteProperty("value", value);
176
+ }
177
+
178
+ unique_ptr<ParsedExpression> ConstantExpression::FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer) {
179
+ auto result = duckdb::unique_ptr<ConstantExpression>(new ConstantExpression());
180
+ deserializer.ReadProperty("value", result->value);
181
+ return std::move(result);
182
+ }
183
+
184
+ void DefaultExpression::FormatSerialize(FormatSerializer &serializer) const {
185
+ ParsedExpression::FormatSerialize(serializer);
186
+ }
187
+
188
+ unique_ptr<ParsedExpression> DefaultExpression::FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer) {
189
+ auto result = duckdb::unique_ptr<DefaultExpression>(new DefaultExpression());
190
+ return std::move(result);
191
+ }
192
+
193
+ void FunctionExpression::FormatSerialize(FormatSerializer &serializer) const {
194
+ ParsedExpression::FormatSerialize(serializer);
195
+ serializer.WriteProperty("function_name", function_name);
196
+ serializer.WriteProperty("schema", schema);
197
+ serializer.WriteProperty("children", children);
198
+ serializer.WriteOptionalProperty("filter", filter);
199
+ serializer.WriteProperty("order_bys", (ResultModifier &)*order_bys);
200
+ serializer.WriteProperty("distinct", distinct);
201
+ serializer.WriteProperty("is_operator", is_operator);
202
+ serializer.WriteProperty("export_state", export_state);
203
+ serializer.WriteProperty("catalog", catalog);
204
+ }
205
+
206
+ unique_ptr<ParsedExpression> FunctionExpression::FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer) {
207
+ auto result = duckdb::unique_ptr<FunctionExpression>(new FunctionExpression());
208
+ deserializer.ReadProperty("function_name", result->function_name);
209
+ deserializer.ReadProperty("schema", result->schema);
210
+ deserializer.ReadProperty("children", result->children);
211
+ deserializer.ReadOptionalProperty("filter", result->filter);
212
+ auto order_bys = deserializer.ReadProperty<unique_ptr<ResultModifier>>("order_bys");
213
+ result->order_bys = unique_ptr_cast<ResultModifier, OrderModifier>(std::move(order_bys));
214
+ deserializer.ReadProperty("distinct", result->distinct);
215
+ deserializer.ReadProperty("is_operator", result->is_operator);
216
+ deserializer.ReadProperty("export_state", result->export_state);
217
+ deserializer.ReadProperty("catalog", result->catalog);
218
+ return std::move(result);
219
+ }
220
+
221
+ void LambdaExpression::FormatSerialize(FormatSerializer &serializer) const {
222
+ ParsedExpression::FormatSerialize(serializer);
223
+ serializer.WriteProperty("lhs", *lhs);
224
+ serializer.WriteProperty("expr", *expr);
225
+ }
226
+
227
+ unique_ptr<ParsedExpression> LambdaExpression::FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer) {
228
+ auto result = duckdb::unique_ptr<LambdaExpression>(new LambdaExpression());
229
+ deserializer.ReadProperty("lhs", result->lhs);
230
+ deserializer.ReadProperty("expr", result->expr);
231
+ return std::move(result);
232
+ }
233
+
234
+ void OperatorExpression::FormatSerialize(FormatSerializer &serializer) const {
235
+ ParsedExpression::FormatSerialize(serializer);
236
+ serializer.WriteProperty("children", children);
237
+ }
238
+
239
+ unique_ptr<ParsedExpression> OperatorExpression::FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer) {
240
+ auto result = duckdb::unique_ptr<OperatorExpression>(new OperatorExpression(type));
241
+ deserializer.ReadProperty("children", result->children);
242
+ return std::move(result);
243
+ }
244
+
245
+ void ParameterExpression::FormatSerialize(FormatSerializer &serializer) const {
246
+ ParsedExpression::FormatSerialize(serializer);
247
+ serializer.WriteProperty("parameter_nr", parameter_nr);
248
+ }
249
+
250
+ unique_ptr<ParsedExpression> ParameterExpression::FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer) {
251
+ auto result = duckdb::unique_ptr<ParameterExpression>(new ParameterExpression());
252
+ deserializer.ReadProperty("parameter_nr", result->parameter_nr);
253
+ return std::move(result);
254
+ }
255
+
256
+ void PositionalReferenceExpression::FormatSerialize(FormatSerializer &serializer) const {
257
+ ParsedExpression::FormatSerialize(serializer);
258
+ serializer.WriteProperty("index", index);
259
+ }
260
+
261
+ unique_ptr<ParsedExpression> PositionalReferenceExpression::FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer) {
262
+ auto result = duckdb::unique_ptr<PositionalReferenceExpression>(new PositionalReferenceExpression());
263
+ deserializer.ReadProperty("index", result->index);
264
+ return std::move(result);
265
+ }
266
+
267
+ void StarExpression::FormatSerialize(FormatSerializer &serializer) const {
268
+ ParsedExpression::FormatSerialize(serializer);
269
+ serializer.WriteProperty("relation_name", relation_name);
270
+ serializer.WriteProperty("exclude_list", exclude_list);
271
+ serializer.WriteProperty("replace_list", replace_list);
272
+ serializer.WriteProperty("columns", columns);
273
+ serializer.WriteOptionalProperty("expr", expr);
274
+ }
275
+
276
+ unique_ptr<ParsedExpression> StarExpression::FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer) {
277
+ auto result = duckdb::unique_ptr<StarExpression>(new StarExpression());
278
+ deserializer.ReadProperty("relation_name", result->relation_name);
279
+ deserializer.ReadProperty("exclude_list", result->exclude_list);
280
+ deserializer.ReadProperty("replace_list", result->replace_list);
281
+ deserializer.ReadProperty("columns", result->columns);
282
+ deserializer.ReadOptionalProperty("expr", result->expr);
283
+ return std::move(result);
284
+ }
285
+
286
+ void SubqueryExpression::FormatSerialize(FormatSerializer &serializer) const {
287
+ ParsedExpression::FormatSerialize(serializer);
288
+ serializer.WriteProperty("subquery_type", subquery_type);
289
+ serializer.WriteProperty("subquery", subquery);
290
+ serializer.WriteOptionalProperty("child", child);
291
+ serializer.WriteProperty("comparison_type", comparison_type);
292
+ }
293
+
294
+ unique_ptr<ParsedExpression> SubqueryExpression::FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer) {
295
+ auto result = duckdb::unique_ptr<SubqueryExpression>(new SubqueryExpression());
296
+ deserializer.ReadProperty("subquery_type", result->subquery_type);
297
+ deserializer.ReadProperty("subquery", result->subquery);
298
+ deserializer.ReadOptionalProperty("child", result->child);
299
+ deserializer.ReadProperty("comparison_type", result->comparison_type);
300
+ return std::move(result);
301
+ }
302
+
303
+ void WindowExpression::FormatSerialize(FormatSerializer &serializer) const {
304
+ ParsedExpression::FormatSerialize(serializer);
305
+ serializer.WriteProperty("function_name", function_name);
306
+ serializer.WriteProperty("schema", schema);
307
+ serializer.WriteProperty("catalog", catalog);
308
+ serializer.WriteProperty("children", children);
309
+ serializer.WriteProperty("partitions", partitions);
310
+ serializer.WriteProperty("orders", orders);
311
+ serializer.WriteProperty("start", start);
312
+ serializer.WriteProperty("end", end);
313
+ serializer.WriteOptionalProperty("start_expr", start_expr);
314
+ serializer.WriteOptionalProperty("end_expr", end_expr);
315
+ serializer.WriteOptionalProperty("offset_expr", offset_expr);
316
+ serializer.WriteOptionalProperty("default_expr", default_expr);
317
+ serializer.WriteProperty("ignore_nulls", ignore_nulls);
318
+ serializer.WriteOptionalProperty("filter_expr", filter_expr);
319
+ }
320
+
321
+ unique_ptr<ParsedExpression> WindowExpression::FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer) {
322
+ auto result = duckdb::unique_ptr<WindowExpression>(new WindowExpression(type));
323
+ deserializer.ReadProperty("function_name", result->function_name);
324
+ deserializer.ReadProperty("schema", result->schema);
325
+ deserializer.ReadProperty("catalog", result->catalog);
326
+ deserializer.ReadProperty("children", result->children);
327
+ deserializer.ReadProperty("partitions", result->partitions);
328
+ deserializer.ReadProperty("orders", result->orders);
329
+ deserializer.ReadProperty("start", result->start);
330
+ deserializer.ReadProperty("end", result->end);
331
+ deserializer.ReadOptionalProperty("start_expr", result->start_expr);
332
+ deserializer.ReadOptionalProperty("end_expr", result->end_expr);
333
+ deserializer.ReadOptionalProperty("offset_expr", result->offset_expr);
334
+ deserializer.ReadOptionalProperty("default_expr", result->default_expr);
335
+ deserializer.ReadProperty("ignore_nulls", result->ignore_nulls);
336
+ deserializer.ReadOptionalProperty("filter_expr", result->filter_expr);
337
+ return std::move(result);
338
+ }
339
+
340
+ } // namespace duckdb
@@ -0,0 +1,122 @@
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/query_node/list.hpp"
9
+
10
+ namespace duckdb {
11
+
12
+ void QueryNode::FormatSerialize(FormatSerializer &serializer) const {
13
+ serializer.WriteProperty("type", type);
14
+ serializer.WriteProperty("modifiers", modifiers);
15
+ serializer.WriteProperty("cte_map", cte_map);
16
+ }
17
+
18
+ unique_ptr<QueryNode> QueryNode::FormatDeserialize(FormatDeserializer &deserializer) {
19
+ auto type = deserializer.ReadProperty<QueryNodeType>("type");
20
+ auto modifiers = deserializer.ReadProperty<vector<unique_ptr<ResultModifier>>>("modifiers");
21
+ auto cte_map = deserializer.ReadProperty<CommonTableExpressionMap>("cte_map");
22
+ unique_ptr<QueryNode> result;
23
+ switch (type) {
24
+ case QueryNodeType::CTE_NODE:
25
+ result = CTENode::FormatDeserialize(deserializer);
26
+ break;
27
+ case QueryNodeType::RECURSIVE_CTE_NODE:
28
+ result = RecursiveCTENode::FormatDeserialize(deserializer);
29
+ break;
30
+ case QueryNodeType::SELECT_NODE:
31
+ result = SelectNode::FormatDeserialize(deserializer);
32
+ break;
33
+ case QueryNodeType::SET_OPERATION_NODE:
34
+ result = SetOperationNode::FormatDeserialize(deserializer);
35
+ break;
36
+ default:
37
+ throw SerializationException("Unsupported type for deserialization of QueryNode!");
38
+ }
39
+ result->modifiers = std::move(modifiers);
40
+ result->cte_map = std::move(cte_map);
41
+ return result;
42
+ }
43
+
44
+ void SelectNode::FormatSerialize(FormatSerializer &serializer) const {
45
+ QueryNode::FormatSerialize(serializer);
46
+ serializer.WriteProperty("select_list", select_list);
47
+ serializer.WriteOptionalProperty("from_table", from_table);
48
+ serializer.WriteOptionalProperty("where_clause", where_clause);
49
+ serializer.WriteProperty("group_expressions", groups.group_expressions);
50
+ serializer.WriteProperty("group_sets", groups.grouping_sets);
51
+ serializer.WriteProperty("aggregate_handling", aggregate_handling);
52
+ serializer.WriteOptionalProperty("having", having);
53
+ serializer.WriteOptionalProperty("sample", sample);
54
+ serializer.WriteOptionalProperty("qualify", qualify);
55
+ }
56
+
57
+ unique_ptr<QueryNode> SelectNode::FormatDeserialize(FormatDeserializer &deserializer) {
58
+ auto result = duckdb::unique_ptr<SelectNode>(new SelectNode());
59
+ deserializer.ReadProperty("select_list", result->select_list);
60
+ deserializer.ReadOptionalProperty("from_table", result->from_table);
61
+ deserializer.ReadOptionalProperty("where_clause", result->where_clause);
62
+ deserializer.ReadProperty("group_expressions", result->groups.group_expressions);
63
+ deserializer.ReadProperty("group_sets", result->groups.grouping_sets);
64
+ deserializer.ReadProperty("aggregate_handling", result->aggregate_handling);
65
+ deserializer.ReadOptionalProperty("having", result->having);
66
+ deserializer.ReadOptionalProperty("sample", result->sample);
67
+ deserializer.ReadOptionalProperty("qualify", result->qualify);
68
+ return std::move(result);
69
+ }
70
+
71
+ void SetOperationNode::FormatSerialize(FormatSerializer &serializer) const {
72
+ QueryNode::FormatSerialize(serializer);
73
+ serializer.WriteProperty("setop_type", setop_type);
74
+ serializer.WriteProperty("left", *left);
75
+ serializer.WriteProperty("right", *right);
76
+ }
77
+
78
+ unique_ptr<QueryNode> SetOperationNode::FormatDeserialize(FormatDeserializer &deserializer) {
79
+ auto result = duckdb::unique_ptr<SetOperationNode>(new SetOperationNode());
80
+ deserializer.ReadProperty("setop_type", result->setop_type);
81
+ deserializer.ReadProperty("left", result->left);
82
+ deserializer.ReadProperty("right", result->right);
83
+ return std::move(result);
84
+ }
85
+
86
+ void RecursiveCTENode::FormatSerialize(FormatSerializer &serializer) const {
87
+ QueryNode::FormatSerialize(serializer);
88
+ serializer.WriteProperty("cte_name", ctename);
89
+ serializer.WriteProperty("union_all", union_all);
90
+ serializer.WriteProperty("left", *left);
91
+ serializer.WriteProperty("right", *right);
92
+ serializer.WriteProperty("aliases", aliases);
93
+ }
94
+
95
+ unique_ptr<QueryNode> RecursiveCTENode::FormatDeserialize(FormatDeserializer &deserializer) {
96
+ auto result = duckdb::unique_ptr<RecursiveCTENode>(new RecursiveCTENode());
97
+ deserializer.ReadProperty("cte_name", result->ctename);
98
+ deserializer.ReadProperty("union_all", result->union_all);
99
+ deserializer.ReadProperty("left", result->left);
100
+ deserializer.ReadProperty("right", result->right);
101
+ deserializer.ReadProperty("aliases", result->aliases);
102
+ return std::move(result);
103
+ }
104
+
105
+ void CTENode::FormatSerialize(FormatSerializer &serializer) const {
106
+ QueryNode::FormatSerialize(serializer);
107
+ serializer.WriteProperty("cte_name", ctename);
108
+ serializer.WriteProperty("query", *query);
109
+ serializer.WriteProperty("child", *child);
110
+ serializer.WriteProperty("aliases", aliases);
111
+ }
112
+
113
+ unique_ptr<QueryNode> CTENode::FormatDeserialize(FormatDeserializer &deserializer) {
114
+ auto result = duckdb::unique_ptr<CTENode>(new CTENode());
115
+ deserializer.ReadProperty("cte_name", result->ctename);
116
+ deserializer.ReadProperty("query", result->query);
117
+ deserializer.ReadProperty("child", result->child);
118
+ deserializer.ReadProperty("aliases", result->aliases);
119
+ return std::move(result);
120
+ }
121
+
122
+ } // namespace duckdb