PostgreSQL在何处处理 sql查询之五十五

接前面。

从 cheapest_total_path 来看：

query_planner 会先调用  build_simple_rel，这里完成了  cheapest_total_path 的初始化。

(query_planner --> add_base_rels_to_query --> query_planner)

然后，query_planner 再在后面调用 create_plan，最终设置 plan_rows。

那么，是在何处 设置了 cheapest_total_path 的值呢？

经过查找，看到了如下的调用关系：

make_one_rel--> set_base_rel_pathlists --> set_rel_pathlist --> set_plain_rel_pathlist--> set_cheapest

先看 set_cheapest:

/*

 * set_cheapest

 *      Find the minimum-cost paths from among a relation's paths,

 *      and save them in the rel's cheapest-path fields.

 *

 * Only unparameterized paths are considered candidates for cheapest_startup

 * and cheapest_total.    The cheapest_parameterized_paths list collects paths

 * that are cheapest-total for their parameterization (i.e., there is no

 * cheaper path with the same or weaker parameterization).    This list always

 * includes the unparameterized cheapest-total path, too.

 *

 * This is normally called only after we've finished constructing the path

 * list for the rel node.

 */

void

set_cheapest(RelOptInfo *parent_rel)

{

    fprintf(stderr,"In set_cheapest ........\n");



    Path       *cheapest_startup_path;

    Path       *cheapest_total_path;

    bool        have_parameterized_paths;

    ListCell   *p;



    Assert(IsA(parent_rel, RelOptInfo));



    cheapest_startup_path = cheapest_total_path = NULL;

    have_parameterized_paths = false;



    foreach(p, parent_rel->pathlist)

    {

        Path       *path = (Path *) lfirst(p);

        int            cmp;



        /* We only consider unparameterized paths in this step */

        if (path->param_info)

        {

            have_parameterized_paths = true;

            continue;

        }



        if (cheapest_total_path == NULL)

        {

            cheapest_startup_path = cheapest_total_path = path;

            continue;

        }



        /*

         * If we find two paths of identical costs, try to keep the

         * better-sorted one.  The paths might have unrelated sort orderings,

         * in which case we can only guess which might be better to keep, but

         * if one is superior then we definitely should keep that one.

         */

        cmp = compare_path_costs(cheapest_startup_path, path, STARTUP_COST);

        if (cmp > 0 ||

            (cmp == 0 &&

             compare_pathkeys(cheapest_startup_path->pathkeys,

                              path->pathkeys) == PATHKEYS_BETTER2))

            cheapest_startup_path = path;



        cmp = compare_path_costs(cheapest_total_path, path, TOTAL_COST);

        if (cmp > 0 ||

            (cmp == 0 &&

             compare_pathkeys(cheapest_total_path->pathkeys,

                              path->pathkeys) == PATHKEYS_BETTER2))

            cheapest_total_path = path;

    }



    if (cheapest_total_path == NULL)

        elog(ERROR, "could not devise a query plan for the given query");



    parent_rel->cheapest_startup_path = cheapest_startup_path;

    parent_rel->cheapest_total_path = cheapest_total_path;

    parent_rel->cheapest_unique_path = NULL;    /* computed only if needed */



    /* Seed the parameterized-paths list with the cheapest total */

    parent_rel->cheapest_parameterized_paths = list_make1(cheapest_total_path);



    /* And, if there are any parameterized paths, add them in one at a time */

    if (have_parameterized_paths)

    {

        foreach(p, parent_rel->pathlist)

        {

            Path       *path = (Path *) lfirst(p);



            if (path->param_info)

                add_parameterized_path(parent_rel, path);

        }

    }

}