/***************************************************************************
 *
 *                       New Function 
 *
 **************************************************************************/
void
qp_add_paths_to_joinrel(PlannerInfo *root,
					 RelOptInfo *joinrel,
					 RelOptInfo *outerrel,
					 RelOptInfo *innerrel,
					 JoinType jointype,
					 SpecialJoinInfo *sjinfo,
					 List *restrictlist,
					 MockPath *mockpath)
{
	List	   *mergeclause_list = NIL;
	int        flag = 0;
	
	/*
	 * Consider mergejoin path if it is a merge join
	 */
    /*
	if(!enable_mergejoin){
		elog(ERROR, "Mergejoin is disabled by the current system setting");
	}else if(mockpath->pathtype == T_MergeJoinOperator){
		mergeclause_list = select_mergejoin_clauses(root,
					joinrel,
					outerrel,
					innerrel,
					restrictlist,
					jointype);
	}*/
	/*
	 * Not sure whether I should add the several cases in function add_paths_to_joinrel;  HQ
	 */

	/*
	 * Consider nestloop path if it is a nestloop join
	 */
	if (mockpath->pathtype == T_NestLoopOperator) {
		match_unsorted_outer(root, joinrel, outerrel, innerrel,
							 restrictlist, mergeclause_list, jointype, sjinfo);
		flag = 1;
	}
	
	
	/*
	 * Consider hashjoin path if it is a hash join
	 */
	if (!enable_hashjoin){
		elog(ERROR, "Hashjoin is disabled by the current system setting");
	}else if (mockpath->pathtype == T_HashJoinOperator) {
		hash_inner_and_outer(root, joinrel, outerrel, innerrel,
							 restrictlist, jointype, sjinfo);
		flag = 1;
	}
	if (flag == 0) {
		elog(ERROR, "Error in building the join path @qp_add_paths_to_joinrel");
	}
}
Ejemplo n.º 2
0
/*
 * add_paths_to_joinrel
 *	  Given a join relation and two component rels from which it can be made,
 *	  consider all possible paths that use the two component rels as outer
 *	  and inner rel respectively.  Add these paths to the join rel's pathlist
 *	  if they survive comparison with other paths (and remove any existing
 *	  paths that are dominated by these paths).
 *
 * Modifies the pathlist field of the joinrel node to contain the best
 * paths found so far.
 */
void
add_paths_to_joinrel(PlannerInfo *root,
					 RelOptInfo *joinrel,
					 RelOptInfo *outerrel,
					 RelOptInfo *innerrel,
					 JoinType jointype,
					 List *restrictlist)
{
	List	   *mergeclause_list = NIL;

	/*
	 * Find potential mergejoin clauses.  We can skip this if we are not
	 * interested in doing a mergejoin.  However, mergejoin is currently our
	 * only way of implementing full outer joins, so override mergejoin
	 * disable if it's a full join.
	 */
	if (enable_mergejoin || jointype == JOIN_FULL)
		mergeclause_list = select_mergejoin_clauses(root,
													joinrel,
													outerrel,
													innerrel,
													restrictlist,
													jointype);

	/*
	 * 1. Consider mergejoin paths where both relations must be explicitly
	 * sorted.
	 */
	sort_inner_and_outer(root, joinrel, outerrel, innerrel,
						 restrictlist, mergeclause_list, jointype);

	/*
	 * 2. Consider paths where the outer relation need not be explicitly
	 * sorted. This includes both nestloops and mergejoins where the outer
	 * path is already ordered.
	 */
	match_unsorted_outer(root, joinrel, outerrel, innerrel,
						 restrictlist, mergeclause_list, jointype);

#ifdef NOT_USED

	/*
	 * 3. Consider paths where the inner relation need not be explicitly
	 * sorted.	This includes mergejoins only (nestloops were already built in
	 * match_unsorted_outer).
	 *
	 * Diked out as redundant 2/13/2000 -- tgl.  There isn't any really
	 * significant difference between the inner and outer side of a mergejoin,
	 * so match_unsorted_inner creates no paths that aren't equivalent to
	 * those made by match_unsorted_outer when add_paths_to_joinrel() is
	 * invoked with the two rels given in the other order.
	 */
	match_unsorted_inner(root, joinrel, outerrel, innerrel,
						 restrictlist, mergeclause_list, jointype);
#endif

	/*
	 * 4. Consider paths where both outer and inner relations must be hashed
	 * before being joined.
	 */
	if (enable_hashjoin)
		hash_inner_and_outer(root, joinrel, outerrel, innerrel,
							 restrictlist, jointype);
}
Ejemplo n.º 3
0
/*
 * add_paths_to_joinrel
 *	  Given a join relation and two component rels from which it can be made,
 *	  consider all possible paths that use the two component rels as outer
 *	  and inner rel respectively.  Add these paths to the join rel's pathlist
 *	  if they survive comparison with other paths (and remove any existing
 *	  paths that are dominated by these paths).
 *
 * Modifies the pathlist field of the joinrel node to contain the best
 * paths found so far.
 *
 * jointype is not necessarily the same as sjinfo->jointype; it might be
 * "flipped around" if we are considering joining the rels in the opposite
 * direction from what's indicated in sjinfo.
 *
 * Also, this routine and others in this module accept the special JoinTypes
 * JOIN_UNIQUE_OUTER and JOIN_UNIQUE_INNER to indicate that we should
 * unique-ify the outer or inner relation and then apply a regular inner
 * join.  These values are not allowed to propagate outside this module,
 * however.  Path cost estimation code may need to recognize that it's
 * dealing with such a case --- the combination of nominal jointype INNER
 * with sjinfo->jointype == JOIN_SEMI indicates that.
 */
