prep.h File Reference

#include "nodes/pathnodes.h"
#include "nodes/plannodes.h"

Include dependency graph for prep.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
void	transform_MERGE_to_join (Query *parse)
void	replace_empty_jointree (Query *parse)
void	pull_up_sublinks (PlannerInfo *root)
void	preprocess_function_rtes (PlannerInfo *root)
Query *	expand_virtual_generated_columns (PlannerInfo *root)
void	pull_up_subqueries (PlannerInfo *root)
void	flatten_simple_union_all (PlannerInfo *root)
void	reduce_outer_joins (PlannerInfo *root)
void	remove_useless_result_rtes (PlannerInfo *root)
Relids	get_relids_in_jointree (Node *jtnode, bool include_outer_joins, bool include_inner_joins)
Relids	get_relids_for_join (Query *query, int joinrelid)
void	preprocess_targetlist (PlannerInfo *root)
List *	extract_update_targetlist_colnos (List *tlist)
PlanRowMark *	get_plan_rowmark (List *rowmarks, Index rtindex)
void	get_agg_clause_costs (PlannerInfo *root, AggSplit aggsplit, AggClauseCosts *costs)
void	preprocess_aggrefs (PlannerInfo *root, Node *clause)
RelOptInfo *	plan_set_operations (PlannerInfo *root)

Function Documentation

expand_virtual_generated_columns()

Query * expand_virtual_generated_columns

(

PlannerInfo *

root

)

Definition at line 969 of file prepjointree.c.

{
    Query      *parse = root->parse;
    int         rt_index;
    ListCell   *lc;
 
    rt_index = 0;
    foreach(lc, parse->rtable)
    {
        RangeTblEntry *rte = (RangeTblEntry *) lfirst(lc);
        Relation    rel;
        TupleDesc   tupdesc;
 
        ++rt_index;
 
        /*
         * Only normal relations can have virtual generated columns.
         */
        if (rte->rtekind != RTE_RELATION)
            continue;
 
        rel = table_open(rte->relid, NoLock);
 
        tupdesc = RelationGetDescr(rel);
        if (tupdesc->constr && tupdesc->constr->has_generated_virtual)
        {
            List       *tlist = NIL;
            pullup_replace_vars_context rvcontext;
 
            for (int i = 0; i < tupdesc->natts; i++)
            {
                Form_pg_attribute attr = TupleDescAttr(tupdesc, i);
                TargetEntry *tle;
 
                if (attr->attgenerated == ATTRIBUTE_GENERATED_VIRTUAL)
                {
                    Node       *defexpr;
 
                    defexpr = build_generation_expression(rel, i + 1);
                    ChangeVarNodes(defexpr, 1, rt_index, 0);
 
                    tle = makeTargetEntry((Expr *) defexpr, i + 1, 0, false);
                    tlist = lappend(tlist, tle);
                }
                else
                {
                    Var        *var;
 
                    var = makeVar(rt_index,
                                  i + 1,
                                  attr->atttypid,
                                  attr->atttypmod,
                                  attr->attcollation,
                                  0);
 
                    tle = makeTargetEntry((Expr *) var, i + 1, 0, false);
                    tlist = lappend(tlist, tle);
                }
            }
 
            Assert(list_length(tlist) > 0);
            Assert(!rte->lateral);
 
            /*
             * The relation's targetlist items are now in the appropriate form
             * to insert into the query, except that we may need to wrap them
             * in PlaceHolderVars.  Set up required context data for
             * pullup_replace_vars.
             */
            rvcontext.root = root;
            rvcontext.targetlist = tlist;
            rvcontext.target_rte = rte;
            rvcontext.result_relation = parse->resultRelation;
            /* won't need these values */
            rvcontext.relids = NULL;
            rvcontext.nullinfo = NULL;
            /* pass NULL for outer_hasSubLinks */
            rvcontext.outer_hasSubLinks = NULL;
            rvcontext.varno = rt_index;
            /* this flag will be set below, if needed */
            rvcontext.wrap_option = REPLACE_WRAP_NONE;
            /* initialize cache array with indexes 0 .. length(tlist) */
            rvcontext.rv_cache = palloc0((list_length(tlist) + 1) *
                                         sizeof(Node *));
 
            /*
             * If the query uses grouping sets, we need a PlaceHolderVar for
             * each expression of the relation's targetlist items.  (See
             * comments in pull_up_simple_subquery().)
             */
            if (parse->groupingSets)
                rvcontext.wrap_option = REPLACE_WRAP_ALL;
 
            /*
             * Apply pullup variable replacement throughout the query tree.
             */
            parse = (Query *) pullup_replace_vars((Node *) parse, &rvcontext);
        }
 
        table_close(rel, NoLock);
    }
 
    return parse;
}

References Assert(), build_generation_expression(), ChangeVarNodes(), TupleDescData::constr, TupleConstr::has_generated_virtual, i, lappend(), lfirst, list_length(), makeTargetEntry(), makeVar(), TupleDescData::natts, NIL, NoLock, pullup_replace_vars_context::nullinfo, pullup_replace_vars_context::outer_hasSubLinks, palloc0(), parse(), pullup_replace_vars(), RelationGetDescr, pullup_replace_vars_context::relids, REPLACE_WRAP_ALL, REPLACE_WRAP_NONE, pullup_replace_vars_context::result_relation, pullup_replace_vars_context::root, root, RTE_RELATION, RangeTblEntry::rtekind, pullup_replace_vars_context::rv_cache, table_close(), table_open(), pullup_replace_vars_context::target_rte, pullup_replace_vars_context::targetlist, TupleDescAttr(), pullup_replace_vars_context::varno, and pullup_replace_vars_context::wrap_option.

Referenced by pull_up_simple_subquery(), and subquery_planner().

extract_update_targetlist_colnos()

List * extract_update_targetlist_colnos

(

List *

tlist

)

Definition at line 348 of file preptlist.c.

{
    List       *update_colnos = NIL;
    AttrNumber  nextresno = 1;
    ListCell   *lc;
 
    foreach(lc, tlist)
    {
        TargetEntry *tle = (TargetEntry *) lfirst(lc);
 
        if (!tle->resjunk)
            update_colnos = lappend_int(update_colnos, tle->resno);
        tle->resno = nextresno++;
    }
    return update_colnos;
}

References lappend_int(), lfirst, NIL, and TargetEntry::resno.

Referenced by make_modifytable(), and preprocess_targetlist().

flatten_simple_union_all()

void flatten_simple_union_all

(

PlannerInfo *

root

)

Definition at line 2983 of file prepjointree.c.

