tlist.c File Reference

#include "postgres.h"
#include "nodes/makefuncs.h"
#include "nodes/nodeFuncs.h"
#include "optimizer/cost.h"
#include "optimizer/optimizer.h"
#include "optimizer/tlist.h"

Include dependency graph for tlist.c:

Go to the source code of this file.

Data Structures
struct	split_pathtarget_item
struct	split_pathtarget_context

Macros
#define	IS_SRF_CALL(node)

Functions
static bool	split_pathtarget_walker (Node *node, split_pathtarget_context *context)
static void	add_sp_item_to_pathtarget (PathTarget *target, split_pathtarget_item *item)
static void	add_sp_items_to_pathtarget (PathTarget *target, List *items)
TargetEntry *	tlist_member (Expr *node, List *targetlist)
static TargetEntry *	tlist_member_match_var (Var *var, List *targetlist)
List *	add_to_flat_tlist (List *tlist, List *exprs)
List *	get_tlist_exprs (List *tlist, bool includeJunk)
int	count_nonjunk_tlist_entries (List *tlist)
bool	tlist_same_exprs (List *tlist1, List *tlist2)
bool	tlist_same_datatypes (List *tlist, List *colTypes, bool junkOK)
bool	tlist_same_collations (List *tlist, List *colCollations, bool junkOK)
void	apply_tlist_labeling (List *dest_tlist, List *src_tlist)
TargetEntry *	get_sortgroupref_tle (Index sortref, List *targetList)
TargetEntry *	get_sortgroupclause_tle (SortGroupClause *sgClause, List *targetList)
Node *	get_sortgroupclause_expr (SortGroupClause *sgClause, List *targetList)
List *	get_sortgrouplist_exprs (List *sgClauses, List *targetList)
SortGroupClause *	get_sortgroupref_clause (Index sortref, List *clauses)
SortGroupClause *	get_sortgroupref_clause_noerr (Index sortref, List *clauses)
Oid *	extract_grouping_ops (List *groupClause)
Oid *	extract_grouping_collations (List *groupClause, List *tlist)
AttrNumber *	extract_grouping_cols (List *groupClause, List *tlist)
bool	grouping_is_sortable (List *groupClause)
bool	grouping_is_hashable (List *groupClause)
PathTarget *	make_pathtarget_from_tlist (List *tlist)
List *	make_tlist_from_pathtarget (PathTarget *target)
PathTarget *	copy_pathtarget (PathTarget *src)
PathTarget *	create_empty_pathtarget (void)
void	add_column_to_pathtarget (PathTarget *target, Expr *expr, Index sortgroupref)
void	add_new_column_to_pathtarget (PathTarget *target, Expr *expr)
void	add_new_columns_to_pathtarget (PathTarget *target, List *exprs)
void	apply_pathtarget_labeling_to_tlist (List *tlist, PathTarget *target)
void	split_pathtarget_at_srfs (PlannerInfo *root, PathTarget *target, PathTarget *input_target, List **targets, List **targets_contain_srfs)

Macro Definition Documentation

IS_SRF_CALL

#define IS_SRF_CALL

(

node

)

Value:

    ((IsA(node, FuncExpr) && ((FuncExpr *) (node))->funcretset) || \
     (IsA(node, OpExpr) && ((OpExpr *) (node))->opretset))

Definition at line 31 of file tlist.c.

Function Documentation

add_column_to_pathtarget()

void add_column_to_pathtarget	(	PathTarget *	target,
		Expr *	expr,
		Index	sortgroupref
	)

Definition at line 695 of file tlist.c.

{
    /* Updating the exprs list is easy ... */
    target->exprs = lappend(target->exprs, expr);
    /* ... the sortgroupref data, a bit less so */
    if (target->sortgrouprefs)
    {
        int         nexprs = list_length(target->exprs);
 
        /* This might look inefficient, but actually it's usually cheap */
        target->sortgrouprefs = (Index *)
            repalloc(target->sortgrouprefs, nexprs * sizeof(Index));
        target->sortgrouprefs[nexprs - 1] = sortgroupref;
    }
    else if (sortgroupref)
    {
        /* Adding sortgroupref labeling to a previously unlabeled target */
        int         nexprs = list_length(target->exprs);
 
        target->sortgrouprefs = (Index *) palloc0(nexprs * sizeof(Index));
        target->sortgrouprefs[nexprs - 1] = sortgroupref;
    }
 
    /*
     * Reset has_volatile_expr to UNKNOWN.  We just leave it up to
     * contain_volatile_functions to set this properly again.  Technically we
     * could save some effort here and just check the new Expr, but it seems
     * better to keep the logic for setting this flag in one location rather
     * than duplicating the logic here.
     */
    if (target->has_volatile_expr == VOLATILITY_NOVOLATILE)
        target->has_volatile_expr = VOLATILITY_UNKNOWN;
}

References PathTarget::exprs, PathTarget::has_volatile_expr, lappend(), list_length(), palloc0(), repalloc(), VOLATILITY_NOVOLATILE, and VOLATILITY_UNKNOWN.

Referenced by add_new_column_to_pathtarget(), add_sp_item_to_pathtarget(), create_one_window_path(), make_group_input_target(), make_partial_grouping_target(), make_sort_input_target(), and make_window_input_target().