void
add_paths_to_joinrel(PlannerInfo *root,
					 RelOptInfo *joinrel,
					 RelOptInfo *outerrel,
					 RelOptInfo *innerrel,
					 JoinType jointype,
					 SpecialJoinInfo *sjinfo,
					 List *restrictlist)
{
	List	   *mergeclause_list = NIL;

	/*
	 * 0. Consider join removal.  This is always the most efficient strategy,
	 * so if it works, there's no need to consider anything further.
	 */
	if (join_is_removable(root, joinrel, outerrel, innerrel,
						  restrictlist, jointype))
	{
		generate_outer_only(root, joinrel, outerrel);
		return;
	}

	/*
	 * Find potential mergejoin clauses.  We can skip this if we are not
	 * interested in doing a mergejoin.  However, mergejoin is currently our
	 * only way of implementing full outer joins, so override mergejoin
	 * disable if it's a full join.
	 *
	 * Note: do this after join_is_removable(), because this sets the
	 * outer_is_left flags in the mergejoin clauses, while join_is_removable
	 * uses those flags for its own purposes.  Currently, they set the flags
	 * the same way anyway, but let's avoid unnecessary entanglement.
	 */
	if (enable_mergejoin || jointype == JOIN_FULL)
		mergeclause_list = select_mergejoin_clauses(root,
													joinrel,
													outerrel,
													innerrel,
													restrictlist,
													jointype);

	/*
	 * 1. Consider mergejoin paths where both relations must be explicitly
	 * sorted.
	 */
	sort_inner_and_outer(root, joinrel, outerrel, innerrel,
						 restrictlist, mergeclause_list, jointype, sjinfo);

	/*
	 * 2. Consider paths where the outer relation need not be explicitly
	 * sorted. This includes both nestloops and mergejoins where the outer
	 * path is already ordered.
	 */
	match_unsorted_outer(root, joinrel, outerrel, innerrel,
						 restrictlist, mergeclause_list, jointype, sjinfo);

#ifdef NOT_USED

	/*
	 * 3. Consider paths where the inner relation need not be explicitly
	 * sorted.	This includes mergejoins only (nestloops were already built in
	 * match_unsorted_outer).
	 *
	 * Diked out as redundant 2/13/2000 -- tgl.  There isn't any really
	 * significant difference between the inner and outer side of a mergejoin,
	 * so match_unsorted_inner creates no paths that aren't equivalent to
	 * those made by match_unsorted_outer when add_paths_to_joinrel() is
	 * invoked with the two rels given in the other order.
	 */
	match_unsorted_inner(root, joinrel, outerrel, innerrel,
						 restrictlist, mergeclause_list, jointype, sjinfo);
#endif

	/*
	 * 4. Consider paths where both outer and inner relations must be hashed
	 * before being joined.
	 */
	if (enable_hashjoin)
		hash_inner_and_outer(root, joinrel, outerrel, innerrel,
							 restrictlist, jointype, sjinfo);
}
Ejemplo n.º 4
0
/*
 * add_paths_to_joinrel
 *	  Given a join relation and two component rels from which it can be made,
 *	  consider all possible paths that use the two component rels as outer
 *	  and inner rel respectively.  Add these paths to the join rel's pathlist
 *	  if they survive comparison with other paths (and remove any existing
 *	  paths that are dominated by these paths).
 *
 * Modifies the pathlist field of the joinrel node to contain the best
 * paths found so far.
 */