{
    Query      *parse = root->parse;
    SetOperationStmt *topop;
    Node       *leftmostjtnode;
    int         leftmostRTI;
    RangeTblEntry *leftmostRTE;
    int         childRTI;
    RangeTblEntry *childRTE;
    RangeTblRef *rtr;
 
    /* Shouldn't be called unless query has setops */
    topop = castNode(SetOperationStmt, parse->setOperations);
    Assert(topop);
 
    /* Can't optimize away a recursive UNION */
    if (root->hasRecursion)
        return;
 
    /*
     * Recursively check the tree of set operations.  If not all UNION ALL
     * with identical column types, punt.
     */
    if (!is_simple_union_all_recurse((Node *) topop, parse, topop->colTypes))
        return;
 
    /*
     * Locate the leftmost leaf query in the setops tree.  The upper query's
     * Vars all refer to this RTE (see transformSetOperationStmt).
     */
    leftmostjtnode = topop->larg;
    while (leftmostjtnode && IsA(leftmostjtnode, SetOperationStmt))
        leftmostjtnode = ((SetOperationStmt *) leftmostjtnode)->larg;
    Assert(leftmostjtnode && IsA(leftmostjtnode, RangeTblRef));
    leftmostRTI = ((RangeTblRef *) leftmostjtnode)->rtindex;
    leftmostRTE = rt_fetch(leftmostRTI, parse->rtable);
    Assert(leftmostRTE->rtekind == RTE_SUBQUERY);
 
    /*
     * Make a copy of the leftmost RTE and add it to the rtable.  This copy
     * will represent the leftmost leaf query in its capacity as a member of
     * the appendrel.  The original will represent the appendrel as a whole.
     * (We must do things this way because the upper query's Vars have to be
     * seen as referring to the whole appendrel.)
     */
    childRTE = copyObject(leftmostRTE);
    parse->rtable = lappend(parse->rtable, childRTE);
    childRTI = list_length(parse->rtable);
 
    /* Modify the setops tree to reference the child copy */
    ((RangeTblRef *) leftmostjtnode)->rtindex = childRTI;
 
    /* Modify the formerly-leftmost RTE to mark it as an appendrel parent */
    leftmostRTE->inh = true;
 
    /*
     * Form a RangeTblRef for the appendrel, and insert it into FROM.  The top
     * Query of a setops tree should have had an empty FromClause initially.
     */
    rtr = makeNode(RangeTblRef);
    rtr->rtindex = leftmostRTI;
    Assert(parse->jointree->fromlist == NIL);
    parse->jointree->fromlist = list_make1(rtr);
 
    /*
     * Now pretend the query has no setops.  We must do this before trying to
     * do subquery pullup, because of Assert in pull_up_simple_subquery.
     */
    parse->setOperations = NULL;
 
    /*
     * Build AppendRelInfo information, and apply pull_up_subqueries to the
     * leaf queries of the UNION ALL.  (We must do that now because they
     * weren't previously referenced by the jointree, and so were missed by
     * the main invocation of pull_up_subqueries.)
     */
    pull_up_union_leaf_queries((Node *) topop, root, leftmostRTI, parse, 0);
}

References Assert(), castNode, copyObject, RangeTblEntry::inh, is_simple_union_all_recurse(), IsA, lappend(), SetOperationStmt::larg, list_length(), list_make1, makeNode, NIL, parse(), pull_up_union_leaf_queries(), root, rt_fetch, RTE_SUBQUERY, RangeTblEntry::rtekind, and RangeTblRef::rtindex.

Referenced by subquery_planner().

get_agg_clause_costs()

void get_agg_clause_costs	(	PlannerInfo *	root,
		AggSplit	aggsplit,
		AggClauseCosts *	costs
	)

Definition at line 559 of file prepagg.c.

{
    ListCell   *lc;
 
    foreach(lc, root->aggtransinfos)
    {
        AggTransInfo *transinfo = lfirst_node(AggTransInfo, lc);
 
        /*
         * Add the appropriate component function execution costs to
         * appropriate totals.
         */
        if (DO_AGGSPLIT_COMBINE(aggsplit))
        {
            /* charge for combining previously aggregated states */
            add_function_cost(root, transinfo->combinefn_oid, NULL,
                              &costs->transCost);
        }
        else
            add_function_cost(root, transinfo->transfn_oid, NULL,
                              &costs->transCost);
        if (DO_AGGSPLIT_DESERIALIZE(aggsplit) &&
            OidIsValid(transinfo->deserialfn_oid))
            add_function_cost(root, transinfo->deserialfn_oid, NULL,
                              &costs->transCost);
        if (DO_AGGSPLIT_SERIALIZE(aggsplit) &&
            OidIsValid(transinfo->serialfn_oid))
            add_function_cost(root, transinfo->serialfn_oid, NULL,
                              &costs->finalCost);
 
        /*
         * These costs are incurred only by the initial aggregate node, so we
         * mustn't include them again at upper levels.
         */
        if (!DO_AGGSPLIT_COMBINE(aggsplit))
        {
            /* add the input expressions' cost to per-input-row costs */
            QualCost    argcosts;
 
            cost_qual_eval_node(&argcosts, (Node *) transinfo->args, root);
            costs->transCost.startup += argcosts.startup;
            costs->transCost.per_tuple += argcosts.per_tuple;
 
            /*
             * Add any filter's cost to per-input-row costs.
             *
             * XXX Ideally we should reduce input expression costs according
             * to filter selectivity, but it's not clear it's worth the
             * trouble.
             */
            if (transinfo->aggfilter)
            {
                cost_qual_eval_node(&argcosts, (Node *) transinfo->aggfilter,
                                    root);
                costs->transCost.startup += argcosts.startup;
                costs->transCost.per_tuple += argcosts.per_tuple;
            }
        }
 
        /*
         * If the transition type is pass-by-value then it doesn't add
         * anything to the required size of the hashtable.  If it is
         * pass-by-reference then we have to add the estimated size of the
         * value itself, plus palloc overhead.
         */
        if (!transinfo->transtypeByVal)
        {
            int32       avgwidth;
 
            /* Use average width if aggregate definition gave one */
            if (transinfo->aggtransspace > 0)
                avgwidth = transinfo->aggtransspace;
            else if (transinfo->transfn_oid == F_ARRAY_APPEND)
            {
                /*
                 * If the transition function is array_append(), it'll use an
                 * expanded array as transvalue, which will occupy at least
                 * ALLOCSET_SMALL_INITSIZE and possibly more.  Use that as the
                 * estimate for lack of a better idea.
                 */
                avgwidth = ALLOCSET_SMALL_INITSIZE;
            }
            else
            {
                avgwidth = get_typavgwidth(transinfo->aggtranstype, transinfo->aggtranstypmod);
            }
 
            avgwidth = MAXALIGN(avgwidth);
            costs->transitionSpace += avgwidth + 2 * sizeof(void *);
        }
        else if (transinfo->aggtranstype == INTERNALOID)
        {
            /*
             * INTERNAL transition type is a special case: although INTERNAL
             * is pass-by-value, it's almost certainly being used as a pointer
             * to some large data structure.  The aggregate definition can
             * provide an estimate of the size.  If it doesn't, then we assume
             * ALLOCSET_DEFAULT_INITSIZE, which is a good guess if the data is
             * being kept in a private memory context, as is done by
             * array_agg() for instance.
             */
            if (transinfo->aggtransspace > 0)
                costs->transitionSpace += transinfo->aggtransspace;
            else
                costs->transitionSpace += ALLOCSET_DEFAULT_INITSIZE;
        }
    }
 
    foreach(lc, root->agginfos)
    {
        AggInfo    *agginfo = lfirst_node(AggInfo, lc);
        Aggref     *aggref = linitial_node(Aggref, agginfo->aggrefs);
 
        /*
         * Add the appropriate component function execution costs to
         * appropriate totals.
         */
        if (!DO_AGGSPLIT_SKIPFINAL(aggsplit) &&
            OidIsValid(agginfo->finalfn_oid))
            add_function_cost(root, agginfo->finalfn_oid, NULL,
                              &costs->finalCost);
 
        /*
         * If there are direct arguments, treat their evaluation cost like the
         * cost of the finalfn.
         */
        if (aggref->aggdirectargs)
        {
            QualCost    argcosts;
 
            cost_qual_eval_node(&argcosts, (Node *) aggref->aggdirectargs,
                                root);
            costs->finalCost.startup += argcosts.startup;
            costs->finalCost.per_tuple += argcosts.per_tuple;
        }
    }
}