add_new_column_to_pathtarget()

void add_new_column_to_pathtarget	(	PathTarget *	target,
		Expr *	expr
	)

Definition at line 741 of file tlist.c.

{
    if (!list_member(target->exprs, expr))
        add_column_to_pathtarget(target, expr, 0);
}

References add_column_to_pathtarget(), PathTarget::exprs, and list_member().

Referenced by add_new_columns_to_pathtarget().

add_new_columns_to_pathtarget()

void add_new_columns_to_pathtarget	(	PathTarget *	target,
		List *	exprs
	)

Definition at line 752 of file tlist.c.

{
    ListCell   *lc;
 
    foreach(lc, exprs)
    {
        Expr       *expr = (Expr *) lfirst(lc);
 
        add_new_column_to_pathtarget(target, expr);
    }
}

References add_new_column_to_pathtarget(), and lfirst.

Referenced by add_paths_with_pathkeys_for_rel(), make_group_input_target(), make_partial_grouping_target(), make_sort_input_target(), and make_window_input_target().

add_sp_item_to_pathtarget()

static void add_sp_item_to_pathtarget ( PathTarget *  target, split_pathtarget_item *  item  )

static

Definition at line 1202 of file tlist.c.

{
    int         lci;
    ListCell   *lc;
 
    /*
     * Look for a pre-existing entry that is equal() and does not have a
     * conflicting sortgroupref already.
     */
    lci = 0;
    foreach(lc, target->exprs)
    {
        Node       *node = (Node *) lfirst(lc);
        Index       sgref = get_pathtarget_sortgroupref(target, lci);
 
        if ((item->sortgroupref == sgref ||
             item->sortgroupref == 0 ||
             sgref == 0) &&
            equal(item->expr, node))
        {
            /* Found a match.  Assign item's sortgroupref if it has one. */
            if (item->sortgroupref)
            {
                if (target->sortgrouprefs == NULL)
                {
                    target->sortgrouprefs = (Index *)
                        palloc0(list_length(target->exprs) * sizeof(Index));
                }
                target->sortgrouprefs[lci] = item->sortgroupref;
            }
            return;
        }
        lci++;
    }
 
    /*
     * No match, so add item to PathTarget.  Copy the expr for safety.
     */
    add_column_to_pathtarget(target, (Expr *) copyObject(item->expr),
                             item->sortgroupref);
}

References add_column_to_pathtarget(), copyObject, equal(), split_pathtarget_item::expr, PathTarget::exprs, get_pathtarget_sortgroupref, lfirst, list_length(), palloc0(), and split_pathtarget_item::sortgroupref.

Referenced by add_sp_items_to_pathtarget(), and split_pathtarget_at_srfs().

add_sp_items_to_pathtarget()

static void add_sp_items_to_pathtarget ( PathTarget *  target, List *  items  )

static

Definition at line 1248 of file tlist.c.

{
    ListCell   *lc;
 
    foreach(lc, items)
    {
        split_pathtarget_item *item = lfirst(lc);
 
        add_sp_item_to_pathtarget(target, item);
    }
}

References add_sp_item_to_pathtarget(), and lfirst.

Referenced by split_pathtarget_at_srfs().

add_to_flat_tlist()

List* add_to_flat_tlist	(	List *	tlist,
		List *	exprs
	)

Definition at line 132 of file tlist.c.

{
    int         next_resno = list_length(tlist) + 1;
    ListCell   *lc;
 
    foreach(lc, exprs)
    {
        Expr       *expr = (Expr *) lfirst(lc);
 
        if (!tlist_member(expr, tlist))
        {
            TargetEntry *tle;
 
            tle = makeTargetEntry(copyObject(expr), /* copy needed?? */
                                  next_resno++,
                                  NULL,
                                  false);
            tlist = lappend(tlist, tle);
        }
    }
    return tlist;
}

References copyObject, lappend(), lfirst, list_length(), makeTargetEntry(), and tlist_member().

Referenced by build_tlist_to_deparse(), and foreign_grouping_ok().

apply_pathtarget_labeling_to_tlist()

void apply_pathtarget_labeling_to_tlist	(	List *	tlist,
		PathTarget *	target
	)

Definition at line 774 of file tlist.c.

{
    int         i;
    ListCell   *lc;
 
    /* Nothing to do if PathTarget has no sortgrouprefs data */
    if (target->sortgrouprefs == NULL)
        return;
 
    i = 0;
    foreach(lc, target->exprs)
    {
        Expr       *expr = (Expr *) lfirst(lc);
        TargetEntry *tle;
 
        if (target->sortgrouprefs[i])
        {
            /*
             * For Vars, use tlist_member_match_var's weakened matching rule;
             * this allows us to deal with some cases where a set-returning
             * function has been inlined, so that we now have more knowledge
             * about what it returns than we did when the original Var was
             * created.  Otherwise, use regular equal() to find the matching
             * TLE.  (In current usage, only the Var case is actually needed;
             * but it seems best to have sane behavior here for non-Vars too.)
             */
            if (expr && IsA(expr, Var))
                tle = tlist_member_match_var((Var *) expr, tlist);
            else
                tle = tlist_member(expr, tlist);
 
            /*
             * Complain if noplace for the sortgrouprefs label, or if we'd
             * have to label a column twice.  (The case where it already has
             * the desired label probably can't happen, but we may as well
             * allow for it.)
             */
            if (!tle)
                elog(ERROR, "ORDER/GROUP BY expression not found in targetlist");
            if (tle->ressortgroupref != 0 &&
                tle->ressortgroupref != target->sortgrouprefs[i])
                elog(ERROR, "targetlist item has multiple sortgroupref labels");
 
            tle->ressortgroupref = target->sortgrouprefs[i];
        }
        i++;
    }
}

