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
@@ -27,8 +27,4 @@ unique_ptr<ParsedExpression> DefaultExpression::Deserialize(ExpressionType type,
27
27
  return make_uniq<DefaultExpression>();
28
28
  }
29
29
 
30
- void DefaultExpression::FormatSerialize(FormatSerializer &serializer) const {
31
- ParsedExpression::FormatSerialize(serializer);
32
- }
33
-
34
30
  } // namespace duckdb
@@ -11,6 +11,9 @@
11
11
 
12
12
  namespace duckdb {
13
13
 
14
+ FunctionExpression::FunctionExpression() : ParsedExpression(ExpressionType::FUNCTION, ExpressionClass::FUNCTION) {
15
+ }
16
+
14
17
  FunctionExpression::FunctionExpression(string catalog, string schema, const string &function_name,
15
18
  vector<unique_ptr<ParsedExpression>> children_p,
16
19
  unique_ptr<ParsedExpression> filter, unique_ptr<OrderModifier> order_bys_p,
@@ -122,36 +125,4 @@ void FunctionExpression::Verify() const {
122
125
  D_ASSERT(!function_name.empty());
123
126
  }
124
127
 
125
- void FunctionExpression::FormatSerialize(FormatSerializer &serializer) const {
126
- ParsedExpression::FormatSerialize(serializer);
127
- serializer.WriteProperty("function_name", function_name);
128
- serializer.WriteProperty("schema", schema);
129
- serializer.WriteProperty("children", children);
130
- serializer.WriteOptionalProperty("filter", filter);
131
- serializer.WriteProperty("order_bys", (ResultModifier &)*order_bys);
132
- serializer.WriteProperty("distinct", distinct);
133
- serializer.WriteProperty("is_operator", is_operator);
134
- serializer.WriteProperty("export_state", export_state);
135
- serializer.WriteProperty("catalog", catalog);
136
- }
137
-
138
- unique_ptr<ParsedExpression> FunctionExpression::FormatDeserialize(ExpressionType type,
139
- FormatDeserializer &deserializer) {
140
- auto function_name = deserializer.ReadProperty<string>("function_name");
141
- auto schema = deserializer.ReadProperty<string>("schema");
142
- auto children = deserializer.ReadProperty<vector<unique_ptr<ParsedExpression>>>("children");
143
- auto filter = deserializer.ReadOptionalProperty<unique_ptr<ParsedExpression>>("filter");
144
- auto order_bys = unique_ptr_cast<ResultModifier, OrderModifier>(
145
- deserializer.ReadProperty<unique_ptr<ResultModifier>>("order_bys"));
146
- auto distinct = deserializer.ReadProperty<bool>("distinct");
147
- auto is_operator = deserializer.ReadProperty<bool>("is_operator");
148
- auto export_state = deserializer.ReadProperty<bool>("export_state");
149
- auto catalog = deserializer.ReadProperty<string>("catalog");
150
-
151
- unique_ptr<FunctionExpression> function;
152
- function = make_uniq<FunctionExpression>(catalog, schema, function_name, std::move(children), std::move(filter),
153
- std::move(order_bys), distinct, is_operator, export_state);
154
- return std::move(function);
155
- }
156
-
157
128
  } // namespace duckdb
@@ -8,6 +8,9 @@
8
8
 
9
9
  namespace duckdb {
10
10
 
11
+ LambdaExpression::LambdaExpression() : ParsedExpression(ExpressionType::LAMBDA, ExpressionClass::LAMBDA) {
12
+ }
13
+
11
14
  LambdaExpression::LambdaExpression(unique_ptr<ParsedExpression> lhs, unique_ptr<ParsedExpression> expr)
12
15
  : ParsedExpression(ExpressionType::LAMBDA, ExpressionClass::LAMBDA), lhs(std::move(lhs)), expr(std::move(expr)) {
13
16
  }
@@ -44,17 +47,4 @@ unique_ptr<ParsedExpression> LambdaExpression::Deserialize(ExpressionType type,
44
47
  return make_uniq<LambdaExpression>(std::move(lhs), std::move(expr));
45
48
  }
46
49
 
47
- void LambdaExpression::FormatSerialize(FormatSerializer &serializer) const {
48
- ParsedExpression::FormatSerialize(serializer);
49
- serializer.WriteProperty("lhs", *lhs);
50
- serializer.WriteProperty("expr", *expr);
51
- }
52
-
53
- unique_ptr<ParsedExpression> LambdaExpression::FormatDeserialize(ExpressionType type,
54
- FormatDeserializer &deserializer) {
55
- auto lhs = deserializer.ReadProperty<unique_ptr<ParsedExpression>>("lhs");
56
- auto expr = deserializer.ReadProperty<unique_ptr<ParsedExpression>>("expr");
57
- return make_uniq<LambdaExpression>(std::move(lhs), std::move(expr));
58
- }
59
-
60
50
  } // namespace duckdb
@@ -58,16 +58,4 @@ unique_ptr<ParsedExpression> OperatorExpression::Deserialize(ExpressionType type
58
58
  return std::move(expression);
59
59
  }
60
60
 
61
- void OperatorExpression::FormatSerialize(FormatSerializer &serializer) const {
62
- ParsedExpression::FormatSerialize(serializer);
63
- serializer.WriteProperty("children", children);
64
- }
65
-
66
- unique_ptr<ParsedExpression> OperatorExpression::FormatDeserialize(ExpressionType type,
67
- FormatDeserializer &deserializer) {
68
- auto expression = make_uniq<OperatorExpression>(type);
69
- expression->children = deserializer.ReadProperty<vector<unique_ptr<ParsedExpression>>>("children");
70
- return std::move(expression);
71
- }
72
-
73
61
  } // namespace duckdb