References add_function_cost(), Aggref::aggdirectargs, AggTransInfo::aggfilter, AggInfo::aggrefs, AggTransInfo::aggtransspace, AggTransInfo::aggtranstype, AggTransInfo::aggtranstypmod, ALLOCSET_DEFAULT_INITSIZE, ALLOCSET_SMALL_INITSIZE, AggTransInfo::args, AggTransInfo::combinefn_oid, cost_qual_eval_node(), AggTransInfo::deserialfn_oid, DO_AGGSPLIT_COMBINE, DO_AGGSPLIT_DESERIALIZE, DO_AGGSPLIT_SERIALIZE, DO_AGGSPLIT_SKIPFINAL, AggClauseCosts::finalCost, AggInfo::finalfn_oid, get_typavgwidth(), lfirst_node, linitial_node, MAXALIGN, OidIsValid, QualCost::per_tuple, root, AggTransInfo::serialfn_oid, QualCost::startup, AggClauseCosts::transCost, AggTransInfo::transfn_oid, AggClauseCosts::transitionSpace, and AggTransInfo::transtypeByVal.

Referenced by create_grouping_paths(), create_partial_grouping_paths(), and estimate_path_cost_size().

get_plan_rowmark()

PlanRowMark * get_plan_rowmark	(	List *	rowmarks,
		Index	rtindex
	)

Definition at line 526 of file preptlist.c.

{
    ListCell   *l;
 
    foreach(l, rowmarks)
    {
        PlanRowMark *rc = (PlanRowMark *) lfirst(l);
 
        if (rc->rti == rtindex)
            return rc;
    }
    return NULL;
}

References lfirst, and PlanRowMark::rti.

Referenced by check_index_predicates(), deparseLockingClause(), and expand_inherited_rtentry().

get_relids_for_join()

Relids get_relids_for_join	(	Query *	query,
		int	joinrelid
	)

Definition at line 4303 of file prepjointree.c.

{
    Node       *jtnode;
 
    jtnode = find_jointree_node_for_rel((Node *) query->jointree,
                                        joinrelid);
    if (!jtnode)
        elog(ERROR, "could not find join node %d", joinrelid);
    return get_relids_in_jointree(jtnode, true, false);
}

References elog, ERROR, find_jointree_node_for_rel(), get_relids_in_jointree(), and Query::jointree.

Referenced by add_nullingrels_if_needed(), and alias_relid_set().

get_relids_in_jointree()

Relids get_relids_in_jointree	(	Node *	jtnode,
		bool	include_outer_joins,
		bool	include_inner_joins
	)

Definition at line 4242 of file prepjointree.c.

{
    Relids      result = NULL;
 
    if (jtnode == NULL)
        return result;
    if (IsA(jtnode, RangeTblRef))
    {
        int         varno = ((RangeTblRef *) jtnode)->rtindex;
 
        result = bms_make_singleton(varno);
    }
    else if (IsA(jtnode, FromExpr))
    {
        FromExpr   *f = (FromExpr *) jtnode;
        ListCell   *l;
 
        foreach(l, f->fromlist)
        {
            result = bms_join(result,
                              get_relids_in_jointree(lfirst(l),
                                                     include_outer_joins,
                                                     include_inner_joins));
        }
    }
    else if (IsA(jtnode, JoinExpr))
    {
        JoinExpr   *j = (JoinExpr *) jtnode;
 
        result = get_relids_in_jointree(j->larg,
                                        include_outer_joins,
                                        include_inner_joins);
        result = bms_join(result,
                          get_relids_in_jointree(j->rarg,
                                                 include_outer_joins,
                                                 include_inner_joins));
        if (j->rtindex)
        {
            if (j->jointype == JOIN_INNER)
            {
                if (include_inner_joins)
                    result = bms_add_member(result, j->rtindex);
            }
            else
            {
                if (include_outer_joins)
                    result = bms_add_member(result, j->rtindex);
            }
        }
    }
    else
        elog(ERROR, "unrecognized node type: %d",
             (int) nodeTag(jtnode));
    return result;
}

References bms_add_member(), bms_join(), bms_make_singleton(), elog, ERROR, FromExpr::fromlist, get_relids_in_jointree(), IsA, j, JOIN_INNER, lfirst, and nodeTag.

Referenced by find_dependent_phvs_in_jointree(), get_relids_for_join(), get_relids_in_jointree(), is_simple_subquery(), mark_nullable_by_grouping(), preprocess_rowmarks(), pull_up_simple_subquery(), and remove_result_refs().

plan_set_operations()

RelOptInfo * plan_set_operations

(

PlannerInfo *

root

)

Definition at line 93 of file prepunion.c.

