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	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_joins)
Relids	get_relids_for_join (Query *query, int joinrelid)
List *	preprocess_targetlist (PlannerInfo *root)
PlanRowMark *	get_plan_rowmark (List *rowmarks, Index rtindex)
RelOptInfo *	plan_set_operations (PlannerInfo *root)

Function Documentation

flatten_simple_union_all()

void flatten_simple_union_all

(

PlannerInfo *

root

)

Definition at line 2433 of file prepjointree.c.

References Assert, castNode, copyObject, FromExpr::fromlist, PlannerInfo::hasRecursion, RangeTblEntry::inh, is_simple_union_all_recurse(), IsA, Query::jointree, lappend(), list_length(), list_make1, makeNode, NIL, parse(), PlannerInfo::parse, pull_up_union_leaf_queries(), rt_fetch, Query::rtable, RTE_SUBQUERY, RangeTblEntry::rtekind, RangeTblRef::rtindex, and Query::setOperations.

Referenced by subquery_planner().

{
    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);
}

get_plan_rowmark()

PlanRowMark* get_plan_rowmark	(	List *	rowmarks,
		Index	rtindex
	)

Definition at line 426 of file preptlist.c.

References lfirst, and PlanRowMark::rti.

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

{
    ListCell   *l;

    foreach(l, rowmarks)
    {
        PlanRowMark *rc = (PlanRowMark *) lfirst(l);

        if (rc->rti == rtindex)
            return rc;
    }
    return NULL;
}

get_relids_for_join()

Relids get_relids_for_join	(	Query *	query,
		int	joinrelid
	)

Definition at line 3478 of file prepjointree.c.

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

Referenced by alias_relid_set().

{
    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, false);
}

get_relids_in_jointree()

Relids get_relids_in_jointree	(	Node *	jtnode,
		bool	include_joins
	)

Definition at line 3434 of file prepjointree.c.

References bms_add_member(), bms_join(), bms_make_singleton(), elog, ERROR, FromExpr::fromlist, get_relids_in_jointree(), IsA, JoinExpr::larg, lfirst, nodeTag, JoinExpr::rarg, JoinExpr::rtindex, and pullup_replace_vars_context::varno.

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

{
    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_joins));
        }
    }
    else if (IsA(jtnode, JoinExpr))
    {
        JoinExpr   *j = (JoinExpr *) jtnode;

        result = get_relids_in_jointree(j->larg, include_joins);
        result = bms_join(result,
                          get_relids_in_jointree(j->rarg, include_joins));
        if (include_joins && j->rtindex)
            result = bms_add_member(result, j->rtindex);
    }
    else
        elog(ERROR, "unrecognized node type: %d",
             (int) nodeTag(jtnode));
    return result;
}

plan_set_operations()

RelOptInfo* plan_set_operations

(

PlannerInfo *

root

)

Definition at line 103 of file prepunion.c.

References Assert, castNode, Query::distinctClause, PlannerInfo::ec_merging_done, PlannerInfo::eq_classes, FromExpr::fromlist, generate_recursion_path(), Query::groupClause, PlannerInfo::hasRecursion, Query::havingQual, IsA, Query::jointree, SetOperationStmt::larg, NIL, parse(), PlannerInfo::parse, PlannerInfo::processed_tlist, FromExpr::quals, recurse_set_operations(), Query::setOperations, setup_simple_rel_arrays(), PlannerInfo::simple_rte_array, RangeTblEntry::subquery, Query::targetList, and Query::windowClause.

Referenced by grouping_planner().

{
    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;
}

preprocess_function_rtes()

void preprocess_function_rtes

(

PlannerInfo *

root

)

Definition at line 635 of file prepjointree.c.

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

{
    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;
            }
        }
    }
}

preprocess_targetlist()

List* preprocess_targetlist

(

PlannerInfo *

root

)

Definition at line 70 of file preptlist.c.

References PlanRowMark::allMarkTypes, Assert, CMD_DELETE, CMD_INSERT, CMD_SELECT, CMD_UPDATE, Query::commandType, elog, ERROR, expand_targetlist(), InvalidOid, IsA, PlanRowMark::isParent, lappend(), lfirst, list_free(), list_length(), makeTargetEntry(), makeVar(), makeWholeRowVar(), NoLock, Query::onConflict, OnConflictExpr::onConflictSet, parse(), PlannerInfo::parse, PlanRowMark::prti, pstrdup(), pull_var_clause(), PVC_INCLUDE_PLACEHOLDERS, PVC_RECURSE_AGGREGATES, PVC_RECURSE_WINDOWFUNCS, RangeTblEntry::relid, Query::resultRelation, Query::returningList, rewriteTargetListUD(), ROW_MARK_COPY, PlanRowMark::rowmarkId, PlannerInfo::rowMarks, rt_fetch, Query::rtable, RTE_RELATION, RangeTblEntry::rtekind, PlanRowMark::rti, SelfItemPointerAttributeNumber, snprintf, table_close(), table_open(), TableOidAttributeNumber, Query::targetList, tlist_member(), and Var::varno.

