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.
- package/binding.gyp +1 -0
- package/package.json +1 -1
- package/src/duckdb/src/catalog/catalog_search_path.cpp +5 -4
- package/src/duckdb/src/common/radix_partitioning.cpp +1 -1
- package/src/duckdb/src/function/table/version/pragma_version.cpp +2 -2
- package/src/duckdb/src/include/duckdb/core_functions/aggregate/algebraic_functions.hpp +3 -1
- package/src/duckdb/src/include/duckdb/core_functions/aggregate/distributive_functions.hpp +3 -1
- package/src/duckdb/src/include/duckdb/core_functions/aggregate/holistic_functions.hpp +3 -1
- package/src/duckdb/src/include/duckdb/core_functions/aggregate/nested_functions.hpp +3 -1
- package/src/duckdb/src/include/duckdb/core_functions/aggregate/regression_functions.hpp +3 -1
- package/src/duckdb/src/include/duckdb/core_functions/scalar/bit_functions.hpp +3 -1
- package/src/duckdb/src/include/duckdb/core_functions/scalar/blob_functions.hpp +3 -1
- package/src/duckdb/src/include/duckdb/core_functions/scalar/date_functions.hpp +3 -1
- package/src/duckdb/src/include/duckdb/core_functions/scalar/enum_functions.hpp +3 -1
- package/src/duckdb/src/include/duckdb/core_functions/scalar/generic_functions.hpp +3 -1
- package/src/duckdb/src/include/duckdb/core_functions/scalar/list_functions.hpp +3 -1
- package/src/duckdb/src/include/duckdb/core_functions/scalar/map_functions.hpp +3 -1
- package/src/duckdb/src/include/duckdb/core_functions/scalar/math_functions.hpp +3 -1
- package/src/duckdb/src/include/duckdb/core_functions/scalar/operators_functions.hpp +3 -1
- package/src/duckdb/src/include/duckdb/core_functions/scalar/random_functions.hpp +3 -1
- package/src/duckdb/src/include/duckdb/core_functions/scalar/string_functions.hpp +3 -1
- package/src/duckdb/src/include/duckdb/core_functions/scalar/struct_functions.hpp +3 -1
- package/src/duckdb/src/include/duckdb/core_functions/scalar/union_functions.hpp +3 -1
- package/src/duckdb/src/include/duckdb/parser/expression/between_expression.hpp +3 -0
- package/src/duckdb/src/include/duckdb/parser/expression/cast_expression.hpp +3 -0
- package/src/duckdb/src/include/duckdb/parser/expression/collate_expression.hpp +3 -0
- package/src/duckdb/src/include/duckdb/parser/expression/columnref_expression.hpp +3 -0
- package/src/duckdb/src/include/duckdb/parser/expression/comparison_expression.hpp +3 -0
- package/src/duckdb/src/include/duckdb/parser/expression/constant_expression.hpp +3 -0
- package/src/duckdb/src/include/duckdb/parser/expression/default_expression.hpp +1 -0
- package/src/duckdb/src/include/duckdb/parser/expression/function_expression.hpp +3 -0
- package/src/duckdb/src/include/duckdb/parser/expression/lambda_expression.hpp +3 -0
- package/src/duckdb/src/include/duckdb/parser/expression/positional_reference_expression.hpp +3 -0
- package/src/duckdb/src/include/duckdb/parser/expression/window_expression.hpp +3 -0
- package/src/duckdb/src/include/duckdb/parser/tableref/emptytableref.hpp +1 -0
- package/src/duckdb/src/include/duckdb/parser/tableref/joinref.hpp +1 -1
- package/src/duckdb/src/include/duckdb/parser/tableref/subqueryref.hpp +3 -0
- package/src/duckdb/src/parser/expression/between_expression.cpp +3 -15
- package/src/duckdb/src/parser/expression/case_expression.cpp +0 -13
- package/src/duckdb/src/parser/expression/cast_expression.cpp +3 -14
- package/src/duckdb/src/parser/expression/collate_expression.cpp +3 -13
- package/src/duckdb/src/parser/expression/columnref_expression.cpp +3 -12
- package/src/duckdb/src/parser/expression/comparison_expression.cpp +3 -13
- package/src/duckdb/src/parser/expression/conjunction_expression.cpp +0 -12
- package/src/duckdb/src/parser/expression/constant_expression.cpp +3 -11
- package/src/duckdb/src/parser/expression/default_expression.cpp +0 -4
- package/src/duckdb/src/parser/expression/function_expression.cpp +3 -32
- package/src/duckdb/src/parser/expression/lambda_expression.cpp +3 -13
- package/src/duckdb/src/parser/expression/operator_expression.cpp +0 -12
- package/src/duckdb/src/parser/expression/parameter_expression.cpp +0 -12
- package/src/duckdb/src/parser/expression/positional_reference_expression.cpp +4 -11
- package/src/duckdb/src/parser/expression/star_expression.cpp +0 -19
- package/src/duckdb/src/parser/expression/subquery_expression.cpp +0 -18
- package/src/duckdb/src/parser/expression/window_expression.cpp +3 -39
- package/src/duckdb/src/parser/parsed_expression.cpp +0 -70
- package/src/duckdb/src/parser/query_node/cte_node.cpp +0 -17
- package/src/duckdb/src/parser/query_node/recursive_cte_node.cpp +0 -19
- package/src/duckdb/src/parser/query_node/select_node.cpp +0 -29
- package/src/duckdb/src/parser/query_node/set_operation_node.cpp +0 -15
- package/src/duckdb/src/parser/query_node.cpp +0 -39
- package/src/duckdb/src/parser/result_modifier.cpp +0 -74
- package/src/duckdb/src/parser/tableref/basetableref.cpp +0 -19
- package/src/duckdb/src/parser/tableref/emptytableref.cpp +0 -4
- package/src/duckdb/src/parser/tableref/expressionlistref.cpp +0 -15
- package/src/duckdb/src/parser/tableref/joinref.cpp +0 -23
- package/src/duckdb/src/parser/tableref/pivotref.cpp +0 -23
- package/src/duckdb/src/parser/tableref/subqueryref.cpp +3 -13
- package/src/duckdb/src/parser/tableref/table_function.cpp +0 -15
- package/src/duckdb/src/parser/tableref.cpp +0 -44
- package/src/duckdb/src/storage/serialization/serialize_parsed_expression.cpp +340 -0
- package/src/duckdb/src/storage/serialization/serialize_query_node.cpp +122 -0
- package/src/duckdb/src/storage/serialization/serialize_result_modifier.cpp +86 -0
- package/src/duckdb/src/storage/serialization/serialize_tableref.cpp +166 -0
- 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
|