{
    Query      *parse = root->parse;
    SetOperationStmt *topop = castNode(SetOperationStmt, parse->setOperations);
    Node       *node;
    RangeTblEntry *leftmostRTE;
    Query      *leftmostQuery;
    RelOptInfo *setop_rel;
    List       *top_tlist;
 
    Assert(topop);
 
    /* check for unsupported stuff */
    Assert(parse->jointree->fromlist == NIL);
    Assert(parse->jointree->quals == NULL);
    Assert(parse->groupClause == NIL);
    Assert(parse->havingQual == NULL);
    Assert(parse->windowClause == NIL);
    Assert(parse->distinctClause == NIL);
 
    /*
     * In the outer query level, equivalence classes are limited to classes
     * which define that the top-level target entry is equivalent to the
     * corresponding child target entry.  There won't be any equivalence class
     * merging.  Mark that merging is complete to allow us to make pathkeys.
     */
    Assert(root->eq_classes == NIL);
    root->ec_merging_done = true;
 
    /*
     * We'll need to build RelOptInfos for each of the leaf subqueries, which
     * are RTE_SUBQUERY rangetable entries in this Query.  Prepare the index
     * arrays for those, and for AppendRelInfos in case they're needed.
     */
    setup_simple_rel_arrays(root);
 
    /*
     * Find the leftmost component Query.  We need to use its column names for
     * all generated tlists (else SELECT INTO won't work right).
     */
    node = topop->larg;
    while (node && IsA(node, SetOperationStmt))
        node = ((SetOperationStmt *) node)->larg;
    Assert(node && IsA(node, RangeTblRef));
    leftmostRTE = root->simple_rte_array[((RangeTblRef *) node)->rtindex];
    leftmostQuery = leftmostRTE->subquery;
    Assert(leftmostQuery != NULL);
 
    /*
     * If the topmost node is a recursive union, it needs special processing.
     */
    if (root->hasRecursion)
    {
        setop_rel = generate_recursion_path(topop, root,
                                            leftmostQuery->targetList,
                                            &top_tlist);
    }
    else
    {
        bool        trivial_tlist;
 
        /*
         * Recurse on setOperations tree to generate paths for set ops. The
         * final output paths should have just the column types shown as the
         * output from the top-level node.
         */
        setop_rel = recurse_set_operations((Node *) topop, root,
                                           NULL,    /* no parent */
                                           topop->colTypes, topop->colCollations,
                                           leftmostQuery->targetList,
                                           &top_tlist,
                                           &trivial_tlist);
    }
 
    /* Must return the built tlist into root->processed_tlist. */
    root->processed_tlist = top_tlist;
 
    return setop_rel;
}

References Assert(), castNode, generate_recursion_path(), IsA, SetOperationStmt::larg, NIL, parse(), recurse_set_operations(), root, setup_simple_rel_arrays(), RangeTblEntry::subquery, and Query::targetList.

Referenced by grouping_planner().

preprocess_aggrefs()

void preprocess_aggrefs	(	PlannerInfo *	root,
		Node *	clause
	)

Definition at line 110 of file prepagg.c.

{
    (void) preprocess_aggrefs_walker(clause, root);
}

References preprocess_aggrefs_walker(), and root.

Referenced by grouping_planner().

preprocess_function_rtes()

void preprocess_function_rtes

(

PlannerInfo *

root

)

Definition at line 914 of file prepjointree.c.

{
    ListCell   *rt;
 
    foreach(rt, root->parse->rtable)
    {
        RangeTblEntry *rte = (RangeTblEntry *) lfirst(rt);
 
        if (rte->rtekind == RTE_FUNCTION)
        {
            Query      *funcquery;
 
            /* Apply const-simplification */
            rte->functions = (List *)
                eval_const_expressions(root, (Node *) rte->functions);
 
            /* Check safety of expansion, and expand if possible */
            funcquery = inline_set_returning_function(root, rte);
            if (funcquery)
            {
                /* Successful expansion, convert the RTE to a subquery */
                rte->rtekind = RTE_SUBQUERY;
                rte->subquery = funcquery;
                rte->security_barrier = false;
 
                /*
                 * Clear fields that should not be set in a subquery RTE.
                 * However, we leave rte->functions filled in for the moment,
                 * in case makeWholeRowVar needs to consult it.  We'll clear
                 * it in setrefs.c (see add_rte_to_flat_rtable) so that this
                 * abuse of the data structure doesn't escape the planner.
                 */
                rte->funcordinality = false;
            }
        }
    }
}

References eval_const_expressions(), RangeTblEntry::funcordinality, RangeTblEntry::functions, inline_set_returning_function(), lfirst, root, RTE_FUNCTION, RTE_SUBQUERY, RangeTblEntry::rtekind, and RangeTblEntry::subquery.

Referenced by pull_up_simple_subquery(), and subquery_planner().

preprocess_targetlist()

void preprocess_targetlist

(

PlannerInfo *

root

)

Definition at line 64 of file preptlist.c.