@@ -44,16 +44,4 @@ unique_ptr<ParsedExpression> ParameterExpression::Deserialize(ExpressionType typ
44
44
  return std::move(expression);
45
45
  }
46
46
 
47
- void ParameterExpression::FormatSerialize(FormatSerializer &serializer) const {
48
- ParsedExpression::FormatSerialize(serializer);
49
- serializer.WriteProperty("parameter_nr", parameter_nr);
50
- }
51
-
52
- unique_ptr<ParsedExpression> ParameterExpression::FormatDeserialize(ExpressionType type,
53
- FormatDeserializer &deserializer) {
54
- auto expression = make_uniq<ParameterExpression>();
55
- expression->parameter_nr = deserializer.ReadProperty<idx_t>("parameter_nr");
56
- return std::move(expression);
57
- }
58
-
59
47
  } // namespace duckdb
@@ -10,6 +10,10 @@
10
10
 
11
11
  namespace duckdb {
12
12
 
13
+ PositionalReferenceExpression::PositionalReferenceExpression()
14
+ : ParsedExpression(ExpressionType::POSITIONAL_REFERENCE, ExpressionClass::POSITIONAL_REFERENCE) {
15
+ }
16
+
13
17
  PositionalReferenceExpression::PositionalReferenceExpression(idx_t index)
14
18
  : ParsedExpression(ExpressionType::POSITIONAL_REFERENCE, ExpressionClass::POSITIONAL_REFERENCE), index(index) {
15
19
  }
@@ -43,15 +47,4 @@ unique_ptr<ParsedExpression> PositionalReferenceExpression::Deserialize(Expressi
43
47
  return std::move(expression);
44
48
  }
45
49
 
46
- void PositionalReferenceExpression::FormatSerialize(FormatSerializer &serializer) const {
47
- ParsedExpression::FormatSerialize(serializer);
48
- serializer.WriteProperty("index", index);
49
- }
50
-
51
- unique_ptr<ParsedExpression> PositionalReferenceExpression::FormatDeserialize(ExpressionType type,
52
- FormatDeserializer &deserializer) {
53
- auto expression = make_uniq<PositionalReferenceExpression>(deserializer.ReadProperty<idx_t>("index"));
54
- return std::move(expression);
55
- }
56
-
57
50
  } // namespace duckdb
@@ -131,23 +131,4 @@ unique_ptr<ParsedExpression> StarExpression::Copy() const {
131
131
  return std::move(copy);
132
132
  }
133
133
 
