void DMLUtils::PrepareAbstractJoinPlanState(AbstractJoinPlanState *j_plan_state,
const JoinState &j_state) {
// Copy join type
j_plan_state->jointype = j_state.jointype;
// Copy join qual expr states
j_plan_state->joinqual = CopyExprStateList(j_state.joinqual);
// Copy ps qual
j_plan_state->qual = CopyExprStateList(j_state.ps.qual);
// Copy target list
j_plan_state->targetlist = CopyExprStateList(j_state.ps.targetlist);
// Copy tuple desc
auto tup_desc = j_state.ps.ps_ResultTupleSlot->tts_tupleDescriptor;
j_plan_state->tts_tupleDescriptor = CreateTupleDescCopy(tup_desc);
// Construct projection info
j_plan_state->ps_ProjInfo =
BuildProjectInfo(j_state.ps.ps_ProjInfo, tup_desc->natts);
}
void DMLUtils::PrepareUpdateState(ModifyTablePlanState *info,
ModifyTableState *mt_plan_state) {
// Should be only one sub plan which is a SeqScan
assert(mt_plan_state->mt_nplans == 1);
assert(mt_plan_state->mt_plans != nullptr);
// Get the first sub plan state
PlanState *sub_planstate = mt_plan_state->mt_plans[0];
assert(sub_planstate);
auto child_tag = nodeTag(sub_planstate->plan);
if (child_tag == T_SeqScan || child_tag == T_IndexScan ||
child_tag == T_IndexOnlyScan ||
child_tag == T_BitmapHeapScan) { // Sub plan is a Scan of any type
LOG_TRACE("Child of Update is %u ", child_tag);
// Extract the projection info from the underlying scan
// and put it in our update node
auto scan_state = reinterpret_cast<ScanState *>(sub_planstate);
auto child_planstate =
(AbstractScanPlanState *)PreparePlanState(nullptr, sub_planstate, true);
child_planstate->proj =
BuildProjectInfo(scan_state->ps.ps_ProjInfo, info->table_nattrs);
info->mt_plans = (AbstractPlanState **)palloc(sizeof(AbstractPlanState *) *
mt_plan_state->mt_nplans);
info->mt_plans[0] = child_planstate;
} else {
LOG_ERROR("Unsupported sub plan type of Update : %u ", child_tag);
}
}
/**
* @brief Convert a Postgres NestLoop into a Peloton SeqScanNode.
* @return Pointer to the constructed AbstractPlanNode.
*/
const planner::AbstractPlan *PlanTransformer::TransformNestLoop(
const NestLoopPlanState *nl_plan_state) {
PelotonJoinType peloton_join_type =
PlanTransformer::TransformJoinType(nl_plan_state->jointype);
NestLoop *nl = nl_plan_state->nl;
if (peloton_join_type == JOIN_TYPE_INVALID) {
LOG_ERROR("unsupported join type: %d", nl_plan_state->jointype);
return nullptr;
}
expression::AbstractExpression *join_filter = ExprTransformer::TransformExpr(
reinterpret_cast<ExprState *>(nl_plan_state->joinqual));
expression::AbstractExpression *plan_filter = ExprTransformer::TransformExpr(
reinterpret_cast<ExprState *>(nl_plan_state->qual));
expression::AbstractExpression *predicate = nullptr;
if (join_filter && plan_filter) {
predicate = expression::ExpressionUtil::ConjunctionFactory(
EXPRESSION_TYPE_CONJUNCTION_AND, join_filter, plan_filter);
} else if (join_filter) {
predicate = join_filter;
} else {
predicate = plan_filter;
}
// TODO: do we need to consider target list here?
// Transform project info
std::unique_ptr<const planner::ProjectInfo> project_info(nullptr);
project_info.reset(BuildProjectInfo(nl_plan_state->ps_ProjInfo));
LOG_INFO("%s", project_info.get()->Debug().c_str());
planner::AbstractPlan *result = nullptr;
planner::NestedLoopJoinPlan *plan_node = nullptr;
auto project_schema = SchemaTransformer::GetSchemaFromTupleDesc(
nl_plan_state->tts_tupleDescriptor);
if (project_info.get()->isNonTrivial()) {
// we have non-trivial projection
LOG_INFO("We have non-trivial projection");
result =
new planner::ProjectionPlan(project_info.release(), project_schema);
plan_node = new planner::NestedLoopJoinPlan(peloton_join_type, predicate,
nullptr, project_schema, nl);
result->AddChild(plan_node);
} else {
LOG_INFO("We have direct mapping projection");
plan_node = new planner::NestedLoopJoinPlan(peloton_join_type, predicate,
project_info.release(),
project_schema, nl);
result = plan_node;
}
const planner::AbstractPlan *outer =
PlanTransformer::TransformPlan(outerAbstractPlanState(nl_plan_state));
const planner::AbstractPlan *inner =
PlanTransformer::TransformPlan(innerAbstractPlanState(nl_plan_state));
/* Add the children nodes */
plan_node->AddChild(outer);
plan_node->AddChild(inner);
LOG_INFO("Finishing mapping Nested loop join, JoinType: %d",
nl_plan_state->jointype);
return result;
}