{
    Query      *parse = root->parse;
    int         result_relation = parse->resultRelation;
    List       *range_table = parse->rtable;
    CmdType     command_type = parse->commandType;
    RangeTblEntry *target_rte = NULL;
    Relation    target_relation = NULL;
    List       *tlist;
    ListCell   *lc;
 
    /*
     * If there is a result relation, open it so we can look for missing
     * columns and so on.  We assume that previous code already acquired at
     * least AccessShareLock on the relation, so we need no lock here.
     */
    if (result_relation)
    {
        target_rte = rt_fetch(result_relation, range_table);
 
        /*
         * Sanity check: it'd better be a real relation not, say, a subquery.
         * Else parser or rewriter messed up.
         */
        if (target_rte->rtekind != RTE_RELATION)
            elog(ERROR, "result relation must be a regular relation");
 
        target_relation = table_open(target_rte->relid, NoLock);
    }
    else
        Assert(command_type == CMD_SELECT);
 
    /*
     * In an INSERT, the executor expects the targetlist to match the exact
     * order of the target table's attributes, including entries for
     * attributes not mentioned in the source query.
     *
     * In an UPDATE, we don't rearrange the tlist order, but we need to make a
     * separate list of the target attribute numbers, in tlist order, and then
     * renumber the processed_tlist entries to be consecutive.
     */
    tlist = parse->targetList;
    if (command_type == CMD_INSERT)
        tlist = expand_insert_targetlist(root, tlist, target_relation);
    else if (command_type == CMD_UPDATE)
        root->update_colnos = extract_update_targetlist_colnos(tlist);
 
    /*
     * For non-inherited UPDATE/DELETE/MERGE, register any junk column(s)
     * needed to allow the executor to identify the rows to be updated or
     * deleted.  In the inheritance case, we do nothing now, leaving this to
     * be dealt with when expand_inherited_rtentry() makes the leaf target
     * relations.  (But there might not be any leaf target relations, in which
     * case we must do this in distribute_row_identity_vars().)
     */
    if ((command_type == CMD_UPDATE || command_type == CMD_DELETE ||
         command_type == CMD_MERGE) &&
        !target_rte->inh)
    {
        /* row-identity logic expects to add stuff to processed_tlist */
        root->processed_tlist = tlist;
        add_row_identity_columns(root, result_relation,
                                 target_rte, target_relation);
        tlist = root->processed_tlist;
    }
 
    /*
     * For MERGE we also need to handle the target list for each INSERT and
     * UPDATE action separately.  In addition, we examine the qual of each
     * action and add any Vars there (other than those of the target rel) to
     * the subplan targetlist.
     */
    if (command_type == CMD_MERGE)
    {
        ListCell   *l;
        List       *vars;
 
        /*
         * For MERGE, handle targetlist of each MergeAction separately. Give
         * the same treatment to MergeAction->targetList as we would have
         * given to a regular INSERT.  For UPDATE, collect the column numbers
         * being modified.
         */
        foreach(l, parse->mergeActionList)
        {
            MergeAction *action = (MergeAction *) lfirst(l);
            ListCell   *l2;
 
            if (action->commandType == CMD_INSERT)
                action->targetList = expand_insert_targetlist(root,
                                                              action->targetList,
                                                              target_relation);
            else if (action->commandType == CMD_UPDATE)
                action->updateColnos =
                    extract_update_targetlist_colnos(action->targetList);
 
            /*
             * Add resjunk entries for any Vars and PlaceHolderVars used in
             * each action's targetlist and WHEN condition that belong to
             * relations other than the target.  We don't expect to see any
             * aggregates or window functions here.
             */
            vars = pull_var_clause((Node *)
                                   list_concat_copy((List *) action->qual,
                                                    action->targetList),
                                   PVC_INCLUDE_PLACEHOLDERS);
            foreach(l2, vars)
            {
                Var        *var = (Var *) lfirst(l2);
                TargetEntry *tle;
 
                if (IsA(var, Var) && var->varno == result_relation)
                    continue;   /* don't need it */
 
                if (tlist_member((Expr *) var, tlist))
                    continue;   /* already got it */
 
                tle = makeTargetEntry((Expr *) var,
                                      list_length(tlist) + 1,
                                      NULL, true);
                tlist = lappend(tlist, tle);
            }
            list_free(vars);
        }
 
        /*
         * Add resjunk entries for any Vars and PlaceHolderVars used in the
         * join condition that belong to relations other than the target.  We
         * don't expect to see any aggregates or window functions here.
         */
        vars = pull_var_clause(parse->mergeJoinCondition,
                               PVC_INCLUDE_PLACEHOLDERS);
        foreach(l, vars)
        {
            Var        *var = (Var *) lfirst(l);
            TargetEntry *tle;
 
            if (IsA(var, Var) && var->varno == result_relation)
                continue;       /* don't need it */
 
            if (tlist_member((Expr *) var, tlist))
                continue;       /* already got it */
 
            tle = makeTargetEntry((Expr *) var,
                                  list_length(tlist) + 1,
                                  NULL, true);
            tlist = lappend(tlist, tle);
        }
    }
 
    /*
     * Add necessary junk columns for rowmarked rels.  These values are needed
     * for locking of rels selected FOR UPDATE/SHARE, and to do EvalPlanQual
     * rechecking.  See comments for PlanRowMark in plannodes.h.  If you
     * change this stanza, see also expand_inherited_rtentry(), which has to
     * be able to add on junk columns equivalent to these.
     *
     * (Someday it might be useful to fold these resjunk columns into the
     * row-identity-column management used for UPDATE/DELETE.  Today is not
     * that day, however.  One notable issue is that it seems important that
     * the whole-row Vars made here use the real table rowtype, not RECORD, so
     * that conversion to/from child relations' rowtypes will happen.  Also,
     * since these entries don't potentially bloat with more and more child
     * relations, there's not really much need for column sharing.)
     */
    foreach(lc, root->rowMarks)
    {
        PlanRowMark *rc = (PlanRowMark *) lfirst(lc);
        Var        *var;
        char        resname[32];
        TargetEntry *tle;
 
        /* child rels use the same junk attrs as their parents */
        if (rc->rti != rc->prti)
            continue;
 
        if (rc->allMarkTypes & ~(1 << ROW_MARK_COPY))
        {
            /* Need to fetch TID */
            var = makeVar(rc->rti,
                          SelfItemPointerAttributeNumber,
                          TIDOID,
                          -1,
                          InvalidOid,
                          0);
            snprintf(resname, sizeof(resname), "ctid%u", rc->rowmarkId);
            tle = makeTargetEntry((Expr *) var,
                                  list_length(tlist) + 1,
                                  pstrdup(resname),
                                  true);
            tlist = lappend(tlist, tle);
        }
        if (rc->allMarkTypes & (1 << ROW_MARK_COPY))
        {
            /* Need the whole row as a junk var */
            var = makeWholeRowVar(rt_fetch(rc->rti, range_table),
                                  rc->rti,
                                  0,
                                  false);
            snprintf(resname, sizeof(resname), "wholerow%u", rc->rowmarkId);
            tle = makeTargetEntry((Expr *) var,
                                  list_length(tlist) + 1,
                                  pstrdup(resname),
                                  true);
            tlist = lappend(tlist, tle);
        }
 
        /* If parent of inheritance tree, always fetch the tableoid too. */
        if (rc->isParent)
        {
            var = makeVar(rc->rti,
                          TableOidAttributeNumber,
                          OIDOID,
                          -1,
                          InvalidOid,
                          0);
            snprintf(resname, sizeof(resname), "tableoid%u", rc->rowmarkId);
            tle = makeTargetEntry((Expr *) var,
                                  list_length(tlist) + 1,
                                  pstrdup(resname),
                                  true);
            tlist = lappend(tlist, tle);
        }
    }
 
    /*
     * If the query has a RETURNING list, add resjunk entries for any Vars
     * used in RETURNING that belong to other relations.  We need to do this
     * to make these Vars available for the RETURNING calculation.  Vars that
     * belong to the result rel don't need to be added, because they will be
     * made to refer to the actual heap tuple.
     */
    if (parse->returningList && list_length(parse->rtable) > 1)
    {
        List       *vars;
        ListCell   *l;
 
        vars = pull_var_clause((Node *) parse->returningList,
                               PVC_RECURSE_AGGREGATES |
                               PVC_RECURSE_WINDOWFUNCS |
                               PVC_INCLUDE_PLACEHOLDERS);
        foreach(l, vars)
        {
            Var        *var = (Var *) lfirst(l);
            TargetEntry *tle;
 
            if (IsA(var, Var) &&
                var->varno == result_relation)
                continue;       /* don't need it */
 
            if (tlist_member((Expr *) var, tlist))
                continue;       /* already got it */
 
            tle = makeTargetEntry((Expr *) var,
                                  list_length(tlist) + 1,
                                  NULL,
                                  true);
 
            tlist = lappend(tlist, tle);
        }
        list_free(vars);
    }
 
    root->processed_tlist = tlist;
 
    if (target_relation)
        table_close(target_relation, NoLock);
}

