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)
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

extract_update_targetlist_colnos()

List* extract_update_targetlist_colnos

(

List *

tlist

)

Definition at line 323 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 2534 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, PlannerInfo::hasRecursion, RangeTblEntry::inh, is_simple_union_all_recurse(), IsA, lappend(), SetOperationStmt::larg, list_length(), list_make1, makeNode, NIL, parse(), PlannerInfo::parse, pull_up_union_leaf_queries(), 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 561 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, PlannerInfo::agginfos, AggInfo::aggrefs, PlannerInfo::aggtransinfos, 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, 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 487 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 3849 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 3788 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, IsA, j, JOIN_INNER, lfirst, and nodeTag.

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

plan_set_operations()

RelOptInfo* plan_set_operations

(

PlannerInfo *

root

)

Definition at line 104 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, we won't have any true equivalences to deal
     * with; but we do want to be able to make pathkeys, which will require
     * single-member EquivalenceClasses.  Indicate that EC merging is complete
     * so that pathkeys.c won't complain.
     */
    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
    {
        /*
         * 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, plus possibly resjunk working
         * columns (we can rely on upper-level nodes to deal with that).
         */
        setop_rel = recurse_set_operations((Node *) topop, root,
                                           topop->colTypes, topop->colCollations,
                                           true, -1,
                                           leftmostQuery->targetList,
                                           &top_tlist,
                                           NULL);
    }
 
    /* Must return the built tlist into root->processed_tlist. */
    root->processed_tlist = top_tlist;
 
    return setop_rel;
}

References Assert(), castNode, PlannerInfo::ec_merging_done, PlannerInfo::eq_classes, generate_recursion_path(), PlannerInfo::hasRecursion, IsA, SetOperationStmt::larg, NIL, parse(), PlannerInfo::parse, PlannerInfo::processed_tlist, recurse_set_operations(), 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 111 of file prepagg.c.

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

References preprocess_aggrefs_walker().

Referenced by grouping_planner().

preprocess_function_rtes()

void preprocess_function_rtes

(

PlannerInfo *

root

)

Definition at line 727 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 */
                rte->functions = NIL;
                rte->funcordinality = false;
            }
        }
    }
}

References eval_const_expressions(), RangeTblEntry::funcordinality, RangeTblEntry::functions, inline_set_returning_function(), lfirst, NIL, PlannerInfo::parse, Query::rtable, RTE_FUNCTION, RTE_SUBQUERY, RangeTblEntry::rtekind, RangeTblEntry::security_barrier, and RangeTblEntry::subquery.

Referenced by pull_up_simple_subquery(), and subquery_planner().

preprocess_targetlist()

void preprocess_targetlist

(

PlannerInfo *

root

)