References elog(), ERROR, PathTarget::exprs, i, IsA, lfirst, TargetEntry::ressortgroupref, tlist_member(), and tlist_member_match_var().

Referenced by create_projection_plan(), and create_scan_plan().

apply_tlist_labeling()

void apply_tlist_labeling	(	List *	dest_tlist,
		List *	src_tlist
	)

Definition at line 318 of file tlist.c.

{
    ListCell   *ld,
               *ls;
 
    Assert(list_length(dest_tlist) == list_length(src_tlist));
    forboth(ld, dest_tlist, ls, src_tlist)
    {
        TargetEntry *dest_tle = (TargetEntry *) lfirst(ld);
        TargetEntry *src_tle = (TargetEntry *) lfirst(ls);
 
        Assert(dest_tle->resno == src_tle->resno);
        dest_tle->resname = src_tle->resname;
        dest_tle->ressortgroupref = src_tle->ressortgroupref;
        dest_tle->resorigtbl = src_tle->resorigtbl;
        dest_tle->resorigcol = src_tle->resorigcol;
        dest_tle->resjunk = src_tle->resjunk;
    }
}

References Assert(), forboth, lfirst, list_length(), TargetEntry::resno, and TargetEntry::ressortgroupref.

Referenced by clean_up_removed_plan_level(), create_modifytable_plan(), and create_plan().

copy_pathtarget()

PathTarget* copy_pathtarget

(

PathTarget *

src

)

Definition at line 657 of file tlist.c.

{
    PathTarget *dst = makeNode(PathTarget);
 
    /* Copy scalar fields */
    memcpy(dst, src, sizeof(PathTarget));
    /* Shallow-copy the expression list */
    dst->exprs = list_copy(src->exprs);
    /* Duplicate sortgrouprefs if any (if not, the memcpy handled this) */
    if (src->sortgrouprefs)
    {
        Size        nbytes = list_length(src->exprs) * sizeof(Index);
 
        dst->sortgrouprefs = (Index *) palloc(nbytes);
        memcpy(dst->sortgrouprefs, src->sortgrouprefs, nbytes);
    }
    return dst;
}

References PathTarget::exprs, list_copy(), list_length(), makeNode, and palloc().

Referenced by add_paths_with_pathkeys_for_rel(), apply_scanjoin_target_to_paths(), create_one_window_path(), create_partitionwise_grouping_paths(), and reparameterize_path_by_child().

count_nonjunk_tlist_entries()

int count_nonjunk_tlist_entries

(

List *

tlist

)

Definition at line 186 of file tlist.c.

{
    int         len = 0;
    ListCell   *l;
 
    foreach(l, tlist)
    {
        TargetEntry *tle = (TargetEntry *) lfirst(l);
 
        if (!tle->resjunk)
            len++;
    }
    return len;
}

References len, and lfirst.

Referenced by get_update_query_targetlist_def(), transformJsonArrayQueryConstructor(), transformMultiAssignRef(), and transformSubLink().

create_empty_pathtarget()

PathTarget* create_empty_pathtarget

(

void

)

Definition at line 681 of file tlist.c.

{
    /* This is easy, but we don't want callers to hard-wire this ... */
    return makeNode(PathTarget);
}

References makeNode.

Referenced by build_child_join_rel(), build_join_rel(), build_simple_rel(), fetch_upper_rel(), make_group_input_target(), make_partial_grouping_target(), make_sort_input_target(), make_window_input_target(), and split_pathtarget_at_srfs().

extract_grouping_collations()

Oid* extract_grouping_collations	(	List *	groupClause,
		List *	tlist
	)

Definition at line 489 of file tlist.c.

{
    int         numCols = list_length(groupClause);
    int         colno = 0;
    Oid        *grpCollations;
    ListCell   *glitem;
 
    grpCollations = (Oid *) palloc(sizeof(Oid) * numCols);
 
    foreach(glitem, groupClause)
    {
        SortGroupClause *groupcl = (SortGroupClause *) lfirst(glitem);
        TargetEntry *tle = get_sortgroupclause_tle(groupcl, tlist);
 
        grpCollations[colno++] = exprCollation((Node *) tle->expr);
    }
 
    return grpCollations;
}

References TargetEntry::expr, exprCollation(), get_sortgroupclause_tle(), lfirst, list_length(), and palloc().

Referenced by create_agg_plan(), create_group_plan(), and create_groupingsets_plan().

extract_grouping_cols()

AttrNumber* extract_grouping_cols	(	List *	groupClause,
		List *	tlist
	)

Definition at line 514 of file tlist.c.