134
- void StarExpression::FormatSerialize(FormatSerializer &serializer) const {
135
- ParsedExpression::FormatSerialize(serializer);
136
- serializer.WriteProperty("relation_name", relation_name);
137
- serializer.WriteProperty("exclude_list", exclude_list);
138
- serializer.WriteProperty("replace_list", replace_list);
139
- serializer.WriteProperty("columns", columns);
140
- serializer.WriteOptionalProperty("expr", expr);
141
- }
142
-
143
- unique_ptr<ParsedExpression> StarExpression::FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer) {
144
- auto result = make_uniq<StarExpression>();
145
- deserializer.ReadProperty("relation_name", result->relation_name);
146
- deserializer.ReadProperty("exclude_list", result->exclude_list);
147
- deserializer.ReadProperty("replace_list", result->replace_list);
148
- deserializer.ReadProperty("columns", result->columns);
149
- deserializer.ReadOptionalProperty("expr", result->expr);
150
- return std::move(result);
151
- }
152
-
153
134
  } // namespace duckdb
@@ -74,22 +74,4 @@ unique_ptr<ParsedExpression> SubqueryExpression::Deserialize(ExpressionType type
74
74
  return std::move(expression);
75
75
  }
76
76
 
77
- void SubqueryExpression::FormatSerialize(FormatSerializer &serializer) const {
78
- ParsedExpression::FormatSerialize(serializer);
79
- serializer.WriteProperty("subquery_type", subquery_type);
80
- serializer.WriteProperty("subquery", *subquery);
81
- serializer.WriteOptionalProperty("child", child);
82
- serializer.WriteProperty("comparison_type", comparison_type);
83
- }
84
-
85
- unique_ptr<ParsedExpression> SubqueryExpression::FormatDeserialize(ExpressionType type,
86
- FormatDeserializer &deserializer) {
87
- auto expression = make_uniq<SubqueryExpression>();
88
- deserializer.ReadProperty("subquery_type", expression->subquery_type);
89
- deserializer.ReadProperty("subquery", expression->subquery);
90
- deserializer.ReadOptionalProperty("child", expression->child);
91
- deserializer.ReadProperty("comparison_type", expression->comparison_type);
92
- return std::move(expression);
93
- }
94
-
95
77
  } // namespace duckdb
@@ -10,6 +10,9 @@
10
10
 