Referenced by grouping_planner(), and inheritance_planner().

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

    /*
     * For UPDATE/DELETE, add any junk column(s) needed to allow the executor
     * to identify the rows to be updated or deleted.  Note that this step
     * scribbles on parse->targetList, which is not very desirable, but we
     * keep it that way to avoid changing APIs used by FDWs.
     */
    if (command_type == CMD_UPDATE || command_type == CMD_DELETE)
        rewriteTargetListUD(parse, target_rte, target_relation);

    /*
     * for heap_form_tuple to work, the targetlist must match the exact order
     * of the attributes. We also need to fill in any missing attributes. -ay
     * 10/94
     */
    tlist = parse->targetList;
    if (command_type == CMD_INSERT || command_type == CMD_UPDATE)
        tlist = expand_targetlist(tlist, command_type,
                                  result_relation, target_relation);

    /*
     * 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.
     */
    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);
    }

    /*
     * If there's an ON CONFLICT UPDATE clause, preprocess its targetlist too
     * while we have the relation open.
     */
    if (parse->onConflict)
        parse->onConflict->onConflictSet =
            expand_targetlist(parse->onConflict->onConflictSet,
                              CMD_UPDATE,
                              result_relation,
                              target_relation);

    if (target_relation)
        table_close(target_relation, NoLock);

    return tlist;
}

pull_up_sublinks()

void pull_up_sublinks

(

PlannerInfo *

root

)

Definition at line 204 of file prepjointree.c.

References IsA, Query::jointree, list_make1, makeFromExpr(), PlannerInfo::parse, pull_up_sublinks_jointree_recurse(), and pullup_replace_vars_context::relids.

Referenced by pull_up_simple_subquery(), and subquery_planner().

{
    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);
}

pull_up_subqueries()

void pull_up_subqueries

(

PlannerInfo *

root

)

Definition at line 676 of file prepjointree.c.

References Assert, IsA, Query::jointree, PlannerInfo::parse, and pull_up_subqueries_recurse().

Referenced by pull_up_simple_subquery(), and subquery_planner().

{
    /* 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, NULL);
    /* We should still have a FromExpr */
    Assert(IsA(root->parse->jointree, FromExpr));
}

reduce_outer_joins()

void reduce_outer_joins

(

PlannerInfo *

root

)

Definition at line 2551 of file prepjointree.c.

References reduce_outer_joins_state::contains_outer, elog, ERROR, Query::jointree, NIL, PlannerInfo::parse, reduce_outer_joins_pass1(), and reduce_outer_joins_pass2().

Referenced by subquery_planner().

{
    reduce_outer_joins_state *state;

    /*
     * 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.
     */
    state = reduce_outer_joins_pass1((Node *) root->parse->jointree);

    /* planner.c shouldn't have called me if no outer joins */
    if (state == NULL || !state->contains_outer)
        elog(ERROR, "so where are the outer joins?");

    reduce_outer_joins_pass2((Node *) root->parse->jointree,
                             state, root, NULL, NIL, NIL);
}

remove_useless_result_rtes()

void remove_useless_result_rtes

(

PlannerInfo *

root

)

Definition at line 2961 of file prepjointree.c.

References Assert, foreach_delete_current, IsA, Query::jointree, lfirst, PlannerInfo::parse, remove_useless_results_recurse(), PlannerInfo::rowMarks, rt_fetch, Query::rtable, RTE_RESULT, and PlanRowMark::rti.

Referenced by subquery_planner().

{
    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);
    /* We should still have a FromExpr */
    Assert(IsA(root->parse->jointree, FromExpr));

    /*
     * 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);
    }
}

replace_empty_jointree()

void replace_empty_jointree

(

Query *

parse

)

Definition at line 146 of file prepjointree.c.

References RangeTblEntry::eref, FromExpr::fromlist, Query::jointree, lappend(), list_length(), list_make1, makeAlias(), makeNode, NIL, Query::rtable, RTE_RESULT, RangeTblEntry::rtekind, RangeTblRef::rtindex, and Query::setOperations.

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

{
    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);
}