References generate_unaccent_rules::action, add_row_identity_columns(), PlanRowMark::allMarkTypes, Assert(), CMD_DELETE, CMD_INSERT, CMD_MERGE, CMD_SELECT, CMD_UPDATE, elog, ERROR, expand_insert_targetlist(), extract_update_targetlist_colnos(), RangeTblEntry::inh, InvalidOid, IsA, PlanRowMark::isParent, lappend(), lfirst, list_concat_copy(), list_free(), list_length(), makeTargetEntry(), makeVar(), makeWholeRowVar(), NoLock, parse(), PlanRowMark::prti, pstrdup(), pull_var_clause(), PVC_INCLUDE_PLACEHOLDERS, PVC_RECURSE_AGGREGATES, PVC_RECURSE_WINDOWFUNCS, root, ROW_MARK_COPY, PlanRowMark::rowmarkId, rt_fetch, RTE_RELATION, RangeTblEntry::rtekind, PlanRowMark::rti, SelfItemPointerAttributeNumber, snprintf, table_close(), table_open(), TableOidAttributeNumber, tlist_member(), and Var::varno.

Referenced by grouping_planner().

pull_up_sublinks()

void pull_up_sublinks

(

PlannerInfo *

root

)

Definition at line 468 of file prepjointree.c.

{
    Node       *jtnode;
    Relids      relids;
 
    /* Begin recursion through the jointree */
    jtnode = pull_up_sublinks_jointree_recurse(root,
                                               (Node *) root->parse->jointree,
                                               &relids);
 
    /*
     * root->parse->jointree must always be a FromExpr, so insert a dummy one
     * if we got a bare RangeTblRef or JoinExpr out of the recursion.
     */
    if (IsA(jtnode, FromExpr))
        root->parse->jointree = (FromExpr *) jtnode;
    else
        root->parse->jointree = makeFromExpr(list_make1(jtnode), NULL);
}

References IsA, list_make1, makeFromExpr(), pull_up_sublinks_jointree_recurse(), and root.

Referenced by pull_up_simple_subquery(), and subquery_planner().

pull_up_subqueries()

void pull_up_subqueries

(

PlannerInfo *

root

)

Definition at line 1083 of file prepjointree.c.

{
    /* Top level of jointree must always be a FromExpr */
    Assert(IsA(root->parse->jointree, FromExpr));
    /* Recursion starts with no containing join nor appendrel */
    root->parse->jointree = (FromExpr *)
        pull_up_subqueries_recurse(root, (Node *) root->parse->jointree,
                                   NULL, NULL);
    /* We should still have a FromExpr */
    Assert(IsA(root->parse->jointree, FromExpr));
}

References Assert(), IsA, pull_up_subqueries_recurse(), and root.

Referenced by pull_up_simple_subquery(), and subquery_planner().

reduce_outer_joins()

void reduce_outer_joins

(

PlannerInfo *

root

)

Definition at line 3102 of file prepjointree.c.

{
    reduce_outer_joins_pass1_state *state1;
    reduce_outer_joins_pass2_state state2;
    ListCell   *lc;
 
    /*
     * To avoid doing strictness checks on more quals than necessary, we want
     * to stop descending the jointree as soon as there are no outer joins
     * below our current point.  This consideration forces a two-pass process.
     * The first pass gathers information about which base rels appear below
     * each side of each join clause, and about whether there are outer
     * join(s) below each side of each join clause. The second pass examines
     * qual clauses and changes join types as it descends the tree.
     */
    state1 = reduce_outer_joins_pass1((Node *) root->parse->jointree);
 
    /* planner.c shouldn't have called me if no outer joins */
    if (state1 == NULL || !state1->contains_outer)
        elog(ERROR, "so where are the outer joins?");
 
    state2.inner_reduced = NULL;
    state2.partial_reduced = NIL;
 
    reduce_outer_joins_pass2((Node *) root->parse->jointree,
                             state1, &state2,
                             root, NULL, NIL);
 
    /*
     * If we successfully reduced the strength of any outer joins, we must
     * remove references to those joins as nulling rels.  This is handled as
     * an additional pass, for simplicity and because we can handle all
     * fully-reduced joins in a single pass over the parse tree.
     */
    if (!bms_is_empty(state2.inner_reduced))
    {
        root->parse = (Query *)
            remove_nulling_relids((Node *) root->parse,
                                  state2.inner_reduced,
                                  NULL);
        /* There could be references in the append_rel_list, too */
        root->append_rel_list = (List *)
            remove_nulling_relids((Node *) root->append_rel_list,
                                  state2.inner_reduced,
                                  NULL);
    }
 
    /*
     * Partially-reduced full joins have to be done one at a time, since
     * they'll each need a different setting of except_relids.
     */
    foreach(lc, state2.partial_reduced)
    {
        reduce_outer_joins_partial_state *statep = lfirst(lc);
        Relids      full_join_relids = bms_make_singleton(statep->full_join_rti);
 
        root->parse = (Query *)
            remove_nulling_relids((Node *) root->parse,
                                  full_join_relids,
                                  statep->unreduced_side);
        root->append_rel_list = (List *)
            remove_nulling_relids((Node *) root->append_rel_list,
                                  full_join_relids,
                                  statep->unreduced_side);
    }
}

References bms_is_empty, bms_make_singleton(), reduce_outer_joins_pass1_state::contains_outer, elog, ERROR, reduce_outer_joins_partial_state::full_join_rti, reduce_outer_joins_pass2_state::inner_reduced, lfirst, NIL, reduce_outer_joins_pass2_state::partial_reduced, reduce_outer_joins_pass1(), reduce_outer_joins_pass2(), remove_nulling_relids(), root, and reduce_outer_joins_partial_state::unreduced_side.

Referenced by subquery_planner().

remove_useless_result_rtes()

void remove_useless_result_rtes

(

PlannerInfo *

root

)

Definition at line 3596 of file prepjointree.c.