void
add_paths_to_joinrel(PlannerInfo *root,
					 RelOptInfo *joinrel,
					 RelOptInfo *outerrel,
					 RelOptInfo *innerrel,
					 JoinType jointype,
					 List *restrictlist)
{
	List	   *mergeclause_list = NIL;
    List       *hashclause_list;

    Assert(outerrel->pathlist &&
           outerrel->cheapest_startup_path &&
           outerrel->cheapest_total_path);
    Assert(innerrel->pathlist &&
           innerrel->cheapest_startup_path &&
           innerrel->cheapest_total_path);

    /*
	 * Find potential mergejoin clauses.  We can skip this if we are not
	 * interested in doing a mergejoin.  However, mergejoin is currently our
	 * only way of implementing full outer joins, so override mergejoin
	 * disable if it's a full join.
     *
     * CDB: Always build mergeclause_list.  We need it for motion planning.
	 */
	mergeclause_list = select_mergejoin_clauses(outerrel,
												innerrel,
												restrictlist,
												jointype);

	/*
	 * 1. Consider mergejoin paths where both relations must be explicitly
	 * sorted.
	 */
	if (root->config->enable_mergejoin ||
        root->config->mpp_trying_fallback_plan ||
        jointype == JOIN_FULL)
	    sort_inner_and_outer(root, joinrel, outerrel, innerrel,
						     restrictlist, mergeclause_list, jointype);

	/*
	 * 2. Consider paths where the outer relation need not be explicitly
	 * sorted. This includes both nestloops and mergejoins where the outer
	 * path is already ordered.
	 */
	match_unsorted_outer(root, joinrel, outerrel, innerrel,
						 restrictlist, mergeclause_list, jointype);

#ifdef NOT_USED

	/*
	 * 3. Consider paths where the inner relation need not be explicitly
	 * sorted.	This includes mergejoins only (nestloops were already built in
	 * match_unsorted_outer).
	 *
	 * Diked out as redundant 2/13/2000 -- tgl.  There isn't any really
	 * significant difference between the inner and outer side of a mergejoin,
	 * so match_unsorted_inner creates no paths that aren't equivalent to
	 * those made by match_unsorted_outer when add_paths_to_joinrel() is
	 * invoked with the two rels given in the other order.
	 */
	match_unsorted_inner(root, joinrel, outerrel, innerrel,
						 restrictlist, mergeclause_list, jointype);
#endif

	/*
	 * 4. Consider paths where both outer and inner relations must be hashed
	 * before being joined.
     *
	 * We consider both the cheapest-total-cost and cheapest-startup-cost
	 * outer paths.  There's no need to consider any but the
	 * cheapest-total-cost inner path, however.
	 */
	if (root->config->enable_hashjoin
			|| root->config->mpp_trying_fallback_plan)
    {
	    hashclause_list = hashclauses_for_join(restrictlist,
                                               outerrel,
                                               innerrel,
                                               jointype);
		if (hashclause_list)
        {
            hash_inner_and_outer(root,
                                 joinrel,
                                 outerrel->cheapest_total_path,
                                 innerrel->cheapest_total_path,
							     restrictlist,
                                 mergeclause_list,
                                 hashclause_list,
                                 jointype);
            if (outerrel->cheapest_startup_path != outerrel->cheapest_total_path)
                hash_inner_and_outer(root,
                                     joinrel,
                                     outerrel->cheapest_startup_path,
                                     innerrel->cheapest_total_path,
							         restrictlist,
                                     mergeclause_list,
                                     hashclause_list,
                                     jointype);
        }
    }
}