对PostgreSQL源代码中的build_jion_rel的理解

其代码结构：

/*

 * build_join_rel

 *      Returns relation entry corresponding to the union of two given rels,

 *      creating a new relation entry if none already exists.

 *

 * 'joinrelids' is the Relids set that uniquely identifies the join

 * 'outer_rel' and 'inner_rel' are relation nodes for the relations to be

 *        joined

 * 'sjinfo': join context info

 * 'restrictlist_ptr': result variable.  If not NULL, *restrictlist_ptr

 *        receives the list of RestrictInfo nodes that apply to this

 *        particular pair of joinable relations.

 *

 * restrictlist_ptr makes the routine's API a little grotty, but it saves

 * duplicated calculation of the restrictlist...

 */

RelOptInfo *

build_join_rel(PlannerInfo *root,

               Relids joinrelids,

               RelOptInfo *outer_rel,

               RelOptInfo *inner_rel,

               SpecialJoinInfo *sjinfo,

               List **restrictlist_ptr)

{

    RelOptInfo *joinrel;

    List       *restrictlist;



    /*

     * See if we already have a joinrel for this set of base rels.

     */

    joinrel = find_join_rel(root, joinrelids);



    if (joinrel)

    {

        /*

         * Yes, so we only need to figure the restrictlist for this particular

         * pair of component relations.

         */

        if (restrictlist_ptr)

            *restrictlist_ptr = build_joinrel_restrictlist(root,

                                                           joinrel,

                                                           outer_rel,

                                                           inner_rel);

        return joinrel;

    }



    /*

     * Nope, so make one.

     */

    joinrel = makeNode(RelOptInfo);

    joinrel->reloptkind = RELOPT_JOINREL;

    joinrel->relids = bms_copy(joinrelids);

    joinrel->rows = 0;

    joinrel->width = 0;

    joinrel->reltargetlist = NIL;

    joinrel->pathlist = NIL;

    joinrel->ppilist = NIL;

    joinrel->cheapest_startup_path = NULL;

    joinrel->cheapest_total_path = NULL;

    joinrel->cheapest_unique_path = NULL;

    joinrel->cheapest_parameterized_paths = NIL;

    joinrel->relid = 0;            /* indicates not a baserel */

    joinrel->rtekind = RTE_JOIN;

    joinrel->min_attr = 0;

    joinrel->max_attr = 0;

    joinrel->attr_needed = NULL;

    joinrel->attr_widths = NULL;

    joinrel->indexlist = NIL;

    joinrel->pages = 0;

    joinrel->tuples = 0;

    joinrel->allvisfrac = 0;

    joinrel->subplan = NULL;

    joinrel->subroot = NULL;

    joinrel->fdwroutine = NULL;

    joinrel->fdw_private = NULL;

    joinrel->baserestrictinfo = NIL;

    joinrel->baserestrictcost.startup = 0;

    joinrel->baserestrictcost.per_tuple = 0;

    joinrel->joininfo = NIL;

    joinrel->has_eclass_joins = false;



    /*

     * Create a new tlist containing just the vars that need to be output from

     * this join (ie, are needed for higher joinclauses or final output).

     *

     * NOTE: the tlist order for a join rel will depend on which pair of outer

     * and inner rels we first try to build it from.  But the contents should

     * be the same regardless.

     */

    build_joinrel_tlist(root, joinrel, outer_rel);

    build_joinrel_tlist(root, joinrel, inner_rel);

    add_placeholders_to_joinrel(root, joinrel);



    /*

     * Construct restrict and join clause lists for the new joinrel. (The

     * caller might or might not need the restrictlist, but I need it anyway

     * for set_joinrel_size_estimates().)

     */

    restrictlist = build_joinrel_restrictlist(root, joinrel,

                                              outer_rel, inner_rel);

    if (restrictlist_ptr)

        *restrictlist_ptr = restrictlist;

    build_joinrel_joinlist(joinrel, outer_rel, inner_rel);



    /*

     * This is also the right place to check whether the joinrel has any

     * pending EquivalenceClass joins.

     */

    joinrel->has_eclass_joins = has_relevant_eclass_joinclause(root, joinrel);



    /*

     * Set estimates of the joinrel's size.

     */

    set_joinrel_size_estimates(root, joinrel, outer_rel, inner_rel,

                               sjinfo, restrictlist);



    /*

     * Add the joinrel to the query's joinrel list, and store it into the

     * auxiliary hashtable if there is one.  NB: GEQO requires us to append

     * the new joinrel to the end of the list!

     */

    root->join_rel_list = lappend(root->join_rel_list, joinrel);



    if (root->join_rel_hash)

    {

        JoinHashEntry *hentry;

        bool        found;



        hentry = (JoinHashEntry *) hash_search(root->join_rel_hash,

                                               &(joinrel->relids),

                                               HASH_ENTER,

                                               &found);

        Assert(!found);

        hentry->join_rel = joinrel;

    }



    /*

     * Also, if dynamic-programming join search is active, add the new joinrel

     * to the appropriate sublist.    Note: you might think the Assert on number

     * of members should be for equality, but some of the level 1 rels might

     * have been joinrels already, so we can only assert <=.

     */

    if (root->join_rel_level)

    {

        Assert(root->join_cur_level > 0);

        Assert(root->join_cur_level <= bms_num_members(joinrel->relids));

        root->join_rel_level[root->join_cur_level] =

            lappend(root->join_rel_level[root->join_cur_level], joinrel);

    }



    return joinrel;

}

其中：

build_joinrel_tlist: 就是targetlist （table 名集合）

restrictlist: 两个table各自的where条件

build_joinrel_jionlist: jion条件集合