{
    AttrNumber *grpColIdx;
    int         numCols = list_length(groupClause);
    int         colno = 0;
    ListCell   *glitem;
 
    grpColIdx = (AttrNumber *) palloc(sizeof(AttrNumber) * numCols);
 
    foreach(glitem, groupClause)
    {
        SortGroupClause *groupcl = (SortGroupClause *) lfirst(glitem);
        TargetEntry *tle = get_sortgroupclause_tle(groupcl, tlist);
 
        grpColIdx[colno++] = tle->resno;
    }
 
    return grpColIdx;
}

References get_sortgroupclause_tle(), lfirst, list_length(), palloc(), and TargetEntry::resno.

Referenced by create_agg_plan(), and create_group_plan().

extract_grouping_ops()

Oid* extract_grouping_ops

(

List *

groupClause

)

Definition at line 463 of file tlist.c.

{
    int         numCols = list_length(groupClause);
    int         colno = 0;
    Oid        *groupOperators;
    ListCell   *glitem;
 
    groupOperators = (Oid *) palloc(sizeof(Oid) * numCols);
 
    foreach(glitem, groupClause)
    {
        SortGroupClause *groupcl = (SortGroupClause *) lfirst(glitem);
 
        groupOperators[colno] = groupcl->eqop;
        Assert(OidIsValid(groupOperators[colno]));
        colno++;
    }
 
    return groupOperators;
}

References Assert(), SortGroupClause::eqop, lfirst, list_length(), OidIsValid, and palloc().

Referenced by create_agg_plan(), create_group_plan(), and create_groupingsets_plan().

get_sortgroupclause_expr()

Node* get_sortgroupclause_expr	(	SortGroupClause *	sgClause,
		List *	targetList
	)

Definition at line 379 of file tlist.c.

{
    TargetEntry *tle = get_sortgroupclause_tle(sgClause, targetList);
 
    return (Node *) tle->expr;
}

References TargetEntry::expr, and get_sortgroupclause_tle().

Referenced by get_sortgrouplist_exprs(), make_pathkeys_for_sortclauses_extended(), transformAggregateCall(), and transformWindowDefinitions().

get_sortgroupclause_tle()

TargetEntry* get_sortgroupclause_tle	(	SortGroupClause *	sgClause,
		List *	targetList
	)

Definition at line 367 of file tlist.c.

{
    return get_sortgroupref_tle(sgClause->tleSortGroupRef, targetList);
}

References get_sortgroupref_tle(), and SortGroupClause::tleSortGroupRef.

Referenced by build_pertrans_for_aggref(), create_groupingsets_plan(), create_limit_plan(), create_windowagg_plan(), extract_grouping_collations(), extract_grouping_cols(), get_sortgroupclause_expr(), make_recursive_union(), make_setop(), make_sort_from_sortclauses(), make_unique_from_sortclauses(), ordered_set_startup(), parseCheckAggregates(), query_is_distinct_for(), remove_useless_groupby_columns(), and transformDistinctClause().

get_sortgrouplist_exprs()

List* get_sortgrouplist_exprs	(	List *	sgClauses,
		List *	targetList
	)

Definition at line 392 of file tlist.c.

{
    List       *result = NIL;
    ListCell   *l;
 
    foreach(l, sgClauses)
    {
        SortGroupClause *sortcl = (SortGroupClause *) lfirst(l);
        Node       *sortexpr;
 
        sortexpr = get_sortgroupclause_expr(sortcl, targetList);
        result = lappend(result, sortexpr);
    }
    return result;
}

References get_sortgroupclause_expr(), lappend(), lfirst, and NIL.

Referenced by create_final_distinct_paths(), create_partial_distinct_paths(), estimate_path_cost_size(), get_number_of_groups(), and group_by_has_partkey().

get_sortgroupref_clause()

SortGroupClause* get_sortgroupref_clause	(	Index	sortref,
		List *	clauses
	)

Definition at line 422 of file tlist.c.

{
    ListCell   *l;
 
    foreach(l, clauses)
    {
        SortGroupClause *cl = (SortGroupClause *) lfirst(l);
 
        if (cl->tleSortGroupRef == sortref)
            return cl;
    }
 
    elog(ERROR, "ORDER/GROUP BY expression not found in list");
    return NULL;                /* keep compiler quiet */
}

References elog(), ERROR, lfirst, and SortGroupClause::tleSortGroupRef.

Referenced by preprocess_groupclause().

get_sortgroupref_clause_noerr()

SortGroupClause* get_sortgroupref_clause_noerr	(	Index	sortref,
		List *	clauses
	)

Definition at line 443 of file tlist.c.

{
    ListCell   *l;
 
    foreach(l, clauses)
    {
        SortGroupClause *cl = (SortGroupClause *) lfirst(l);
 
        if (cl->tleSortGroupRef == sortref)
            return cl;
    }
 
    return NULL;
}

References lfirst, and SortGroupClause::tleSortGroupRef.

Referenced by find_em_for_rel_target(), foreign_grouping_ok(), make_group_input_target(), and make_partial_grouping_target().

get_sortgroupref_tle()

TargetEntry* get_sortgroupref_tle	(	Index	sortref,
		List *	targetList
	)

Definition at line 345 of file tlist.c.

