1#include "duckdb/parser/result_modifier.hpp"
2#include "duckdb/common/serializer.hpp"
3#include "duckdb/parser/expression_util.hpp"
4
5namespace duckdb {
6
7bool ResultModifier::Equals(const ResultModifier *other) const {
8 if (!other) {
9 return false;
10 }
11 return type == other->type;
12}
13
14void ResultModifier::Serialize(Serializer &serializer) {
15 serializer.Write<ResultModifierType>(type);
16}
17
18unique_ptr<ResultModifier> ResultModifier::Deserialize(Deserializer &source) {
19 auto type = source.Read<ResultModifierType>();
20 switch (type) {
21 case ResultModifierType::LIMIT_MODIFIER:
22 return LimitModifier::Deserialize(source);
23 case ResultModifierType::ORDER_MODIFIER:
24 return OrderModifier::Deserialize(source);
25 case ResultModifierType::DISTINCT_MODIFIER:
26 return DistinctModifier::Deserialize(source);
27 default:
28 return nullptr;
29 }
30}
31
32bool LimitModifier::Equals(const ResultModifier *other_) const {
33 if (!ResultModifier::Equals(other_)) {
34 return false;
35 }
36 auto &other = (LimitModifier &)*other_;
37 if (!BaseExpression::Equals(limit.get(), other.limit.get())) {
38 return false;
39 }
40 if (!BaseExpression::Equals(offset.get(), other.offset.get())) {
41 return false;
42 }
43 return true;
44}
45
46unique_ptr<ResultModifier> LimitModifier::Copy() {
47 auto copy = make_unique<LimitModifier>();
48 if (limit) {
49 copy->limit = limit->Copy();
50 }
51 if (offset) {
52 copy->offset = offset->Copy();
53 }
54 return move(copy);
55}
56
57void LimitModifier::Serialize(Serializer &serializer) {
58 ResultModifier::Serialize(serializer);
59 serializer.WriteOptional(limit);
60 serializer.WriteOptional(offset);
61}
62
63unique_ptr<ResultModifier> LimitModifier::Deserialize(Deserializer &source) {
64 auto mod = make_unique<LimitModifier>();
65 mod->limit = source.ReadOptional<ParsedExpression>();
66 mod->offset = source.ReadOptional<ParsedExpression>();
67 return move(mod);
68}
69
70bool DistinctModifier::Equals(const ResultModifier *other_) const {
71 if (!ResultModifier::Equals(other_)) {
72 return false;
73 }
74 auto &other = (DistinctModifier &)*other_;
75 if (!ExpressionUtil::ListEquals(distinct_on_targets, other.distinct_on_targets)) {
76 return false;
77 }
78 return true;
79}
80
81unique_ptr<ResultModifier> DistinctModifier::Copy() {
82 auto copy = make_unique<DistinctModifier>();
83 for (auto &expr : distinct_on_targets) {
84 copy->distinct_on_targets.push_back(expr->Copy());
85 }
86 return move(copy);
87}
88
89void DistinctModifier::Serialize(Serializer &serializer) {
90 ResultModifier::Serialize(serializer);
91 serializer.WriteList(distinct_on_targets);
92}
93
94unique_ptr<ResultModifier> DistinctModifier::Deserialize(Deserializer &source) {
95 auto mod = make_unique<DistinctModifier>();
96 source.ReadList<ParsedExpression>(mod->distinct_on_targets);
97 return move(mod);
98}
99
100bool OrderModifier::Equals(const ResultModifier *other_) const {
101 if (!ResultModifier::Equals(other_)) {
102 return false;
103 }
104 auto &other = (OrderModifier &)*other_;
105 if (orders.size() != other.orders.size()) {
106 return false;
107 }
108 for (idx_t i = 0; i < orders.size(); i++) {
109 if (orders[i].type != other.orders[i].type) {
110 return false;
111 }
112 if (!BaseExpression::Equals(orders[i].expression.get(), other.orders[i].expression.get())) {
113 return false;
114 }
115 }
116 return true;
117}
118
119unique_ptr<ResultModifier> OrderModifier::Copy() {
120 auto copy = make_unique<OrderModifier>();
121 for (auto &order : orders) {
122 OrderByNode node;
123 node.type = order.type;
124 node.expression = order.expression->Copy();
125 copy->orders.push_back(move(node));
126 }
127 return move(copy);
128}
129
130void OrderModifier::Serialize(Serializer &serializer) {
131 ResultModifier::Serialize(serializer);
132 serializer.Write<int64_t>(orders.size());
133 for (auto &order : orders) {
134 serializer.Write<OrderType>(order.type);
135 order.expression->Serialize(serializer);
136 }
137}
138
139unique_ptr<ResultModifier> OrderModifier::Deserialize(Deserializer &source) {
140 auto mod = make_unique<OrderModifier>();
141 auto order_count = source.Read<int64_t>();
142 for (int64_t i = 0; i < order_count; i++) {
143 OrderByNode node;
144 node.type = source.Read<OrderType>();
145 node.expression = ParsedExpression::Deserialize(source);
146 mod->orders.push_back(move(node));
147 }
148 return move(mod);
149}
150
151} // namespace duckdb
152