{
    Relids      dropped_outer_joins = NULL;
    ListCell   *cell;
 
    /* Top level of jointree must always be a FromExpr */
    Assert(IsA(root->parse->jointree, FromExpr));
    /* Recurse ... */
    root->parse->jointree = (FromExpr *)
        remove_useless_results_recurse(root,
                                       (Node *) root->parse->jointree,
                                       NULL,
                                       &dropped_outer_joins);
    /* We should still have a FromExpr */
    Assert(IsA(root->parse->jointree, FromExpr));
 
    /*
     * If we removed any outer-join nodes from the jointree, run around and
     * remove references to those joins as nulling rels.  (There could be such
     * references in PHVs that we pulled up out of the original subquery that
     * the RESULT rel replaced.  This is kosher on the grounds that we now
     * know that such an outer join wouldn't really have nulled anything.)  We
     * don't do this during the main recursion, for simplicity and because we
     * can handle all such joins in a single pass over the parse tree.
     */
    if (!bms_is_empty(dropped_outer_joins))
    {
        root->parse = (Query *)
            remove_nulling_relids((Node *) root->parse,
                                  dropped_outer_joins,
                                  NULL);
        /* There could be references in the append_rel_list, too */
        root->append_rel_list = (List *)
            remove_nulling_relids((Node *) root->append_rel_list,
                                  dropped_outer_joins,
                                  NULL);
    }
 
    /*
     * Remove any PlanRowMark referencing an RTE_RESULT RTE.  We obviously
     * must do that for any RTE_RESULT that we just removed.  But one for a
     * RTE that we did not remove can be dropped anyway: since the RTE has
     * only one possible output row, there is no need for EPQ to mark and
     * restore that row.
     *
     * It's necessary, not optional, to remove the PlanRowMark for a surviving
     * RTE_RESULT RTE; otherwise we'll generate a whole-row Var for the
     * RTE_RESULT, which the executor has no support for.
     */
    foreach(cell, root->rowMarks)
    {
        PlanRowMark *rc = (PlanRowMark *) lfirst(cell);
 
        if (rt_fetch(rc->rti, root->parse->rtable)->rtekind == RTE_RESULT)
            root->rowMarks = foreach_delete_current(root->rowMarks, cell);
    }
}

References Assert(), bms_is_empty, foreach_delete_current, IsA, lfirst, remove_nulling_relids(), remove_useless_results_recurse(), root, rt_fetch, RTE_RESULT, and PlanRowMark::rti.

Referenced by subquery_planner().

replace_empty_jointree()

void replace_empty_jointree

(

Query *

parse

)

Definition at line 410 of file prepjointree.c.

{
    RangeTblEntry *rte;
    Index       rti;
    RangeTblRef *rtr;
 
    /* Nothing to do if jointree is already nonempty */
    if (parse->jointree->fromlist != NIL)
        return;
 
    /* We mustn't change it in the top level of a setop tree, either */
    if (parse->setOperations)
        return;
 
    /* Create suitable RTE */
    rte = makeNode(RangeTblEntry);
    rte->rtekind = RTE_RESULT;
    rte->eref = makeAlias("*RESULT*", NIL);
 
    /* Add it to rangetable */
    parse->rtable = lappend(parse->rtable, rte);
    rti = list_length(parse->rtable);
 
    /* And jam a reference into the jointree */
    rtr = makeNode(RangeTblRef);
    rtr->rtindex = rti;
    parse->jointree->fromlist = list_make1(rtr);
}

References lappend(), list_length(), list_make1, makeAlias(), makeNode, NIL, parse(), RTE_RESULT, RangeTblEntry::rtekind, and RangeTblRef::rtindex.

Referenced by convert_EXISTS_sublink_to_join(), pull_up_simple_subquery(), and subquery_planner().

transform_MERGE_to_join()

void transform_MERGE_to_join

(

Query *

parse

)

Definition at line 183 of file prepjointree.c.