{
    ListCell   *l;
 
    foreach(l, targetList)
    {
        TargetEntry *tle = (TargetEntry *) lfirst(l);
 
        if (tle->ressortgroupref == sortref)
            return tle;
    }
 
    elog(ERROR, "ORDER/GROUP BY expression not found in targetlist");
    return NULL;                /* keep compiler quiet */
}

References elog(), ERROR, lfirst, and TargetEntry::ressortgroupref.

Referenced by convert_subquery_pathkeys(), deparseSortGroupClause(), foreign_expr_walker(), get_rule_sortgroupclause(), get_sortgroupclause_tle(), make_unique_from_pathkeys(), prepare_sort_from_pathkeys(), and transformDistinctOnClause().

get_tlist_exprs()

List* get_tlist_exprs	(	List *	tlist,
		bool	includeJunk
	)

Definition at line 163 of file tlist.c.

{
    List       *result = NIL;
    ListCell   *l;
 
    foreach(l, tlist)
    {
        TargetEntry *tle = (TargetEntry *) lfirst(l);
 
        if (tle->resjunk && !includeJunk)
            continue;
 
        result = lappend(result, tle->expr);
    }
    return result;
}

References TargetEntry::expr, lappend(), lfirst, and NIL.

Referenced by recurse_set_operations().

grouping_is_hashable()

bool grouping_is_hashable

(

List *

groupClause

)

Definition at line 560 of file tlist.c.

{
    ListCell   *glitem;
 
    foreach(glitem, groupClause)
    {
        SortGroupClause *groupcl = (SortGroupClause *) lfirst(glitem);
 
        if (!groupcl->hashable)
            return false;
    }
    return true;
}

References lfirst.

Referenced by choose_hashed_setop(), create_final_distinct_paths(), create_grouping_paths(), create_partial_distinct_paths(), and generate_recursion_path().

grouping_is_sortable()

bool grouping_is_sortable

(

List *

groupClause

)

Definition at line 540 of file tlist.c.

{
    ListCell   *glitem;
 
    foreach(glitem, groupClause)
    {
        SortGroupClause *groupcl = (SortGroupClause *) lfirst(glitem);
 
        if (!OidIsValid(groupcl->sortop))
            return false;
    }
    return true;
}

References lfirst, OidIsValid, and SortGroupClause::sortop.

Referenced by adjust_foreign_grouping_path_cost(), choose_hashed_setop(), create_final_distinct_paths(), create_grouping_paths(), create_partial_distinct_paths(), make_pathkeys_for_window(), and standard_qp_callback().

make_pathtarget_from_tlist()

PathTarget* make_pathtarget_from_tlist

(

List *

tlist

)

Definition at line 591 of file tlist.c.

{
    PathTarget *target = makeNode(PathTarget);
    int         i;
    ListCell   *lc;
 
    target->sortgrouprefs = (Index *) palloc(list_length(tlist) * sizeof(Index));
 
    i = 0;
    foreach(lc, tlist)
    {
        TargetEntry *tle = (TargetEntry *) lfirst(lc);
 
        target->exprs = lappend(target->exprs, tle->expr);
        target->sortgrouprefs[i] = tle->ressortgroupref;
        i++;
    }
 
    /*
     * Mark volatility as unknown.  The contain_volatile_functions function
     * will determine if there are any volatile functions when called for the
     * first time with this PathTarget.
     */
    target->has_volatile_expr = VOLATILITY_UNKNOWN;
 
    return target;
}

References TargetEntry::expr, PathTarget::exprs, PathTarget::has_volatile_expr, i, lappend(), lfirst, list_length(), makeNode, palloc(), TargetEntry::ressortgroupref, and VOLATILITY_UNKNOWN.

make_tlist_from_pathtarget()

List* make_tlist_from_pathtarget

(

PathTarget *

target

)

Definition at line 624 of file tlist.c.

{
    List       *tlist = NIL;
    int         i;
    ListCell   *lc;
 
    i = 0;
    foreach(lc, target->exprs)
    {
        Expr       *expr = (Expr *) lfirst(lc);
        TargetEntry *tle;
 
        tle = makeTargetEntry(expr,
                              i + 1,
                              NULL,
                              false);
        if (target->sortgrouprefs)
            tle->ressortgroupref = target->sortgrouprefs[i];
        tlist = lappend(tlist, tle);
        i++;
    }
 
    return tlist;
}

References PathTarget::exprs, i, lappend(), lfirst, makeTargetEntry(), NIL, and TargetEntry::ressortgroupref.

Referenced by set_subquery_pathlist().

split_pathtarget_at_srfs()

void split_pathtarget_at_srfs	(	PlannerInfo *	root,
		PathTarget *	target,
		PathTarget *	input_target,
		List **	targets,
		List **	targets_contain_srfs
	)

Definition at line 881 of file tlist.c.

