void
query_planner(PlannerInfo *root, List *tlist,double tuple_fraction, double limit_tuples,Path **cheapest_path, Path **sorted_path,double *num_groups)
{Query       *parse = root->parse;List       *joinlist;RelOptInfo *final_rel;Path       *cheapestpath;Path       *sortedpath;Index        rti;double        total_pages;    ...*cheapest_path = cheapestpath;*sorted_path = sortedpath;
}

Path       *cheapestpath;.../** Pick out the cheapest-total path and the cheapest presorted path for* the requested pathkeys (if there is one).  We should take the tuple* fraction into account when selecting the cheapest presorted path, but* not when selecting the cheapest-total path, since if we have to sort* then we'll have to fetch all the tuples.  (But there's a special case:* if query_pathkeys is NIL, meaning order doesn't matter, then the* "cheapest presorted" path will be the cheapest overall for the tuple* fraction.)** The cheapest-total path is also the one to use if grouping_planner* decides to use hashed aggregation, so we return it separately even if* this routine thinks the presorted path is the winner.*/cheapestpath = final_rel->cheapest_total_path;

RelOptInfo *final_rel;.../** Ready to do the primary planning.*/final_rel = make_one_rel(root, joinlist);...cheapestpath = final_rel->cheapest_total_path;

/** make_one_rel*      Finds all possible access paths for executing a query, returning a*      single rel that represents the join of all base rels in the query.*/
RelOptInfo *
make_one_rel(PlannerInfo *root, List *joinlist)
{RelOptInfo *rel;Index        rti;/** Construct the all_baserels Relids set.*/root->all_baserels = NULL;for (rti = 1; rti < root->simple_rel_array_size; rti++){RelOptInfo *brel = root->simple_rel_array[rti];/* there may be empty slots corresponding to non-baserel RTEs */if (brel == NULL)continue;Assert(brel->relid == rti);        /* sanity check on array *//* ignore RTEs that are "other rels" */if (brel->reloptkind != RELOPT_BASEREL)continue;root->all_baserels = bms_add_member(root->all_baserels, brel->relid);}/** Generate access paths for the base rels.*/set_base_rel_sizes(root);set_base_rel_pathlists(root);/** Generate access paths for the entire join tree.*/rel = make_rel_from_joinlist(root, joinlist);/** The result should join all and only the query's base rels.*/Assert(bms_equal(rel->relids, root->all_baserels));return rel;
}

/** make_rel_from_joinlist*      Build access paths using a "joinlist" to guide the join path search.** See comments for deconstruct_jointree() for definition of the joinlist* data structure.*/
static RelOptInfo *
make_rel_from_joinlist(PlannerInfo *root, List *joinlist)
{int            levels_needed;List       *initial_rels;ListCell   *jl;/** Count the number of child joinlist nodes.  This is the depth of the* dynamic-programming algorithm we must employ to consider all ways of* joining the child nodes.*/levels_needed = list_length(joinlist);if (levels_needed <= 0)return NULL;            /* nothing to do? *//** Construct a list of rels corresponding to the child joinlist nodes.* This may contain both base rels and rels constructed according to* sub-joinlists.*/initial_rels = NIL;foreach(jl, joinlist){Node       *jlnode = (Node *) lfirst(jl);RelOptInfo *thisrel;if (IsA(jlnode, RangeTblRef)){int            varno = ((RangeTblRef *) jlnode)->rtindex;thisrel = find_base_rel(root, varno);}else if (IsA(jlnode, List)){/* Recurse to handle subproblem */thisrel = make_rel_from_joinlist(root, (List *) jlnode);}else{elog(ERROR, "unrecognized joinlist node type: %d",(int) nodeTag(jlnode));thisrel = NULL;        /* keep compiler quiet */}initial_rels = lappend(initial_rels, thisrel);}if (levels_needed == 1){/** Single joinlist node, so we're done.*/return (RelOptInfo *) linitial(initial_rels);}else{/** Consider the different orders in which we could join the rels,* using a plugin, GEQO, or the regular join search code.** We put the initial_rels list into a PlannerInfo field because* has_legal_joinclause() needs to look at it (ugly :-().*/root->initial_rels = initial_rels;if (join_search_hook)return (*join_search_hook) (root, levels_needed, initial_rels);else if (enable_geqo && levels_needed >= geqo_threshold)return geqo(root, levels_needed, initial_rels);elsereturn standard_join_search(root, levels_needed, initial_rels);}
}

static RelOptInfo *
make_rel_from_joinlist(PlannerInfo *root, List *joinlist)
{int            levels_needed;List       *initial_rels;ListCell   *jl;/** Count the number of child joinlist nodes.  This is the depth of the* dynamic-programming algorithm we must employ to consider all ways of* joining the child nodes.*/levels_needed = list_length(joinlist);    .../** Construct a list of rels corresponding to the child joinlist nodes.* This may contain both base rels and rels constructed according to* sub-joinlists.*/initial_rels = NIL;foreach(jl, joinlist){       Node       *jlnode = (Node *) lfirst(jl);RelOptInfo *thisrel;if (IsA(jlnode, RangeTblRef)){
int   varno = ((RangeTblRef *) jlnode)->rtindex;thisrel = find_base_rel(root, varno);}else if (IsA(jlnode, List)){...}
        ...initial_rels = lappend(initial_rels, thisrel);}if (levels_needed == 1){
        /** Single joinlist node, so we're done.*/return (RelOptInfo *) linitial(initial_rels);}else{
       ...}
}

int            varno = ((RangeTblRef *) jlnode)->rtindex;

thisrel = find_base_rel(root, varno);

 initial_rels = lappend(initial_rels, thisrel);

return (RelOptInfo *) linitial(initial_rels);