11
11
  namespace duckdb {
12
12
 
13
+ WindowExpression::WindowExpression(ExpressionType type) : ParsedExpression(type, ExpressionClass::WINDOW) {
14
+ }
15
+
13
16
  WindowExpression::WindowExpression(ExpressionType type, string catalog_name, string schema, const string &function_name)
14
17
  : ParsedExpression(type, ExpressionClass::WINDOW), catalog(std::move(catalog_name)), schema(std::move(schema)),
15
18
  function_name(StringUtil::Lower(function_name)), ignore_nulls(false) {
@@ -159,45 +162,6 @@ void WindowExpression::Serialize(FieldWriter &writer) const {
159
162
  writer.WriteString(catalog);
160
163
  }
161
164
 
162
- void WindowExpression::FormatSerialize(FormatSerializer &serializer) const {
163
- ParsedExpression::FormatSerialize(serializer);
164
- serializer.WriteProperty("function_name", function_name);
165
- serializer.WriteProperty("schema", schema);
166
- serializer.WriteProperty("children", children);
167
- serializer.WriteProperty("partitions", partitions);
168
- serializer.WriteProperty("orders", orders);
169
- serializer.WriteProperty("start", start);
170
- serializer.WriteProperty("end", end);
171
- serializer.WriteOptionalProperty("start_expr", start_expr);
172
- serializer.WriteOptionalProperty("end_expr", end_expr);
173
- serializer.WriteOptionalProperty("offset_expr", offset_expr);
174
- serializer.WriteOptionalProperty("default_expr", default_expr);
175
- serializer.WriteProperty("ignore_nulls", ignore_nulls);
176
- serializer.WriteOptionalProperty("filter_expr", filter_expr);
177
- serializer.WriteProperty("catalog", catalog);
178
- }
179
-
180
- unique_ptr<ParsedExpression> WindowExpression::FormatDeserialize(ExpressionType type,
181
- FormatDeserializer &deserializer) {
182
- auto function_name = deserializer.ReadProperty<string>("function_name");
183
- auto schema = deserializer.ReadProperty<string>("schema");
184
- auto expr = make_uniq<WindowExpression>(type, INVALID_CATALOG, std::move(schema), function_name);
185
-
186
- deserializer.ReadProperty("children", expr->children);
187
- deserializer.ReadProperty("partitions", expr->partitions);
188
- deserializer.ReadProperty("orders", expr->orders);
189
- deserializer.ReadProperty("start", expr->start);
190
- deserializer.ReadProperty("end", expr->end);
191
- deserializer.ReadOptionalProperty("start_expr", expr->start_expr);
192
- deserializer.ReadOptionalProperty("end_expr", expr->end_expr);
193
- deserializer.ReadOptionalProperty("offset_expr", expr->offset_expr);
194
- deserializer.ReadOptionalProperty("default_expr", expr->default_expr);
195
- deserializer.ReadProperty("ignore_nulls", expr->ignore_nulls);
196
- deserializer.ReadOptionalProperty("filter_expr", expr->filter_expr);
197
- deserializer.ReadProperty("catalog", expr->catalog);
198
- return std::move(expr);
199
- }
200
-
201
165
  unique_ptr<ParsedExpression> WindowExpression::Deserialize(ExpressionType type, FieldReader &reader) {
202
166
  auto function_name = reader.ReadRequired<string>();
203
167
  auto schema = reader.ReadRequired<string>();
@@ -110,76 +110,6 @@ void ParsedExpression::Serialize(Serializer &serializer) const {
110
110
  writer.Finalize();
111
111
  }
112
112
 
113
- void ParsedExpression::FormatSerialize(FormatSerializer &serializer) const {
114
- serializer.WriteProperty("class", GetExpressionClass());
115
- serializer.WriteProperty("type", type);
116
- serializer.WriteProperty("alias", alias);
117
- }
118
-
119
- unique_ptr<ParsedExpression> ParsedExpression::FormatDeserialize(FormatDeserializer &deserializer) {
120
- auto expression_class = deserializer.ReadProperty<ExpressionClass>("class");
121
- auto type = deserializer.ReadProperty<ExpressionType>("type");
122
- auto alias = deserializer.ReadProperty<string>("alias");
123
- unique_ptr<ParsedExpression> result;
124
- switch (expression_class) {
125
- case ExpressionClass::BETWEEN:
126
- result = BetweenExpression::FormatDeserialize(type, deserializer);
127
- break;
128
- case ExpressionClass::CASE:
129
- result = CaseExpression::FormatDeserialize(type, deserializer);
130
- break;
131
- case ExpressionClass::CAST:
132
- result = CastExpression::FormatDeserialize(type, deserializer);
133
- break;
134
- case ExpressionClass::COLLATE:
135
- result = CollateExpression::FormatDeserialize(type, deserializer);
136
- break;
137
- case ExpressionClass::COLUMN_REF:
138
- result = ColumnRefExpression::FormatDeserialize(type, deserializer);
139
- break;
140
- case ExpressionClass::COMPARISON:
141
- result = ComparisonExpression::FormatDeserialize(type, deserializer);
142
- break;
143
- case ExpressionClass::CONJUNCTION:
144
- result = ConjunctionExpression::FormatDeserialize(type, deserializer);
145
- break;
146
- case ExpressionClass::CONSTANT:
147
- result = ConstantExpression::FormatDeserialize(type, deserializer);
148
- break;
149
- case ExpressionClass::DEFAULT:
150
- result = make_uniq<DefaultExpression>();
151
- break;
152
- case ExpressionClass::FUNCTION:
153
- result = FunctionExpression::FormatDeserialize(type, deserializer);
154
- break;
155
- case ExpressionClass::LAMBDA:
156
- result = LambdaExpression::FormatDeserialize(type, deserializer);
157
- break;
158
- case ExpressionClass::OPERATOR:
159
- result = OperatorExpression::FormatDeserialize(type, deserializer);
160
- break;
161
- case ExpressionClass::PARAMETER:
162
- result = ParameterExpression::FormatDeserialize(type, deserializer);
163
- break;
164
- case ExpressionClass::POSITIONAL_REFERENCE:
165
- result = PositionalReferenceExpression::FormatDeserialize(type, deserializer);
166
- break;
167
- case ExpressionClass::STAR:
168
- result = StarExpression::FormatDeserialize(type, deserializer);
169
- break;
170
- case ExpressionClass::SUBQUERY:
171
- result = SubqueryExpression::FormatDeserialize(type, deserializer);
172
- break;
173
- case ExpressionClass::WINDOW:
174
- result = WindowExpression::FormatDeserialize(type, deserializer);
175
- break;
176
- default:
177
- throw SerializationException("Unsupported type for expression deserialization!");
178
- }
179
- result->alias = alias;
180
- return result;
181
- }
182
-
183
113
  unique_ptr<ParsedExpression> ParsedExpression::Deserialize(Deserializer &source) {
184
114
  FieldReader reader(source);
185
115
  auto expression_class = reader.ReadRequired<ExpressionClass>();
@@ -55,21 +55,4 @@ unique_ptr<QueryNode> CTENode::Deserialize(FieldReader &reader) {
55
55
  return std::move(result);
56
56
  }
57
57
 
58
- void CTENode::FormatSerialize(FormatSerializer &serializer) const {
59
- QueryNode::FormatSerialize(serializer);
60
- serializer.WriteProperty("cte_name", ctename);
61
- serializer.WriteProperty("query", *query);
62
- serializer.WriteProperty("child", *child);
63
- serializer.WriteProperty("aliases", aliases);
64
- }
65
-
66
- unique_ptr<QueryNode> CTENode::FormatDeserialize(FormatDeserializer &deserializer) {
67
- auto result = make_uniq<CTENode>();
68
- deserializer.ReadProperty("cte_name", result->ctename);
69
- deserializer.ReadProperty("query", result->query);
70
- deserializer.ReadProperty("child", result->child);
71
- deserializer.ReadProperty("aliases", result->aliases);
72
- return std::move(result);
73
- }
74
-
75
58
  } // namespace duckdb
@@ -66,23 +66,4 @@ unique_ptr<QueryNode> RecursiveCTENode::Deserialize(FieldReader &reader) {
66
66
  return std::move(result);
67
67
  }
68
68
 
69
- void RecursiveCTENode::FormatSerialize(FormatSerializer &serializer) const {
70
- QueryNode::FormatSerialize(serializer);
71
- serializer.WriteProperty("cte_name", ctename);
72
- serializer.WriteProperty("union_all", union_all);
73
- serializer.WriteProperty("left", *left);
74
- serializer.WriteProperty("right", *right);
75
- serializer.WriteProperty("aliases", aliases);
76
- }
77
-
78
- unique_ptr<QueryNode> RecursiveCTENode::FormatDeserialize(FormatDeserializer &deserializer) {
79
- auto result = make_uniq<RecursiveCTENode>();
80
- deserializer.ReadProperty("cte_name", result->ctename);
81
- deserializer.ReadProperty("union_all", result->union_all);
82
- deserializer.ReadProperty("left", result->left);
83
- deserializer.ReadProperty("right", result->right);
84
- deserializer.ReadProperty("aliases", result->aliases);
85
- return std::move(result);
86
- }
87
-
88
69
  } // namespace duckdb
@@ -187,35 +187,6 @@ void SelectNode::Serialize(FieldWriter &writer) const {
187
187
  writer.WriteOptional(qualify);
188
188
  }
189
189
 
190
- void SelectNode::FormatSerialize(FormatSerializer &serializer) const {
191
- QueryNode::FormatSerialize(serializer);
192
- serializer.WriteProperty("select_list", select_list);
193
- serializer.WriteOptionalProperty("from_table", from_table);
194
- serializer.WriteOptionalProperty("where_clause", where_clause);
195
- serializer.WriteProperty("group_expressions", groups.group_expressions);
196
- serializer.WriteProperty("group_sets", groups.grouping_sets);
197
- serializer.WriteProperty("aggregate_handling", aggregate_handling);
198
- serializer.WriteOptionalProperty("having", having);
199
- serializer.WriteOptionalProperty("sample", sample);
200
- serializer.WriteOptionalProperty("qualify", qualify);
201
- }
202
-
203
- unique_ptr<QueryNode> SelectNode::FormatDeserialize(FormatDeserializer &deserializer) {
204
- auto result = make_uniq<SelectNode>();
205
-
206
- deserializer.ReadProperty("select_list", result->select_list);
207
- deserializer.ReadOptionalProperty("from_table", result->from_table);
208
- deserializer.ReadOptionalProperty("where_clause", result->where_clause);
209
- deserializer.ReadProperty("group_expressions", result->groups.group_expressions);
210
- deserializer.ReadProperty("group_sets", result->groups.grouping_sets);
211
- deserializer.ReadProperty("aggregate_handling", result->aggregate_handling);
212
- deserializer.ReadOptionalProperty("having", result->having);
213
- deserializer.ReadOptionalProperty("sample", result->sample);
214
- deserializer.ReadOptionalProperty("qualify", result->qualify);
215
-
216
- return std::move(result);
217
- }
218
-
219
190
  unique_ptr<QueryNode> SelectNode::Deserialize(FieldReader &reader) {
220
191
  auto result = make_uniq<SelectNode>();
221
192
  result->select_list = reader.ReadRequiredSerializableList<ParsedExpression>();
@@ -83,19 +83,4 @@ unique_ptr<QueryNode> SetOperationNode::Deserialize(FieldReader &reader) {
83
83
  return std::move(result);
84
84
  }
85
85
 
86
- void SetOperationNode::FormatSerialize(duckdb::FormatSerializer &serializer) const {
87
- QueryNode::FormatSerialize(serializer);
88
- serializer.WriteProperty("set_op_type", setop_type);
89
- serializer.WriteProperty("left", *left);
90
- serializer.WriteProperty("right", *right);
91
- }
92
-
93
- unique_ptr<QueryNode> SetOperationNode::FormatDeserialize(duckdb::FormatDeserializer &deserializer) {
94
- auto result = make_uniq<SetOperationNode>();
95
- deserializer.ReadProperty("set_op_type", result->setop_type);
96
- deserializer.ReadProperty("left", result->left);
97
- deserializer.ReadProperty("right", result->right);
98
- return std::move(result);
99
- }
100
-
101
86
  } // namespace duckdb
@@ -191,45 +191,6 @@ void QueryNode::Serialize(Serializer &main_serializer) const {
191
191
  writer.Finalize();
192
192
  }
193
193
 
194
- // Children should call the base method before their own.
195
- void QueryNode::FormatSerialize(FormatSerializer &serializer) const {
196
- serializer.WriteProperty("type", type);
197
- serializer.WriteProperty("modifiers", modifiers);
198
- serializer.WriteProperty("cte_map", cte_map);
199
- }
200
-
201
- unique_ptr<QueryNode> QueryNode::FormatDeserialize(FormatDeserializer &deserializer) {
202
-
203
- auto type = deserializer.ReadProperty<QueryNodeType>("type");
204
-
205
- auto modifiers = deserializer.ReadProperty<vector<unique_ptr<ResultModifier>>>("modifiers");
206
- auto cte_map = deserializer.ReadProperty<CommonTableExpressionMap>("cte_map");
207
-
208
- unique_ptr<QueryNode> result;
209
-
210
- switch (type) {
211
- case QueryNodeType::SELECT_NODE:
212
- result = SelectNode::FormatDeserialize(deserializer);
213
- break;
214
- case QueryNodeType::SET_OPERATION_NODE:
215
- result = SetOperationNode::FormatDeserialize(deserializer);
216
- break;
217
- case QueryNodeType::RECURSIVE_CTE_NODE:
218
- result = RecursiveCTENode::FormatDeserialize(deserializer);
219
- break;
220
- case QueryNodeType::CTE_NODE:
221
- result = CTENode::FormatDeserialize(deserializer);
222
- break;
223
- default:
224
- throw SerializationException("Could not deserialize Query Node: unknown type!");
225
- }
226
-
227
- result->type = type;
228
- result->modifiers = std::move(modifiers);
229
- result->cte_map = std::move(cte_map);
230
- return result;
231
- }
232
-
233
194
  unique_ptr<QueryNode> QueryNode::Deserialize(Deserializer &main_source) {
234
195
  FieldReader reader(main_source);
235
196
 
@@ -17,33 +17,6 @@ void ResultModifier::Serialize(Serializer &serializer) const {
17
17
  writer.Finalize();
18
18
  }
19
19
 
20
- void ResultModifier::FormatSerialize(FormatSerializer &serializer) const {
21
- serializer.WriteProperty("type", type);
22
- }
23
-
24
- unique_ptr<ResultModifier> ResultModifier::FormatDeserialize(FormatDeserializer &deserializer) {
25
- auto type = deserializer.ReadProperty<ResultModifierType>("type");
26
-
27
- unique_ptr<ResultModifier> result;
28
- switch (type) {
29
- case ResultModifierType::LIMIT_MODIFIER:
30
- result = LimitModifier::FormatDeserialize(deserializer);
31
- break;
32
- case ResultModifierType::ORDER_MODIFIER:
33
- result = OrderModifier::FormatDeserialize(deserializer);
34
- break;
35
- case ResultModifierType::DISTINCT_MODIFIER:
36
- result = DistinctModifier::FormatDeserialize(deserializer);
37
- break;
38
- case ResultModifierType::LIMIT_PERCENT_MODIFIER:
39
- result = LimitPercentModifier::FormatDeserialize(deserializer);
40
- break;
41
- default:
42
- throw InternalException("Unrecognized ResultModifierType for Deserialization");
43
- }
44
- return result;
45
- }
46
-
47
20
  unique_ptr<ResultModifier> ResultModifier::Deserialize(Deserializer &source) {
48
21
  FieldReader reader(source);
49
22
  auto type = reader.ReadRequired<ResultModifierType>();
@@ -99,19 +72,6 @@ void LimitModifier::Serialize(FieldWriter &writer) const {
99
72
  writer.WriteOptional(offset);
100
73
  }
101
74
 
102
- void LimitModifier::FormatSerialize(FormatSerializer &serializer) const {
103
- ResultModifier::FormatSerialize(serializer);
104
- serializer.WriteOptionalProperty("limit", limit);
105
- serializer.WriteOptionalProperty("offset", offset);
106
- }
107
-
108
- unique_ptr<ResultModifier> LimitModifier::FormatDeserialize(FormatDeserializer &deserializer) {
109
- auto mod = make_uniq<LimitModifier>();
110
- deserializer.ReadOptionalProperty("limit", mod->limit);
111
- deserializer.ReadOptionalProperty("offset", mod->offset);
112
- return std::move(mod);
113
- }
114
-
115
75
  unique_ptr<ResultModifier> LimitModifier::Deserialize(FieldReader &reader) {
116
76
  auto mod = make_uniq<LimitModifier>();
117
77
  mod->limit = reader.ReadOptional<ParsedExpression>(nullptr);
@@ -142,17 +102,6 @@ void DistinctModifier::Serialize(FieldWriter &writer) const {
142
102
  writer.WriteSerializableList(distinct_on_targets);
143
103
  }
144
104
 
145
- void DistinctModifier::FormatSerialize(duckdb::FormatSerializer &serializer) const {
146
- ResultModifier::FormatSerialize(serializer);
147
- serializer.WriteProperty("distinct_on_targets", distinct_on_targets);
148
- }
149
-
150
- unique_ptr<ResultModifier> DistinctModifier::FormatDeserialize(FormatDeserializer &deserializer) {
151
- auto mod = make_uniq<DistinctModifier>();
152
- deserializer.ReadProperty("distinct_on_targets", mod->distinct_on_targets);
153
- return std::move(mod);
154
- }
155
-
156
105
  unique_ptr<ResultModifier> DistinctModifier::Deserialize(FieldReader &reader) {
157
106
  auto mod = make_uniq<DistinctModifier>();
158
107
  mod->distinct_on_targets = reader.ReadRequiredSerializableList<ParsedExpression>();
@@ -256,16 +205,6 @@ void OrderModifier::Serialize(FieldWriter &writer) const {
256
205
  writer.WriteRegularSerializableList(orders);
257
206
  }
258
207
 
259
- void OrderModifier::FormatSerialize(FormatSerializer &serializer) const {
260
- ResultModifier::FormatSerialize(serializer);
261
- serializer.WriteProperty("orders", orders);
262
- }
263
- unique_ptr<ResultModifier> OrderModifier::FormatDeserialize(FormatDeserializer &deserializer) {
264
- auto mod = make_uniq<OrderModifier>();
265
- deserializer.ReadProperty("orders", mod->orders);
266
- return std::move(mod);
267
- }
268
-
269
208
  unique_ptr<ResultModifier> OrderModifier::Deserialize(FieldReader &reader) {
270
209
  auto mod = make_uniq<OrderModifier>();
271
210
  mod->orders = reader.ReadRequiredSerializableList<OrderByNode, OrderByNode>();
@@ -302,12 +241,6 @@ void LimitPercentModifier::Serialize(FieldWriter &writer) const {
302
241
  writer.WriteOptional(offset);
303
242
  }
304
243
 
305
- void LimitPercentModifier::FormatSerialize(FormatSerializer &serializer) const {
306
- ResultModifier::FormatSerialize(serializer);
307
- serializer.WriteOptionalProperty("limit", limit);
308
- serializer.WriteOptionalProperty("offset", offset);
309
- }
310
-
311
244
  unique_ptr<ResultModifier> LimitPercentModifier::Deserialize(FieldReader &reader) {
312
245
  auto mod = make_uniq<LimitPercentModifier>();
313
246
  mod->limit = reader.ReadOptional<ParsedExpression>(nullptr);
@@ -315,11 +248,4 @@ unique_ptr<ResultModifier> LimitPercentModifier::Deserialize(FieldReader &reader
315
248
  return std::move(mod);
316
249
  }
317
250
 
318
- unique_ptr<ResultModifier> LimitPercentModifier::FormatDeserialize(FormatDeserializer &deserializer) {
319
- auto mod = make_uniq<LimitPercentModifier>();
320
- deserializer.ReadOptionalProperty("limit", mod->limit);
321
- deserializer.ReadOptionalProperty("offset", mod->offset);
322
- return std::move(mod);
323
- }
324
-
325
251
  } // namespace duckdb
@@ -31,25 +31,6 @@ void BaseTableRef::Serialize(FieldWriter &writer) const {
31
31
  writer.WriteString(catalog_name);
32
32
  }
33
33
 
34
- void BaseTableRef::FormatSerialize(FormatSerializer &serializer) const {
35
- TableRef::FormatSerialize(serializer);
36
- serializer.WriteProperty("schema_name", schema_name);
37
- serializer.WriteProperty("table_name", table_name);
38
- serializer.WriteProperty("column_name_alias", column_name_alias);
39
- serializer.WriteProperty("catalog_name", catalog_name);
40
- }
41
-
42
- unique_ptr<TableRef> BaseTableRef::FormatDeserialize(FormatDeserializer &deserializer) {
43
- auto result = make_uniq<BaseTableRef>();
44
-
45
- deserializer.ReadProperty("schema_name", result->schema_name);
46
- deserializer.ReadProperty("table_name", result->table_name);
47
- deserializer.ReadProperty("column_name_alias", result->column_name_alias);
48
- deserializer.ReadProperty("catalog_name", result->catalog_name);
49
-
50
- return std::move(result);
51
- }
52
-
53
34
  unique_ptr<TableRef> BaseTableRef::Deserialize(FieldReader &reader) {
54
35
  auto result = make_uniq<BaseTableRef>();
55
36
 
@@ -23,8 +23,4 @@ unique_ptr<TableRef> EmptyTableRef::Deserialize(FieldReader &reader) {
23
23
  return make_uniq<EmptyTableRef>();
24
24
  }
25
25
 
26
- unique_ptr<TableRef> EmptyTableRef::FormatDeserialize(FormatDeserializer &source) {
27
- return make_uniq<EmptyTableRef>();
28
- }
29
-
30
26
  } // namespace duckdb
@@ -75,21 +75,6 @@ void ExpressionListRef::Serialize(FieldWriter &writer) const {
75
75
  }
76
76
  }
77
77
 
78
- void ExpressionListRef::FormatSerialize(FormatSerializer &serializer) const {
79
- TableRef::FormatSerialize(serializer);
80
- serializer.WriteProperty("expected_names", expected_names);
81
- serializer.WriteProperty("expected_types", expected_types);
82
- serializer.WriteProperty("values", values);
83
- }
84
-
85
- unique_ptr<TableRef> ExpressionListRef::FormatDeserialize(FormatDeserializer &source) {
86
- auto result = make_uniq<ExpressionListRef>();
87
- source.ReadProperty("expected_names", result->expected_names);
88
- source.ReadProperty("expected_types", result->expected_types);
89
- source.ReadProperty("values", result->values);
90
- return std::move(result);
91
- }
92
-
93
78
  unique_ptr<TableRef> ExpressionListRef::Deserialize(FieldReader &reader) {
94
79
  auto result = make_uniq<ExpressionListRef>();
95
80
  // value list