{
    split_pathtarget_context context;
    int         max_depth;
    bool        need_extra_projection;
    List       *prev_level_tlist;
    int         lci;
    ListCell   *lc,
               *lc1,
               *lc2,
               *lc3;
 
    /*
     * It's not unusual for planner.c to pass us two physically identical
     * targets, in which case we can conclude without further ado that all
     * expressions are available from the input.  (The logic below would
     * arrive at the same conclusion, but much more tediously.)
     */
    if (target == input_target)
    {
        *targets = list_make1(target);
        *targets_contain_srfs = list_make1_int(false);
        return;
    }
 
    /* Pass any input_target exprs down to split_pathtarget_walker() */
    context.input_target_exprs = input_target ? input_target->exprs : NIL;
 
    /*
     * Initialize with empty level-zero lists, and no levels after that.
     * (Note: we could dispense with representing level zero explicitly, since
     * it will never receive any SRFs, but then we'd have to special-case that
     * level when we get to building result PathTargets.  Level zero describes
     * the SRF-free PathTarget that will be given to the input plan node.)
     */
    context.level_srfs = list_make1(NIL);
    context.level_input_vars = list_make1(NIL);
    context.level_input_srfs = list_make1(NIL);
 
    /* Initialize data we'll accumulate across all the target expressions */
    context.current_input_vars = NIL;
    context.current_input_srfs = NIL;
    max_depth = 0;
    need_extra_projection = false;
 
    /* Scan each expression in the PathTarget looking for SRFs */
    lci = 0;
    foreach(lc, target->exprs)
    {
        Node       *node = (Node *) lfirst(lc);
 
        /* Tell split_pathtarget_walker about this expr's sortgroupref */
        context.current_sgref = get_pathtarget_sortgroupref(target, lci);
        lci++;
 
        /*
         * Find all SRFs and Vars (and Var-like nodes) in this expression, and
         * enter them into appropriate lists within the context struct.
         */
        context.current_depth = 0;
        split_pathtarget_walker(node, &context);
 
        /* An expression containing no SRFs is of no further interest */
        if (context.current_depth == 0)
            continue;
 
        /*
         * Track max SRF nesting depth over the whole PathTarget.  Also, if
         * this expression establishes a new max depth, we no longer care
         * whether previous expressions contained nested SRFs; we can handle
         * any required projection for them in the final ProjectSet node.
         */
        if (max_depth < context.current_depth)
        {
            max_depth = context.current_depth;
            need_extra_projection = false;
        }
 
        /*
         * If any maximum-depth SRF is not at the top level of its expression,
         * we'll need an extra Result node to compute the top-level scalar
         * expression.
         */
        if (max_depth == context.current_depth && !IS_SRF_CALL(node))
            need_extra_projection = true;
    }
 
    /*
     * If we found no SRFs needing evaluation (maybe they were all present in
     * input_target, or maybe they were all removed by const-simplification),
     * then no ProjectSet is needed; fall out.
     */
    if (max_depth == 0)
    {
        *targets = list_make1(target);
        *targets_contain_srfs = list_make1_int(false);
        return;
    }
 
    /*
     * The Vars and SRF outputs needed at top level can be added to the last
     * level_input lists if we don't need an extra projection step.  If we do
     * need one, add a SRF-free level to the lists.
     */
    if (need_extra_projection)
    {
        context.level_srfs = lappend(context.level_srfs, NIL);
        context.level_input_vars = lappend(context.level_input_vars,
                                           context.current_input_vars);
        context.level_input_srfs = lappend(context.level_input_srfs,
                                           context.current_input_srfs);
    }
    else
    {
        lc = list_nth_cell(context.level_input_vars, max_depth);
        lfirst(lc) = list_concat(lfirst(lc), context.current_input_vars);
        lc = list_nth_cell(context.level_input_srfs, max_depth);
        lfirst(lc) = list_concat(lfirst(lc), context.current_input_srfs);
    }
 
    /*
     * Now construct the output PathTargets.  The original target can be used
     * as-is for the last one, but we need to construct a new SRF-free target
     * representing what the preceding plan node has to emit, as well as a
     * target for each intermediate ProjectSet node.
     */
    *targets = *targets_contain_srfs = NIL;
    prev_level_tlist = NIL;
 
    forthree(lc1, context.level_srfs,
             lc2, context.level_input_vars,
             lc3, context.level_input_srfs)
    {
        List       *level_srfs = (List *) lfirst(lc1);
        PathTarget *ntarget;
 
        if (lnext(context.level_srfs, lc1) == NULL)
        {
            ntarget = target;
        }
        else
        {
            ntarget = create_empty_pathtarget();
 
            /*
             * This target should actually evaluate any SRFs of the current
             * level, and it needs to propagate forward any Vars needed by
             * later levels, as well as SRFs computed earlier and needed by
             * later levels.
             */
            add_sp_items_to_pathtarget(ntarget, level_srfs);
            for_each_cell(lc, context.level_input_vars,
                          lnext(context.level_input_vars, lc2))
            {
                List       *input_vars = (List *) lfirst(lc);
 
                add_sp_items_to_pathtarget(ntarget, input_vars);
            }
            for_each_cell(lc, context.level_input_srfs,
                          lnext(context.level_input_srfs, lc3))
            {
                List       *input_srfs = (List *) lfirst(lc);
                ListCell   *lcx;
 
                foreach(lcx, input_srfs)
                {
                    split_pathtarget_item *item = lfirst(lcx);
 
                    if (list_member(prev_level_tlist, item->expr))
                        add_sp_item_to_pathtarget(ntarget, item);
                }
            }
            set_pathtarget_cost_width(root, ntarget);
        }
 
        /*
         * Add current target and does-it-compute-SRFs flag to output lists.
         */
        *targets = lappend(*targets, ntarget);
        *targets_contain_srfs = lappend_int(*targets_contain_srfs,
                                            (level_srfs != NIL));
 
        /* Remember this level's output for next pass */
        prev_level_tlist = ntarget->exprs;
    }
}

