int main(int argc, char *argv[]) { int count = 0; Vector2d tP_B(Vector2d::Zero()); double tth_B = 0.0; FootStepPlanner plan_node(0.32, 0.04); while(1){ // 一歩分の蹴足位置と目標ZMPを取得 plan_node.getNextStep(tP_B, tth_B); // 停止判定 if(plan_node.getWalkState() == STOP) break; // 指定の歩数歩いたら終了 count++; if(MAX_STEP <= count) plan_node.setStopFlag(); // 体幹位置を一歩分移動 tP_B += Vector2d(0.03, 0.03); tth_B += 5.0; } plan_node.plot_foot_pattern(); }
/** * @brief Convert a Postgres ModifyTableState with DELETE operation * into a Peloton DeleteNode. * @return Pointer to the constructed AbstractPlan. * * Just like Peloton, * the delete plan state in Postgres simply deletes tuples * returned by a subplan (mostly Scan). * So we don't need to handle predicates locally . */ std::unique_ptr<planner::AbstractPlan> PlanTransformer::TransformDelete( const ModifyTablePlanState *mt_plan_state, const TransformOptions options) { // Grab Database ID and Table ID Oid database_oid = mt_plan_state->database_oid; Oid table_oid = mt_plan_state->table_oid; /* Get the target table */ storage::DataTable *target_table = static_cast<storage::DataTable *>( catalog::Manager::GetInstance().GetTableWithOid(database_oid, table_oid)); if (target_table == nullptr) { LOG_ERROR("Target table is not found : database oid %u table oid %u", database_oid, table_oid); return nullptr; } LOG_INFO("Delete :: database oid %u table oid %u: %s", database_oid, table_oid, target_table->GetName().c_str()); // Create the peloton plan node bool truncate = false; std::unique_ptr<planner::AbstractPlan> plan_node( new planner::DeletePlan(target_table, truncate)); // Add child plan node(s) TransformOptions new_options = options; new_options.use_projInfo = false; auto sub_planstate = mt_plan_state->mt_plans[0]; auto child_plan_node = TransformPlan(sub_planstate, new_options); plan_node.get()->AddChild(std::move(child_plan_node)); return plan_node; }
/** * @brief Convert a Postgres HashState into a Peloton HashPlanNode * @return Pointer to the constructed AbstractPlan */ std::unique_ptr<planner::AbstractPlan> PlanTransformer::TransformHashJoin( const HashJoinPlanState *hj_plan_state) { std::unique_ptr<planner::AbstractPlan> result; PelotonJoinType join_type = PlanTransformer::TransformJoinType(hj_plan_state->jointype); if (join_type == JOIN_TYPE_INVALID) { LOG_ERROR("unsupported join type: %d", hj_plan_state->jointype); return nullptr; } LOG_INFO("Handle hash join with join type: %d", join_type); /* std::vector<planner::HashJoinPlan::JoinClause> join_clauses( BuildHashJoinClauses(mj_plan_state->mj_Clauses, mj_plan_state->mj_NumClauses); */ expression::AbstractExpression *join_filter = ExprTransformer::TransformExpr( reinterpret_cast<ExprState *>(hj_plan_state->joinqual)); expression::AbstractExpression *plan_filter = ExprTransformer::TransformExpr( reinterpret_cast<ExprState *>(hj_plan_state->qual)); std::unique_ptr<const expression::AbstractExpression> predicate(nullptr); if (join_filter && plan_filter) { predicate.reset(expression::ExpressionUtil::ConjunctionFactory( EXPRESSION_TYPE_CONJUNCTION_AND, join_filter, plan_filter)); } else if (join_filter) { predicate.reset(join_filter); } else { predicate.reset(plan_filter); } /* Transform project info */ std::unique_ptr<const planner::ProjectInfo> project_info(nullptr); project_info.reset(BuildProjectInfoFromTLSkipJunk(hj_plan_state->targetlist)); if (project_info.get() != nullptr) { LOG_INFO("%s", project_info.get()->Debug().c_str()); } else { LOG_INFO("empty projection info"); } std::shared_ptr<const catalog::Schema> project_schema( SchemaTransformer::GetSchemaFromTupleDesc( hj_plan_state->tts_tupleDescriptor)); std::vector<oid_t> outer_hashkeys = BuildColumnListFromExpStateList(hj_plan_state->outer_hashkeys); bool non_trivial = (project_info.get() != nullptr && project_info.get()->isNonTrivial()); if (non_trivial) { // we have non-trivial projection LOG_INFO("We have non-trivial projection"); result = std::unique_ptr<planner::AbstractPlan>( new planner::ProjectionPlan(std::move(project_info), project_schema)); // set project_info to nullptr project_info.reset(); } else { LOG_INFO("We have direct mapping projection"); } std::unique_ptr<planner::HashJoinPlan> plan_node(new planner::HashJoinPlan( join_type, std::move(predicate), std::move(project_info), project_schema, outer_hashkeys)); std::unique_ptr<planner::AbstractPlan> outer{std::move( PlanTransformer::TransformPlan(outerAbstractPlanState(hj_plan_state)))}; std::unique_ptr<planner::AbstractPlan> inner{std::move( PlanTransformer::TransformPlan(innerAbstractPlanState(hj_plan_state)))}; /* Add the children nodes */ plan_node->AddChild(std::move(outer)); plan_node->AddChild(std::move(inner)); if (non_trivial) { result->AddChild(std::move(plan_node)); } else { result.reset(plan_node.release()); } LOG_INFO("Finishing mapping Hash join, JoinType: %d", join_type); return result; }