Definition at line 62 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(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;
 
        /*
         * 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);
            List       *vars;
            ListCell   *l2;
 
            if (action->commandType == CMD_INSERT)
                action->targetList = expand_insert_targetlist(action->targetList,
                                                              target_relation);
            else if (action->commandType == CMD_UPDATE)
                action->updateColnos =
                    extract_update_targetlist_colnos(action->targetList);
 
            /*
             * Add resjunk entries for any Vars used in each action's
             * targetlist and WHEN condition that belong to relations other
             * than target.  Note that aggregates, window functions and
             * placeholder vars are not possible anywhere in MERGE's WHEN
             * clauses.  (PHVs may be added later, but they don't concern us
             * here.)
             */
            vars = pull_var_clause((Node *)
                                   list_concat_copy((List *) action->qual,
                                                    action->targetList),
                                   0);
            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 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(), PlannerInfo::parse, PlannerInfo::processed_tlist, PlanRowMark::prti, pstrdup(), pull_var_clause(), PVC_INCLUDE_PLACEHOLDERS, PVC_RECURSE_AGGREGATES, PVC_RECURSE_WINDOWFUNCS, RangeTblEntry::relid, ROW_MARK_COPY, PlanRowMark::rowmarkId, PlannerInfo::rowMarks, rt_fetch, RTE_RELATION, RangeTblEntry::rtekind, PlanRowMark::rti, SelfItemPointerAttributeNumber, snprintf, table_close(), table_open(), TableOidAttributeNumber, tlist_member(), PlannerInfo::update_colnos, and Var::varno.

Referenced by grouping_planner().

pull_up_sublinks()

void pull_up_sublinks

(

PlannerInfo *

root

)

Definition at line 293 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, Query::jointree, list_make1, makeFromExpr(), PlannerInfo::parse, and pull_up_sublinks_jointree_recurse().

Referenced by pull_up_simple_subquery(), and subquery_planner().

pull_up_subqueries()

void pull_up_subqueries

(

PlannerInfo *

root

)

Definition at line 768 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, Query::jointree, PlannerInfo::parse, and pull_up_subqueries_recurse().

Referenced by pull_up_simple_subquery(), and subquery_planner().

reduce_outer_joins()

void reduce_outer_joins

(

PlannerInfo *

root

)

Definition at line 2652 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 PlannerInfo::append_rel_list, 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, Query::jointree, lfirst, NIL, PlannerInfo::parse, reduce_outer_joins_pass2_state::partial_reduced, reduce_outer_joins_pass1(), reduce_outer_joins_pass2(), remove_nulling_relids(), 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 3145 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 PlannerInfo::append_rel_list, Assert(), bms_is_empty(), foreach_delete_current, IsA, Query::jointree, lfirst, PlannerInfo::parse, remove_nulling_relids(), remove_useless_results_recurse(), PlannerInfo::rowMarks, rt_fetch, Query::rtable, RTE_RESULT, and PlanRowMark::rti.

Referenced by subquery_planner().

replace_empty_jointree()

void replace_empty_jointree

(

Query *

parse

)

Definition at line 235 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 RangeTblEntry::eref, 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 152 of file prepjointree.c.

{
    RangeTblEntry *joinrte;
    JoinExpr   *joinexpr;
    JoinType    jointype;
    int         joinrti;
    List       *vars;
 
    if (parse->commandType != CMD_MERGE)
        return;
 
    /* XXX probably bogus */
    vars = NIL;
 
    /*
     * When any WHEN NOT MATCHED THEN INSERT clauses exist, we need to use an
     * outer join so that we process all unmatched tuples from the source
     * relation.  If none exist, we can use an inner join.
     */
    if (parse->mergeUseOuterJoin)
        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.
     */
    joinexpr = makeNode(JoinExpr);
    joinexpr->jointype = jointype;
    joinexpr->isNatural = false;
    joinexpr->larg = (Node *) makeNode(RangeTblRef);
    ((RangeTblRef *) joinexpr->larg)->rtindex = parse->resultRelation;
    joinexpr->rarg = linitial(parse->jointree->fromlist);   /* original join */
    joinexpr->usingClause = NIL;
    joinexpr->join_using_alias = NULL;
    /* The quals are removed from the jointree and into this specific join */
    joinexpr->quals = parse->jointree->quals;
    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;
}

References RangeTblEntry::alias, CMD_MERGE, RangeTblEntry::eref, RangeTblEntry::inFromCl, RangeTblEntry::inh, JoinExpr::isNatural, JOIN_INNER, JOIN_RIGHT, RangeTblEntry::join_using_alias, RangeTblEntry::joinaliasvars, RangeTblEntry::joinleftcols, RangeTblEntry::joinmergedcols, RangeTblEntry::joinrightcols, RangeTblEntry::jointype, JoinExpr::jointype, lappend(), JoinExpr::larg, RangeTblEntry::lateral, linitial, list_length(), list_make1, makeAlias(), makeNode, NIL, parse(), JoinExpr::quals, JoinExpr::rarg, RTE_JOIN, RangeTblEntry::rtekind, and JoinExpr::rtindex.

Referenced by subquery_planner().