Skip to content
This repository was archived by the owner on Sep 27, 2019. It is now read-only.

Commit 18a1467

Browse files
author
GustavoAngulo
committed
More tests + formatting
1 parent 7d083d5 commit 18a1467

File tree

2 files changed

+148
-28
lines changed

2 files changed

+148
-28
lines changed

‎src/optimizer/rule_impls.cpp

Lines changed: 6 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -97,7 +97,6 @@ void InnerJoinAssociativity::Transform(
9797
std::shared_ptr<OperatorExpression> input,
9898
std::vector<std::shared_ptr<OperatorExpression>> &transformed,
9999
OptimizeContext *context) const {
100-
101100
// NOTE: Transforms (left JOIN middle) JOIN right -> left JOIN (middle JOIN
102101
// right) Variables are named accordingly to above transformation
103102
auto parent_join = input->Op().As<LogicalInnerJoin>();
@@ -113,7 +112,8 @@ void InnerJoinAssociativity::Transform(
113112
// Get Alias sets
114113
auto &memo = context->metadata->memo;
115114

116-
auto middle_group_id = children[0]->Children()[1]->Op().As<LeafOperator>()->origin_group;
115+
auto middle_group_id =
116+
children[0]->Children()[1]->Op().As<LeafOperator>()->origin_group;
117117
auto right_group_id = children[1]->Op().As<LeafOperator>()->origin_group;
118118

119119
const auto &middle_group_aliases_set =
@@ -123,8 +123,10 @@ void InnerJoinAssociativity::Transform(
123123

124124
// Union Predicates into single alias set for new child join
125125
std::unordered_set<std::string> right_join_aliases_set;
126-
right_join_aliases_set.insert(middle_group_aliases_set.begin(), middle_group_aliases_set.end());
127-
right_join_aliases_set.insert(right_group_aliases_set.begin(), right_group_aliases_set.end());
126+
right_join_aliases_set.insert(middle_group_aliases_set.begin(),
127+
middle_group_aliases_set.end());
128+
right_join_aliases_set.insert(right_group_aliases_set.begin(),
129+
right_group_aliases_set.end());
128130

129131
// Redistribute predicates
130132
auto parent_join_predicates =

‎test/optimizer/optimizer_rule_test.cpp

Lines changed: 142 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -38,7 +38,6 @@
3838
#include "sql/testing_sql_util.h"
3939
#include "type/value_factory.h"
4040

41-
4241
namespace peloton {
4342
namespace test {
4443

@@ -82,52 +81,78 @@ TEST_F(OptimizerRuleTests, SimpleCommutativeRuleTest) {
8281
}
8382

8483
TEST_F(OptimizerRuleTests, SimpleAssociativeRuleTest) {
85-
86-
// (left JOIN middle) JOIN right
87-
// Build Operator Expression
84+
// Start Join Structure: (left JOIN middle) JOIN right
85+
// End Join Structure: left JOIN (middle JOIN right)
86+
// Query: SELECT * from test1, test2, test3 WHERE test1.a = test2.a AND
87+
// test1.a = test3.a; Test ensures that predicate "test1.a = test2.a" is
88+
// redistributed to parent join
8889

8990
// Setup Memo
9091
Optimizer optimizer;
9192

92-
auto left_get = std::make_shared<OperatorExpression>(LogicalGet::make(0, {}, nullptr, "test1"));
93-
auto middle_get = std::make_shared<OperatorExpression>(LogicalGet::make(0, {}, nullptr, "test2"));
94-
auto right_get = std::make_shared<OperatorExpression>(LogicalGet::make(0, {}, nullptr, "test3"));
95-
96-
auto left_get_group = optimizer.metadata_.memo.InsertExpression(optimizer.metadata_.MakeGroupExpression(left_get), true);
97-
auto middle_get_group = optimizer.metadata_.memo.InsertExpression(optimizer.metadata_.MakeGroupExpression(middle_get),true);
98-
auto right_get_group = optimizer.metadata_.memo.InsertExpression(optimizer.metadata_.MakeGroupExpression(right_get),true);
99-
100-
auto left_leaf = std::make_shared<OperatorExpression>(LeafOperator::make(left_get_group->GetGroupID()));
101-
auto middle_leaf = std::make_shared<OperatorExpression>(LeafOperator::make(middle_get_group->GetGroupID()));
102-
auto right_leaf = std::make_shared<OperatorExpression>(LeafOperator::make(right_get_group->GetGroupID()));
93+
auto left_get = std::make_shared<OperatorExpression>(
94+
LogicalGet::make(0, {}, nullptr, "test1"));
95+
auto middle_get = std::make_shared<OperatorExpression>(
96+
LogicalGet::make(1, {}, nullptr, "test2"));
97+
auto right_get = std::make_shared<OperatorExpression>(
98+
LogicalGet::make(2, {}, nullptr, "test3"));
99+
100+
auto left_get_group = optimizer.metadata_.memo.InsertExpression(
101+
optimizer.metadata_.MakeGroupExpression(left_get), true);
102+
auto middle_get_group = optimizer.metadata_.memo.InsertExpression(
103+
optimizer.metadata_.MakeGroupExpression(middle_get), true);
104+
auto right_get_group = optimizer.metadata_.memo.InsertExpression(
105+
optimizer.metadata_.MakeGroupExpression(right_get), true);
106+
107+
auto left_leaf = std::make_shared<OperatorExpression>(
108+
LeafOperator::make(left_get_group->GetGroupID()));
109+
auto middle_leaf = std::make_shared<OperatorExpression>(
110+
LeafOperator::make(middle_get_group->GetGroupID()));
111+
auto right_leaf = std::make_shared<OperatorExpression>(
112+
LeafOperator::make(right_get_group->GetGroupID()));
103113

104114
// Make Child Join
105115
std::vector<AnnotatedExpression> child_join_predicates;
106-
std::unordered_set<std::string> child_tables({"test1","test2"});
116+
std::unordered_set<std::string> child_tables({"test1", "test2"});
107117
auto dummy_expr = std::shared_ptr<expression::AbstractExpression>{
108-
new expression::OperatorExpression(ExpressionType::COMPARE_EQUAL, type::TypeId::INTEGER)};
118+
new expression::OperatorExpression(ExpressionType::COMPARE_EQUAL,
119+
type::TypeId::INTEGER)};
109120

110121
AnnotatedExpression pred = {dummy_expr, child_tables};
111122
child_join_predicates.push_back(pred);
112123

113-
auto child_join = std::make_shared<OperatorExpression>(LogicalInnerJoin::make(child_join_predicates));
124+
auto child_join = std::make_shared<OperatorExpression>(
125+
LogicalInnerJoin::make(child_join_predicates));
114126
child_join->PushChild(left_leaf);
115127
child_join->PushChild(middle_leaf);
116-
optimizer.metadata_.memo.InsertExpression(optimizer.metadata_.MakeGroupExpression(child_join), true);
128+
optimizer.metadata_.memo.InsertExpression(
129+
optimizer.metadata_.MakeGroupExpression(child_join), true);
117130

118131
// Make Parent join
119132
std::vector<AnnotatedExpression> parent_join_predicates;
120-
std::unordered_set<std::string> parent_tables({"test1","test3"});
133+
std::unordered_set<std::string> parent_tables({"test1", "test3"});
121134
pred = {dummy_expr, parent_tables};
122135
parent_join_predicates.push_back(pred);
123136

124-
auto parent_join = std::make_shared<OperatorExpression>(LogicalInnerJoin::make(parent_join_predicates));
137+
auto parent_join = std::make_shared<OperatorExpression>(
138+
LogicalInnerJoin::make(parent_join_predicates));
125139
parent_join->PushChild(child_join);
126140
parent_join->PushChild(right_leaf);
127141

128-
optimizer.metadata_.memo.InsertExpression(optimizer.metadata_.MakeGroupExpression(parent_join), true);
129-
OptimizeContext* root_context = new OptimizeContext(&(optimizer.metadata_), nullptr);
130-
LOG_DEBUG("Set up Memo");
142+
optimizer.metadata_.memo.InsertExpression(
143+
optimizer.metadata_.MakeGroupExpression(parent_join), true);
144+
OptimizeContext *root_context =
145+
new OptimizeContext(&(optimizer.metadata_), nullptr);
146+
147+
EXPECT_EQ(left_leaf, parent_join->Children()[0]->Children()[0]);
148+
EXPECT_EQ(middle_leaf, parent_join->Children()[0]->Children()[1]);
149+
EXPECT_EQ(right_leaf, parent_join->Children()[1]);
150+
EXPECT_EQ(1,
151+
parent_join->Op().As<LogicalInnerJoin>()->join_predicates.size());
152+
EXPECT_EQ(1, parent_join->Children()[0]
153+
->Op()
154+
.As<LogicalInnerJoin>()
155+
->join_predicates.size());
131156

132157
// Setup rule
133158
InnerJoinAssociativity rule;
@@ -147,7 +172,100 @@ TEST_F(OptimizerRuleTests, SimpleAssociativeRuleTest) {
147172
auto child_join_op = output_join->Children()[1]->Op().As<LogicalInnerJoin>();
148173
EXPECT_EQ(2, parent_join_op->join_predicates.size());
149174
EXPECT_EQ(0, child_join_op->join_predicates.size());
175+
}
176+
177+
TEST_F(OptimizerRuleTests, SimpleAssociativeRuleTest2) {
178+
// Start Join Structure: (left JOIN middle) JOIN right
179+
// End Join Structure: left JOIN (middle JOIN right)
180+
// Query: SELECT * from test1, test2, test3 WHERE test1.a = test3.a AND
181+
// test2.a = test3.a; Test ensures that predicate "test2.a = test3.a" is
182+
// redistributed to child join
183+
184+
// Setup Memo
185+
Optimizer optimizer;
186+
auto &memo = optimizer.metadata_.memo;
187+
188+
auto left_get = std::make_shared<OperatorExpression>(
189+
LogicalGet::make(0, {}, nullptr, "test1"));
190+
auto middle_get = std::make_shared<OperatorExpression>(
191+
LogicalGet::make(1, {}, nullptr, "test2"));
192+
auto right_get = std::make_shared<OperatorExpression>(
193+
LogicalGet::make(2, {}, nullptr, "test3"));
194+
195+
// Create Groups for Get Operators
196+
auto left_get_group = memo.InsertExpression(
197+
optimizer.metadata_.MakeGroupExpression(left_get), true);
198+
auto middle_get_group = memo.InsertExpression(
199+
optimizer.metadata_.MakeGroupExpression(middle_get), true);
200+
auto right_get_group = memo.InsertExpression(
201+
optimizer.metadata_.MakeGroupExpression(right_get), true);
202+
203+
auto left_leaf = std::make_shared<OperatorExpression>(
204+
LeafOperator::make(left_get_group->GetGroupID()));
205+
auto middle_leaf = std::make_shared<OperatorExpression>(
206+
LeafOperator::make(middle_get_group->GetGroupID()));
207+
auto right_leaf = std::make_shared<OperatorExpression>(
208+
LeafOperator::make(right_get_group->GetGroupID()));
209+
210+
// Make Child Join
211+
auto child_join =
212+
std::make_shared<OperatorExpression>(LogicalInnerJoin::make());
213+
child_join->PushChild(left_leaf);
214+
child_join->PushChild(middle_leaf);
215+
optimizer.metadata_.memo.InsertExpression(
216+
optimizer.metadata_.MakeGroupExpression(child_join), true);
217+
218+
// Make Parent join
219+
std::vector<AnnotatedExpression> parent_join_predicates;
220+
auto dummy_expr = std::shared_ptr<expression::AbstractExpression>{
221+
new expression::OperatorExpression(ExpressionType::COMPARE_EQUAL,
222+
type::TypeId::INTEGER)};
223+
std::unordered_set<std::string> pred1_tables({"test1", "test3"});
224+
AnnotatedExpression pred1 = {dummy_expr, pred1_tables};
225+
parent_join_predicates.push_back(pred1);
226+
227+
std::unordered_set<std::string> pred2_tables({"test2", "test3"});
228+
AnnotatedExpression pred2 = {dummy_expr, pred2_tables};
229+
parent_join_predicates.push_back(pred2);
230+
231+
auto parent_join = std::make_shared<OperatorExpression>(
232+
LogicalInnerJoin::make(parent_join_predicates));
233+
parent_join->PushChild(child_join);
234+
parent_join->PushChild(right_leaf);
235+
236+
optimizer.metadata_.memo.InsertExpression(
237+
optimizer.metadata_.MakeGroupExpression(parent_join), true);
238+
OptimizeContext *root_context =
239+
new OptimizeContext(&(optimizer.metadata_), nullptr);
240+
241+
EXPECT_EQ(left_leaf, parent_join->Children()[0]->Children()[0]);
242+
EXPECT_EQ(middle_leaf, parent_join->Children()[0]->Children()[1]);
243+
EXPECT_EQ(right_leaf, parent_join->Children()[1]);
244+
EXPECT_EQ(2,
245+
parent_join->Op().As<LogicalInnerJoin>()->join_predicates.size());
246+
EXPECT_EQ(0, parent_join->Children()[0]
247+
->Op()
248+
.As<LogicalInnerJoin>()
249+
->join_predicates.size());
250+
251+
// Setup rule
252+
InnerJoinAssociativity rule;
253+
254+
EXPECT_TRUE(rule.Check(parent_join, root_context));
255+
std::vector<std::shared_ptr<OperatorExpression>> outputs;
256+
rule.Transform(parent_join, outputs, root_context);
257+
EXPECT_EQ(1, outputs.size());
258+
259+
auto output_join = outputs[0];
150260

261+
EXPECT_EQ(left_leaf, output_join->Children()[0]);
262+
EXPECT_EQ(middle_leaf, output_join->Children()[1]->Children()[0]);
263+
EXPECT_EQ(right_leaf, output_join->Children()[1]->Children()[1]);
264+
265+
auto parent_join_op = output_join->Op().As<LogicalInnerJoin>();
266+
auto child_join_op = output_join->Children()[1]->Op().As<LogicalInnerJoin>();
267+
EXPECT_EQ(1, parent_join_op->join_predicates.size());
268+
EXPECT_EQ(1, child_join_op->join_predicates.size());
151269
}
152270

153271
} // namespace test

0 commit comments

Comments
 (0)