References add_sp_item_to_pathtarget(), add_sp_items_to_pathtarget(), create_empty_pathtarget(), split_pathtarget_context::current_depth, split_pathtarget_context::current_input_srfs, split_pathtarget_context::current_input_vars, split_pathtarget_context::current_sgref, split_pathtarget_item::expr, PathTarget::exprs, for_each_cell, forthree, get_pathtarget_sortgroupref, split_pathtarget_context::input_target_exprs, IS_SRF_CALL, lappend(), lappend_int(), split_pathtarget_context::level_input_srfs, split_pathtarget_context::level_input_vars, split_pathtarget_context::level_srfs, lfirst, list_concat(), list_make1, list_make1_int, list_member(), list_nth_cell(), lnext(), NIL, set_pathtarget_cost_width(), and split_pathtarget_walker().

Referenced by grouping_planner().

split_pathtarget_walker()

static bool split_pathtarget_walker ( Node *  node, split_pathtarget_context *  context  )

static

Definition at line 1077 of file tlist.c.

{
    if (node == NULL)
        return false;
 
    /*
     * A subexpression that matches an expression already computed in
     * input_target can be treated like a Var (which indeed it will be after
     * setrefs.c gets done with it), even if it's actually a SRF.  Record it
     * as being needed for the current expression, and ignore any
     * substructure.  (Note in particular that this preserves the identity of
     * any expressions that appear as sortgrouprefs in input_target.)
     */
    if (list_member(context->input_target_exprs, node))
    {
        split_pathtarget_item *item = palloc(sizeof(split_pathtarget_item));
 
        item->expr = node;
        item->sortgroupref = context->current_sgref;
        context->current_input_vars = lappend(context->current_input_vars,
                                              item);
        return false;
    }
 
    /*
     * Vars and Var-like constructs are expected to be gotten from the input,
     * too.  We assume that these constructs cannot contain any SRFs (if one
     * does, there will be an executor failure from a misplaced SRF).
     */
    if (IsA(node, Var) ||
        IsA(node, PlaceHolderVar) ||
        IsA(node, Aggref) ||
        IsA(node, GroupingFunc) ||
        IsA(node, WindowFunc))
    {
        split_pathtarget_item *item = palloc(sizeof(split_pathtarget_item));
 
        item->expr = node;
        item->sortgroupref = context->current_sgref;
        context->current_input_vars = lappend(context->current_input_vars,
                                              item);
        return false;
    }
 
    /*
     * If it's a SRF, recursively examine its inputs, determine its level, and
     * make appropriate entries in the output lists.
     */
    if (IS_SRF_CALL(node))
    {
        split_pathtarget_item *item = palloc(sizeof(split_pathtarget_item));
        List       *save_input_vars = context->current_input_vars;
        List       *save_input_srfs = context->current_input_srfs;
        int         save_current_depth = context->current_depth;
        int         srf_depth;
        ListCell   *lc;
 
        item->expr = node;
        item->sortgroupref = context->current_sgref;
 
        context->current_input_vars = NIL;
        context->current_input_srfs = NIL;
        context->current_depth = 0;
        context->current_sgref = 0; /* subexpressions are not sortgroup items */
 
        (void) expression_tree_walker(node, split_pathtarget_walker,
                                      (void *) context);
 
        /* Depth is one more than any SRF below it */
        srf_depth = context->current_depth + 1;
 
        /* If new record depth, initialize another level of output lists */
        if (srf_depth >= list_length(context->level_srfs))
        {
            context->level_srfs = lappend(context->level_srfs, NIL);
            context->level_input_vars = lappend(context->level_input_vars, NIL);
            context->level_input_srfs = lappend(context->level_input_srfs, NIL);
        }
 
        /* Record this SRF as needing to be evaluated at appropriate level */
        lc = list_nth_cell(context->level_srfs, srf_depth);
        lfirst(lc) = lappend(lfirst(lc), item);
 
        /* Record its inputs as being needed at the same level */
        lc = list_nth_cell(context->level_input_vars, srf_depth);
        lfirst(lc) = list_concat(lfirst(lc), context->current_input_vars);
        lc = list_nth_cell(context->level_input_srfs, srf_depth);
        lfirst(lc) = list_concat(lfirst(lc), context->current_input_srfs);
 
        /*
         * Restore caller-level state and update it for presence of this SRF.
         * Notice we report the SRF itself as being needed for evaluation of
         * surrounding expression.
         */
        context->current_input_vars = save_input_vars;
        context->current_input_srfs = lappend(save_input_srfs, item);
        context->current_depth = Max(save_current_depth, srf_depth);
 
        /* We're done here */
        return false;
    }
 
    /*
     * Otherwise, the node is a scalar (non-set) expression, so recurse to
     * examine its inputs.
     */
    context->current_sgref = 0; /* subexpressions are not sortgroup items */
    return expression_tree_walker(node, split_pathtarget_walker,
                                  (void *) context);
}

