#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:

Data Structures
struct	split_pathtarget_item

struct	split_pathtarget_context

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)

Function Documentation

◆ add_column_to_pathtarget()

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

Definition at line 684 of file tlist.c.

References PathTarget::exprs, PathTarget::has_volatile_expr, lappend(), list_length(), palloc0(), repalloc(), PathTarget::sortgrouprefs, 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().

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

◆ add_new_column_to_pathtarget()

void add_new_column_to_pathtarget	(	PathTarget *	target,
		Expr *	expr
	)

Definition at line 730 of file tlist.c.

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

Referenced by add_new_columns_to_pathtarget().

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

◆ add_new_columns_to_pathtarget()

void add_new_columns_to_pathtarget	(	PathTarget *	target,
		List *	exprs
	)

Definition at line 741 of file tlist.c.

References add_new_column_to_pathtarget(), and lfirst.

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

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

◆ add_sp_item_to_pathtarget()

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

static

Definition at line 1191 of file tlist.c.

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

Referenced by add_sp_items_to_pathtarget(), and split_pathtarget_at_srfs().

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

◆ add_sp_items_to_pathtarget()

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

static

Definition at line 1237 of file tlist.c.

References add_sp_item_to_pathtarget(), and lfirst.

Referenced by split_pathtarget_at_srfs().

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

◆ add_to_flat_tlist()

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

Definition at line 121 of file tlist.c.

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

Referenced by build_tlist_to_deparse(), and foreign_grouping_ok().

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

◆ apply_pathtarget_labeling_to_tlist()

void apply_pathtarget_labeling_to_tlist	(	List *	tlist,
		PathTarget *	target
	)

Definition at line 763 of file tlist.c.

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

Referenced by create_projection_plan(), and create_scan_plan().

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

◆ apply_tlist_labeling()

void apply_tlist_labeling	(	List *	dest_tlist,
		List *	src_tlist
	)

Definition at line 307 of file tlist.c.

References Assert, forboth, lfirst, list_length(), TargetEntry::resjunk, TargetEntry::resname, TargetEntry::resno, TargetEntry::resorigcol, TargetEntry::resorigtbl, and TargetEntry::ressortgroupref.

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

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

◆ copy_pathtarget()

PathTarget* copy_pathtarget ( PathTarget * src )

Definition at line 646 of file tlist.c.

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

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

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

◆ count_nonjunk_tlist_entries()

int count_nonjunk_tlist_entries ( List * tlist )

Definition at line 175 of file tlist.c.

References lfirst, and TargetEntry::resjunk.

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

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

◆ create_empty_pathtarget()

PathTarget* create_empty_pathtarget ( void )

Definition at line 670 of file tlist.c.

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

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

◆ extract_grouping_collations()

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

Definition at line 478 of file tlist.c.

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

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

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

◆ extract_grouping_cols()

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

Definition at line 503 of file tlist.c.

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

Referenced by create_agg_plan(), and create_group_plan().

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

◆ extract_grouping_ops()

Oid* extract_grouping_ops ( List * groupClause )

Definition at line 452 of file tlist.c.

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

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

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

◆ get_sortgroupclause_expr()

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

Definition at line 368 of file tlist.c.

References TargetEntry::expr, and get_sortgroupclause_tle().

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

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

◆ get_sortgroupclause_tle()

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

Definition at line 356 of file tlist.c.

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

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

◆ get_sortgrouplist_exprs()

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

Definition at line 381 of file tlist.c.

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

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

◆ get_sortgroupref_clause()

SortGroupClause* get_sortgroupref_clause	(	Index	sortref,
		List *	clauses
	)

Definition at line 411 of file tlist.c.

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

Referenced by preprocess_groupclause().

 {
     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 */
 }

◆ get_sortgroupref_clause_noerr()

SortGroupClause* get_sortgroupref_clause_noerr	(	Index	sortref,
		List *	clauses
	)

Definition at line 432 of file tlist.c.

References lfirst, and SortGroupClause::tleSortGroupRef.

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

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

◆ get_sortgroupref_tle()

TargetEntry* get_sortgroupref_tle	(	Index	sortref,
		List *	targetList
	)

Definition at line 334 of file tlist.c.

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

 {
     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 */
 }

◆ get_tlist_exprs()

List* get_tlist_exprs	(	List *	tlist,
		bool	includeJunk
	)

Definition at line 152 of file tlist.c.

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

Referenced by recurse_set_operations().

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

◆ grouping_is_hashable()

bool grouping_is_hashable ( List * groupClause )

Definition at line 549 of file tlist.c.

References SortGroupClause::hashable, and lfirst.

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

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

◆ grouping_is_sortable()

bool grouping_is_sortable ( List * groupClause )

Definition at line 529 of file tlist.c.

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

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

◆ make_pathtarget_from_tlist()

PathTarget* make_pathtarget_from_tlist ( List * tlist )

Definition at line 580 of file tlist.c.

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

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

◆ make_tlist_from_pathtarget()

List* make_tlist_from_pathtarget ( PathTarget * target )

Definition at line 613 of file tlist.c.

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

Referenced by set_subquery_pathlist().

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

◆ 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 870 of file tlist.c.

Referenced by grouping_planner().

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

◆ split_pathtarget_walker()

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

static

Definition at line 1066 of file tlist.c.

Referenced by split_pathtarget_at_srfs().

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

◆ tlist_member()

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

Definition at line 68 of file tlist.c.

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

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

◆ tlist_member_match_var()

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

static

Definition at line 91 of file tlist.c.

References TargetEntry::expr, IsA, lfirst, Var::varattno, Var::varlevelsup, Var::varno, and Var::vartype.

Referenced by apply_pathtarget_labeling_to_tlist().

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

◆ tlist_same_collations()

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

Definition at line 271 of file tlist.c.

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

Referenced by recurse_set_operations().

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

◆ tlist_same_datatypes()

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

Definition at line 237 of file tlist.c.

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

Referenced by is_simple_union_all_recurse(), and recurse_set_operations().

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

◆ tlist_same_exprs()

bool tlist_same_exprs	(	List *	tlist1,
		List *	tlist2
	)

Definition at line 207 of file tlist.c.

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

Referenced by change_plan_targetlist(), and create_projection_plan().

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

Data Structures

Functions

Function Documentation

◆ add_column_to_pathtarget()

◆ add_new_column_to_pathtarget()

◆ add_new_columns_to_pathtarget()

◆ add_sp_item_to_pathtarget()

◆ add_sp_items_to_pathtarget()

◆ add_to_flat_tlist()

◆ apply_pathtarget_labeling_to_tlist()

◆ apply_tlist_labeling()

◆ copy_pathtarget()

◆ count_nonjunk_tlist_entries()

◆ create_empty_pathtarget()

◆ extract_grouping_collations()

◆ extract_grouping_cols()

◆ extract_grouping_ops()

◆ get_sortgroupclause_expr()

◆ get_sortgroupclause_tle()

◆ get_sortgrouplist_exprs()

◆ get_sortgroupref_clause()

◆ get_sortgroupref_clause_noerr()

◆ get_sortgroupref_tle()

◆ get_tlist_exprs()

◆ grouping_is_hashable()

◆ grouping_is_sortable()

◆ make_pathtarget_from_tlist()

◆ make_tlist_from_pathtarget()

◆ split_pathtarget_at_srfs()

◆ split_pathtarget_walker()

◆ tlist_member()

◆ tlist_member_match_var()

◆ tlist_same_collations()

◆ tlist_same_datatypes()

◆ tlist_same_exprs()