bool NestLoopExecutor::p_execute(const NValueArray ¶ms) {
VOLT_DEBUG("executing NestLoop...");
NestLoopPlanNode* node = dynamic_cast<NestLoopPlanNode*>(m_abstractNode);
assert(node);
assert(node->getInputTables().size() == 2);
Table* output_table_ptr = node->getOutputTable();
assert(output_table_ptr);
// output table must be a temp table
TempTable* output_table = dynamic_cast<TempTable*>(output_table_ptr);
assert(output_table);
Table* outer_table = node->getInputTables()[0];
assert(outer_table);
Table* inner_table = node->getInputTables()[1];
assert(inner_table);
VOLT_TRACE ("input table left:\n %s", outer_table->debug().c_str());
VOLT_TRACE ("input table right:\n %s", inner_table->debug().c_str());
//
// Pre Join Expression
//
AbstractExpression *preJoinPredicate = node->getPreJoinPredicate();
if (preJoinPredicate) {
preJoinPredicate->substitute(params);
VOLT_TRACE ("Pre Join predicate: %s", preJoinPredicate == NULL ?
"NULL" : preJoinPredicate->debug(true).c_str());
}
//
// Join Expression
//
AbstractExpression *joinPredicate = node->getJoinPredicate();
if (joinPredicate) {
joinPredicate->substitute(params);
VOLT_TRACE ("Join predicate: %s", joinPredicate == NULL ?
"NULL" : joinPredicate->debug(true).c_str());
}
//
// Where Expression
//
AbstractExpression *wherePredicate = node->getWherePredicate();
if (wherePredicate) {
wherePredicate->substitute(params);
VOLT_TRACE ("Where predicate: %s", wherePredicate == NULL ?
"NULL" : wherePredicate->debug(true).c_str());
}
// Join type
JoinType join_type = node->getJoinType();
assert(join_type == JOIN_TYPE_INNER || join_type == JOIN_TYPE_LEFT);
int outer_cols = outer_table->columnCount();
int inner_cols = inner_table->columnCount();
TableTuple outer_tuple(node->getInputTables()[0]->schema());
TableTuple inner_tuple(node->getInputTables()[1]->schema());
TableTuple &joined = output_table->tempTuple();
TableTuple null_tuple = m_null_tuple;
TableIterator iterator0 = outer_table->iterator();
while (iterator0.next(outer_tuple)) {
// did this loop body find at least one match for this tuple?
bool match = false;
// For outer joins if outer tuple fails pre-join predicate
// (join expression based on the outer table only)
// it can't match any of inner tuples
if (preJoinPredicate == NULL || preJoinPredicate->eval(&outer_tuple, NULL).isTrue()) {
// populate output table's temp tuple with outer table's values
// probably have to do this at least once - avoid doing it many
// times per outer tuple
joined.setNValues(0, outer_tuple, 0, outer_cols);
TableIterator iterator1 = inner_table->iterator();
while (iterator1.next(inner_tuple)) {
// Apply join filter to produce matches for each outer that has them,
// then pad unmatched outers, then filter them all
if (joinPredicate == NULL || joinPredicate->eval(&outer_tuple, &inner_tuple).isTrue()) {
match = true;
// Filter the joined tuple
if (wherePredicate == NULL || wherePredicate->eval(&outer_tuple, &inner_tuple).isTrue()) {
// Matched! Complete the joined tuple with the inner column values.
joined.setNValues(outer_cols, inner_tuple, 0, inner_cols);
output_table->insertTupleNonVirtual(joined);
}
}
}
}
//
// Left Outer Join
//
if (join_type == JOIN_TYPE_LEFT && !match) {
// Still needs to pass the filter
if (wherePredicate == NULL || wherePredicate->eval(&outer_tuple, &null_tuple).isTrue()) {
joined.setNValues(outer_cols, null_tuple, 0, inner_cols);
output_table->insertTupleNonVirtual(joined);
}
}
}
return (true);
}
bool NestLoopExecutor::p_execute(const NValueArray ¶ms, ReadWriteTracker *tracker) {
VOLT_DEBUG("executing NestLoop...");
NestLoopPlanNode* node = dynamic_cast<NestLoopPlanNode*>(abstract_node);
assert(node);
assert(node->getInputTables().size() == 2);
Table* output_table_ptr = node->getOutputTable();
assert(output_table_ptr);
// output table must be a temp table
TempTable* output_table = dynamic_cast<TempTable*>(output_table_ptr);
assert(output_table);
Table* outer_table = node->getInputTables()[0];
assert(outer_table);
Table* inner_table = node->getInputTables()[1];
assert(inner_table);
VOLT_TRACE ("input table left:\n %s", outer_table->debug().c_str());
VOLT_TRACE ("input table right:\n %s", inner_table->debug().c_str());
//
// Join Expression
//
AbstractExpression *predicate = node->getPredicate();
if (predicate) {
predicate->substitute(params);
VOLT_TRACE ("predicate: %s", predicate == NULL ?
"NULL" : predicate->debug(true).c_str());
}
int outer_cols = outer_table->columnCount();
int inner_cols = inner_table->columnCount();
TableTuple outer_tuple(node->getInputTables()[0]->schema());
TableTuple inner_tuple(node->getInputTables()[1]->schema());
TableTuple &joined = output_table->tempTuple();
TableIterator iterator0(outer_table);
while (iterator0.next(outer_tuple)) {
// populate output table's temp tuple with outer table's values
// probably have to do this at least once - avoid doing it many
// times per outer tuple
for (int col_ctr = 0; col_ctr < outer_cols; col_ctr++) {
joined.setNValue(col_ctr, outer_tuple.getNValue(col_ctr));
}
TableIterator iterator1(inner_table);
while (iterator1.next(inner_tuple)) {
if (predicate == NULL || predicate->eval(&outer_tuple, &inner_tuple).isTrue()) {
// Matched! Complete the joined tuple with the inner column values.
for (int col_ctr = 0; col_ctr < inner_cols; col_ctr++) {
joined.setNValue(col_ctr + outer_cols, inner_tuple.getNValue(col_ctr));
}
output_table->insertTupleNonVirtual(joined);
}
}
}
return (true);
}