References split_pathtarget_context::current_depth, split_pathtarget_context::current_input_srfs, split_pathtarget_context::current_input_vars, split_pathtarget_context::current_sgref, split_pathtarget_item::expr, expression_tree_walker, split_pathtarget_context::input_target_exprs, IS_SRF_CALL, IsA, lappend(), split_pathtarget_context::level_input_srfs, split_pathtarget_context::level_input_vars, split_pathtarget_context::level_srfs, lfirst, list_concat(), list_length(), list_member(), list_nth_cell(), Max, NIL, palloc(), and split_pathtarget_item::sortgroupref.

Referenced by split_pathtarget_at_srfs().

tlist_member()

TargetEntry* tlist_member	(	Expr *	node,
		List *	targetlist
	)

Definition at line 79 of file tlist.c.

{
    ListCell   *temp;
 
    foreach(temp, targetlist)
    {
        TargetEntry *tlentry = (TargetEntry *) lfirst(temp);
 
        if (equal(node, tlentry->expr))
            return tlentry;
    }
    return NULL;
}

References equal(), TargetEntry::expr, and lfirst.

Referenced by add_to_flat_tlist(), apply_pathtarget_labeling_to_tlist(), build_remote_returning(), create_unique_plan(), preprocess_targetlist(), rebuild_fdw_scan_tlist(), and search_indexed_tlist_for_non_var().

tlist_member_match_var()

static TargetEntry* tlist_member_match_var ( Var *  var, List *  targetlist  )

static

Definition at line 102 of file tlist.c.

{
    ListCell   *temp;
 
    foreach(temp, targetlist)
    {
        TargetEntry *tlentry = (TargetEntry *) lfirst(temp);
        Var        *tlvar = (Var *) tlentry->expr;
 
        if (!tlvar || !IsA(tlvar, Var))
            continue;
        if (var->varno == tlvar->varno &&
            var->varattno == tlvar->varattno &&
            var->varlevelsup == tlvar->varlevelsup &&
            var->vartype == tlvar->vartype)
            return tlentry;
    }
    return NULL;
}

References TargetEntry::expr, if(), IsA, lfirst, Var::varattno, Var::varlevelsup, and Var::varno.

Referenced by apply_pathtarget_labeling_to_tlist().

tlist_same_collations()

bool tlist_same_collations	(	List *	tlist,
		List *	colCollations,
		bool	junkOK
	)

Definition at line 282 of file tlist.c.

{
    ListCell   *l;
    ListCell   *curColColl = list_head(colCollations);
 
    foreach(l, tlist)
    {
        TargetEntry *tle = (TargetEntry *) lfirst(l);
 
        if (tle->resjunk)
        {
            if (!junkOK)
                return false;
        }
        else
        {
            if (curColColl == NULL)
                return false;   /* tlist longer than colCollations */
            if (exprCollation((Node *) tle->expr) != lfirst_oid(curColColl))
                return false;
            curColColl = lnext(colCollations, curColColl);
        }
    }
    if (curColColl != NULL)
        return false;           /* tlist shorter than colCollations */
    return true;
}

References TargetEntry::expr, exprCollation(), lfirst, lfirst_oid, list_head(), and lnext().

Referenced by recurse_set_operations().

tlist_same_datatypes()

bool tlist_same_datatypes	(	List *	tlist,
		List *	colTypes,
		bool	junkOK
	)

Definition at line 248 of file tlist.c.

{
    ListCell   *l;
    ListCell   *curColType = list_head(colTypes);
 
    foreach(l, tlist)
    {
        TargetEntry *tle = (TargetEntry *) lfirst(l);
 
        if (tle->resjunk)
        {
            if (!junkOK)
                return false;
        }
        else
        {
            if (curColType == NULL)
                return false;   /* tlist longer than colTypes */
            if (exprType((Node *) tle->expr) != lfirst_oid(curColType))
                return false;
            curColType = lnext(colTypes, curColType);
        }
    }
    if (curColType != NULL)
        return false;           /* tlist shorter than colTypes */
    return true;
}

References TargetEntry::expr, exprType(), lfirst, lfirst_oid, list_head(), and lnext().

Referenced by is_simple_union_all_recurse(), and recurse_set_operations().

tlist_same_exprs()

bool tlist_same_exprs	(	List *	tlist1,
		List *	tlist2
	)

Definition at line 218 of file tlist.c.

{
    ListCell   *lc1,
               *lc2;
 
    if (list_length(tlist1) != list_length(tlist2))
        return false;           /* not same length, so can't match */
 
    forboth(lc1, tlist1, lc2, tlist2)
    {
        TargetEntry *tle1 = (TargetEntry *) lfirst(lc1);
        TargetEntry *tle2 = (TargetEntry *) lfirst(lc2);
 
        if (!equal(tle1->expr, tle2->expr))
            return false;
    }
 
    return true;
}

References equal(), TargetEntry::expr, forboth, lfirst, and list_length().

Referenced by apply_scanjoin_target_to_paths(), change_plan_targetlist(), and create_projection_plan().