{
    RangeTblEntry *joinrte;
    JoinExpr   *joinexpr;
    bool        have_action[NUM_MERGE_MATCH_KINDS];
    JoinType    jointype;
    int         joinrti;
    List       *vars;
    RangeTblRef *rtr;
    FromExpr   *target;
    Node       *source;
    int         sourcerti;
 
    if (parse->commandType != CMD_MERGE)
        return;
 
    /* XXX probably bogus */
    vars = NIL;
 
    /*
     * Work out what kind of join is required.  If there any WHEN NOT MATCHED
     * BY SOURCE/TARGET actions, an outer join is required so that we process
     * all unmatched tuples from the source and/or target relations.
     * Otherwise, we can use an inner join.
     */
    have_action[MERGE_WHEN_MATCHED] = false;
    have_action[MERGE_WHEN_NOT_MATCHED_BY_SOURCE] = false;
    have_action[MERGE_WHEN_NOT_MATCHED_BY_TARGET] = false;
 
    foreach_node(MergeAction, action, parse->mergeActionList)
    {
        if (action->commandType != CMD_NOTHING)
            have_action[action->matchKind] = true;
    }
 
    if (have_action[MERGE_WHEN_NOT_MATCHED_BY_SOURCE] &&
        have_action[MERGE_WHEN_NOT_MATCHED_BY_TARGET])
        jointype = JOIN_FULL;
    else if (have_action[MERGE_WHEN_NOT_MATCHED_BY_SOURCE])
        jointype = JOIN_LEFT;
    else if (have_action[MERGE_WHEN_NOT_MATCHED_BY_TARGET])
        jointype = JOIN_RIGHT;
    else
        jointype = JOIN_INNER;
 
    /* Manufacture a join RTE to use. */
    joinrte = makeNode(RangeTblEntry);
    joinrte->rtekind = RTE_JOIN;
    joinrte->jointype = jointype;
    joinrte->joinmergedcols = 0;
    joinrte->joinaliasvars = vars;
    joinrte->joinleftcols = NIL;    /* MERGE does not allow JOIN USING */
    joinrte->joinrightcols = NIL;   /* ditto */
    joinrte->join_using_alias = NULL;
 
    joinrte->alias = NULL;
    joinrte->eref = makeAlias("*MERGE*", NIL);
    joinrte->lateral = false;
    joinrte->inh = false;
    joinrte->inFromCl = true;
 
    /*
     * Add completed RTE to pstate's range table list, so that we know its
     * index.
     */
    parse->rtable = lappend(parse->rtable, joinrte);
    joinrti = list_length(parse->rtable);
 
    /*
     * Create a JOIN between the target and the source relation.
     *
     * Here the target is identified by parse->mergeTargetRelation.  For a
     * regular table, this will equal parse->resultRelation, but for a
     * trigger-updatable view, it will be the expanded view subquery that we
     * need to pull data from.
     *
     * The source relation is in parse->jointree->fromlist, but any quals in
     * parse->jointree->quals are restrictions on the target relation (if the
     * target relation is an auto-updatable view).
     */
    /* target rel, with any quals */
    rtr = makeNode(RangeTblRef);
    rtr->rtindex = parse->mergeTargetRelation;
    target = makeFromExpr(list_make1(rtr), parse->jointree->quals);
 
    /* source rel (expect exactly one -- see transformMergeStmt()) */
    Assert(list_length(parse->jointree->fromlist) == 1);
    source = linitial(parse->jointree->fromlist);
 
    /*
     * index of source rel (expect either a RangeTblRef or a JoinExpr -- see
     * transformFromClauseItem()).
     */
    if (IsA(source, RangeTblRef))
        sourcerti = ((RangeTblRef *) source)->rtindex;
    else if (IsA(source, JoinExpr))
        sourcerti = ((JoinExpr *) source)->rtindex;
    else
    {
        elog(ERROR, "unrecognized source node type: %d",
             (int) nodeTag(source));
        sourcerti = 0;          /* keep compiler quiet */
    }
 
    /* Join the source and target */
    joinexpr = makeNode(JoinExpr);
    joinexpr->jointype = jointype;
    joinexpr->isNatural = false;
    joinexpr->larg = (Node *) target;
    joinexpr->rarg = source;
    joinexpr->usingClause = NIL;
    joinexpr->join_using_alias = NULL;
    joinexpr->quals = parse->mergeJoinCondition;
    joinexpr->alias = NULL;
    joinexpr->rtindex = joinrti;
 
    /* Make the new join be the sole entry in the query's jointree */
    parse->jointree->fromlist = list_make1(joinexpr);
    parse->jointree->quals = NULL;
 
    /*
     * If necessary, mark parse->targetlist entries that refer to the target
     * as nullable by the join.  Normally the targetlist will be empty for a
     * MERGE, but if the target is a trigger-updatable view, it will contain a
     * whole-row Var referring to the expanded view query.
     */
    if (parse->targetList != NIL &&
        (jointype == JOIN_RIGHT || jointype == JOIN_FULL))
        parse->targetList = (List *)
            add_nulling_relids((Node *) parse->targetList,
                               bms_make_singleton(parse->mergeTargetRelation),
                               bms_make_singleton(joinrti));
 
    /*
     * If the source relation is on the outer side of the join, mark any
     * source relation Vars in the join condition, actions, and RETURNING list
     * as nullable by the join.  These Vars will be added to the targetlist by
     * preprocess_targetlist(), so it's important to mark them correctly here.
     *
     * It might seem that this is not necessary for Vars in the join
     * condition, since it is inside the join, but it is also needed above the
     * join (in the ModifyTable node) to distinguish between the MATCHED and
     * NOT MATCHED BY SOURCE cases -- see ExecMergeMatched().  Note that this
     * creates a modified copy of the join condition, for use above the join,
     * without modifying the original join condition, inside the join.
     */
    if (jointype == JOIN_LEFT || jointype == JOIN_FULL)
    {
        parse->mergeJoinCondition =
            add_nulling_relids(parse->mergeJoinCondition,
                               bms_make_singleton(sourcerti),
                               bms_make_singleton(joinrti));
 
        foreach_node(MergeAction, action, parse->mergeActionList)
        {
            action->qual =
                add_nulling_relids(action->qual,
                                   bms_make_singleton(sourcerti),
                                   bms_make_singleton(joinrti));
 
            action->targetList = (List *)
                add_nulling_relids((Node *) action->targetList,
                                   bms_make_singleton(sourcerti),
                                   bms_make_singleton(joinrti));
        }
 
        parse->returningList = (List *)
            add_nulling_relids((Node *) parse->returningList,
                               bms_make_singleton(sourcerti),
                               bms_make_singleton(joinrti));
    }
 
    /*
     * If there are any WHEN NOT MATCHED BY SOURCE actions, the executor will
     * use the join condition to distinguish between MATCHED and NOT MATCHED
     * BY SOURCE cases.  Otherwise, it's no longer needed, and we set it to
     * NULL, saving cycles during planning and execution.
     *
     * We need to be careful though: the executor evaluates this condition
     * using the output of the join subplan node, which nulls the output from
     * the source relation when the join condition doesn't match.  That risks
     * producing incorrect results when rechecking using a "non-strict" join
     * condition, such as "src.col IS NOT DISTINCT FROM tgt.col".  To guard
     * against that, we add an additional "src IS NOT NULL" check to the join
     * condition, so that it does the right thing when performing a recheck
     * based on the output of the join subplan.
     */
    if (have_action[MERGE_WHEN_NOT_MATCHED_BY_SOURCE])
    {
        Var        *var;
        NullTest   *ntest;
 
        /* source wholerow Var (nullable by the new join) */
        var = makeWholeRowVar(rt_fetch(sourcerti, parse->rtable),
                              sourcerti, 0, false);
        var->varnullingrels = bms_make_singleton(joinrti);
 
        /* "src IS NOT NULL" check */
        ntest = makeNode(NullTest);
        ntest->arg = (Expr *) var;
        ntest->nulltesttype = IS_NOT_NULL;
        ntest->argisrow = false;
        ntest->location = -1;
 
        /* combine it with the original join condition */
        parse->mergeJoinCondition =
            (Node *) make_and_qual((Node *) ntest, parse->mergeJoinCondition);
    }
    else
        parse->mergeJoinCondition = NULL;   /* join condition not needed */
}

References generate_unaccent_rules::action, add_nulling_relids(), NullTest::arg, Assert(), bms_make_singleton(), CMD_MERGE, CMD_NOTHING, elog, ERROR, foreach_node, RangeTblEntry::inh, IS_NOT_NULL, IsA, JoinExpr::isNatural, JOIN_FULL, JOIN_INNER, JOIN_LEFT, JOIN_RIGHT, RangeTblEntry::jointype, JoinExpr::jointype, lappend(), JoinExpr::larg, linitial, list_length(), list_make1, NullTest::location, make_and_qual(), makeAlias(), makeFromExpr(), makeNode, makeWholeRowVar(), MERGE_WHEN_MATCHED, MERGE_WHEN_NOT_MATCHED_BY_SOURCE, MERGE_WHEN_NOT_MATCHED_BY_TARGET, NIL, nodeTag, NullTest::nulltesttype, NUM_MERGE_MATCH_KINDS, parse(), JoinExpr::quals, JoinExpr::rarg, rt_fetch, RTE_JOIN, RangeTblEntry::rtekind, RangeTblRef::rtindex, JoinExpr::rtindex, and source.

Referenced by subquery_planner().